@camstack/addon-post-analysis 1.2.18 → 1.2.20

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-CjwPOJKc.js");
+const require_dist = require("../dist-vIJhE1KT.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
@@ -1441,6 +1441,94 @@ function resolveDetectionLabel(input) {
 	if (top) return top;
 	return input.originalClass && input.originalClass !== input.className ? input.originalClass : void 0;
 }
+var DEFAULT_ZONE_TRANSITION_CONFIG = {
+	enterFrames: 2,
+	exitFrames: 4
+};
+var NO_TRANSITIONS = {
+	entered: [],
+	exited: []
+};
+function newState() {
+	return {
+		inside: /* @__PURE__ */ new Set(),
+		enterStreak: /* @__PURE__ */ new Map(),
+		exitStreak: /* @__PURE__ */ new Map()
+	};
+}
+var ZoneTransitionTracker = class {
+	config;
+	tracks = /* @__PURE__ */ new Map();
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_ZONE_TRANSITION_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Feed one frame's zone membership for one track.
+	*
+	* `currentZoneIds` is the set the geometry says the box is in RIGHT NOW; the
+	* return value is only what has persisted long enough to be believed.
+	*/
+	observe(trackId, currentZoneIds) {
+		const state = this.tracks.get(trackId) ?? newState();
+		this.tracks.set(trackId, state);
+		const now = new Set(currentZoneIds);
+		const entered = [];
+		const exited = [];
+		for (const zoneId of now) {
+			if (state.inside.has(zoneId)) {
+				state.exitStreak.delete(zoneId);
+				continue;
+			}
+			const streak = (state.enterStreak.get(zoneId) ?? 0) + 1;
+			if (streak >= this.config.enterFrames) {
+				state.enterStreak.delete(zoneId);
+				state.inside.add(zoneId);
+				entered.push(zoneId);
+			} else state.enterStreak.set(zoneId, streak);
+		}
+		for (const zoneId of [...state.enterStreak.keys()]) if (!now.has(zoneId)) state.enterStreak.delete(zoneId);
+		for (const zoneId of [...state.inside]) {
+			if (now.has(zoneId)) continue;
+			const streak = (state.exitStreak.get(zoneId) ?? 0) + 1;
+			if (streak >= this.config.exitFrames) {
+				state.exitStreak.delete(zoneId);
+				state.inside.delete(zoneId);
+				exited.push(zoneId);
+			} else state.exitStreak.set(zoneId, streak);
+		}
+		if (entered.length === 0 && exited.length === 0) return NO_TRANSITIONS;
+		return {
+			entered,
+			exited
+		};
+	}
+	/** Zones a track is currently confirmed to be inside. */
+	zonesFor(trackId) {
+		const state = this.tracks.get(trackId);
+		return state ? [...state.inside] : [];
+	}
+	/**
+	* Drop a track and report the zones it was still inside.
+	*
+	* The caller uses these to close the subject's presence — a track that
+	* disappears mid-zone has genuinely left it, and nothing else will ever say
+	* so. Without this, a zone entry would have no matching exit whenever the
+	* subject walked out of frame rather than out of the zone.
+	*/
+	forget(trackId) {
+		const state = this.tracks.get(trackId);
+		if (!state) return [];
+		this.tracks.delete(trackId);
+		return [...state.inside];
+	}
+	/** Number of tracks held — a leak check for the caller's tests. */
+	size() {
+		return this.tracks.size;
+	}
+};
 //#endregion
 //#region src/pipeline-analytics/pipeline/zones/geometry.ts
 /** Ray-casting point-in-polygon test */
@@ -2302,22 +2390,48 @@ function resolveRuleThreshold(rule) {
 */
 var ZoneEngine = class {
 	/**
-	* Annotate a single detection with its zone memberships.
-	* Returns zones where the detection overlaps above any active
-	* rule's threshold (or the engine default if no rule sets one).
+	* Annotate a single detection with its zone memberships — every zone whose
+	* polygon the detection overlaps by MORE than `minOverlap` (0–1 fraction of
+	* the detection's own area).
+	*
+	* The previous version of this comment claimed memberships were returned
+	* "above any active rule's threshold"; they were not — the threshold was
+	* hardcoded to {@link MEMBERSHIP_MIN_OVERLAP} (zero) and no rule was ever
+	* consulted. Read the parameter, not this paragraph.
+	*
+	* `minOverlap` matters because membership is what lands on an event as
+	* `zones`, and a notification rule's `zones` condition is a plain set test
+	* over that field — so this, not the zone-RULE threshold, is what decides
+	* whether a zone-scoped notification fires. At the default of 0 a subject
+	* clipping a zone by one pixel counts as inside it (measured 2026-07-30: a
+	* dog overlapping `Aiuola` by 4.8% would have been stamped as in it).
 	*/
-	annotateDetection(bbox, zones, frameWidth, frameHeight, mask, maskWidth, maskHeight) {
+	annotateDetection(bbox, zones, frameWidth, frameHeight, mask, maskWidth, maskHeight, minOverlap = MEMBERSHIP_MIN_OVERLAP) {
+		return [...this.splitDetectionZones(bbox, zones, frameWidth, frameHeight, mask, maskWidth, maskHeight, minOverlap).memberships];
+	}
+	/**
+	* {@link annotateDetection}, keeping the zones the bar REJECTED as well as
+	* the ones it admitted. Same geometry, one pass — see
+	* {@link ZoneMembershipSplit} for why the rejected side has to survive.
+	*/
+	splitDetectionZones(bbox, zones, frameWidth, frameHeight, mask, maskWidth, maskHeight, minOverlap = MEMBERSHIP_MIN_OVERLAP) {
 		const memberships = [];
+		const belowBar = [];
 		for (const zone of zones) {
 			const pixelPolygon = zone.polygon.map((p) => normalizeToPixel(p, frameWidth, frameHeight));
 			const overlap = mask && maskWidth && maskHeight ? maskPolygonOverlap(mask, maskWidth, maskHeight, bbox, pixelPolygon, frameWidth, frameHeight) : bboxPolygonOverlap(bbox, pixelPolygon);
-			if (overlap > MEMBERSHIP_MIN_OVERLAP) memberships.push({
+			const entry = {
 				zoneId: zone.id,
 				zoneName: zone.name,
 				overlap
-			});
+			};
+			if (overlap > minOverlap) memberships.push(entry);
+			else if (overlap > 0) belowBar.push(entry);
 		}
-		return memberships;
+		return {
+			memberships,
+			belowBar
+		};
 	}
 	/**
 	* Filter detections through a zone-rule set. `zones` provides the
@@ -2378,6 +2492,66 @@ function ruleApplies(resolved, det, className, maskInfo, _zones, frameWidth, fra
 	return false;
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/rider-pairing.ts
+/**
+* Fine classes that carry a rider. A scooter/moped reaches us as
+* `motorcycle` (COCO) or `motorbike` depending on the model's label set.
+*/
+var TWO_WHEELERS = new Set([
+	"bicycle",
+	"motorcycle",
+	"motorbike"
+]);
+/** Intersection area of two boxes. */
+function intersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+}
+/** True when `vehicle` is a two-wheeler that `person` is riding. */
+function isRiderPair(person, vehicle) {
+	if (person.macroClass !== "person") return false;
+	if (vehicle.macroClass !== "vehicle") return false;
+	if (!TWO_WHEELERS.has((vehicle.originalClass ?? "").toLowerCase())) return false;
+	const personArea = person.bbox.w * person.bbox.h;
+	if (!(personArea > 0)) return false;
+	if (intersection(person.bbox, vehicle.bbox) / personArea < .25) return false;
+	return person.bbox.y + person.bbox.h / 2 < vehicle.bbox.y + vehicle.bbox.h / 2;
+}
+/**
+* Pair every rider with their machine. A person is paired at most once — with
+* the two-wheeler they overlap MOST — so two bikes side by side cannot both
+* claim the same rider.
+*/
+function pairRiders(detections) {
+	const people = detections.filter((d) => d.macroClass === "person");
+	const twoWheelers = detections.filter((d) => d.macroClass === "vehicle" && TWO_WHEELERS.has((d.originalClass ?? "").toLowerCase()));
+	if (people.length === 0 || twoWheelers.length === 0) return [];
+	const pairs = [];
+	const claimed = /* @__PURE__ */ new Set();
+	for (const person of people) {
+		let best = null;
+		const personArea = person.bbox.w * person.bbox.h;
+		if (!(personArea > 0)) continue;
+		for (const vehicle of twoWheelers) {
+			if (claimed.has(vehicle.id)) continue;
+			if (!isRiderPair(person, vehicle)) continue;
+			const overlap = intersection(person.bbox, vehicle.bbox) / personArea;
+			if (!best || overlap > best.overlap) best = {
+				vehicle,
+				overlap
+			};
+		}
+		if (best) {
+			claimed.add(best.vehicle.id);
+			pairs.push({
+				personId: person.id,
+				vehicleId: best.vehicle.id,
+				overlap: Math.round(best.overlap * 1e3) / 1e3
+			});
+		}
+	}
+	return pairs;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/frame-processor.ts
 /** Mapping from StateAnalyzer's `ObjectState.state` values to the
 *  canonical TrackState enum used on tracks + events. */
@@ -2411,6 +2585,21 @@ var FrameProcessor = class {
 	* runners that haven't picked up the new gating yet.
 	*/
 	detectionRules;
+	/** See {@link setZoneMembershipMinOverlap}. 0 = any positive overlap. */
+	zoneMembershipMinOverlap;
+	/** See {@link getLastZoneOverlaps}. */
+	lastZoneOverlaps;
+	/** See {@link getLastZoneRejections}. */
+	lastZoneRejections;
+	/** Zone crossings per track — the producer of `zone.enter` / `zone.exit`. */
+	zoneTransitions = new ZoneTransitionTracker();
+	/**
+	* Last zone membership seen per track, so an event for a track that is GONE
+	* this frame still carries the zones it was in. See the use site.
+	*/
+	lastZonesByTrack = /* @__PURE__ */ new Map();
+	/** See {@link getLastRiderPairs}. */
+	lastRiderPairs = [];
 	zoneEngine = new ZoneEngine();
 	/** Optional stationary-object gate (parked-object suppression). Null until
 	*  the addon wires it via {@link setStationaryGate}. */
@@ -2423,10 +2612,46 @@ var FrameProcessor = class {
 		this.eventEmitter = new DetectionEventEmitter(emitterConfig);
 		this.zones = [];
 		this.detectionRules = [];
+		this.zoneMembershipMinOverlap = 0;
+		this.lastZoneOverlaps = /* @__PURE__ */ new Map();
+		this.lastZoneRejections = /* @__PURE__ */ new Map();
 	}
 	setZones(zones) {
 		this.zones = zones;
 	}
+	/**
+	* How much of a detection's box must lie inside a zone for the zone to be
+	* stamped onto it (0–1 fraction of the box's own area).
+	*
+	* DEFAULT 0 — byte-identical to the behaviour before 2026-07-31, where any
+	* positive overlap counted. Raising it is an operator decision and needs
+	* evidence: a bar set blind removes notifications silently, which is the
+	* failure mode this whole area keeps producing. {@link lastZoneOverlaps}
+	* exists so the distribution can be read before a number is picked.
+	*/
+	setZoneMembershipMinOverlap(minOverlap) {
+		this.zoneMembershipMinOverlap = Number.isFinite(minOverlap) && minOverlap >= 0 && minOverlap <= 1 ? minOverlap : 0;
+	}
+	/** Rider pairings folded on the most recent frame — the PERSON half that was
+	*  dropped so the passage counts once, as a vehicle. Reported so both
+	*  entities stay on the record rather than one silently disappearing. */
+	getLastRiderPairs() {
+		return this.lastRiderPairs;
+	}
+	/** Per-track zone memberships WITH their overlap fractions, from the most
+	*  recent frame. The engine computes these and the pipeline previously
+	*  discarded everything but the ids — which is why no amount of production
+	*  data could say how far inside the zone a notifying subject actually was. */
+	getLastZoneOverlaps() {
+		return this.lastZoneOverlaps;
+	}
+	/** Per-track zones the membership bar REJECTED (0 < overlap ≤ the bar), from
+	*  the most recent frame. Raising the bar otherwise makes the stamping log go
+	*  quiet for exactly the cases it was armed to measure — see
+	*  `ZoneMembershipSplit` in `zones/zone-engine.ts`. */
+	getLastZoneRejections() {
+		return this.lastZoneRejections;
+	}
 	setDetectionRules(rules) {
 		this.detectionRules = rules;
 	}
@@ -2519,7 +2744,24 @@ var FrameProcessor = class {
 			});
 		}
 		const { passed } = this.zoneEngine.filterDetections(flatDetections, this.zones, this.detectionRules, frameWidth, frameHeight, (fd) => fd.detection.class);
-		const filteredDetections = passed.map((fd) => fd.detection);
+		let filteredDetections = passed.map((fd) => fd.detection);
+		const riderPairs = pairRiders(filteredDetections.map((d, i) => ({
+			id: String(i),
+			macroClass: d.class,
+			...d.originalClass !== void 0 ? { originalClass: d.originalClass } : {},
+			bbox: d.bbox,
+			score: d.score
+		})));
+		if (riderPairs.length > 0) {
+			const riderIdx = new Set(riderPairs.map((p) => Number(p.personId)));
+			this.lastRiderPairs = riderPairs.map((p) => ({
+				overlap: p.overlap,
+				personScore: filteredDetections[Number(p.personId)]?.score ?? 0,
+				vehicleScore: filteredDetections[Number(p.vehicleId)]?.score ?? 0,
+				vehicleClass: filteredDetections[Number(p.vehicleId)]?.originalClass ?? "two-wheeler"
+			}));
+			filteredDetections = filteredDetections.filter((_, i) => !riderIdx.has(i));
+		} else if (this.lastRiderPairs.length > 0) this.lastRiderPairs = [];
 		const gate = this.stationaryGate ? this.stationaryGate.filter({
 			detections: filteredDetections,
 			frameWidth,
@@ -2535,12 +2777,46 @@ var FrameProcessor = class {
 			frameHeight
 		});
 		const objectStates = this.stateAnalyzer.analyze(trackedDetections, timestamp);
-		const rawEvents = this.eventEmitter.emit(trackedDetections, objectStates, [], [], String(this.deviceId));
 		const zonesByTrack = /* @__PURE__ */ new Map();
+		const overlapsByTrack = /* @__PURE__ */ new Map();
+		const rejectedByTrack = /* @__PURE__ */ new Map();
 		for (const td of trackedDetections) {
 			const m = maskByBbox.get(td.bbox);
-			const memberships = this.zoneEngine.annotateDetection(td.bbox, this.zones, frameWidth, frameHeight, m?.mask, m?.width, m?.height);
+			const { memberships, belowBar } = this.zoneEngine.splitDetectionZones(td.bbox, this.zones, frameWidth, frameHeight, m?.mask, m?.width, m?.height, this.zoneMembershipMinOverlap);
 			zonesByTrack.set(td.trackId, memberships.map((m2) => m2.zoneId));
+			if (memberships.length > 0) overlapsByTrack.set(td.trackId, memberships);
+			if (belowBar.length > 0) rejectedByTrack.set(td.trackId, belowBar);
+		}
+		this.lastZoneOverlaps = overlapsByTrack;
+		this.lastZoneRejections = rejectedByTrack;
+		for (const [trackId, zoneIds] of zonesByTrack) this.lastZonesByTrack.set(trackId, zoneIds);
+		for (const state of objectStates) {
+			if (zonesByTrack.has(state.trackId)) continue;
+			const remembered = this.lastZonesByTrack.get(state.trackId);
+			if (remembered && remembered.length > 0) zonesByTrack.set(state.trackId, remembered);
+		}
+		const zoneEvents = [];
+		const pushZoneEvent = (type, zoneId, detection) => {
+			const zone = this.zones.find((z) => z.id === zoneId);
+			zoneEvents.push({
+				type,
+				zoneId,
+				zoneName: zone?.name ?? zoneId,
+				trackId: detection.trackId,
+				detection,
+				timestamp
+			});
+		};
+		for (const td of trackedDetections) {
+			const crossings = this.zoneTransitions.observe(td.trackId, zonesByTrack.get(td.trackId) ?? []);
+			for (const zoneId of crossings.entered) pushZoneEvent("zone-enter", zoneId, td);
+			for (const zoneId of crossings.exited) pushZoneEvent("zone-exit", zoneId, td);
+		}
+		const rawEvents = this.eventEmitter.emit(trackedDetections, objectStates, zoneEvents, [], String(this.deviceId));
+		for (const state of objectStates) {
+			if (state.state !== "leaving") continue;
+			this.zoneTransitions.forget(state.trackId);
+			this.lastZonesByTrack.delete(state.trackId);
 		}
 		const tracked = trackedDetections.map((td) => {
 			const state = mapObjectStateToTrackState(objectStates.find((o) => o.trackId === td.trackId)?.state);
@@ -2579,10 +2855,22 @@ var FrameProcessor = class {
 				} : {}
 			};
 		});
+		const crossingOf = (e) => {
+			const direction = e.type === "zone.enter" ? "enter" : e.type === "zone.exit" ? "exit" : void 0;
+			if (direction === void 0) return void 0;
+			const ze = e.zoneEvents[0];
+			if (ze === void 0) return void 0;
+			return {
+				direction,
+				zoneId: ze.zoneId,
+				zoneName: ze.zoneName
+			};
+		};
 		const toObjectEvent = (e, forcedState) => {
 			const td = trackedDetections.find((t) => t.trackId === e.detection.trackId);
 			const state = forcedState ?? mapObjectStateToTrackState(objectStates.find((o) => o.trackId === e.detection.trackId)?.state);
 			const zones = zonesByTrack.get(e.detection.trackId) ?? [];
+			const crossing = crossingOf(e);
 			const label = td ? resolveDetectionLabel({
 				className: td.class,
 				originalClass: td.originalClass,
@@ -2606,6 +2894,7 @@ var FrameProcessor = class {
 				},
 				zones,
 				state,
+				...crossing !== void 0 ? { zoneCrossing: crossing } : {},
 				...label ? { label } : {},
 				frameWidth,
 				frameHeight
@@ -3504,7 +3793,8 @@ var DEFAULT_ZERO_MEDIA_POLICY_CONFIG = {
 * for the full contract.
 */
 function decideZeroMediaPolicy(input, config = DEFAULT_ZERO_MEDIA_POLICY_CONFIG) {
-	if (input.hasMedia) return "persist";
+	if (input.hasBestMedia) return "persist";
+	if (input.hasMedia) return input.hasRasterFallback ? "raster-fallback" : "persist";
 	if (input.durationMs < config.suppressMaxDurationMs && !input.confirmed) return "suppress";
 	if (!input.hasRasterFallback && input.durationMs < config.nothingToShowMaxDurationMs) return "suppress";
 	return input.hasRasterFallback ? "raster-fallback" : "persist";
@@ -3698,9 +3988,11 @@ var TrackCloser = class {
 		const duration = t.lastSeen - t.firstSeen;
 		const closure = this.deps.residents.closure(t.trackId);
 		const ownedMedia = await this.deps.mediaStore()?.listByOwner("track", t.trackId) ?? [];
+		const hasBestMedia = ownedMedia.some((m) => m.kind === "thumbnail" || m.kind === "keyFrame");
 		const outcome = decideZeroMediaPolicy({
 			durationMs: duration,
 			hasMedia: ownedMedia.length > 0,
+			hasBestMedia,
 			confirmed: closure?.confirmed ?? false,
 			hasRasterFallback: closure?.rasterFallback !== void 0
 		});
@@ -4042,6 +4334,7 @@ function subjectFromObjectEvent(ev) {
 		...ev.trackId !== void 0 ? { trackId: ev.trackId } : {},
 		source: ev.source ?? "pipeline",
 		...ev.importance !== void 0 ? { importance: ev.importance } : {},
+		...ev.zoneCrossing !== void 0 ? { crossing: ev.zoneCrossing } : {},
 		...bboxPatch(normalizeBbox(ev.bbox, ev.frameWidth, ev.frameHeight))
 	};
 }
@@ -4208,6 +4501,7 @@ function presentConditionIds(c) {
 	if (c.minDwellSeconds !== void 0) ids.push("minDwellSeconds");
 	if (c.zones !== void 0) ids.push("zones");
 	if (c.zonesExclude !== void 0 && c.zonesExclude.length > 0) ids.push("zonesExclude");
+	if (c.crossing !== void 0 && c.crossing !== "enter") ids.push("crossing");
 	if (c.labelEquals !== void 0 && c.labelEquals.length > 0) ids.push("labelEquals");
 	if (c.identities !== void 0 && c.identities.length > 0) ids.push("identities");
 	if (c.identitiesExclude !== void 0 && c.identitiesExclude.length > 0) ids.push("identitiesExclude");
@@ -4243,6 +4537,21 @@ function matchesOccupancy(occ, s) {
 		case "<=": return s.occupied === false && s.threshold === occ.count + 1;
 	}
 }
+/**
+* The zone ids a `zones` / `zonesExclude` condition tests against: the
+* record's membership PLUS the zone it crossed, when it is a crossing.
+*
+* The union is what makes an EXIT addressable. Membership is computed from the
+* box's current geometry, so on the frame an exit is confirmed the subject is
+* by definition no longer in the zone — a rule scoped to "Uscio" would never
+* see the exit from Uscio. An ENTRY's zone is already in the membership, so
+* this changes nothing for every rule that exists today.
+*/
+function zonesVisitedBy(subject) {
+	const visited = new Set(subject.zones);
+	if (subject.crossing !== void 0) visited.add(subject.crossing.zoneId);
+	return visited;
+}
 function toLowerSet(values) {
 	return new Set(values.map((v) => v.trim().toLowerCase()));
 }
@@ -4328,14 +4637,20 @@ function evaluateRule(rule, subject) {
 	if (c.minDwellSeconds !== void 0) {
 		if (subject.dwellSeconds === void 0 || subject.dwellSeconds < c.minDwellSeconds) return fail("minDwellSeconds");
 	}
+	if (c.crossing !== "any") {
+		const direction = subject.crossing?.direction;
+		if (c.crossing === "exit") {
+			if (direction !== "exit") return fail("crossing");
+		} else if (direction === "exit") return fail("crossing");
+	}
 	if (c.zones !== void 0) {
-		const visited = new Set(subject.zones);
+		const visited = zonesVisitedBy(subject);
 		if (c.zones.match === "all") {
 			for (const id of c.zones.ids) if (!visited.has(id)) return fail("zones");
 		} else if (!c.zones.ids.some((id) => visited.has(id))) return fail("zones");
 	}
 	if (c.zonesExclude !== void 0 && c.zonesExclude.length > 0) {
-		const visited = new Set(subject.zones);
+		const visited = zonesVisitedBy(subject);
 		if (c.zonesExclude.some((id) => visited.has(id))) return fail("zonesExclude");
 	}
 	if (c.customZones !== void 0 && c.customZones.length > 0) {
@@ -4464,10 +4779,28 @@ function matchesPlate(label, values, maxDistance) {
 	for (const v of values) if (levenshtein(plate, normalizePlate(v)) <= maxDistance) return true;
 	return false;
 }
-/** Stable cooldown key per the rule's throttle scope. */
+/**
+* Should this subject's class be part of the cooldown key?
+*
+* AUDIO is unconditional and predates the setting: a rule opted into several
+* audio classes (dog + scream) must not have a safety-relevant scream
+* swallowed by an unrelated bark's 60 s window.
+*
+* Every other subject gets the same treatment only when the rule ASKS for it
+* (`granularity: 'per-class'`) — cat→dog fires at once, cat→cat still waits.
+* Absent / `shared` reproduces the class-agnostic key byte for byte, because
+* changing how often an operator's existing rules fire is not a side effect
+* anyone asked for.
+*/
+function keysPerClass(rule, subject) {
+	if (subject.kind === "audio-event") return true;
+	return rule.throttle.granularity === "per-class";
+}
+/** Stable cooldown key per the rule's throttle scope + class granularity. */
 function cooldownKey(rule, subject) {
-	const audioClass = subject.kind === "audio-event" && subject.classNames[0] !== void 0 ? `:c:${subject.classNames[0]}` : "";
-	return rule.throttle.scope === "rule" ? `r:${rule.id}${audioClass}` : `r:${rule.id}:d:${subject.deviceId}${audioClass}`;
+	const first = subject.classNames[0];
+	const classKey = keysPerClass(rule, subject) && first !== void 0 ? `:c:${first}` : "";
+	return rule.throttle.scope === "rule" ? `r:${rule.id}${classKey}` : `r:${rule.id}:d:${subject.deviceId}${classKey}`;
 }
 /** True when the rule fired within its cooldown window before `now`. */
 function isCoolingDown(rule, lastFiredAt, now) {
@@ -4635,7 +4968,9 @@ var NcDispatcher = class {
 					ruleId: entry.ruleId,
 					target: target.name,
 					kind: target.kind,
-					recordKind: entry.recordKind
+					recordKind: entry.recordKind,
+					eventId: entry.recordId,
+					...entry.trackId !== void 0 ? { trackId: entry.trackId } : {}
 				}
 			});
 			return { ok: true };
@@ -4673,9 +5008,10 @@ var NcDispatcher = class {
 	async buildNotification(entry) {
 		const subject = entry.payload.subject;
 		const deviceName = await this.deps.getDeviceName(subject.deviceId).catch(() => null) ?? `camera ${subject.deviceId}`;
-		const vars = buildTemplateVars(entry, deviceName);
+		const zoneLabels = await resolveZoneLabels(this.deps.getZoneNames, subject.deviceId, subject.zones);
+		const vars = buildTemplateVars(entry, deviceName, zoneLabels);
 		const title = renderTemplate(entry.payload.template?.title, vars) ?? entry.payload.ruleName;
-		const body = renderTemplate(entry.payload.template?.body, vars) ?? defaultBody(entry, deviceName);
+		const body = renderTemplate(entry.payload.template?.body, vars) ?? defaultBody(entry, deviceName, zoneLabels);
 		const attachments = await this.withArtifactUrls(await this.resolveAttachments(entry));
 		const params = pickParams(entry.payload.params);
 		return {
@@ -4874,15 +5210,37 @@ var NcDispatcher = class {
 		return null;
 	}
 };
-function buildTemplateVars(entry, deviceName) {
+/**
+* Map admin zone IDs to their display names for rendering only.
+*
+* Order follows `zoneIds` (the order the track visited them), not the zone
+* catalog. Every failure mode degrades to the ID rather than dropping the
+* zone: an unknown id, a blank name, a throwing lookup, or no lookup wired at
+* all. A body that silently loses a zone is worse than one that shows a UUID.
+*/
+async function resolveZoneLabels(getZoneNames, deviceId, zoneIds) {
+	if (zoneIds.length === 0) return [];
+	if (getZoneNames === void 0) return [...zoneIds];
+	try {
+		const zones = await getZoneNames(deviceId);
+		const byId = new Map(zones.map((z) => [z.id, z.name]));
+		return zoneIds.map((id) => {
+			const name = byId.get(id);
+			return name !== void 0 && name.trim().length > 0 ? name : id;
+		});
+	} catch {
+		return [...zoneIds];
+	}
+}
+function buildTemplateVars(entry, deviceName, zoneLabels) {
 	const subject = entry.payload.subject;
 	const occupancy = subject.occupancy;
 	return {
 		camera: deviceName,
 		class: subject.className,
 		label: subject.label ?? "",
-		zones: subject.zones.join(", "),
-		zone: occupancy?.zone ?? subject.zones[0] ?? "",
+		zones: zoneLabels.join(", "),
+		zone: occupancy?.zone ?? zoneLabels[0] ?? "",
 		confidence: subject.confidence !== void 0 ? `${Math.round(subject.confidence * 100)}%` : "",
 		time: new Date(subject.timestamp).toLocaleTimeString(),
 		rule: entry.payload.ruleName,
@@ -4900,12 +5258,12 @@ function renderTemplate(template, vars) {
 	if (template === void 0 || template.trim().length === 0) return null;
 	return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_m, name) => vars[name] ?? "");
 }
-function defaultBody(entry, deviceName) {
+function defaultBody(entry, deviceName, zoneLabels) {
 	const subject = entry.payload.subject;
 	const occupancy = subject.occupancy;
 	if (occupancy !== void 0) return `${occupancy.zone ?? deviceName} ${occupancyOpWord(occupancy.occupied)} (${occupancy.count}/${occupancy.capacity})`;
 	const label = subject.label !== void 0 ? ` (${subject.label})` : "";
-	const zones = subject.zones.length > 0 ? ` in ${subject.zones.join(", ")}` : "";
+	const zones = zoneLabels.length > 0 ? ` in ${zoneLabels.join(", ")}` : "";
 	const suffix = entry.recordKind === "track-end" ? " — visit ended" : "";
 	return `${subject.className}${label} on ${deviceName}${zones}${suffix}`;
 }
@@ -6232,6 +6590,13 @@ var TimelapseStore = class {
 };
 //#endregion
 //#region src/notification-center/index.ts
+/**
+* How often the "matched NO rule" report may fire per device. Long enough that
+* a busy camera prints one line rather than one per event, short enough that a
+* rule which has stopped matching is visible within minutes rather than by
+* comparison with another system fifteen hours later.
+*/
+var NO_MATCH_REPORT_INTERVAL_MS = 6e4;
 var DEFAULT_DRAIN_INTERVAL_MS = 2e3;
 var DEFAULT_RULE_RELOAD_INTERVAL_MS = 3e4;
 var DEFAULT_RECONCILE_WINDOW_MS = 15 * 6e4;
@@ -6342,6 +6707,9 @@ var NotificationCenter = class NotificationCenter {
 	occupancyEnabled = false;
 	/** In-memory cooldown map — seeded from persisted outbox rows on start. */
 	lastFiredAt = /* @__PURE__ */ new Map();
+	/** Per-device rate limit for the "matched NO rule" report — see `reportNoMatch`. */
+	lastNoMatchReportAt = /* @__PURE__ */ new Map();
+	noMatchSuppressed = /* @__PURE__ */ new Map();
 	/**
 	* Serialized evaluation chain. The persist hooks are fire-and-forget for
 	* the frame path, but two concurrent evaluations of the same device
@@ -6673,9 +7041,12 @@ var NotificationCenter = class NotificationCenter {
 			return;
 		}
 		const now = this.now();
+		let anyMatched = false;
+		const rejections = [];
 		for (const rule of candidates) {
 			const evaluation = evaluateRule(rule, subject);
 			if (!evaluation.matched) {
+				rejections.push(`${rule.name}:${evaluation.failedCondition ?? "unknown"}`);
 				this.logger.debug("rule did not match", {
 					tags: { deviceId: subject.deviceId },
 					meta: {
@@ -6683,7 +7054,9 @@ var NotificationCenter = class NotificationCenter {
 						rule: rule.name,
 						kind,
 						failed: evaluation.failedCondition,
-						classes: subject.classNames
+						classes: subject.classNames,
+						eventId: subject.recordId,
+						...subject.trackId !== void 0 ? { trackId: subject.trackId } : {}
 					}
 				});
 				continue;
@@ -6695,7 +7068,9 @@ var NotificationCenter = class NotificationCenter {
 					meta: {
 						ruleId: rule.id,
 						rule: rule.name,
-						key
+						key,
+						eventId: subject.recordId,
+						...subject.trackId !== void 0 ? { trackId: subject.trackId } : {}
 					}
 				});
 				continue;
@@ -6706,12 +7081,42 @@ var NotificationCenter = class NotificationCenter {
 					ruleId: rule.id,
 					rule: rule.name,
 					kind,
-					targets: rule.targets.length
+					targets: rule.targets.length,
+					eventId: subject.recordId,
+					...subject.trackId !== void 0 ? { trackId: subject.trackId } : {},
+					...subject.confidence !== void 0 ? { confidence: subject.confidence } : {},
+					...subject.zones.length > 0 ? { zones: subject.zones } : {}
 				}
 			});
 			const userTargets = await this.resolveUserTargets(rule, subject.deviceId);
 			if (await this.outbox.enqueue(this.buildEntries(rule, subject, kind, evaluation.matchedOn, userTargets)) > 0) this.lastFiredAt.set(key, now);
+			anyMatched = true;
 		}
+		if (!anyMatched && rejections.length > 0) this.reportNoMatch(subject, kind, rejections, now);
+	}
+	/** See the call site. Bounded to one line per device per window. */
+	reportNoMatch(subject, kind, rejections, now) {
+		const last = this.lastNoMatchReportAt.get(subject.deviceId) ?? 0;
+		const suppressed = this.noMatchSuppressed.get(subject.deviceId) ?? 0;
+		if (now - last < NO_MATCH_REPORT_INTERVAL_MS) {
+			this.noMatchSuppressed.set(subject.deviceId, suppressed + 1);
+			return;
+		}
+		this.lastNoMatchReportAt.set(subject.deviceId, now);
+		this.noMatchSuppressed.set(subject.deviceId, 0);
+		this.logger.info("event matched NO rule", {
+			tags: { deviceId: subject.deviceId },
+			meta: {
+				kind,
+				rejectedBy: rejections,
+				classes: subject.classNames,
+				...subject.confidence !== void 0 ? { confidence: subject.confidence } : {},
+				...subject.zones.length > 0 ? { zones: subject.zones } : { zones: [] },
+				eventId: subject.recordId,
+				...subject.trackId !== void 0 ? { trackId: subject.trackId } : {},
+				...suppressed > 0 ? { alsoSuppressedSinceLastReport: suppressed } : {}
+			}
+		});
 	}
 	buildEntries(rule, subject, kind, matchedOn, userTargets = []) {
 		const hasEventMedia = kind === "object-event" || kind === "package-event";
@@ -7806,6 +8211,63 @@ function classifyTrackAppearance(input) {
 	return input.positionsCount > 1 ? "resurrection" : "birth";
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/suppressed-births.ts
+/**
+* Memory of births the confirmation gate rejected, per device.
+*
+* The gate runs AFTER the TrackStore upsert, and it has to: the upsert's
+* position count is what distinguishes a true birth from a tracker
+* resurrection. So a rejected birth has already been written by the time the
+* verdict exists. It correctly gets no `start`, no media and no notification —
+* but the record stayed, and surfaced in `listRecentTracks`. On 2026-07-31 six
+* full-frame phantoms on device 615 in nine minutes were every one of them
+* suppressed AND listed.
+*
+* Retracting once is not enough. The tracker keeps carrying a rejected id for
+* as long as the phantom persists — 27 seconds in the worst measured case — and
+* every later frame would write it straight back. So the rejection is
+* remembered until the id stops being tracked, and only then forgotten.
+*
+* Kept as its own module because the state is the part with real risk: forget
+* too early and the phantom returns, never forget and a camera producing
+* phantoms continuously grows this set for the process's lifetime.
+*/
+var SuppressedBirthRegistry = class {
+	byDevice = /* @__PURE__ */ new Map();
+	/** Record that this birth was rejected; later frames must not re-upsert it. */
+	reject(deviceKey, trackId) {
+		let ids = this.byDevice.get(deviceKey);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			this.byDevice.set(deviceKey, ids);
+		}
+		ids.add(trackId);
+	}
+	isRejected(deviceKey, trackId) {
+		return this.byDevice.get(deviceKey)?.has(trackId) === true;
+	}
+	/**
+	* Forget every rejected id the tracker is no longer carrying.
+	*
+	* Called once per frame with the ids present THIS frame. An id absent from
+	* that set can never be upserted again, so holding it serves nothing.
+	*/
+	retain(deviceKey, currentTrackIds) {
+		const ids = this.byDevice.get(deviceKey);
+		if (!ids) return;
+		for (const id of ids) if (!currentTrackIds.has(id)) ids.delete(id);
+		if (ids.size === 0) this.byDevice.delete(deviceKey);
+	}
+	/** Rejected ids currently held for a device — diagnostics and tests. */
+	size(deviceKey) {
+		return this.byDevice.get(deviceKey)?.size ?? 0;
+	}
+	/** Drop a device's memory wholesale (device removed / pipeline reset). */
+	clearDevice(deviceKey) {
+		this.byDevice.delete(deviceKey);
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/pipeline/key-event-query.ts
 async function rankKeyEvents(candidates, options, peakLookup) {
 	const scored = [];
@@ -8310,9 +8772,9 @@ async function extractCrop(frameData, frameWidth, frameHeight, bbox) {
 * padding === 0 is the identity operation. Pure, immutable — always returns a
 * new object.
 *
-* NOTE: clamping is single-sided — when the box hugs an edge, the origin is
-* clamped to 0/keeps the full padded extent against the opposite bound, so the
-* crop can extend slightly further on the far side than the symmetric padding
+* NOTE: clamping SHIFTS, it does not truncate — a window that overflows a
+* bound slides inward and keeps the extent that was asked for, on either side.
+* It shrinks only when the padded window is larger than the frame itself
 * would (e.g. a left-hugging box gains a bit more right-side context). This is
 * acceptable for detection crops (more context, never out of [0,1]); the
 * downstream `extractCrop` clamps to pixel bounds again regardless.
@@ -8322,13 +8784,13 @@ function padBbox(bbox, padding) {
 	const rawY = bbox.y - padding * bbox.h;
 	const rawW = bbox.w * (1 + 2 * padding);
 	const rawH = bbox.h * (1 + 2 * padding);
-	const x = Math.max(0, rawX);
-	const y = Math.max(0, rawY);
+	const w = Math.min(rawW, 1);
+	const h = Math.min(rawH, 1);
 	return {
-		x,
-		y,
-		w: Math.min(rawW, 1 - x),
-		h: Math.min(rawH, 1 - y)
+		x: Math.min(Math.max(0, rawX), 1 - w),
+		y: Math.min(Math.max(0, rawY), 1 - h),
+		w,
+		h
 	};
 }
 //#endregion
@@ -12023,7 +12485,11 @@ function squareSubjectCropRegion(bbox, frame) {
 *      cases). `C` becomes the middle square of the output.
 *   2. canvas: `canvasW = round(c × 16/9)`, `canvasH = c`.
 *   3. anchor: place the canvas so `C` is its horizontal middle →
-*      `frameOriginX = C.x − (canvasW − c)/2` (frame-x mapping to canvas-x 0).
+*      `frameOriginX = C.x − (canvasW − c)/2` (frame-x mapping to canvas-x 0),
+*      then CLAMP the window fully inside the frame whenever it fits. The
+*      subject therefore drifts off-centre near a frame edge and the output
+*      carries no padding at all. Centring is a preference; containing the
+*      subject is the contract, and clamping cannot break it.
 *   4. in-frame slab: intersect `[frameOriginX, frameOriginX + canvasW]` with
 *      `[0, W]`; the slab is that intersection at full height `c` (C ⊆ frame ⇒
 *      the vertical extent is always in-frame). Its canvas offset is
@@ -12035,13 +12501,8 @@ function wideCentralSquareLayout(bbox, frame) {
 	const canvasW = Math.round(c * 16 / 9);
 	const centralX0 = Math.round((canvasW - c) / 2);
 	let frameOriginX = central.x - (canvasW - c) / 2;
-	if (canvasW <= frame.W) {
-		const slideRightMax = Math.max(0, bbox.x - central.x);
-		const slideLeftMax = Math.max(0, central.x + c - (bbox.x + bbox.w));
-		if (frameOriginX < 0) frameOriginX += Math.min(-frameOriginX, slideRightMax);
-		const overRight = frameOriginX + canvasW - frame.W;
-		if (overRight > 0) frameOriginX -= Math.min(overRight, slideLeftMax);
-	} else frameOriginX = (frame.W - canvasW) / 2;
+	if (canvasW <= frame.W) frameOriginX = Math.min(Math.max(0, frameOriginX), frame.W - canvasW);
+	else frameOriginX = (frame.W - canvasW) / 2;
 	const fxa = Math.max(0, frameOriginX);
 	const slabW = Math.min(frame.W, frameOriginX + canvasW) - fxa;
 	const slabOffsetX = fxa - frameOriginX;
@@ -12090,10 +12551,17 @@ var LETTERBOX_BLUR_BRIGHTNESS = .55;
 /**
 * Compose the native-resolution 16:9 central-square WINDOW (`thumbnail`) from the
 * in-frame slab fetched for `layout`. The slab is placed at its computed offset
-* on a 16:9 canvas; any lateral part of the window outside the frame (a subject
-* flush against a frame edge — the geometry already slides the window in-frame
-* wherever the subject has slack) is filled with a BLURRED, dimmed stretch of
-* the slab itself instead of dead black bars (operator triage 2026-07-22).
+* on a 16:9 canvas; any lateral part of the window outside the frame is filled
+* with a BLURRED, dimmed stretch of the slab itself instead of dead black bars
+* (operator triage 2026-07-22).
+*
+* **That fill is now nearly unreachable, and deliberately so.** The geometry
+* clamps the window fully inside the frame whenever it fits, so a subject
+* against a frame edge yields real pixels off-centre rather than ambience
+* (operator directive 2026-07-31). Only a window WIDER THAN THE FRAME ITSELF
+* still pads — there is no more scene to slide into — which is why this code
+* stays. If you are looking at a blurred band in a best shot, the window was
+* wider than the frame; do not go looking for a sliding bug.
 * When the whole window is in-frame (`slab` already spans the full canvas) the
 * slab is returned VERBATIM (no re-encode). NEVER upscales the real image —
 * the canvas is at the slab's native scale; only the out-of-frame ambience fill
@@ -13216,6 +13684,13 @@ var ZoneAnalyticsProvider = class {
 					zones: snapshot.zones.length
 				}
 			});
+			this.ctx.emitOccupancyChanged?.({
+				deviceId: input.deviceId,
+				timestamp: input.timestamp,
+				totalObjects: total,
+				byClass: snapshot.frame.byClass,
+				zones: snapshot.zones.length
+			});
 		}
 		this.snapshots.set(input.deviceId, snapshot);
 		this.appendHistory(input.deviceId, snapshot);
@@ -13853,6 +14328,23 @@ function resolveDetectionSensitivitySettings(raw) {
 	};
 }
 var TrackingSettingsSchema = require_dist.object({
+	/**
+	* How much of a detection's box must lie inside a zone (0-1 fraction of the
+	* box's own area) for that zone to be STAMPED onto the detection.
+	*
+	* This is the field a zone-scoped notification rule ultimately depends on: a
+	* rule's `zones` condition is a plain set test over the stamped zone ids, so
+	* a subject that merely clips a zone edge satisfies it. Measured on
+	* 2026-07-30: a dog overlapping `Aiuola` by 4.8% would have counted as
+	* inside it.
+	*
+	* DEFAULT 0 — byte-identical to the behaviour before 2026-07-31. Raising it
+	* is deliberately an operator decision: the overlap fractions are now logged
+	* (`zone membership` lines), so the bar can be chosen from the distribution
+	* instead of guessed. Distinct from a zone RULE's `bboxInclusionPct`, which
+	* gates the DETECTION stage, not what gets stamped.
+	*/
+	zoneMembershipMinOverlap: require_dist.number().min(0).max(1).default(0),
 	/** IoU required to match a (predicted) track to a detection. */
 	iouThreshold: require_dist.number().min(0).max(1).default(.3),
 	/** Wall-clock coasting budget (ms) before a missed track is dropped. Time-
@@ -13989,6 +14481,7 @@ function resolveTrackingSettings(raw) {
 	const maxMissedMs = raw.maxMissedMs !== void 0 ? s.maxMissedMs.catch(TRACKING_DEFAULTS.maxMissedMs).parse(raw.maxMissedMs) : raw.maxMissedFrames !== void 0 ? Math.round(maxMissedFrames * 133) : TRACKING_DEFAULTS.maxMissedMs;
 	const occlusionMaxMissedMs = raw.occlusionMaxMissedMs !== void 0 ? s.occlusionMaxMissedMs.catch(TRACKING_DEFAULTS.occlusionMaxMissedMs).parse(raw.occlusionMaxMissedMs) : raw.occlusionMaxMissedFrames !== void 0 ? Math.round(occlusionMaxMissedFrames * 133) : TRACKING_DEFAULTS.occlusionMaxMissedMs;
 	return {
+		zoneMembershipMinOverlap: s.zoneMembershipMinOverlap.catch(TRACKING_DEFAULTS.zoneMembershipMinOverlap).parse(raw.zoneMembershipMinOverlap),
 		iouThreshold: s.iouThreshold.catch(TRACKING_DEFAULTS.iouThreshold).parse(raw.iouThreshold),
 		maxMissedMs,
 		minTrackAgeMs: s.minTrackAgeMs.catch(TRACKING_DEFAULTS.minTrackAgeMs).parse(raw.minTrackAgeMs),
@@ -14043,7 +14536,11 @@ function resolveTrackingSettings(raw) {
 * low-res detection frame (a static "person" phantom, a parked-truck ghost, a
 * misclassified static object).
 *
-* Ships DORMANT: `enabled` defaults to `false`, so behaviour is byte-identical
+* ON by default (`enabled` defaults to TRUE). An earlier version of this line
+* said "Ships DORMANT: `enabled` defaults to `false`" — that was stale, and on
+* 2026-07-30 it nearly produced the conclusion that the gate was not running at
+* all. It is: it suppressed several phantom births on device 615 that same day.
+* Read the schema, not this paragraph. Historically the intent was byte-identical
 * to today until an operator opts in per camera. The gate is fail-OPEN — any
 * missing frame handle, unavailable inference cap, crop-fetch miss, re-detection
 * error, or timeout ALLOWS the birth (a real track is never suppressed because
@@ -14139,10 +14636,11 @@ function isConfirmationCompatible(trackClassName, detectionMacroClass) {
 	if (track === "other" || det === "other") return true;
 	return track === det;
 }
-var failOpen = (trackId, reason) => ({
-	trackId,
+var failOpen = (candidate, reason) => ({
+	trackId: candidate.trackId,
 	confirmed: true,
-	reason
+	reason,
+	className: candidate.className
 });
 function withTimeout(promise, timeoutMs) {
 	return new Promise((resolve, reject) => {
@@ -14158,23 +14656,34 @@ function withTimeout(promise, timeoutMs) {
 }
 async function runConfirmation(candidate, config, deps) {
 	const crop = await deps.fetchCrop(candidate);
-	if (!crop) return failOpen(candidate.trackId, "no-crop");
+	if (!crop) return failOpen(candidate, "no-crop");
 	const detections = await deps.redetect(crop);
-	if (detections === null) return failOpen(candidate.trackId, "redetect-error");
-	const confirmed = detections.some((d) => d.score >= config.minConfidence && isConfirmationCompatible(candidate.className, d.macroClass));
+	if (detections === null) return failOpen(candidate, "redetect-error");
+	let best;
+	let bestIncompatible;
+	for (const d of detections) if (isConfirmationCompatible(candidate.className, d.macroClass)) {
+		if (!best || d.score > best.score) best = d;
+	} else if (!bestIncompatible || d.score > bestIncompatible.score) bestIncompatible = d;
+	const confirmed = best !== void 0 && best.score >= config.minConfidence;
 	return {
 		trackId: candidate.trackId,
 		confirmed,
-		reason: confirmed ? "confirmed" : "suppressed"
+		reason: confirmed ? "confirmed" : "suppressed",
+		className: candidate.className,
+		...best ? { bestScore: best.score } : {},
+		...bestIncompatible ? {
+			bestIncompatibleClass: bestIncompatible.macroClass,
+			bestIncompatibleScore: bestIncompatible.score
+		} : {}
 	};
 }
 async function confirmOne(candidate, config, deps) {
 	const cropPx = Math.max(candidate.bbox.w, candidate.bbox.h);
-	if (config.minCropPx > 0 && cropPx < config.minCropPx) return failOpen(candidate.trackId, "below-min-crop");
+	if (config.minCropPx > 0 && cropPx < config.minCropPx) return failOpen(candidate, "below-min-crop");
 	try {
 		return await withTimeout(runConfirmation(candidate, config, deps), config.timeoutMs);
 	} catch {
-		return failOpen(candidate.trackId, "timeout");
+		return failOpen(candidate, "timeout");
 	}
 }
 /**
@@ -14357,8 +14866,23 @@ function resolveMediaSettings(raw) {
 * §3.3 draft said 45s).
 */
 var PackageDropSettingsSchema = require_dist.object({
-	/** Master switch — off by default; opt-in per camera (porch/door cams). */
-	packageDropEnabled: require_dist.boolean().default(false),
+	/**
+	* Explicit per-camera OFF. **On by default: the ZONE RULE is what enables
+	* package detection**, not a second switch.
+	*
+	* As an opt-in default-false this was a parallel source of truth. Device 615
+	* on 2026-07-30 had the zone (`Uscio`), an enabled `package`-stage zone rule
+	* (`Pacchetti`, classFilter `['package']`), and a notification rule on
+	* `delivery: 'package-event'` — three layers of operator intent, all defeated
+	* silently by a boolean none of them mentions.
+	*
+	* Defaulting to true costs nothing on cameras nobody configured:
+	* `PackageDropDetector.onAppeared` still returns early when the device has no
+	* enabled `package`-stage rule, so the work is a class check plus one cached
+	* lookup. Set this false to force the feature off on a camera that HAS a zone
+	* rule.
+	*/
+	packageDropEnabled: require_dist.boolean().default(true),
 	/**
 	* Minimum OBSERVED dwell (seconds, since first-seen) before a newly
 	* promoted stationary package counts as a delivery. Kills a bag briefly
@@ -14899,6 +15423,15 @@ function buildDetectionSettingsSections() {
 					step: .05,
 					default: TRACKING_DEFAULTS.rescueIouThreshold
 				},
+				{
+					type: "number",
+					key: "rescueCentroidFactor",
+					label: "Rescue centroid distance",
+					description: "The other half of the rescue gate: how far a detection’s centre may sit from the track’s last-known centre, as a fraction of the box diagonal. A rescue must pass BOTH this and the rescue IoU, so raising the IoU alone does not tighten re-attachment.",
+					min: 0,
+					step: .05,
+					default: TRACKING_DEFAULTS.rescueCentroidFactor
+				},
 				{
 					type: "number",
 					key: "stationarySpeedPx",
@@ -15180,6 +15713,16 @@ function buildDetectionSettingsSections() {
 					label: "Person/animal group matching",
 					description: "Let a detection that flips between person and animal for a frame (a crouching / bending person is often read as an animal) re-match its existing track instead of spawning a concurrent animal track. The reported class is still decided by the per-track class vote.",
 					default: TRACKING_DEFAULTS.classGroupAssoc
+				},
+				{
+					type: "number",
+					key: "zoneMembershipMinOverlap",
+					label: "Zone membership minimum overlap",
+					description: "How much of a detection box must fall inside a zone for the detection to be STAMPED with it — as a fraction of the BOX area, not of the zone. 0 stamps on any touch, which is what let a plant brushing a zone by 6% fire a \"person on the doorstep\" rule. Only a stamped zone can match a zone-scoped notification rule. Read the \"zone membership stamped on event\" log line to choose the value: it prints the achieved percentage per zone.",
+					min: 0,
+					max: 1,
+					step: .05,
+					default: TRACKING_DEFAULTS.zoneMembershipMinOverlap
 				}
 			]
 		},
@@ -19577,7 +20120,21 @@ function decodeEmbeddingBase64(base64) {
 	const view = new Float32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 4));
 	return Array.from(view);
 }
+/** A track shorter than this is a candidate phantom, not a subject that came
+*  and went. Brackets the observed plant tracks (3.8-19.0 s). */
+var SHORT_TRACK_MAX_MS = 25e3;
+/** Total displacement under this is "did not move at all" (observed: 0-2.5 px). */
+var MOTIONLESS_MAX_PX = 8;
+/** Grid the spawn point is quantised to, so respawns whose boxes never repeat
+*  to the pixel still land in one cell. */
+var PHANTOM_CELL_PX = 32;
+/** How long a cell remembers its closes. */
+var PHANTOM_CELL_WINDOW_MS = 360 * 6e4;
 var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
+	/** Recent SHORT+MOTIONLESS track closes per `<device>:<class>:<cell>` —
+	*  see {@link noteShortMotionlessTrack}. Measurement only; each entry is
+	*  filtered against the 6-hour window on write, so it stays bounded. */
+	shortMotionlessCells = /* @__PURE__ */ new Map();
 	processors = /* @__PURE__ */ new Map();
 	trackStore = null;
 	/** Parked-object registry: promotes a track that stopped moving into a
@@ -19735,6 +20292,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*  dataPlane facility in the current environment). */
 	eventMediaBaseUrl = null;
 	lastActiveTrackIds = /* @__PURE__ */ new Map();
+	/** See `pipeline/suppressed-births.ts` — rejected births must not be
+	*  re-upserted, and must be forgotten when the tracker drops the id. */
+	suppressedBirths = new SuppressedBirthRegistry();
 	lastFrameDimsByDevice = /* @__PURE__ */ new Map();
 	lastAudioInsertByDevice = /* @__PURE__ */ new Map();
 	lastMotionInsertByDevice = /* @__PURE__ */ new Map();
@@ -19887,7 +20447,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					});
 				},
 				emitTrackLifecycle: (payload, timestampMs) => this.emitTrackLifecycle(payload, timestampMs),
-				onTrackClosed: (track, ownedMedia, info) => this.notificationCenter?.onTrackClosed(track, ownedMedia, info),
+				onTrackClosed: (track, ownedMedia, info) => {
+					this.noteShortMotionlessTrack(track);
+					return this.notificationCenter?.onTrackClosed(track, ownedMedia, info);
+				},
 				deriveThumbnailFromKeyFrame: async (input) => {
 					const derived = await deriveKeyFrameThumbnailJpeg({
 						...input,
@@ -20033,7 +20596,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-Dwh-F2Zf.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-C1I1svLc.js"));
 			storage = new FilesystemStorageProvider(mediaRoot, { eventMedia: mediaRoot });
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -20315,6 +20878,22 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const zoneAnalytics = new ZoneAnalyticsProvider({
 			logger: logger.child("ZoneAnalytics"),
 			fetchDevice: (deviceId) => this.ctx.fetchDevice(deviceId),
+			emitOccupancyChanged: (payload) => this.ctx.eventBus.emit({
+				id: `za-occ-${payload.deviceId}-${payload.timestamp}`,
+				timestamp: new Date(payload.timestamp),
+				source: {
+					type: "addon",
+					id: "pipeline-analytics",
+					addonId: "pipeline-analytics"
+				},
+				category: require_dist.EventCategory.ZoneAnalyticsOccupancyChanged,
+				data: {
+					deviceId: payload.deviceId,
+					totalObjects: payload.totalObjects,
+					byClass: payload.byClass,
+					zones: payload.zones
+				}
+			}),
 			listStationaryObjects: (deviceId) => this.stationaryRegistry?.listViews(deviceId) ?? [],
 			listStationaryDeviceIds: () => this.stationaryRegistry?.deviceIds() ?? [],
 			resolveZones: (deviceId) => this.resolveDeviceZones(deviceId),
@@ -20374,6 +20953,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				};
 			},
 			dispatcher: {
+				getZoneNames: async (deviceId) => {
+					return (await api.zones.listZones.query({ deviceId })).map((z) => ({
+						id: z.id,
+						name: z.name
+					}));
+				},
 				getZonePolygons: async (deviceId, zoneIds) => {
 					const zones = await api.zones.listZones.query({ deviceId });
 					const wanted = new Set(zoneIds);
@@ -20751,10 +21336,20 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const liveRules = proxy?.state.zoneRules.value?.detection ?? [];
 		processor.setZones(liveZones);
 		processor.setDetectionRules(liveRules);
+		processor.setZoneMembershipMinOverlap(trk.zoneMembershipMinOverlap);
 		const result = processor.process({
 			timestamp: frame.timestamp,
 			frame
 		});
+		for (const r of processor.getLastRiderPairs()) this.ctx.logger.info("rider folded into vehicle", {
+			tags: { deviceId },
+			meta: {
+				vehicleClass: r.vehicleClass,
+				personScore: r.personScore,
+				vehicleScore: r.vehicleScore,
+				overlap: r.overlap
+			}
+		});
 		if (source === "pipeline") this.stationaryRegistry?.noteFrame(deviceId, result.timestamp);
 		if (this.stationaryRegistry && (result.stationaryConfirmed.length > 0 || result.stationaryWoken.length > 0)) this.stationaryRegistry.applyFrameOutcome({
 			deviceId,
@@ -20785,6 +21380,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const positionsCountById = /* @__PURE__ */ new Map();
 		for (const t of result.tracked) {
 			currentTrackIds.add(t.trackId);
+			if (this.suppressedBirths.isRejected(key, t.trackId)) continue;
 			const center = {
 				x: t.bbox.x + t.bbox.w / 2,
 				y: t.bbox.y + t.bbox.h / 2
@@ -20851,7 +21447,16 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			frameHeight: result.frameHeight
 		});
 		for (const { id, t } of bornCandidates) {
-			if (!confirmedBirths.has(id)) continue;
+			if (!confirmedBirths.has(id)) {
+				this.suppressedBirths.reject(key, id);
+				this.trackStore?.dropActive(id);
+				log.info("birth suppressed — track record retracted", { meta: {
+					trackId: id,
+					className: t.className,
+					source
+				} });
+				continue;
+			}
 			newTrackCount += 1;
 			log.info("track started", { meta: {
 				trackId: id,
@@ -20912,6 +21517,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				source
 			} });
 		}
+		this.suppressedBirths.retain(key, currentTrackIds);
 		this.lastActiveTrackIds.set(key, currentTrackIds);
 		const stationarySettings = this.stationarySettingsFromCache(deviceId);
 		if (source === "pipeline" && this.stationaryRegistry && stationarySettings.enabled) {
@@ -20981,7 +21587,46 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			} });
 		}
 		await Promise.all([...result.objectEvents, ...result.appearanceEvents].map((e) => this.eventStore.insertObject(e)));
-		if (this.notificationCenter !== null) for (const e of result.objectEvents) this.notificationCenter.onObjectEventPersisted(e);
+		if (this.notificationCenter !== null) {
+			const overlaps = processor.getLastZoneOverlaps();
+			const rejections = processor.getLastZoneRejections();
+			for (const e of result.objectEvents) {
+				if (e.zones && e.zones.length > 0) {
+					const m = e.trackId ? overlaps.get(e.trackId) : void 0;
+					this.ctx.logger.info("zone membership stamped on event", {
+						tags: { deviceId },
+						meta: {
+							eventId: e.id,
+							trackId: e.trackId,
+							className: e.className,
+							minOverlap: trk.zoneMembershipMinOverlap,
+							zones: (m ?? []).map((z) => ({
+								id: z.zoneId,
+								name: z.zoneName,
+								overlapPct: Math.round(z.overlap * 1e3) / 10
+							}))
+						}
+					});
+				}
+				const rejected = e.trackId ? rejections.get(e.trackId) : void 0;
+				if (rejected !== void 0 && rejected.length > 0) this.ctx.logger.info("zone membership REJECTED by the bar", {
+					tags: { deviceId },
+					meta: {
+						eventId: e.id,
+						trackId: e.trackId,
+						className: e.className,
+						minOverlap: trk.zoneMembershipMinOverlap,
+						stamped: e.zones?.length ?? 0,
+						zones: rejected.map((z) => ({
+							id: z.zoneId,
+							name: z.zoneName,
+							overlapPct: Math.round(z.overlap * 1e3) / 10
+						}))
+					}
+				});
+				this.notificationCenter.onObjectEventPersisted(e);
+			}
+		}
 		const objectEmbeddingBests = [];
 		if (this.objectEmbeddingStore) for (const t of result.tracked) {
 			if (!isClipObjectEmbedding(t)) continue;
@@ -21333,19 +21978,28 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			}),
 			redetect: (cropJpeg) => this.redetectCropForConfirmation(nodeId, deviceId, cropJpeg),
 			onDecision: (decision) => {
+				const meta = {
+					trackId: decision.trackId,
+					reason: decision.reason,
+					className: decision.className,
+					...decision.bestScore !== void 0 ? { bestScore: decision.bestScore } : {},
+					...decision.bestIncompatibleClass !== void 0 ? {
+						bestIncompatibleClass: decision.bestIncompatibleClass,
+						bestIncompatibleScore: decision.bestIncompatibleScore
+					} : {},
+					minConfidence: config.minConfidence
+				};
 				if (!decision.confirmed) this.ctx.logger.info("confirmation gate: birth suppressed (false positive)", {
 					tags: { deviceId },
-					meta: {
-						trackId: decision.trackId,
-						reason: decision.reason
-					}
+					meta
 				});
 				else if (decision.reason !== "confirmed") this.ctx.logger.debug("confirmation gate: birth allowed (fail-open)", {
 					tags: { deviceId },
-					meta: {
-						trackId: decision.trackId,
-						reason: decision.reason
-					}
+					meta
+				});
+				else this.ctx.logger.info("confirmation gate: birth confirmed", {
+					tags: { deviceId },
+					meta
 				});
 			}
 		});
@@ -21362,6 +22016,48 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	async resolveDeviceStationarySettings(deviceId) {
 		return this.stationarySettingsCache.get(deviceId, (id) => this.readDeviceSettings(id, resolveStationarySettings));
 	}
+	/**
+	* Count SHORT + MOTIONLESS track closes per frame cell.
+	*
+	* The stationary registry cannot see this class of phantom. Promotion needs a
+	* track that has EXISTED for `PROMOTION_WINDOW_MS` (30 s), and these die long
+	* before: the dead ornamental grass on device 615 produced tracks of 3.8 s,
+	* 4.1 s, 6.5 s and 19.0 s with 0-2.5 px of total displacement, roughly
+	* fifteen of them in a day, all at the same spot. Each one is individually
+	* innocent; the RECURRENCE is the signal, and nothing survives a track death
+	* to notice it.
+	*
+	* Lowering the promotion window is not the fix — those 30 s exist so someone
+	* standing still at a door is not declared scenery.
+	*
+	* This is the measurement half: it establishes how often a cell repeats
+	* before any suppression is built, so "N closes in what window" comes from
+	* data rather than intuition. It suppresses NOTHING.
+	*/
+	noteShortMotionlessTrack(track) {
+		const lifeMs = track.lastSeen - track.firstSeen;
+		const moved = track.totalDistance ?? 0;
+		if (lifeMs > SHORT_TRACK_MAX_MS || moved > MOTIONLESS_MAX_PX) return;
+		const first = track.positions?.[0];
+		if (!first) return;
+		const cell = `${Math.round(first.x / PHANTOM_CELL_PX)},${Math.round(first.y / PHANTOM_CELL_PX)}`;
+		const key = `${track.deviceId}:${track.className}:${cell}`;
+		const now = Date.now();
+		const seen = this.shortMotionlessCells.get(key)?.filter((t) => now - t < PHANTOM_CELL_WINDOW_MS) ?? [];
+		seen.push(now);
+		this.shortMotionlessCells.set(key, seen);
+		this.ctx.logger.info("short motionless track closed", {
+			tags: { deviceId: track.deviceId },
+			meta: {
+				trackId: track.trackId,
+				className: track.className,
+				lifeMs,
+				movedPx: Math.round(moved * 10) / 10,
+				cell,
+				repeatsInWindow: seen.length
+			}
+		});
+	}
 	stationarySettingsFromCache(deviceId) {
 		return this.stationarySettingsCache.peek(deviceId) ?? STATIONARY_DEFAULTS;
 	}
@@ -21371,9 +22067,14 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	/**
 	* Resolve a device's ENABLED `package`-stage zone rules independent of the
 	* live frame path (mirrors `resolveDeviceZones`). Warms the proxy and,
-	* when the cached slice is empty, forces one refresh. The `package` slice
-	* is written by the orchestrator's package-stage provider (a later slice);
-	* until then this returns `[]` and no package events fire.
+	* when the cached slice is empty, forces one refresh.
+	*
+	* The `package` slice is written through the `zone-rules` capability
+	* (`zoneRules.setRules({stage:'package'})`), which is live. An earlier
+	* version of this comment claimed the provider did not exist yet and that
+	* "no package events fire" — that was stale, and believing it produced a
+	* confidently wrong diagnosis on 2026-07-30. An empty list here means the
+	* operator has drawn no package zone rule, nothing more.
 	*/
 	async resolveDevicePackageRules(deviceId) {
 		const proxy = await this.ensureProxy(deviceId);