@camstack/addon-post-analysis 1.2.302 → 1.2.304

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-CQIBimj5.js");
+const require_clip_model_registry = require("../clip-model-registry--qJe8fTH.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -14209,11 +14209,26 @@ function sortedSystemEvent(condition) {
 		...packageNames !== void 0 ? { packageNames: packageNames.toSorted(byValue) } : {}
 	};
 }
+/**
+* `zones` with its redundant quantifier dropped: `match: 'any'` says exactly
+* what an absent `match` says (D690 — the editors write `{ ids }`, the store
+* still holds `match: 'any'` on every rule written before). `'all'` is kept:
+* it IS a different rule.
+*/
+function canonicalZones(conditions) {
+	const zones = conditions.zones;
+	if (zones?.match !== "any") return conditions;
+	return {
+		...conditions,
+		zones: { ids: zones.ids }
+	};
+}
 /** The canonical form two conditions are compared in. */
 function conditionsFingerprint(conditions) {
-	const { systemEvent } = conditions;
-	return require_clip_model_registry.canonicalHash(systemEvent === void 0 ? conditions : {
-		...conditions,
+	const canonical = canonicalZones(conditions);
+	const { systemEvent } = canonical;
+	return require_clip_model_registry.canonicalHash(systemEvent === void 0 ? canonical : {
+		...canonical,
 		systemEvent: sortedSystemEvent(systemEvent)
 	});
 }
@@ -14222,7 +14237,8 @@ function conditionsFingerprint(conditions) {
 * (the normalisation the store applies on every write) and are compared
 * canonically: key order is irrelevant, an `undefined` key equals an absent
 * one, and the system-event `kinds` and id-list filters are compared as SETS.
-* Every other array keeps its order. A side that does not parse is treated as
+* Every other array keeps its order, and `zones.match: 'any'` equals an absent
+* `match`. A side that does not parse is treated as
 * a change, so it is judged rather than waved through.
 */
 function sameConditions(a, b) {
@@ -14267,7 +14283,7 @@ function assertPatchKeepsFamily(existing, patch) {
 * the offending kind or filter). Then rethrow. A refused save is dropped work,
 * and dropped work is never silent. Any other error passes through unlogged.
 */
-function logRefusal$3(check, ctx) {
+function logRefusal$4(check, ctx) {
 	try {
 		check();
 	} catch (err) {
@@ -14283,11 +14299,11 @@ function logRefusal$3(check, ctx) {
 }
 /** {@link assertRuleFamily}, logged. The create path of both routes. */
 function guardRuleFamily(rule, ctx) {
-	logRefusal$3(() => assertRuleFamily(rule), ctx);
+	logRefusal$4(() => assertRuleFamily(rule), ctx);
 }
 /** {@link assertPatchKeepsFamily}, logged. The update path of both routes. */
 function guardPatchFamily(existing, patch, ctx) {
-	logRefusal$3(() => assertPatchKeepsFamily(existing, patch), ctx);
+	logRefusal$4(() => assertPatchKeepsFamily(existing, patch), ctx);
 }
 //#endregion
 //#region src/notification-center/device-scope-guard.ts
@@ -14312,15 +14328,15 @@ function assertDevicesExcludeDelivery(rule) {
 	throw new NcDevicesExcludeRefusal(rule.delivery, excluded);
 }
 /** Run the check; a refusal is dropped work, so it is logged before it is rethrown. */
-function logRefusal$2(check, ctx) {
+function logRefusal$3(check, ctx) {
 	try {
 		check();
 	} catch (err) {
-		if (err instanceof NcDevicesExcludeRefusal) warnRefusal$1(ctx.logger, err, ctx);
+		if (err instanceof NcDevicesExcludeRefusal) warnRefusal$2(ctx.logger, err, ctx);
 		throw err;
 	}
 }
-function warnRefusal$1(logger, err, ctx) {
+function warnRefusal$2(logger, err, ctx) {
 	logger.warn("nc rule refused: devicesExclude on a system rule", { meta: {
 		...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
 		by: ctx.by,
@@ -14330,7 +14346,7 @@ function warnRefusal$1(logger, err, ctx) {
 }
 /** The create path of both routes. */
 function guardRuleDevicesExclude(rule, ctx) {
-	logRefusal$2(() => assertDevicesExcludeDelivery(rule), ctx);
+	logRefusal$3(() => assertDevicesExcludeDelivery(rule), ctx);
 }
 /**
 * The update path of both routes: the MERGED rule is judged, and only when the
@@ -14340,7 +14356,7 @@ function guardPatchDevicesExclude(existing, patch, ctx) {
 	if (existing === null) return;
 	const merged = mergedFamilySubject(existing, patch);
 	if (merged === null) return;
-	logRefusal$2(() => assertDevicesExcludeDelivery(merged), ctx);
+	logRefusal$3(() => assertDevicesExcludeDelivery(merged), ctx);
 }
 //#endregion
 //#region src/notification-center/rule-summary-guard.ts
@@ -14398,7 +14414,7 @@ function mergedDeliverySubject(existing, patch, clear) {
 	};
 	return JUDGED_KEYS.some((key) => require_clip_model_registry.canonicalHash(merged[key] ?? null) !== require_clip_model_registry.canonicalHash(existing[key] ?? null)) ? merged : null;
 }
-function logRefusal$1(check, ctx) {
+function logRefusal$2(check, ctx) {
 	try {
 		check();
 	} catch (err) {
@@ -14412,14 +14428,14 @@ function logRefusal$1(check, ctx) {
 }
 /** The create path of both routes. */
 function guardRuleSystemEventDelivery(rule, ctx) {
-	logRefusal$1(() => assertSystemEventDelivery(rule), ctx);
+	logRefusal$2(() => assertSystemEventDelivery(rule), ctx);
 }
 /** The update path of both routes: the MERGED rule, when the patch changes what is judged. */
 function guardPatchSystemEventDelivery(existing, patch, clear, ctx) {
 	if (existing === null) return;
 	const merged = mergedDeliverySubject(existing, patch, clear);
 	if (merged === null) return;
-	logRefusal$1(() => assertSystemEventDelivery(merged), ctx);
+	logRefusal$2(() => assertSystemEventDelivery(merged), ctx);
 }
 //#endregion
 //#region src/notification-center/sensor-transition-guard.ts
@@ -14441,15 +14457,15 @@ function assertSensorTransitionDelivery(rule) {
 	throw new NcSensorTransitionRefusal(rule.delivery, transition);
 }
 /** Run the check; a refusal is dropped work, so it is logged before it is rethrown. */
-function logRefusal(check, ctx) {
+function logRefusal$1(check, ctx) {
 	try {
 		check();
 	} catch (err) {
-		if (err instanceof NcSensorTransitionRefusal) warnRefusal(ctx.logger, err, ctx);
+		if (err instanceof NcSensorTransitionRefusal) warnRefusal$1(ctx.logger, err, ctx);
 		throw err;
 	}
 }
-function warnRefusal(logger, err, ctx) {
+function warnRefusal$1(logger, err, ctx) {
 	logger.warn("nc rule refused: sensorTransition off a device-event rule", { meta: {
 		...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
 		by: ctx.by,
@@ -14459,7 +14475,7 @@ function warnRefusal(logger, err, ctx) {
 }
 /** The create path of both routes. */
 function guardRuleSensorTransition(rule, ctx) {
-	logRefusal(() => assertSensorTransitionDelivery(rule), ctx);
+	logRefusal$1(() => assertSensorTransitionDelivery(rule), ctx);
 }
 /**
 * The update path of both routes: the MERGED rule is judged, and only when the
@@ -14470,7 +14486,92 @@ function guardPatchSensorTransition(existing, patch, ctx) {
 	if (existing === null) return;
 	const merged = mergedFamilySubject(existing, patch);
 	if (merged === null) return;
-	logRefusal(() => assertSensorTransitionDelivery(merged), ctx);
+	logRefusal$1(() => assertSensorTransitionDelivery(merged), ctx);
+}
+//#endregion
+//#region src/notification-center/detection-audio-guard.ts
+var NcDetectionAudioRefusal = class extends Error {
+	audioClasses;
+	constructor(audioClasses) {
+		super(`rule refused: a detection rule cannot name sounds (${audioClasses.join(", ")}) — create a Sound rule for them`);
+		this.name = "NcDetectionAudioRefusal";
+		this.audioClasses = audioClasses;
+	}
+};
+/**
+* The audio classes a DETECTION rule carries (include and exclude), in stored
+* order. Empty for a Sound rule (its `audio` condition owns its sounds) and for
+* a system rule (it has no class scope).
+*/
+function audioClassesOnDetectionRule(rule) {
+	if (require_clip_model_registry.isSystemDelivery(rule.delivery)) return [];
+	if (rule.conditions.audio !== void 0) return [];
+	return [...rule.conditions.classes ?? [], ...rule.conditions.classesExclude ?? []].filter(require_clip_model_registry.isAudioClassName);
+}
+function assertNoAudioClassOnDetectionRule(rule) {
+	const audioClasses = audioClassesOnDetectionRule(rule);
+	if (audioClasses.length > 0) throw new NcDetectionAudioRefusal(audioClasses);
+}
+/** Run the check; a refusal is dropped work, so it is logged before it is rethrown. */
+function logRefusal(check, ctx) {
+	try {
+		check();
+	} catch (err) {
+		if (err instanceof NcDetectionAudioRefusal) warnRefusal(ctx.logger, err, ctx);
+		throw err;
+	}
+}
+function warnRefusal(logger, err, ctx) {
+	logger.warn("nc rule refused: a detection rule names sounds", { meta: {
+		...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
+		by: ctx.by,
+		audioClasses: err.audioClasses.join(", ")
+	} });
+}
+/** The create path of both routes. */
+function guardRuleDetectionAudio(rule, ctx) {
+	logRefusal(() => assertNoAudioClassOnDetectionRule(rule), ctx);
+}
+/**
+* The update path of both routes: the MERGED rule, only when the patch changes
+* it — and only the sounds the save ADDS. A legacy rule that already names a
+* sound stays editable (a threshold, a schedule, a zone); what is refused is
+* naming a new one.
+*/
+function guardPatchDetectionAudio(existing, patch, ctx) {
+	if (existing === null) return;
+	const merged = mergedFamilySubject(existing, patch);
+	if (merged === null) return;
+	const stored = new Set(audioClassesOnDetectionRule(existing).map(normalisedClass));
+	const added = audioClassesOnDetectionRule(merged).filter((name) => !stored.has(normalisedClass(name)));
+	if (added.length === 0) return;
+	logRefusal(() => {
+		throw new NcDetectionAudioRefusal(added);
+	}, ctx);
+}
+function normalisedClass(name) {
+	return name.trim().toLowerCase();
+}
+/**
+* The loader's half: every stored detection rule that names a sound is KEPT
+* (it loads and fires as it always did) and reported at WARN with its id —
+* once per rule per process, never on every reload tick. Returns the ids it
+* reported this time, for the caller's bookkeeping.
+*/
+function warnLegacyAudioClassRules(rules, alreadyWarned, logger) {
+	const reported = [];
+	for (const rule of rules) {
+		if (alreadyWarned.has(rule.id)) continue;
+		const audioClasses = audioClassesOnDetectionRule(rule);
+		if (audioClasses.length === 0) continue;
+		logger.warn("notification rule is a detection rule naming sounds — kept as it is; recreate it as a Sound rule", { meta: {
+			ruleId: rule.id,
+			name: rule.name,
+			audioClasses: audioClasses.join(", ")
+		} });
+		reported.push(rule.id);
+	}
+	return reported;
 }
 //#endregion
 //#region src/notification-center/occupancy-watcher.ts
@@ -17221,6 +17322,10 @@ function makeNcActionHandlers(deps) {
 				logger: deps.logger,
 				by: c.userId
 			});
+			guardRuleDetectionAudio(parsed, {
+				logger: deps.logger,
+				by: c.userId
+			});
 			guardRuleDevicesExclude(parsed, {
 				logger: deps.logger,
 				by: c.userId
@@ -17257,6 +17362,11 @@ function makeNcActionHandlers(deps) {
 				by: c.userId,
 				ruleId: input.ruleId
 			});
+			guardPatchDetectionAudio(existing, patch, {
+				logger: deps.logger,
+				by: c.userId,
+				ruleId: input.ruleId
+			});
 			guardPatchDevicesExclude(existing, patch, {
 				logger: deps.logger,
 				by: c.userId,
@@ -25420,6 +25530,8 @@ var NcRuleStore = class {
 	identityIdsByName;
 	/** Has a {@link load} ever completed? See the note there. */
 	loaded = false;
+	/** Legacy detection rules naming sounds already reported (D690) — once each. */
+	audioClassWarned = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.store = deps.store;
 		this.ledger = new DurableLedger({
@@ -25454,6 +25566,7 @@ var NcRuleStore = class {
 	async load() {
 		await this.ledger.load();
 		if (this.ledger.hasAnswered()) this.loaded = true;
+		for (const id of warnLegacyAudioClassRules(this.ledger.snapshot(), this.audioClassWarned, this.logger)) this.audioClassWarned.add(id);
 		this.logger.debug("notification rules loaded", { meta: { rules: this.ledger.size } });
 	}
 	/**
@@ -33685,6 +33798,10 @@ var NotificationCenter = class NotificationCenter {
 					logger: this.logger,
 					by: caller.userId
 				});
+				guardRuleDetectionAudio(rule, {
+					logger: this.logger,
+					by: caller.userId
+				});
 				guardRuleDevicesExclude(rule, {
 					logger: this.logger,
 					by: caller.userId
@@ -33716,6 +33833,11 @@ var NotificationCenter = class NotificationCenter {
 					by: caller.userId,
 					ruleId
 				});
+				guardPatchDetectionAudio(existing, patch, {
+					logger: this.logger,
+					by: caller.userId,
+					ruleId
+				});
 				guardPatchDevicesExclude(existing, patch, {
 					logger: this.logger,
 					by: caller.userId,
@@ -67320,6 +67442,22 @@ function messageOf(err) {
 function isDetailNotAttachedRefusal(err) {
 	return messageOf(err).includes(DETAIL_NOT_ATTACHED_MARKER);
 }
+/**
+* The runner's TYPED handle-expired refusal (D688): the frame handle a dispatch
+* named is past the native lease age bound, and the registry will refuse it on
+* every later ask. TWIN of `addon-pipeline/src/pipeline-runner/detail-park.ts`
+* `DETAIL_HANDLE_EXPIRED_MARKER` — keep the two identical.
+*
+* Why the dispatcher cares: unlike not-attached this is about ONE handle, not
+* the session — the parked frame still serves — but the handle itself is
+* finished. Naming it again (next tick, or through the native-strict crop rung)
+* can only be refused again; on the live fleet that was ~7 refusals per handle.
+*/
+var DETAIL_HANDLE_EXPIRED_MARKER = "runDetailSubtree-refused:handle-expired";
+/** Did this `runDetailSubtree` error carry the runner's handle-expired marker? */
+function isDetailHandleExpiredRefusal(err) {
+	return messageOf(err).includes(DETAIL_HANDLE_EXPIRED_MARKER);
+}
 //#endregion
 //#region src/pipeline-analytics/detail-scheduler.ts
 /** Default backoff/period when a step's cadence omits `minIntervalMs`. */
@@ -67776,6 +67914,7 @@ var TrackDetailDispatcher = class {
 			className: frame.className
 		};
 		const steps = composeDetailSteps(req, (trackId) => this.deps.hasTrackLabel?.(trackId) ?? false);
+		let handleRefused = false;
 		if (frame.frameHandle !== void 0) try {
 			const primary = await this.deps.runDetailSubtree({
 				deviceId,
@@ -67789,7 +67928,10 @@ var TrackDetailDispatcher = class {
 				this.warnNotAttachedThrottled(deviceId, dev, req);
 				return null;
 			}
-			this.deps.logger.debug("detail primary call failed — trying frame fallback", {
+			if (isDetailHandleExpiredRefusal(err)) {
+				handleRefused = true;
+				this.retireRefusedHandle(deviceId, dev, req, frame);
+			} else this.deps.logger.debug("detail primary call failed — trying frame fallback", {
 				tags: { deviceId },
 				meta: {
 					trackId: req.trackId,
@@ -67839,7 +67981,7 @@ var TrackDetailDispatcher = class {
 				}
 			});
 		}
-		if (this.deps.captureCropBase64 !== void 0) try {
+		if (this.deps.captureCropBase64 !== void 0 && frame.frameHandle !== void 0 && !handleRefused) try {
 			const cropJpeg = await this.deps.captureCropBase64(frame);
 			if (cropJpeg !== null) {
 				const retry = await this.deps.runDetailSubtree({
@@ -67868,6 +68010,35 @@ var TrackDetailDispatcher = class {
 		return null;
 	}
 	/**
+	* The runner refused `frame`'s handle as past the lease age bound (D688).
+	* That verdict is final for the handle, so the track's stored association
+	* loses it: later dispatches skip rung 1 and the native-strict crop rung
+	* (both would name the same handle and be refused again — ~7 times per
+	* handle on the live fleet) and go straight to the parked frame, until a
+	* newly OBSERVED frame brings a fresh handle via {@link onFrame}.
+	*
+	* Only the refused handle is dropped: if a newer frame replaced it while the
+	* dispatch was in flight, that one stands. The line is therefore emitted once
+	* per (track, handle) — a concurrent dispatch refused on the same handle
+	* finds it already gone and says nothing.
+	*/
+	retireRefusedHandle(deviceId, dev, req, frame) {
+		const current = dev.tracks.get(req.trackId);
+		if (current === void 0 || current.frameHandle !== frame.frameHandle) return;
+		const { frameHandle: refused, ...withoutHandle } = current;
+		dev.tracks.set(req.trackId, withoutHandle);
+		this.deps.logger.info("detail dispatch: frame handle refused as expired — retired for this track, parked frame only until a fresh observation", {
+			tags: { deviceId },
+			meta: {
+				trackId: req.trackId,
+				stepId: req.stepId,
+				reason: "handle-expired",
+				handle: refused === void 0 ? null : `${refused.shmId}#${refused.slot}#${refused.seq}`,
+				parkedFrameRung: this.deps.captureParkedFrame !== void 0
+			}
+		});
+	}
+	/**
 	* The typed refusal is EXPECTED for a track that outlives the runner's
 	* detail park grace (a closing track's last dispatches), so it logs its own
 	* line — the reason is knowable, unlike the every-rung-missed warn — and