@camstack/addon-post-analysis 1.2.611 → 1.2.612

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-D1PS6-db.js");
+const require_clip_model_registry = require("../clip-model-registry-C7WMvftu.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -935,6 +935,7 @@ function actionTtlMs(subject) {
 		case "snooze": return SNOOZE_ACTION_TTL_MS;
 		case "alarm":
 			if (subject.action === "arm-anyway") return ARM_ANYWAY_TTL_MS;
+			if (subject.action === "bypass-input") return DEFAULT_ACTION_TTL_MS;
 			return subject.action === "disarm" ? ALARM_DISARM_TTL_MS : DEFAULT_ACTION_TTL_MS;
 		case "sequence": return DEFAULT_ACTION_TTL_MS;
 		case "addon-update": return DEFAULT_ACTION_TTL_MS;
@@ -1019,6 +1020,7 @@ function describeGrant(grant) {
 		case "snooze": return grant.classes === void 0 || grant.classes.length === 0 ? `Silenced for ${grant.minutes} min` : `Silenced for ${grant.minutes} min — ${grant.classes.join(", ")}`;
 		case "alarm":
 			if (grant.action === "arm-anyway") return "Alarm armed, around the open devices";
+			if (grant.action === "bypass-input") return `Input bypassed until disarm — ${grant.ruleName}`;
 			return grant.action === "disarm" ? "Alarm disarmed" : `Alarm armed${grant.mode !== void 0 ? ` (${grant.mode})` : ""}`;
 		case "addon-update": return `${grant.packages.length} addon update(s) on ${grant.nodeId}`;
 		case "server-update": return `Server update on ${grant.nodeId}`;
@@ -1046,17 +1048,26 @@ function grantMeta(grant) {
 			minutes: grant.minutes,
 			classes: grant.classes ?? null
 		};
-		case "alarm": return grant.action === "arm-anyway" ? {
-			...common,
-			alarm: grant.action,
-			refusalId: grant.refusalId,
-			panelDeviceId: grant.panelDeviceId
-		} : {
-			...common,
-			alarm: grant.action,
-			mode: grant.mode ?? null,
-			panelDeviceId: grant.panelDeviceId
-		};
+		case "alarm":
+			if (grant.action === "bypass-input") return {
+				...common,
+				alarm: grant.action,
+				ruleId: grant.ruleId,
+				rule: grant.ruleName,
+				inputDeviceId: grant.inputDeviceId,
+				panelDeviceId: grant.panelDeviceId
+			};
+			return grant.action === "arm-anyway" ? {
+				...common,
+				alarm: grant.action,
+				refusalId: grant.refusalId,
+				panelDeviceId: grant.panelDeviceId
+			} : {
+				...common,
+				alarm: grant.action,
+				mode: grant.mode ?? null,
+				panelDeviceId: grant.panelDeviceId
+			};
 		case "addon-update": return {
 			...common,
 			nodeId: grant.nodeId,
@@ -1580,6 +1591,128 @@ var NcAlarmExclusions = class {
 	}
 };
 //#endregion
+//#region src/notification-center/alarm/alarm-input-bypasses.ts
+/**
+* The alarm INPUTS the operator silenced for the rest of this arm — "Bypass
+* this input until disarm".
+*
+* An input is ONE (rule, device) pair: the rule gated on `armed_*` and the
+* device whose match pressed the panel (the sensor when the match was about
+* one, else the camera — `intrusionDeviceOf`). A false positive that keeps
+* re-triggering the alarm is exactly one such pair; bypassing it leaves every
+* other device of the same rule, and the same device under every other rule,
+* armed.
+*
+* Not an exclusion (`alarm-exclusions.ts`): an exclusion is an opening that was
+* open at ARM time and lifts on its own two-phase edge. A bypass never lifts by
+* itself. It belongs to the arm SESSION and ends with it — on a disarm (any
+* path: the operator, the bridge, the cap, a `disableAfter` auto-disarm) and on
+* a new arm. A bounded siren that RE-ARMS itself is the same session, and the
+* bypass survives it — that re-trigger is the thing it exists to stop.
+*
+* Persisted with the panel's machine, in the panel's own device config, for the
+* exclusions' reason: a deploy in the middle of the night must not quietly hand
+* the false positive back its siren. No second store (D62): this is state of
+* the arm, and it lives where the arm lives.
+*/
+/** At most this many bypassed inputs per arm — a bound on the persisted blob, not a target. */
+var NC_ALARM_INPUT_BYPASS_MAX = 200;
+/** One bypassed input, as persisted. Read back through {@link NcAlarmInputBypasses.restore}. */
+var NcAlarmInputBypassRecordSchema = require_clip_model_registry.object({
+	ruleId: require_clip_model_registry.string().min(1),
+	/** The rule's name when it was bypassed — a fallback for the view; the mirror's name wins. */
+	ruleName: require_clip_model_registry.string(),
+	/** The INPUT: the sensor of the match, else its camera (`intrusionDeviceOf`). */
+	deviceId: require_clip_model_registry.number().int(),
+	/** The match's camera — kept so a rule edit that drops the camera can be recognised. */
+	cameraId: require_clip_model_registry.number().int(),
+	/** When the bypass was made. */
+	at: require_clip_model_registry.number(),
+	/** Presses dropped since — the count the status shows. */
+	dropped: require_clip_model_registry.number().int().min(0)
+});
+var NcAlarmInputBypasses = class {
+	entries = [];
+	/** Bypass one input. Idempotent: the same pair twice is one bypass. */
+	add(request, at) {
+		if (this.find(request.ruleId, request.deviceId) !== void 0) return "already-bypassed";
+		if (this.entries.length >= NC_ALARM_INPUT_BYPASS_MAX) return "full";
+		this.entries = [...this.entries, {
+			ruleId: request.ruleId,
+			ruleName: request.ruleName,
+			deviceId: request.deviceId,
+			cameraId: request.cameraId,
+			at,
+			dropped: 0
+		}];
+		return "bypassed";
+	}
+	/** True while this (rule, input) pair must not press the panel. */
+	blocks(ruleId, deviceId) {
+		return this.find(ruleId, deviceId) !== void 0;
+	}
+	/** Count one dropped press of a bypassed input; returns the new count, or null when not bypassed. */
+	recordDrop(ruleId, deviceId) {
+		const current = this.find(ruleId, deviceId);
+		if (current === void 0) return null;
+		const dropped = current.dropped + 1;
+		this.entries = this.entries.map((e) => e === current ? {
+			...e,
+			dropped
+		} : e);
+		return dropped;
+	}
+	/** Every bypassed input, in the order it was bypassed. */
+	snapshot() {
+		return this.entries;
+	}
+	get size() {
+		return this.entries.length;
+	}
+	/** Drop every bypass — the arm session ended. Returns what was dropped. */
+	clear() {
+		const dropped = this.entries;
+		this.entries = [];
+		return dropped;
+	}
+	/** Drop the bypasses `keep` refuses (a rule deleted, disabled or no longer naming the input). */
+	prune(keep) {
+		const removed = this.entries.filter((e) => !keep(e));
+		if (removed.length > 0) this.entries = this.entries.filter((e) => keep(e));
+		return removed;
+	}
+	/**
+	* Rebuild from the persisted blob — defensively, per entry: an entry a later
+	* release wrote in another shape is dropped, never the whole list. Returns
+	* how many entries were dropped so the caller can say so.
+	*/
+	restore(raw) {
+		if (!Array.isArray(raw)) {
+			this.entries = [];
+			return 0;
+		}
+		const kept = [];
+		let dropped = 0;
+		for (const item of raw) {
+			const parsed = NcAlarmInputBypassRecordSchema.safeParse(item);
+			if (!parsed.success || kept.length >= NC_ALARM_INPUT_BYPASS_MAX) {
+				dropped += 1;
+				continue;
+			}
+			if (kept.some((e) => e.ruleId === parsed.data.ruleId && e.deviceId === parsed.data.deviceId)) {
+				dropped += 1;
+				continue;
+			}
+			kept.push(parsed.data);
+		}
+		this.entries = kept;
+		return dropped;
+	}
+	find(ruleId, deviceId) {
+		return this.entries.find((e) => e.ruleId === ruleId && e.deviceId === deviceId);
+	}
+};
+//#endregion
 //#region src/notification-center/alarm/alarm-mode-delays.ts
 /**
 * The persisted per-mode delay overrides, read through a guard (D697).
@@ -1880,6 +2013,10 @@ function alarmPushDecision(phase, heard) {
 			kind: "suppress",
 			reason: "alarm-sensor-excluded"
 		} };
+		case "bypassed": return { verdict: {
+			kind: "suppress",
+			reason: "alarm-input-bypassed"
+		} };
 		case "triggered": return { verdict: { kind: "intrusion" } };
 		case "starts-entry-delay": return heard.pending ? { verdict: {
 			kind: "suppress",
@@ -2178,6 +2315,18 @@ var ncAlarmPanelSchema = require_clip_model_registry.object({
 	*/
 	exclusions: require_clip_model_registry.array(require_clip_model_registry.unknown()).default([]),
 	/**
+	* The (rule, input) pairs the operator bypassed for the rest of THIS arm
+	* session (`alarm-input-bypasses.ts`). Persisted for the exclusions' reason;
+	* read back through a guard, never a cast.
+	*/
+	inputBypasses: require_clip_model_registry.array(require_clip_model_registry.unknown()).default([]),
+	/**
+	* When the current arm session began (the last arm). A bypass request about a
+	* match older than this belongs to an arm that is over. Absent on an older
+	* blob ⇒ no session check until the next arm.
+	*/
+	armSessionAt: require_clip_model_registry.number().optional(),
+	/**
 	* Per arm mode, the covered devices whose being open does not refuse the arm
 	* (D630). Loose on purpose — `mode` is a string here — and read back through
 	* {@link nonBlockingFromPersisted}, never a cast: a blob written by a later
@@ -2436,6 +2585,8 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	attribution = new NcAlarmAttribution();
 	/** Sensors this arm is ignoring — see {@link NcAlarmExclusions}. */
 	exclusions = new NcAlarmExclusions();
+	/** The inputs this arm session ignores — see {@link NcAlarmInputBypasses}. */
+	bypasses = new NcAlarmInputBypasses();
 	/** Who answers "is anything open" — null until the centre wires itself in. */
 	armGuard = null;
 	/**
@@ -2920,6 +3071,11 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 			kind: "excluded",
 			sensorDeviceId: intrusionDeviceOf(ref)
 		};
+		if (this.bypasses.blocks(ref.ruleId, intrusionDeviceOf(ref))) return {
+			kind: "bypassed",
+			ruleId: ref.ruleId,
+			sensorDeviceId: intrusionDeviceOf(ref)
+		};
 		const mode = armModeOf(this.machine.target, NC_ALARM_MODES);
 		if (mode === null) return { kind: "none" };
 		const state = stateAt(this.machine, now);
@@ -3112,6 +3268,77 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 		this.publish();
 	}
 	/**
+	* "Bypass this input until disarm" — ONE (rule, input) pair stops pressing
+	* the panel for the rest of this arm session.
+	*
+	* Refused on a disarmed panel (there is no session to bypass in) and for a
+	* notification about an arm that is already over (`stale`). It never cancels
+	* an entry delay or a siren already running — it stops the NEXT presses of
+	* that input; the disarm stays the operator's own button.
+	*/
+	bypassInput(input, now = Date.now()) {
+		const refuse = (reason) => {
+			this.ctx.logger.info("alarm input bypass refused", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					panelDeviceId: this.id,
+					ruleId: input.ruleId,
+					rule: input.ruleName,
+					reason
+				}
+			});
+			return {
+				outcome: "refused",
+				reason
+			};
+		};
+		if (this.machine.target === "disarmed") return refuse("disarmed");
+		const sessionAt = this.config.get("armSessionAt");
+		if (input.notedAt !== void 0 && sessionAt !== void 0 && input.notedAt < sessionAt) return refuse("stale");
+		const added = this.bypasses.add(input, now);
+		if (added === "full") return refuse("full");
+		if (added === "bypassed") {
+			this.persist();
+			this.ctx.logger.info("alarm input bypassed until disarm", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					panelDeviceId: this.id,
+					ruleId: input.ruleId,
+					rule: input.ruleName,
+					cameraId: input.cameraId,
+					state: stateAt(this.machine, now),
+					bypassed: this.bypasses.size
+				}
+			});
+		}
+		return {
+			outcome: added,
+			bypassed: this.bypasses.snapshot()
+		};
+	}
+	/** The inputs this arm session ignores — what the live view reports. A read, never a copy. */
+	inputBypasses() {
+		return this.bypasses.snapshot();
+	}
+	/**
+	* Drop the bypasses whose input is no longer an input — the rule was
+	* deleted, disabled, or no longer names the device. Called from the centre's
+	* rule-reload tick; one line per drop, tagged with the input.
+	*/
+	pruneInputBypasses(keep) {
+		const removed = this.bypasses.prune(keep);
+		if (removed.length === 0) return;
+		this.persist();
+		for (const entry of removed) this.ctx.logger.info("alarm input bypass dropped — the rule no longer has this input", {
+			tags: { deviceId: entry.deviceId },
+			meta: {
+				panelDeviceId: this.id,
+				ruleId: entry.ruleId,
+				rule: entry.ruleName
+			}
+		});
+	}
+	/**
 	* One opening's reading (`open` / `secure`, D630's vocabulary — a cover is
 	* secure only when `closed`, a lock only when `locked`), from whoever saw
 	* it: the sensor's own event, or the centre's reconcile tick.
@@ -3311,6 +3538,8 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 			this.persist();
 		}
 		const resolved = this.delaysFor(mode);
+		this.endInputBypasses("arm");
+		this.config.set("armSessionAt", now);
 		this.machine = arm(mode, resolved, now);
 		this.ctx.logger.info("alarm delays applied", {
 			tags: { deviceId: this.id },
@@ -3436,6 +3665,21 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 			this.announceIgnoredTrigger(sensor, now, moved);
 			return "ignored-excluded";
 		}
+		if (source !== null && sensor !== void 0 && this.bypasses.blocks(source.ruleId, sensor)) {
+			const dropped = this.bypasses.recordDrop(source.ruleId, sensor);
+			this.persist();
+			this.ctx.logger.info("alarm trigger dropped — this input is bypassed until disarm", {
+				tags: { deviceId: sensor },
+				meta: {
+					panelDeviceId: this.id,
+					ruleId: source.ruleId,
+					rule: source.ruleName,
+					state: stateAt(this.machine, now),
+					dropped
+				}
+			});
+			return "ignored-bypassed";
+		}
 		const armed = armModeOf(this.machine.target, NC_ALARM_MODES);
 		const resolved = this.delaysFor(armed);
 		const next = trigger(this.machine, resolved, now);
@@ -3495,6 +3739,7 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	publish(now = Date.now()) {
 		const autoCleared = this.machine.clearAt !== void 0 && now >= this.machine.clearAt && this.machine.clearToDisarmed === true;
 		this.machine = settle(this.machine, now);
+		if (this.machine.target === "disarmed") this.endInputBypasses("disarm");
 		const state = stateAt(this.machine, now);
 		this.runtimeState.setCapState("alarm-panel", this.status(now));
 		this.persist();
@@ -3743,9 +3988,31 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	persist() {
 		this.config.set("machine", { ...this.machine });
 		this.config.set("exclusions", [...this.exclusions.snapshot()]);
+		this.config.set("inputBypasses", [...this.bypasses.snapshot()]);
+	}
+	/** The session is over: drop every bypass, one line per input. */
+	endInputBypasses(why) {
+		const ended = this.bypasses.clear();
+		if (ended.length === 0) return;
+		this.config.set("inputBypasses", []);
+		for (const entry of ended) this.ctx.logger.info("alarm input bypass ended with the arm session — watched again", {
+			tags: { deviceId: entry.deviceId },
+			meta: {
+				panelDeviceId: this.id,
+				ruleId: entry.ruleId,
+				rule: entry.ruleName,
+				why,
+				dropped: entry.dropped
+			}
+		});
 	}
 	restore() {
 		this.exclusions.restore(this.config.get("exclusions"));
+		const unreadable = this.bypasses.restore(this.config.get("inputBypasses"));
+		if (unreadable > 0) this.ctx.logger.info("alarm input bypasses: persisted entries this release cannot read were dropped", {
+			tags: { deviceId: this.id },
+			meta: { dropped: unreadable }
+		});
 		const restored = machineFromPersisted(this.config.get("machine"));
 		if (restored === null) return;
 		this.machine = restored;
@@ -3799,6 +4066,9 @@ function ncAlarmPanelPort(panel) {
 		excludedDevices: () => panel.excludedDevices(),
 		exclusionPhases: () => panel.exclusionPhases(),
 		forgetExcluded: (deviceId) => panel.forgetExcluded(deviceId),
+		bypassInput: (input) => panel.bypassInput(input),
+		inputBypasses: () => panel.inputBypasses(),
+		pruneInputBypasses: (keep) => panel.pruneInputBypasses(keep),
 		currentState: () => panel.currentState(),
 		currentTarget: () => panel.currentTarget(),
 		armWith: (mode) => panel.armWith(mode),
@@ -5374,6 +5644,53 @@ async function notificationLinkEndpoints(api, logger) {
 	});
 }
 //#endregion
+//#region src/notification-center/tracks-at-instant.ts
+/**
+* How many persisted rows the wiring reads per instant. A scene holds a handful
+* of subjects; the read is newest-first from the instant, so this bounds a
+* busy street without missing the tracks that were on screen.
+*/
+var NC_TRACKS_AT_INSTANT_LIMIT = 25;
+/**
+* Every source track with a position within `toleranceMs` of `timestamp`, its
+* nearest box normalised, deduplicated by track id (a live copy and a
+* persisted copy of one track are one track). Pure.
+*/
+function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims) {
+	const out = /* @__PURE__ */ new Map();
+	for (const track of sources) {
+		if (out.has(track.trackId)) continue;
+		if (track.firstSeen > timestamp + toleranceMs || track.lastSeen < timestamp - toleranceMs) continue;
+		const w = track.frameWidth ?? fallbackDims?.w ?? 0;
+		const h = track.frameHeight ?? fallbackDims?.h ?? 0;
+		if (w <= 0 || h <= 0) continue;
+		let best = null;
+		let bestDelta = Number.POSITIVE_INFINITY;
+		for (const p of track.positions) {
+			const delta = Math.abs(p.timestamp - timestamp);
+			if (delta < bestDelta) {
+				bestDelta = delta;
+				best = p;
+			}
+		}
+		if (best === null || bestDelta > toleranceMs) continue;
+		const label = track.subLabel ?? track.label;
+		out.set(track.trackId, {
+			trackId: track.trackId,
+			className: track.className,
+			...label !== void 0 && label !== track.className ? { label } : {},
+			...best.score !== void 0 ? { confidence: best.score } : {},
+			bbox: {
+				x: best.bbox.x / w,
+				y: best.bbox.y / h,
+				w: best.bbox.w / w,
+				h: best.bbox.h / h
+			}
+		});
+	}
+	return [...out.values()];
+}
+//#endregion
 //#region src/notification-center/artifact-read-plane.ts
 /**
 * Parse a single-range `Range` header against a known length.
@@ -23075,7 +23392,7 @@ function referenceOf(boxes) {
 function displaced(ref, b) {
 	return Math.hypot(b.x + b.w / 2 - ref.x, b.y + b.h / 2 - ref.y) > ref.span;
 }
-function judge(ref, run, b) {
+function judge$1(ref, run, b) {
 	const next = displaced(ref, b) ? run + 1 : 0;
 	return {
 		early: [],
@@ -23095,7 +23412,7 @@ function judgeAll(boxes) {
 	};
 	for (const b of boxes) {
 		if (probe.moved) return probe;
-		probe = judge(ref, probe.run, b);
+		probe = judge$1(ref, probe.run, b);
 	}
 	return probe;
 }
@@ -23110,7 +23427,7 @@ function isMeasurableBox(box) {
 function stepMovedProbe(probe, box) {
 	if (probe.moved || !isMeasurableBox(box)) return probe;
 	if (probe.reference !== null) {
-		const next = judge(probe.reference, probe.run, box);
+		const next = judge$1(probe.reference, probe.run, box);
 		return next.run === probe.run && !next.moved ? probe : next;
 	}
 	const early = [...probe.early, box];
@@ -26221,6 +26538,11 @@ var MAX_ARM_BUTTONS = 3;
 * | `alarm-arm-refused` | **Arma comunque**, bound to the row's refusal |
 * | `alarm-sensor-bypass` | nothing — it reports, there is nothing to undo |
 *
+* `alarm-triggered` and `alarm-pending` rows a RULE caused also carry **Bypass
+* this input**, bound to the row's (rule, input) pair: that one input stops
+* pressing the panel until the next disarm. It never cancels the countdown or
+* the siren already running — Disarm beside it does that.
+*
 * The `alarm-arming` row is the one that earns its keep: that notification
 * arrives at the START of the exit delay, so its Disarm is the only alarm
 * button an operator can press to cancel something rather than to undo it.
@@ -26257,7 +26579,7 @@ function buildAlarmButtons(input) {
 		};
 	});
 	const actionId = "alarm-disarm";
-	return [{
+	const disarm = {
 		id: actionId,
 		label: input.labels.disarm,
 		url: input.mintUrl({
@@ -26267,6 +26589,19 @@ function buildAlarmButtons(input) {
 		icon: "disarm",
 		destructive: true,
 		mode: "background"
+	};
+	const bypassable = input.bypassable;
+	if (bypassable === void 0 || input.kind !== "alarm-triggered" && input.kind !== "alarm-pending") return [disarm];
+	const bypassId = "alarm-bypass-input";
+	return [disarm, {
+		id: bypassId,
+		label: input.labels.bypassInput,
+		url: input.mintUrl({
+			actionId: bypassId,
+			action: "bypass-input",
+			...bypassable
+		}),
+		mode: "background"
 	}];
 }
 /**
@@ -26501,6 +26836,14 @@ function buildAlarmLive(input) {
 			deviceId: e.deviceId,
 			name: input.name(e.deviceId),
 			phase: e.phase
+		})),
+		bypassedInputs: input.bypasses.map((b) => ({
+			ruleId: b.ruleId,
+			ruleName: input.ruleName(b.ruleId) ?? b.ruleName,
+			deviceId: b.deviceId,
+			name: input.name(b.deviceId),
+			since: b.at,
+			dropped: b.dropped
 		}))
 	};
 }
@@ -28726,78 +29069,31 @@ function isCoolingDown(rule, lastFiredAt, now) {
 	return now - lastFiredAt < rule.throttle.cooldownSec * 1e3;
 }
 /**
-* The media policy EVERY sensor rule attaches: one whole-scene photograph,
-* never a selector. `attach: 'keyFrame'` is the existing "clean full scene
-* frame" ladder (`attachmentKindPreference`) — the closest existing concept
-* to a plain snapshot, as opposed to `'best'`/`'best-matching'`, which chase a
-* SUBJECT crop a sensor subject (a doorbell press, a contact change) has
-* none of to chase. No zone crop, no gif, no clip, no profile — a sensor
-* subject has no zone condition to crop to and no reason to animate.
-*/
-var NC_SENSOR_MEDIA_POLICY = { attach: "keyFrame" };
-/**
-* The media policy actually used to build a delivery, for a rule of this
-* KIND. A sensor rule's STORED `media` is never read at evaluation — the
-* editor offers no media control for one any more, and `media.attach` /
-* `.gif` / `.clip` / `.profile` on an existing sensor rule (authored before
-* this ruling, from the viewer or the API) are IGNORED here, never refused at
-* load. See {@link mediaPolicyMatchesSensorDefault} for the sampled-log gate.
+* The media policy a delivery is built from: the rule's own, with its picture
+* mode RESOLVED (`resolveNcMediaImage`) — a sensor rule included. Until D897 a
+* sensor rule's stored media was ignored for a fixed one-snapshot policy; it
+* now goes through the same selector and the same render stage as a detection
+* rule, its source frame being the linked camera's.
 */
 function effectiveMediaPolicy(rule, kind) {
-	return kind === "sensor" ? NC_SENSOR_MEDIA_POLICY : rule.media;
-}
-/**
-* True when a stored media policy already reads as the sensor default — the
-* gate the boot/evaluation path uses to decide whether an existing sensor
-* rule's stored choice is being silently overridden (and so is worth a
-* sampled log line) or already matches and there is nothing to say.
-*/
-function mediaPolicyMatchesSensorDefault(media) {
-	return media.attach === NC_SENSOR_MEDIA_POLICY.attach && media.frame === void 0 && media.zoneCrop !== true && media.gif !== true && media.clip !== true && media.profile === void 0;
+	return {
+		...rule.media,
+		image: require_clip_model_registry.resolveNcMediaImage(rule.media, kind)
+	};
 }
-/** `effectiveMediaPolicy`, resolving the kind itself — the call-site shortcut
-*  every production caller uses; `effectiveMediaPolicy` stays the unit under
-*  test because `ruleKindOf` needs no fixture of its own there. */
+/** `effectiveMediaPolicy`, resolving the kind itself — the call-site shortcut. */
 function effectiveMediaPolicyForRule(rule) {
 	return effectiveMediaPolicy(rule, require_clip_model_registry.ruleKindOf(rule));
 }
-/**
-* Ordered media-kind preference for one attachment, per policy and owner.
-* `best` favours the tight subject crop; `keyFrame` the clean scene frame
-* (small variant first — the degrade engine enforces per-backend byte
-* caps, but there is no reason to ship a native 4K frame by default).
-*/
-function attachmentKindPreference(policy, ownerKind) {
-	if (policy === "keyFrame") return ownerKind === "track" ? [
-		"keyFrameSmall",
-		"keyFrame",
-		SCENE_TWIN_KIND,
-		ROLLING_SCENE_TWIN_KIND,
-		"fullFrameBoxed",
-		"firstFrame",
-		"lastFrame",
-		"snapshot"
-	] : [
-		"fullFrameBoxed",
-		"fullFrame",
-		"crop"
-	];
-	return ownerKind === "track" ? [
-		"thumbnail",
-		"thumbnailSmall",
-		"crop",
-		"keyFrameSmall",
-		"firstFrame"
-	] : [
-		"crop",
-		"thumbnail",
-		"fullFrameBoxed"
-	];
+/** True when a rule ships no still at all. */
+function ruleShipsNoStill(rule) {
+	return effectiveMediaPolicyForRule(rule).image === "none";
 }
 /**
 * The media kinds whose stored bytes carry a BURNT-IN detection box.
 *
-* This is the family boundary for {@link framePreference}, and it exists as one
+* This is the family boundary for {@link cleanSourcePreference} (D897; the retired
+* `framePreference` before it), and it exists as one
 * exported constant because the alternative was tried and failed in production:
 * the `boxed` ladder listed `snapshot` / `lastFrame` / `firstFrame` as *"the
 * kinds that actually carry a burnt-in box today"* while, eleven lines below,
@@ -28813,7 +29109,7 @@ function attachmentKindPreference(policy, ownerKind) {
 *
 * ## Why `full` still ends with three of these kinds (D654)
 *
-* `framePreference('full', 'track')` used to reach these kinds as soon as the
+* The retired `framePreference('full', 'track')` used to reach these kinds as soon as the
 * key frame was out of band, so a rule asking for the clean scene was answered
 * with an annotated one: of 38 `frame:'full'` deliveries sha256-matched back to
 * stored media, **19 (50%) were `firstFrame` / `snapshot` / `lastFrame`**.
@@ -28876,90 +29172,36 @@ function isAnnotatedSceneKind(kind) {
 	return ANNOTATED_SCENE_KINDS.includes(kind);
 }
 /**
-* The kind ladder for an EXPLICIT frame choice. Strict by design — each option
-* stays inside its own family, because a rule that asked for the clean scene
-* and received the boxed one (or vice versa) is not "degrading gracefully", it
-* is answering a different question.
-*
-* Two exceptions, both degrading to the SAME scene and never to a subject
-* crop, which shows something else entirely: `boxed` with no annotated frame
-* stored falls back to the CLEAN scene; `full` with no clean frame stored falls
-* back, last, to the annotated tile of the trigger instant — reported by the
-* dispatcher on every delivery that reaches it (D654).
-*
-* **`boxed` used to decide nothing.** Its first rung was `fullFrameBoxed`, a
-* kind RETIRED for new tracks on 2026-07-21 (`event-media-dispatcher.ts`), and
-* the rest of the ladder was the clean `keyFrame` family — so an authorable
-* option degraded, silently and always, to exactly what `full` returns. A knob
-* that decides nothing is worse than no knob: the operator set it and believed
-* they had asked for something.
-*
-* The annotated frames were there the whole time under different names.
-* `firstFrame` / `snapshot` / `lastFrame` are written by `boxedTimelineFrame`
-* — the track's OWN box burned onto the native full frame — so `boxed` now asks
-* for them, newest-moment-first-per-family, before degrading to the clean
-* scene. No new capture path, no new kind, and the option answers its own
-* question again.
-*
-* The strictness is about FAMILY, and the family boundary is
-* {@link ANNOTATED_SCENE_KINDS} — ONE declaration, consumed by both ladders, so
-* `boxed` and `full` can never again hold different opinions about the same
-* kind. They did, and it shipped: see that constant.
-*/
-function framePreference(frame, ownerKind) {
-	if (frame === "cropped") return ownerKind === "track" ? [
-		"thumbnail",
-		"thumbnailSmall",
-		"crop"
-	] : [
-		"crop",
-		"thumbnail",
-		"thumbnailSmall"
-	];
-	if (frame === "boxed") return [
-		...ANNOTATED_SCENE_KINDS,
-		...CLEAN_SCENE_KINDS,
-		SCENE_TWIN_KIND,
-		ROLLING_SCENE_TWIN_KIND
-	];
+* The SOURCE ladder of every notification picture (D897): the clean whole-scene
+* kinds of an owner, best first, then — LAST — the annotated tiles, for a
+* track that holds no clean frame at all (written before the D654 twin, or a
+* twin write that failed). The picture is rendered from what this picks, by
+* mode (`notification-image.ts`), so a rule no longer chooses a stored KIND:
+* `crop` cuts the subject out of the clean frame, `scene-boxes` draws on it.
+*
+* `keyFrame` leads because it is the native best-detection frame — the crop
+* keeps its resolution; the scene modes downscale it once at render. The twins
+* (`sceneFrame` at a boxed tile's instant, `lastSceneFrame` at the rolling
+* one) are what MOMENT finds near the trigger when the best shot is later.
+* A still-shelf photograph holds `keyFrameSmall` / `keyFrame` / `fullFrame`,
+* so a sound or a linked-camera still resolves through the same ladder.
+*/
+function cleanSourcePreference(ownerKind) {
 	return ownerKind === "track" ? [
 		"keyFrame",
 		"keyFrameSmall",
 		SCENE_TWIN_KIND,
 		ROLLING_SCENE_TWIN_KIND,
+		"fullFrame",
 		"firstFrame",
 		"lastFrame",
-		"snapshot"
+		"snapshot",
+		"fullFrameBoxed"
 	] : [
 		"fullFrame",
 		"keyFrame",
-		"keyFrameSmall"
-	];
-}
-/**
-* Derive the `best-matching` media signal from a matched rule's condition
-* summary ({@link NcEvaluation.matchedOn}). Identity takes priority over plate
-* (D-3 ordering: a face rule that ALSO plate-matched attaches the face crop).
-*/
-function matchSignal(matchedOn) {
-	if (matchedOn === void 0) return null;
-	if (matchedOn.includes("identities")) return "face";
-	if (matchedOn.includes("plates")) return "plate";
-	return null;
-}
-/**
-* Ordered media-kind preference for a `best-matching` attachment. The
-* signal-specific crop (`faceCrop` / `plateCrop`, both event-owned) leads;
-* then the plain `best` subject ladder, then the `keyFrame` clean-scene
-* ladder — so a missing specific crop degrades to best → keyFrame → none
-* (the dispatcher returns null when nothing resolves) without ever blocking
-* the send. A `null` signal is exactly the `best` ladder.
-*/
-function bestMatchingKindPreference(signal, ownerKind) {
-	return [
-		...signal === "face" ? ["faceCrop"] : signal === "plate" ? ["plateCrop"] : [],
-		...attachmentKindPreference("best", ownerKind),
-		...attachmentKindPreference("keyFrame", ownerKind)
+		"keyFrameSmall",
+		"fullFrameBoxed"
 	];
 }
 //#endregion
@@ -31354,7 +31596,8 @@ var NcGroupMemberFateSchema = require_clip_model_registry.union([require_clip_mo
 	"close-failed",
 	"alarm-entry-delay-started",
 	"alarm-entry-delay",
-	"alarm-sensor-excluded"
+	"alarm-sensor-excluded",
+	"alarm-input-bypassed"
 ]), require_clip_model_registry.templateLiteral(["failed-condition:", require_clip_model_registry.string()])]);
 /** Read cap, so a client cannot ask for the whole ring in one call. */
 var MAX_QUERY_LIMIT = 200;
@@ -31666,6 +31909,8 @@ var NcPruneRecordSchema = require_clip_model_registry.object({
 });
 /** Rules × deleted subjects — small; a generous ceiling. */
 var LOAD_LIMIT$1 = 1e4;
+/** Page size of the load's records query. */
+var LOAD_PAGE = 1e3;
 function keyOf$1(row) {
 	return `${row.kind}:${row.ruleId}:${row.field}:${row.subject}`;
 }
@@ -31691,18 +31936,23 @@ NC_DEVICE_PRUNES_SPEC.fromRecord, NC_DEVICE_PRUNES_SPEC.toValue, NC_DEVICE_PRUNE
 var KEPT_OUTCOMES = new Set(["kept-disabled", "kept"]);
 var NcPruneLedger = class {
 	ledger;
-	store;
+	/**
+	* The SAME handle the ledger writes through — the records kind wherever
+	* `ctx.records` exists. The load reads it, never the legacy table: no boot
+	* declares that table any more, so a direct read of it fails forever.
+	*/
+	kind;
 	logger;
 	loaded = false;
 	/** Bumped on every {@link record} write — a load ignores keys written after it began. */
 	writes = 0;
 	writtenAt = /* @__PURE__ */ new Map();
 	constructor(deps) {
-		this.store = deps.store;
 		this.logger = deps.logger;
+		this.kind = resolveDurableKind(NC_DEVICE_PRUNES_SPEC, ncDurableRecordKinds["device-prunes"], deps);
 		this.ledger = new DurableLedger({
 			spec: NC_DEVICE_PRUNES_SPEC,
-			kind: resolveDurableKind(NC_DEVICE_PRUNES_SPEC, ncDurableRecordKinds["device-prunes"], deps),
+			kind: this.kind,
 			logger: deps.logger
 		});
 	}
@@ -31718,15 +31968,7 @@ var NcPruneLedger = class {
 		const startedAt = this.writes;
 		const writtenSince = (key) => (this.writtenAt.get(key) ?? 0) > startedAt;
 		try {
-			const records = await this.store.query.query({
-				collection: NC_DEVICE_PRUNES_COLLECTION,
-				filter: { limit: LOAD_LIMIT$1 }
-			});
-			const next = /* @__PURE__ */ new Map();
-			for (const record of records) {
-				const row = NC_DEVICE_PRUNES_SPEC.fromRecord(record.id, record.data);
-				if (row !== null) next.set(keyOf$1(row), row);
-			}
+			const next = await this.readAll();
 			for (const key of heldBefore) if (!next.has(key) && !writtenSince(key)) this.ledger.evict(key);
 			for (const [key, row] of next) if (!writtenSince(key)) this.ledger.stage(row);
 			this.loaded = true;
@@ -31738,6 +31980,26 @@ var NcPruneLedger = class {
 			} });
 		}
 	}
+	/** Every row the kind holds, paged. THROWS on a failed page — `load` is the guard. */
+	async readAll() {
+		const next = /* @__PURE__ */ new Map();
+		let seen = 0;
+		let cursor;
+		while (seen < LOAD_LIMIT$1) {
+			const page = await this.kind.query({
+				limit: Math.min(LOAD_PAGE, LOAD_LIMIT$1 - seen),
+				...cursor === void 0 ? {} : { cursor }
+			});
+			seen += page.records.length;
+			for (const record of page.records) {
+				const row = NC_DEVICE_PRUNES_SPEC.fromRecord(record.id, record.data);
+				if (row !== null) next.set(keyOf$1(row), row);
+			}
+			if (page.nextCursor === null || page.records.length === 0) break;
+			cursor = page.nextCursor;
+		}
+		return next;
+	}
 	/** Has a load ever SUCCEEDED? The pruner acts on nothing until it has. */
 	isLoaded() {
 		return this.loaded;
@@ -32141,6 +32403,7 @@ var en_default = {
 	},
 	"button.alarm.disarm": "Disarm",
 	"button.alarm.armAnyway": "Arm anyway",
+	"button.alarm.bypassInput": "Bypass until disarm",
 	"button.alarm.arm.home": "Arm home",
 	"button.alarm.arm.away": "Arm away",
 	"button.alarm.arm.night": "Arm night",
@@ -32527,6 +32790,7 @@ var it_default = {
 	},
 	"button.alarm.disarm": "Disarma",
 	"button.alarm.armAnyway": "Arma comunque",
+	"button.alarm.bypassInput": "Escludi fino al disinserimento",
 	"button.alarm.arm.home": "Arma casa",
 	"button.alarm.arm.away": "Arma fuori",
 	"button.alarm.arm.night": "Arma notte",
@@ -33995,6 +34259,65 @@ function sameConfirm(a, b) {
 	return a?.enabled === true === (b?.enabled === true) && a?.expect?.op === b?.expect?.op && a?.expect?.count === b?.expect?.count;
 }
 //#endregion
+//#region src/notification-center/media-guard.ts
+/**
+* The hub's half of D897: a rule's picture is ONE mode (`media.image`) plus
+* `showTriggerZone`, and both are judged against the rule they are saved on.
+*
+*  - `showTriggerZone` draws the zone that FIRED the rule. A rule whose trigger
+*    is not a zone (no `zones` condition, no occupancy zone) has nothing to
+*    draw, so the flag is refused rather than stored as a knob that does
+*    nothing.
+*  - `image` must be a mode the rule's kind can honour
+*    (`imageModesForKind`): a sound owns no region of the frame, so it is never
+*    offered `crop`.
+*
+* The predicate is `ncMediaPolicyError` (`@camstack/types`), read by the admin
+* editor too. It runs on both save routes — the cap provider
+* (`notificationRules.createRule/updateRule`) and the rule bridge
+* (`nc.createRule/updateRule`) — beside the other guards.
+*
+* Only media the CALLER sent is judged: a create's `media`, an update's
+* `media`, against the MERGED delivery and conditions. A stored rule is never
+* judged on load — `normalizeNcMediaPolicy` drops a flag it cannot draw there,
+* because a refusal at load would cost the rule its notifications.
+*
+* Not in Zod for the reason `rule-family-guard.ts` gives: a refine would also
+* run when the store LOADS a rule.
+*/
+var NcMediaPolicyRefusal = class extends Error {
+	reason;
+	constructor(reason) {
+		super(`rule refused: ${reason}`);
+		this.name = "NcMediaPolicyRefusal";
+		this.reason = reason;
+	}
+};
+function judge(subject, ctx) {
+	if (subject.media === void 0) return;
+	const reason = require_clip_model_registry.ncMediaPolicyError(subject.media, subject);
+	if (reason === null) return;
+	ctx.logger.warn("nc rule refused: media policy the rule cannot honour", { meta: {
+		...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
+		by: ctx.by,
+		reason
+	} });
+	throw new NcMediaPolicyRefusal(reason);
+}
+/** The create path of both routes. */
+function guardRuleMedia(rule, ctx) {
+	judge(rule, ctx);
+}
+/** The update path of both routes: the patch's media on the MERGED rule. */
+function guardPatchMedia(existing, patch, ctx) {
+	if (existing === null || patch.media === void 0) return;
+	judge({
+		delivery: patch.delivery ?? existing.delivery,
+		conditions: patch.conditions ?? existing.conditions,
+		media: patch.media
+	}, ctx);
+}
+//#endregion
 //#region src/notification-center/occupancy-watcher.ts
 /** Sentinel key segments for the "no zone" (whole-frame) and "no class" scopes. */
 var FRAME_SCOPE = "@frame";
@@ -36279,6 +36602,29 @@ var NcAlarmStatusSchema = require_clip_model_registry.object({
 	deviceId: require_clip_model_registry.number().int().nullable(),
 	live: require_clip_model_registry.NcAlarmConfigSchema.shape.live.unwrap().nullable()
 });
+/** `nc.bypassAlarmInput` — one (rule, input) pair, until the next disarm. */
+var NcAlarmBypassInputRequestSchema = require_clip_model_registry.object({
+	ruleId: require_clip_model_registry.string().min(1),
+	/** The input: the sensor whose match pressed the panel, else the camera. */
+	deviceId: require_clip_model_registry.number().int()
+});
+var NcAlarmBypassInputResultSchema = require_clip_model_registry.object({
+	outcome: require_clip_model_registry._enum([
+		"bypassed",
+		"already-bypassed",
+		"refused"
+	]),
+	/**
+	* Why a `refused` did nothing: the panel is disarmed, the rule is not an
+	* alarm rule with this input, or the per-arm bound is reached. Null otherwise.
+	*/
+	reason: require_clip_model_registry._enum([
+		"disarmed",
+		"stale",
+		"full",
+		"not-an-input"
+	]).nullable()
+});
 /**
 * The action catalog — the tRPC contract Group B (the viewer client) consumes
 * against `addonId: 'pipeline-analytics'`. Every entry that depends on the
@@ -36407,6 +36753,17 @@ var ncActions = require_clip_model_registry.defineCustomActions({
 		caller: "required"
 	}),
 	/**
+	* "Bypass this input until disarm" from the app — the same panel path the
+	* trigger notification's button takes, for the same principals who may
+	* disarm here (admin). The live view (`nc.getAlarmStatus`) then lists it
+	* under `bypassedInputs` until the next disarm.
+	*/
+	"nc.bypassAlarmInput": require_clip_model_registry.customAction(NcAlarmBypassInputRequestSchema, NcAlarmBypassInputResultSchema, {
+		kind: "mutation",
+		auth: "admin",
+		caller: "required"
+	}),
+	/**
 	* What the deleted-device / deleted-target prune did to the rules
 	* (`device-prune-runner.ts`) — the source of the banner both UIs show on a
 	* rule it switched off ("Disabled on <date>: its last device (#id) was
@@ -37087,6 +37444,10 @@ function makeNcActionHandlers(deps) {
 				logger: deps.logger,
 				by: c.userId
 			});
+			guardRuleMedia(parsed, {
+				logger: deps.logger,
+				by: c.userId
+			});
 			guardRuleDevicesExclude(parsed, {
 				logger: deps.logger,
 				by: c.userId
@@ -37139,6 +37500,11 @@ function makeNcActionHandlers(deps) {
 				by: c.userId,
 				ruleId: input.ruleId
 			});
+			guardPatchMedia(existing, patch, {
+				logger: deps.logger,
+				by: c.userId,
+				ruleId: input.ruleId
+			});
 			guardPatchDevicesExclude(existing, patch, {
 				logger: deps.logger,
 				by: c.userId,
@@ -37244,6 +37610,10 @@ function makeNcActionHandlers(deps) {
 			await requireAlarm("nc.disarmAlarm").disarm(c.userId);
 			return { success: true };
 		},
+		"nc.bypassAlarmInput": async (input, caller) => {
+			const c = requireAdmin(caller);
+			return requireAlarm("nc.bypassAlarmInput").bypassInput(input, c.userId);
+		},
 		"nc.listPrunes": async (_input, caller) => {
 			requireAdmin(caller);
 			const list = deps.listPrunes;
@@ -40251,7 +40621,7 @@ var GLYPH_ADVANCE = .56;
 var LABEL_USABLE_FRACTION = .94;
 /** `<`, `>`, `&`, `'`, `"` in a camera name or an operator caption would each
 *  turn the overlay into a document librsvg refuses. */
-function escapeXml$2(s) {
+function escapeXml$3(s) {
 	return s.replace(/[<>&'"]/g, (ch) => {
 		switch (ch) {
 			case "<": return "&lt;";
@@ -40419,7 +40789,7 @@ function tileLabelSvg(width, height, label) {
 	const baseline = height - Math.round((bandHeight - fitted.fontPx) / 2) - Math.round(fitted.fontPx * .18);
 	return Buffer.from(`<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
   <rect x="0" y="${height - bandHeight}" width="${width}" height="${bandHeight}" fill="black" fill-opacity="0.55"/>
-  <text x="${padding}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" fill="white">${escapeXml$2(fitted.text)}</text>
+  <text x="${padding}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" fill="white">${escapeXml$3(fitted.text)}</text>
 </svg>`);
 }
 /** The mosaic's own title band. */
@@ -40428,7 +40798,7 @@ function titleSvg(width, height, caption) {
 	const baseline = Math.round(height / 2 + fitted.fontPx * .36);
 	return Buffer.from(`<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
   <rect x="0" y="0" width="${width}" height="${height}" fill="#111111"/>
-  <text x="${Math.round(width / 2)}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" text-anchor="middle" fill="white">${escapeXml$2(fitted.text)}</text>
+  <text x="${Math.round(width / 2)}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" text-anchor="middle" fill="white">${escapeXml$3(fitted.text)}</text>
 </svg>`);
 }
 /**
@@ -40851,11 +41221,11 @@ function withTimeout$3(promise, ms, what) {
 *    {@link NC_GROUPED_MOSAIC_MAX_TILES}; the sentence still counts every member;
 *  - each tile is resolved through the rule's own ladder on a DERIVED entry
 *    ({@link groupedTileEntry}) that carries the member's own subject, zones and
-*    `matchedOn`, forced to `cropped` (N full scenes would be the same picture N times)
-*    and never zone-cropped.
+*    `matchedOn`, rendered as `crop` (N full scenes would be the same picture N times)
+*    and never with a zone drawn.
 *  - a member whose owner is a PHOTOGRAPH held in RAM (a sensor's linked-camera still or a
 *    still-shelf capture — an alarm incident's sensor member, D705) owns no subject crop:
-*    its tile is the whole photograph (`full`), or it would never land;
+*    its tile is the whole photograph (`clean`), or it would never land;
 *  - a tile is about its member ALONE: the row's system event (an alarm's `alarmSource`)
 *    is dropped, or the member's object read would be scoped to the source's generation.
 *
@@ -40896,16 +41266,18 @@ function ownsSubjectCrop(ownerId) {
 /**
 * A NEW entry whose media read is about ONE member. Never mutates `entry`.
 *
-* Drops the primary's `mediaZoneIds` (no zone crop on a tile), its `triggerZoneIds` and
-* `matchedOn` (the member's own replace them, or none), and forces `mediaFrame: 'cropped'` (`full` for a RAM photograph — see the header).
+* Drops the primary's zone overlay (no zone on a tile — `mediaShowTriggerZone`, and a
+* legacy row's `mediaZoneIds`), its `triggerZoneIds` and `matchedOn` (the member's own
+* replace them, or none), and renders the tile as `crop` (`clean` for a RAM photograph —
+* see the header) through the same image stage as every still (D897).
 */
 function groupedTileEntry(entry, m) {
-	const { mediaZoneIds: _zoneCrop, triggerZoneIds: _primaryZones, matchedOn: _primaryMatch, ...payload } = entry.payload;
+	const { mediaZoneIds: _zoneCrop, mediaShowTriggerZone: _zoneOverlay, mediaFrame: _legacyFrame, triggerZoneIds: _primaryZones, matchedOn: _primaryMatch, ...payload } = entry.payload;
 	return {
 		...entry,
 		payload: {
 			...payload,
-			mediaFrame: ownsSubjectCrop(m.trackId) ? "cropped" : "full",
+			mediaImage: ownsSubjectCrop(m.trackId) ? "crop" : "clean",
 			subject: memberSubject(entry.payload.subject, m, entry.deviceId),
 			...m.triggerZoneIds !== void 0 ? { triggerZoneIds: m.triggerZoneIds } : {},
 			...m.matchedOn !== void 0 ? { matchedOn: m.matchedOn } : {}
@@ -41338,8 +41710,9 @@ function zoneOverlap(point, polygons) {
 	}
 	return best;
 }
-/** The trail point closest to `timestamp`, or null when none is close enough. */
-function trailAt(trail, timestamp) {
+/** The trail point closest to `timestamp`, or null when none is within `maxMs`
+*  (default {@link TRAIL_MATCH_MAX_MS}). */
+function trailAt(trail, timestamp, maxMs = TRAIL_MATCH_MAX_MS) {
 	let best = null;
 	let bestDelta = Number.POSITIVE_INFINITY;
 	for (const point of trail) {
@@ -41349,7 +41722,7 @@ function trailAt(trail, timestamp) {
 			best = point;
 		}
 	}
-	return best !== null && bestDelta <= TRAIL_MATCH_MAX_MS ? best : null;
+	return best !== null && bestDelta <= maxMs ? best : null;
 }
 /**
 * The candidates that show the subject inside the triggering zone, in the order
@@ -41367,6 +41740,407 @@ function selectTriggerZoneCandidates(input) {
 	return strict === true ? [] : candidates;
 }
 //#endregion
+//#region src/notification-center/notification-image.ts
+/** How long a rendered picture is reused for the same record (N targets, retries). */
+var NC_IMAGE_MEMO_TTL_MS = 15 * 6e4;
+/** At most this many rendered pictures are held. */
+var NC_IMAGE_MEMO_MAX = 128;
+/** How far a trail point may sit from the source frame's instant and still be its box. */
+var NC_IMAGE_BOX_MATCH_MAX_MS = 750;
+/** A scene picture is downscaled to at most this width (a phone shows it). */
+var NC_IMAGE_SCENE_MAX_WIDTH = 1920;
+/** A crop is downscaled to at most this long edge. */
+var NC_IMAGE_CROP_MAX_EDGE = 1280;
+/** Padding around the subject box of a crop, as a fraction of the box's side. */
+var NC_IMAGE_CROP_PAD = .25;
+/** The subject's outline. */
+var NC_IMAGE_SUBJECT_COLOR = "#ffb300";
+/** Every other track's outline. */
+var NC_IMAGE_OTHER_COLOR = "#f2f2f2";
+/** The trigger zone's outline. */
+var NC_IMAGE_ZONE_COLOR = "#29b6f6";
+/** Two tracks whose boxes overlap this much at one instant are the same subject (a fused id). */
+var SAME_SUBJECT_IOU = .8;
+var JPEG_QUALITY = 85;
+/** The caption of a box: class (or label) and confidence — "dog 87%". Language-free. */
+function imageLabelText(name, confidence) {
+	if (confidence === void 0 || !Number.isFinite(confidence)) return name;
+	const pct = Math.round(Math.min(1, Math.max(0, confidence)) * 100);
+	return `${name} ${String(pct)}%`;
+}
+/** Stroke widths for an output of this size: the subject's is the thick one. */
+function overlayStrokes(width, height) {
+	const subject = Math.max(4, Math.round(Math.min(width, height) / 110));
+	return {
+		subject,
+		other: Math.max(2, Math.round(subject / 2.5))
+	};
+}
+function escapeXml$2(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function clampPx(value, max) {
+	return Math.max(0, Math.min(Math.round(value), max));
+}
+/** Scale a normalised box to an output of `width` × `height`, clamped inside it. */
+function toPixels(box, width, height) {
+	const x = clampPx(box.x * width, width - 1);
+	const y = clampPx(box.y * height, height - 1);
+	return {
+		x,
+		y,
+		w: Math.max(1, Math.min(Math.round(box.w * width), width - x)),
+		h: Math.max(1, Math.min(Math.round(box.h * height), height - y))
+	};
+}
+/**
+* The SVG drawn over a scene picture of `width` × `height`. The subject is
+* drawn LAST so a crowd never hides it. Captions sit on a dark plate above
+* the box (inside it when the box touches the top edge), white text.
+*/
+function notificationOverlaySvg(input) {
+	const { width, height } = input;
+	const strokes = overlayStrokes(width, height);
+	const fontSize = Math.max(14, Math.round(height / 36));
+	const parts = [];
+	for (const zone of input.zones) {
+		if (zone.length < 3) continue;
+		const points = zone.map((p) => `${String(clampPx(p.x * width, width))},${String(clampPx(p.y * height, height))}`).join(" ");
+		parts.push(`<polygon data-role="zone" points="${points}" fill="${NC_IMAGE_ZONE_COLOR}" fill-opacity="0.18" stroke="${NC_IMAGE_ZONE_COLOR}" stroke-width="${String(strokes.other)}" stroke-dasharray="${String(strokes.subject * 2)},${String(strokes.subject)}"/>`);
+	}
+	const ordered = [...input.boxes.filter((b) => b.role === "other"), ...input.boxes.filter((b) => b.role === "subject")];
+	for (const box of ordered) {
+		const subject = box.role === "subject";
+		const color = subject ? NC_IMAGE_SUBJECT_COLOR : NC_IMAGE_OTHER_COLOR;
+		const stroke = subject ? strokes.subject : strokes.other;
+		parts.push(`<rect data-role="${box.role}" x="${String(box.x)}" y="${String(box.y)}" width="${String(box.w)}" height="${String(box.h)}" fill="none" stroke="${color}" stroke-width="${String(stroke)}"/>`);
+		if (box.label.length === 0) continue;
+		const plateH = Math.round(fontSize * 1.35);
+		const plateW = Math.round(box.label.length * fontSize * .62 + fontSize * .8);
+		const plateY = box.y - plateH >= 0 ? box.y - plateH : box.y;
+		const plateX = Math.min(box.x, Math.max(0, width - plateW));
+		parts.push(`<rect data-role="${box.role}-plate" x="${String(plateX)}" y="${String(plateY)}" width="${String(plateW)}" height="${String(plateH)}" fill="#000000" fill-opacity="0.72" stroke="${color}" stroke-width="${String(subject ? 2 : 1)}"/>`, `<text data-role="${box.role}-label" x="${String(plateX + Math.round(fontSize * .4))}" y="${String(plateY + Math.round(plateH * .75))}" font-family="DejaVu Sans, Helvetica, Arial, sans-serif" font-size="${String(fontSize)}" font-weight="${subject ? "700" : "400"}" fill="#ffffff">${escapeXml$2(box.label)}</text>`);
+	}
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(width)}" height="${String(height)}">${parts.join("")}</svg>`;
+}
+/** The pixel rectangle a `crop` cuts from a `width` × `height` frame, or null when too small. */
+function subjectCropRect(box, width, height) {
+	const px = toPixels(box, width, height);
+	const padX = Math.max(16, Math.round(px.w * NC_IMAGE_CROP_PAD));
+	const padY = Math.max(16, Math.round(px.h * NC_IMAGE_CROP_PAD));
+	const left = Math.max(0, px.x - padX);
+	const top = Math.max(0, px.y - padY);
+	const right = Math.min(width, px.x + px.w + padX);
+	const bottom = Math.min(height, px.y + px.h + padY);
+	if (right - left < 16 || bottom - top < 16) return null;
+	return {
+		left,
+		top,
+		width: right - left,
+		height: bottom - top
+	};
+}
+function iou$4(a, b) {
+	const x1 = Math.max(a.x, b.x);
+	const y1 = Math.max(a.y, b.y);
+	const x2 = Math.min(a.x + a.w, b.x + b.w);
+	const y2 = Math.min(a.y + a.h, b.y + b.h);
+	const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+	const union = a.w * a.h + b.w * b.h - inter;
+	return union <= 0 ? 0 : inter / union;
+}
+/**
+* The tracks to draw thin: every track at the instant except the subject —
+* the same id, or a box that is the subject's (a fused id reads under its
+* survivor's name).
+*/
+function otherTracks(tracks, subjectTrackId, subjectBox) {
+	return tracks.filter((t) => t.trackId !== subjectTrackId && (subjectBox === null || iou$4(t.bbox, subjectBox) < SAME_SUBJECT_IOU));
+}
+/**
+* What picture a ROW asks for. A row written since D897 carries `mediaImage`;
+* an older row (still in the outbox across the upgrade) is read through what
+* its legacy fields meant — the same mapping the rule migration applies.
+*/
+function payloadImageMode(payload) {
+	if (payload.media === "none") return "none";
+	if (payload.mediaImage !== void 0) return payload.mediaImage;
+	if (payload.mediaZoneIds !== void 0 && payload.mediaZoneIds.length > 0) return "clean";
+	if (payload.mediaFrame === "full") return "clean";
+	if (payload.mediaFrame === "boxed") return "scene-boxes";
+	if (payload.mediaFrame === "cropped") return "crop";
+	if (payload.media === "keyFrame") return "clean";
+	return "crop";
+}
+/** The zone ids a row's picture outlines: the zones that fired it, when it asked. */
+function payloadZoneOverlayIds(payload) {
+	if (payload.mediaShowTriggerZone === true) return payload.triggerZoneIds ?? [];
+	if (payload.mediaImage === void 0) return payload.mediaZoneIds ?? [];
+	return [];
+}
+/**
+* Which camera the primary still SHOWS, or `composite` when it is a composed
+* mosaic of several. A sensor row of a linked set names its cameras primary
+* first; in `each` mode the primary's still is that first camera's alone.
+*/
+function primaryImageCamera(payload) {
+	const linked = payload.subject.linkedCameraIds;
+	if (linked === void 0 || linked.length === 0) return payload.subject.deviceId;
+	if (linked.length > 1 && payload.subject.extraStills === void 0) return "composite";
+	return linked[0] ?? payload.subject.deviceId;
+}
+/** True when the row's subject is a tracked subject (not a RAM photograph owner). */
+function hasTrackedSubject(trackId) {
+	return trackId !== void 0 && !isLinkedStillId(trackId) && !isStillShelfId(trackId);
+}
+function toArrayBufferBytes(buf) {
+	const out = new Uint8Array(buf.byteLength);
+	out.set(buf);
+	return out;
+}
+/**
+* Render one picture from a clean JPEG. A `crop` with no box, and every
+* `clean`, are the scene with nothing drawn. Throws on undecodable bytes; the
+* stage turns that into the source shipped as it is.
+*/
+async function renderNotificationImage(req) {
+	const { default: sharp$18 } = await import("sharp");
+	const meta = await sharp$18(Buffer.from(req.bytes)).metadata();
+	const srcW = meta.width ?? 0;
+	const srcH = meta.height ?? 0;
+	if (srcW === 0 || srcH === 0) throw new Error("source frame has no dimensions");
+	if (req.mode === "crop" && req.subject !== null) {
+		const rect = subjectCropRect(req.subject, srcW, srcH);
+		if (rect !== null) return {
+			bytes: toArrayBufferBytes(await sharp$18(Buffer.from(req.bytes)).extract(rect).resize({
+				width: NC_IMAGE_CROP_MAX_EDGE,
+				height: NC_IMAGE_CROP_MAX_EDGE,
+				fit: "inside",
+				withoutEnlargement: true
+			}).jpeg({ quality: JPEG_QUALITY }).toBuffer()),
+			name: "crop.jpg",
+			rendered: "crop"
+		};
+	}
+	const scale = Math.min(1, NC_IMAGE_SCENE_MAX_WIDTH / srcW);
+	const outW = Math.max(1, Math.round(srcW * scale));
+	const outH = Math.max(1, Math.round(srcH * scale));
+	const boxes = req.mode === "scene-boxes" ? [...req.others.map((o) => ({
+		...toPixels(o, outW, outH),
+		role: "other",
+		label: o.label
+	})), ...req.subject !== null ? [{
+		...toPixels(req.subject, outW, outH),
+		role: "subject",
+		label: req.subject.label
+	}] : []] : [];
+	const zones = req.mode === "crop" ? [] : req.zones;
+	let pipeline = sharp$18(Buffer.from(req.bytes)).resize({
+		width: outW,
+		height: outH,
+		fit: "fill"
+	});
+	if (boxes.length > 0 || zones.length > 0) {
+		const svg = notificationOverlaySvg({
+			width: outW,
+			height: outH,
+			boxes,
+			zones
+		});
+		pipeline = pipeline.composite([{
+			input: Buffer.from(svg),
+			top: 0,
+			left: 0
+		}]);
+	}
+	const out = await pipeline.jpeg({ quality: JPEG_QUALITY }).toBuffer();
+	const rendered = req.mode === "scene-boxes" && boxes.length > 0 ? "scene-boxes" : "clean";
+	return {
+		bytes: toArrayBufferBytes(out),
+		name: `${rendered}.jpg`,
+		rendered
+	};
+}
+var NcNotificationImageStage = class {
+	deps;
+	memo = /* @__PURE__ */ new Map();
+	render;
+	constructor(deps) {
+		this.deps = deps;
+		this.render = deps.render ?? renderNotificationImage;
+	}
+	/** Rendered pictures currently held (spec + diagnostics). */
+	size() {
+		return this.memo.size;
+	}
+	/**
+	* The picture for this row from this source, rendered once per record +
+	* subject + mode + zone flag + camera and reused for every target and retry.
+	* Null when the row ships no still.
+	*/
+	async notificationImage(input) {
+		const payload = input.entry.payload;
+		const mode = payloadImageMode(payload);
+		if (mode === "none") return null;
+		const zoneIds = input.withSubject ? payloadZoneOverlayIds(payload) : [];
+		const key = [
+			input.entry.recordId,
+			payload.subject.trackId ?? "",
+			mode,
+			zoneIds.length > 0 ? "z" : "-",
+			String(input.camera)
+		].join("|");
+		const now = this.deps.now();
+		const hit = this.memo.get(key);
+		if (hit !== void 0 && now - hit.at <= NC_IMAGE_MEMO_TTL_MS) {
+			this.memo.delete(key);
+			this.memo.set(key, hit);
+			return hit.value;
+		}
+		const value = this.compute(input, mode, zoneIds);
+		this.remember(key, {
+			at: now,
+			value
+		});
+		value.then((image) => {
+			if (image.reason === "render-failed") this.memo.delete(key);
+		}, () => this.memo.delete(key));
+		return value;
+	}
+	remember(key, entry) {
+		const now = this.deps.now();
+		for (const [k, v] of this.memo) if (now - v.at > NC_IMAGE_MEMO_TTL_MS) this.memo.delete(k);
+		while (this.memo.size >= NC_IMAGE_MEMO_MAX) {
+			const oldest = this.memo.keys().next();
+			if (oldest.done === true) break;
+			this.memo.delete(oldest.value);
+		}
+		this.memo.set(key, entry);
+	}
+	async compute(input, mode, zoneIds) {
+		const { entry, source, camera } = input;
+		const payload = entry.payload;
+		if (source.annotated) return this.asStored(input, mode, "annotated-source");
+		if (camera === "composite") return mode === "clean" ? this.asStored(input, mode) : this.asStored(input, mode, "composite-source");
+		const subjectTrackId = input.withSubject ? payload.subject.trackId : void 0;
+		const subjectBox = hasTrackedSubject(subjectTrackId) ? await this.subjectBoxAt(camera, subjectTrackId, source.timestamp) : null;
+		const subject = subjectBox !== null ? {
+			...subjectBox,
+			label: imageLabelText(payload.subject.label ?? payload.subject.className, payload.subject.confidence)
+		} : null;
+		const others = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox).map((t) => ({
+			...t.bbox,
+			label: imageLabelText(t.label ?? t.className, t.confidence)
+		})) : [];
+		const zones = mode === "crop" || zoneIds.length === 0 ? [] : await this.zonePolygons(camera, zoneIds);
+		try {
+			const image = await this.render({
+				mode,
+				bytes: source.bytes,
+				subject,
+				others,
+				zones
+			});
+			const reason = image.rendered === mode ? void 0 : mode === "crop" ? "no-subject-box" : "no-tracks-at-instant";
+			if (reason !== void 0) this.reportFallback(input, mode, reason);
+			return reason !== void 0 ? {
+				...image,
+				reason
+			} : image;
+		} catch (err) {
+			this.deps.logger.warn("notification picture render failed — shipping the source frame", {
+				tags: { deviceId: camera },
+				meta: {
+					ruleId: entry.ruleId,
+					recordId: entry.recordId,
+					asked: mode,
+					kind: source.kind,
+					error: String(err)
+				}
+			});
+			return {
+				bytes: source.bytes,
+				name: `${source.kind}.jpg`,
+				rendered: "clean",
+				reason: "render-failed"
+			};
+		}
+	}
+	asStored(input, mode, reason) {
+		if (reason !== void 0) this.reportFallback(input, mode, reason);
+		return {
+			bytes: input.source.bytes,
+			name: `${input.source.kind}.jpg`,
+			rendered: input.source.annotated ? "scene-boxes" : "clean",
+			...reason !== void 0 ? { reason } : {}
+		};
+	}
+	/** ONE line per rendered record (the memo makes it so): what was asked, what ships, why. */
+	reportFallback(input, asked, reason) {
+		const camera = input.camera === "composite" ? input.entry.payload.subject.deviceId : input.camera;
+		this.deps.logger.info("notification picture shipped without the mode the rule asked for", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: input.entry.ruleId,
+				recordId: input.entry.recordId,
+				...input.entry.payload.subject.trackId !== void 0 ? { trackId: input.entry.payload.subject.trackId } : {},
+				asked,
+				reason,
+				kind: input.source.kind,
+				offsetMs: input.source.timestamp - input.entry.payload.subject.timestamp
+			}
+		});
+	}
+	async subjectBoxAt(camera, trackId, timestamp) {
+		const read = this.deps.getSubjectTrail;
+		if (read === void 0) return null;
+		try {
+			return trailAt(await read(camera, trackId), timestamp, NC_IMAGE_BOX_MATCH_MAX_MS)?.bbox ?? null;
+		} catch (err) {
+			this.deps.logger.debug("subject trail read failed — no subject box on the picture", {
+				tags: { deviceId: camera },
+				meta: {
+					trackId,
+					error: String(err)
+				}
+			});
+			return null;
+		}
+	}
+	async tracksAt(camera, timestamp) {
+		const read = this.deps.getTracksAt;
+		if (read === void 0) return [];
+		try {
+			return await read(camera, timestamp, NC_IMAGE_BOX_MATCH_MAX_MS);
+		} catch (err) {
+			this.deps.logger.debug("tracks-at-instant read failed — no other boxes on the picture", {
+				tags: { deviceId: camera },
+				meta: {
+					timestamp,
+					error: String(err)
+				}
+			});
+			return [];
+		}
+	}
+	async zonePolygons(camera, zoneIds) {
+		const read = this.deps.getZonePolygons;
+		if (read === void 0) return [];
+		try {
+			return await read(camera, zoneIds);
+		} catch (err) {
+			this.deps.logger.debug("zone polygon read failed — the trigger zone is not drawn", {
+				tags: { deviceId: camera },
+				meta: {
+					zoneIds: zoneIds.join(","),
+					error: String(err)
+				}
+			});
+			return [];
+		}
+	}
+};
+//#endregion
 //#region src/notification-center/dispatcher.ts
 /**
 * NcDispatcher — turns a durable outbox entry into ONE canonical
@@ -41509,12 +42283,6 @@ var NC_STILL_WAIT_INTERVAL_MS = 500;
 * is the instant; the ladder then runs among the frames that are about it.
 */
 var NC_TRIGGER_STILL_MAX_AGE_MS = TRAIL_MATCH_MAX_MS;
-/** Bound on the once-per-record memo of the annotated-fallback line. */
-var NC_ANNOTATED_FALLBACK_MEMO_MAX = 5e3;
-function cleanSceneAsk(policy, frame) {
-	if (frame !== void 0) return frame === "full" ? "full" : null;
-	return policy === "keyFrame" ? "keyFrame" : null;
-}
 /**
 * Past this age the poll is pointless and only adds latency: the seconds in
 * which this subject's media was being written are long gone, so a row that has
@@ -41548,10 +42316,8 @@ var NcDispatcher = class {
 	now;
 	sleep;
 	targetCacheTtlMs;
-	/** Records whose annotated-fallback line was already said — see
-	*  {@link reportAnnotatedFallback}. Bounded by
-	*  {@link NC_ANNOTATED_FALLBACK_MEMO_MAX}. */
-	reportedAnnotatedFallbacks = /* @__PURE__ */ new Set();
+	/** The ONE render stage of every notification picture (D897). */
+	imageStage;
 	texts;
 	/** One recorded cut per moment, and the recorder-busy breaker (D686). */
 	recordedCuts = new NcRecordedCutMemo();
@@ -41561,6 +42327,13 @@ var NcDispatcher = class {
 		this.sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
 		this.targetCacheTtlMs = deps.targetCacheTtlMs ?? DEFAULT_TARGET_CACHE_TTL_MS;
 		this.texts = deps.texts ?? new NcTextCatalog();
+		this.imageStage = new NcNotificationImageStage({
+			logger: deps.logger,
+			now: this.now,
+			...deps.getSubjectTrail !== void 0 ? { getSubjectTrail: deps.getSubjectTrail } : {},
+			...deps.getTracksAt !== void 0 ? { getTracksAt: deps.getTracksAt } : {},
+			...deps.getZonePolygons !== void 0 ? { getZonePolygons: deps.getZonePolygons } : {}
+		});
 	}
 	/**
 	* Drop held recorded cuts past their TTL (re-review R4). Driven by the
@@ -42634,16 +43407,14 @@ var NcDispatcher = class {
 	*  analyst to judge ({@link NcBuiltNotification.grouped}). */
 	async resolveAttachments(entry) {
 		const out = [];
-		const zoneIdsWanted = entry.payload.mediaZoneIds;
-		const stillOverride = zoneIdsWanted !== void 0 && zoneIdsWanted.length > 0 ? "keyFrame" : void 0;
 		const groupView = readOutboxGroup(entry.payload.group);
 		const groupMembers = groupedTileMembers(groupView);
 		const groupTiles = entry.payload.media === "none" ? null : groupMembers;
 		const memberTrackIds = (groupView?.members ?? []).map((m) => m.trackId);
-		const firstLook = groupTiles !== null ? null : await this.resolveAttachment(entry, stillOverride, canStillGainMedia(entry) ? "trigger-only" : "any");
+		const firstLook = groupTiles !== null ? null : await this.resolveAttachment(entry, canStillGainMedia(entry) ? "trigger-only" : "any");
 		const footagePending = this.renderFootage(entry);
 		const mosaic = groupView !== void 0 && groupTiles !== null ? await this.groupedMosaic(entry, groupView, groupTiles) : null;
-		const still = mosaic !== null ? mosaic.attachment : firstLook !== null || entry.payload.media === "none" ? firstLook : await this.waitForStill(entry, stillOverride);
+		const still = mosaic !== null ? mosaic.attachment : firstLook !== null || entry.payload.media === "none" ? firstLook : await this.waitForStill(entry);
 		const grouped = groupView !== void 0 && groupMembers !== null ? {
 			windowKey: groupView.key,
 			members: groupView.members.length,
@@ -42651,17 +43422,8 @@ var NcDispatcher = class {
 		} : null;
 		const footage = await footagePending;
 		const extras = await this.linkedExtraStills(entry);
-		if (still !== null) {
-			const zoneIds = zoneIdsWanted;
-			if (groupTiles === null && zoneIds !== void 0 && zoneIds.length > 0) {
-				const cropped = await this.zoneCrop(entry.payload.subject.deviceId, zoneIds, still.bytes);
-				out.push(cropped !== null ? {
-					...still,
-					bytes: cropped,
-					name: "zone.jpg"
-				} : still);
-			} else out.push(still);
-		} else if (entry.payload.media !== "none" && extras.length > 0) this.deps.logger.info("no still of the primary camera could be resolved — the other linked cameras' stills ship without it", {
+		if (still !== null) out.push(still);
+		else if (entry.payload.media !== "none" && extras.length > 0) this.deps.logger.info("no still of the primary camera could be resolved — the other linked cameras' stills ship without it", {
 			tags: { deviceId: entry.payload.subject.deviceId },
 			meta: {
 				recordKind: entry.recordKind,
@@ -42677,7 +43439,7 @@ var NcDispatcher = class {
 				recordKind: entry.recordKind,
 				recordId: entry.recordId,
 				policy: entry.payload.media,
-				...entry.payload.mediaFrame !== void 0 ? { frame: entry.payload.mediaFrame } : {},
+				...entry.payload.mediaImage !== void 0 ? { image: entry.payload.mediaImage } : {},
 				...memberTrackIds.length > 1 ? { memberTrackIds } : {},
 				owners: [...entry.payload.subject.eventId !== void 0 ? [`object:${entry.payload.subject.eventId}`] : [], ...entry.payload.subject.trackId !== void 0 ? [`track:${entry.payload.subject.trackId}`] : []]
 			}
@@ -42705,7 +43467,7 @@ var NcDispatcher = class {
 		for (const { ownerId, cameraId } of subject.extraStills ?? []) {
 			const file = await this.linkedStillFile(entry, ownerId, cameraId);
 			const bytes = file === void 0 ? null : decodeStillBytes(file.base64);
-			if (bytes === null) {
+			if (file === void 0 || bytes === null) {
 				this.deps.logger.info("linked camera picture missing at send — skipped", {
 					tags: { deviceId: cameraId },
 					meta: {
@@ -42716,9 +43478,21 @@ var NcDispatcher = class {
 				});
 				continue;
 			}
+			const image = await this.imageStage.notificationImage({
+				entry,
+				source: {
+					bytes,
+					kind: file.kind,
+					timestamp: file.timestamp,
+					annotated: isAnnotatedSceneKind(file.kind)
+				},
+				camera: cameraId,
+				withSubject: false
+			});
+			if (image === null) continue;
 			out.push({
 				mediaType: "image",
-				bytes,
+				bytes: image.bytes,
 				mime: "image/jpeg",
 				name: `camera-${String(cameraId)}.jpg`
 			});
@@ -43175,14 +43949,14 @@ var NcDispatcher = class {
 	* Bounded and then abandoned — a text-only notification about a person at the
 	* door beats a punctual one nobody received.
 	*/
-	async waitForStill(entry, policyOverride) {
+	async waitForStill(entry) {
 		const subject = entry.payload.subject;
-		if (this.now() - subject.timestamp > NC_STILL_WAIT_MAX_AGE_MS) return this.resolveAttachment(entry, policyOverride, "any");
+		if (this.now() - subject.timestamp > NC_STILL_WAIT_MAX_AGE_MS) return this.resolveAttachment(entry, "any");
 		if (subject.eventId === void 0 && subject.trackId === void 0) return null;
 		const attempts = Math.floor(NC_STILL_WAIT_MS / NC_STILL_WAIT_INTERVAL_MS);
 		for (let i = 0; i < attempts; i += 1) {
 			await this.sleep(NC_STILL_WAIT_INTERVAL_MS);
-			const still = await this.resolveAttachment(entry, policyOverride, "trigger-only");
+			const still = await this.resolveAttachment(entry, "trigger-only");
 			if (still !== null) {
 				this.deps.logger.info("the still landed during the bounded wait", {
 					tags: { deviceId: entry.payload.subject.deviceId },
@@ -43196,55 +43970,7 @@ var NcDispatcher = class {
 				return still;
 			}
 		}
-		return this.resolveAttachment(entry, policyOverride, "any");
-	}
-	/** Crop a JPEG to the padded bbox of the given zones (normalized polygons →
-	*  pixel rect via sharp metadata). Null on any failure — caller falls back
-	*  to the uncropped still. */
-	async zoneCrop(deviceId, zoneIds, jpeg) {
-		try {
-			const points = (await this.deps.getZonePolygons?.(deviceId, zoneIds) ?? []).flat();
-			if (points.length === 0) return null;
-			const { default: sharp$18 } = await import("sharp");
-			const img = sharp$18(Buffer.from(jpeg));
-			const meta = await img.metadata();
-			const W = meta.width ?? 0;
-			const H = meta.height ?? 0;
-			if (W === 0 || H === 0) return null;
-			let minX = 1;
-			let minY = 1;
-			let maxX = 0;
-			let maxY = 0;
-			for (const p of points) {
-				if (p.x < minX) minX = p.x;
-				if (p.y < minY) minY = p.y;
-				if (p.x > maxX) maxX = p.x;
-				if (p.y > maxY) maxY = p.y;
-			}
-			if (maxX <= minX || maxY <= minY) return null;
-			const padX = (maxX - minX) * .1;
-			const padY = (maxY - minY) * .1;
-			const left = Math.max(0, Math.floor((minX - padX) * W));
-			const top = Math.max(0, Math.floor((minY - padY) * H));
-			const width = Math.min(W - left, Math.ceil((maxX - minX + 2 * padX) * W));
-			const height = Math.min(H - top, Math.ceil((maxY - minY + 2 * padY) * H));
-			if (width < 16 || height < 16) return null;
-			const outBuf = await img.extract({
-				left,
-				top,
-				width,
-				height
-			}).jpeg({ quality: 82 }).toBuffer();
-			const bytes = new Uint8Array(outBuf.byteLength);
-			bytes.set(outBuf);
-			return bytes;
-		} catch (err) {
-			this.deps.logger.debug("zone crop failed — attaching uncropped still", { meta: {
-				deviceId,
-				error: String(err)
-			} });
-			return null;
-		}
+		return this.resolveAttachment(entry, "any");
 	}
 	/**
 	* The grouped MOSAIC (D692 §6.2): one tile per member, at most
@@ -43376,7 +44102,7 @@ var NcDispatcher = class {
 				const tileEntry = entries[index];
 				const m = tiles[index];
 				if (tileEntry === void 0 || m === void 0) return;
-				const still = await this.resolveAttachment(tileEntry, void 0, freshness);
+				const still = await this.resolveAttachment(tileEntry, freshness);
 				if (still !== null) found.set(index, {
 					trackId: m.trackId,
 					className: m.className,
@@ -43508,53 +44234,32 @@ var NcDispatcher = class {
 		return ordered;
 	}
 	/**
-	* A rule that asked for the CLEAN scene was answered by an annotated frame.
+	* The row's still: the CLEAN source frame of the trigger moment, rendered by
+	* the row's picture mode (D897, `notification-image.ts`).
 	*
-	* The documented last rung of the `full` / `keyFrame` ladders (D654): the
-	* clean twin is written beside every boxed tile, so reaching an annotated
-	* kind means this track holds no clean frame at all — written before the
-	* twin existed, or a twin write that failed. The picture ships (it is of the
-	* right moment), but never silently as "full frame": this is the line that
-	* answers "why does my full-frame notification have a box on it".
+	* The source ladder is the same for every mode — `cleanSourcePreference`,
+	* the track owner first (the scene frames live there), then the object
+	* event's — and MOMENT then PLACE filter it exactly as before. What the
+	* rule asked to SEE is decided once, by the render, never by which stored
+	* kind happened to land.
 	*/
-	reportAnnotatedFallback(entry, asked, kind, ownerId) {
-		if (asked === null || !isAnnotatedSceneKind(kind)) return;
-		if (this.reportedAnnotatedFallbacks.has(entry.recordId)) return;
-		if (this.reportedAnnotatedFallbacks.size >= NC_ANNOTATED_FALLBACK_MEMO_MAX) this.reportedAnnotatedFallbacks.clear();
-		this.reportedAnnotatedFallbacks.add(entry.recordId);
-		this.deps.logger.warn("clean scene asked — only an annotated frame is stored, shipping it", {
-			tags: { deviceId: entry.payload.subject.deviceId },
-			meta: {
-				ruleId: entry.ruleId,
-				recordId: entry.recordId,
-				ownerId,
-				asked,
-				kind
-			}
-		});
-	}
-	async resolveAttachment(entry, policyOverride, freshness = "any") {
-		const policy = policyOverride ?? entry.payload.media;
-		if (policy === "none") return null;
-		const frame = policyOverride === void 0 ? entry.payload.mediaFrame : void 0;
+	async resolveAttachment(entry, freshness = "any") {
+		if (entry.payload.media === "none") return null;
 		const subject = entry.payload.subject;
-		const signal = policy === "best-matching" ? matchSignal(entry.payload.matchedOn) : null;
 		const owners = [];
-		if (subject.eventId !== void 0) owners.push({
-			kind: "object",
-			id: subject.eventId
-		});
 		if (subject.trackId !== void 0) owners.push({
 			kind: "track",
 			id: subject.trackId
 		});
-		if (policy === "keyFrame" || frame === "full" || frame === "boxed") owners.reverse();
+		if (subject.eventId !== void 0) owners.push({
+			kind: "object",
+			id: subject.eventId
+		});
 		for (const owner of owners) try {
 			const files = owner.kind === "object" ? await this.deps.getMediaForOwner(owner.kind, owner.id, eventMediaScopeOf(subject)) : await this.deps.getMediaForOwner(owner.kind, owner.id);
 			if (files.length === 0) continue;
-			const preference = frame !== void 0 ? framePreference(frame, owner.kind) : policy === "best-matching" ? bestMatchingKindPreference(signal, owner.kind) : attachmentKindPreference(policy, owner.kind);
 			const ordered = [];
-			for (const kind of preference) for (const file of files) if (file.kind === kind) ordered.push(file);
+			for (const kind of cleanSourcePreference(owner.kind)) for (const file of files) if (file.kind === kind) ordered.push(file);
 			const inBand = this.narrowToTriggerInstant(entry, ordered, freshness);
 			if (inBand.length === 0) continue;
 			const shortlist = await this.narrowToTriggerZone(entry, inBand, freshness);
@@ -43562,12 +44267,23 @@ var NcDispatcher = class {
 			for (const file of shortlist) {
 				const bytes = decodeStillBytes(file.base64);
 				if (bytes === null) continue;
-				this.reportAnnotatedFallback(entry, cleanSceneAsk(entry.payload.media, entry.payload.mediaFrame), file.kind, owner.id);
+				const image = await this.imageStage.notificationImage({
+					entry,
+					source: {
+						bytes,
+						kind: file.kind,
+						timestamp: file.timestamp,
+						annotated: isAnnotatedSceneKind(file.kind)
+					},
+					camera: primaryImageCamera(entry.payload),
+					withSubject: true
+				});
+				if (image === null) return null;
 				return {
 					mediaType: "image",
-					bytes,
+					bytes: image.bytes,
 					mime: "image/jpeg",
-					name: `${file.kind}.jpg`
+					name: image.name
 				};
 			}
 		} catch (err) {
@@ -48371,7 +49087,20 @@ function bodyToRule(id, raw, onProjection) {
 	});
 	if (!parsed.success) return null;
 	if (projection.kind === "projected") onProjection?.(id, projection);
-	return parsed.data;
+	return withNormalizedMedia(parsed.data);
+}
+/**
+* D897: the rule with its media policy in the stored shape — `image` set, the
+* legacy `attach` / `frame` / `zoneCrop` folded into it. Applied on LOAD (a read
+* projection: a rule nobody saved since keeps its row as written) and on every
+* WRITE, so the first save of a rule converges its row and an editor that still
+* sends the legacy triple is folded on the way in.
+*/
+function withNormalizedMedia(rule) {
+	return {
+		...rule,
+		media: require_clip_model_registry.normalizeNcMediaPolicy(rule.media, rule)
+	};
 }
 function isLegacyDeps$2(deps) {
 	return "store" in deps;
@@ -48648,14 +49377,14 @@ var NcRuleStore = class NcRuleStore {
 	/** Create a new rule. `createdBy` is the SERVER-injected caller userId. */
 	async create(input, createdBy) {
 		const now = this.now();
-		const rule = {
+		const rule = withNormalizedMedia({
 			...input,
 			id: this.newId(),
 			createdBy,
 			createdAt: now,
 			updatedAt: now,
 			disabledTargetIds: []
-		};
+		});
 		await this.write(rule);
 		return rule;
 	}
@@ -48693,7 +49422,7 @@ var NcRuleStore = class NcRuleStore {
 			createdAt: existing.createdAt,
 			updatedAt: this.now()
 		};
-		const updated = require_clip_model_registry.NcRuleSchema.parse(candidate);
+		const updated = withNormalizedMedia(require_clip_model_registry.NcRuleSchema.parse(candidate));
 		await this.write(updated);
 		return updated;
 	}
@@ -55254,19 +55983,20 @@ var NC_ALARM_ANNOUNCE_RULE_ID = "nc-alarm-announce";
 * every row a rule addresses AND by the alarm's own announcement row when it is
 * the COMBINED siren (the triggering rule's pictures on the alarm's words).
 *
-* `effectiveMediaPolicyForRule` is what actually resolves it: a SENSOR rule's
-* stored `media` is ignored here, in favour of the one-snapshot default
-* (operator ruling, 2026-10-01) — the rule still LOADS with whatever it has
-* stored, and `buildEntries` is where the sampled log fires when that stored
-* choice is about to be overridden.
+* `effectiveMediaPolicyForRule` resolves the picture MODE (D897) — a sensor
+* rule's included: it goes through the same selector and render stage as a
+* detection rule. `triggerZoneIds` are the zones of the rule that owns the
+* media (the SOURCE rule of a combined alarm row), and a zone overlay is
+* frozen only when the rule asked for one AND fired on a zone.
 */
 function mediaPolicyFields(mediaRule, cropZoneIds) {
 	const media = effectiveMediaPolicyForRule(mediaRule);
+	const image = media.image ?? "crop";
 	return {
-		media: media.attach,
-		...media.zoneCrop === true && cropZoneIds !== void 0 ? { mediaZoneIds: [...cropZoneIds] } : {},
+		media: image === "none" ? "none" : "best",
+		mediaImage: image,
+		...media.showTriggerZone === true && cropZoneIds !== void 0 && cropZoneIds.length > 0 ? { mediaShowTriggerZone: true } : {},
 		...cropZoneIds !== void 0 ? { triggerZoneIds: [...cropZoneIds] } : {},
-		...media.frame !== void 0 ? { mediaFrame: media.frame } : {},
 		...media.profile !== void 0 ? { mediaProfile: media.profile } : {},
 		...media.gif === true ? { mediaGif: true } : {},
 		...media.clip === true ? { mediaClip: true } : {},
@@ -55306,6 +56036,36 @@ function alarmButtonKind(kind) {
 		default: return null;
 	}
 }
+/**
+* Is a bypassed (rule, input) pair still an input of that rule? The rule must
+* exist, be enabled, still press the panel, and — when it names devices —
+* still name the input or its camera, and not exclude the input. A false
+* "no" re-arms the input (protection restored), which is the safe direction.
+*/
+function alarmRuleStillHasInput(rule, entry) {
+	if (rule === null || !rule.enabled || !require_clip_model_registry.ruleAutoTriggersAlarm(rule)) return false;
+	if ((rule.conditions.devicesExclude ?? []).includes(entry.deviceId)) return false;
+	const scope = rule.conditions.devices;
+	if (scope === void 0 || scope.length === 0) return true;
+	return scope.includes(entry.deviceId) || scope.includes(entry.cameraId);
+}
+/**
+* The (rule, input) pair an `alarm-triggered` / `alarm-pending` row is about,
+* from the source it FROZE (`alarmSource`). Undefined on a manual trigger.
+*/
+function rowBypassableInput(systemEvent) {
+	const kind = systemEvent?.kind;
+	if (kind !== "alarm-triggered" && kind !== "alarm-pending") return void 0;
+	const source = systemEvent?.alarmSource;
+	if (source === void 0) return void 0;
+	return {
+		ruleId: source.ruleId,
+		ruleName: source.ruleName,
+		inputDeviceId: intrusionDeviceOf(source),
+		cameraId: source.deviceId,
+		notedAt: source.timestamp
+	};
+}
 /** The refusal id an `alarm-arm-refused` row froze (`incomingFromAlarmTransition`). */
 function rowRefusalId(systemEvent) {
 	const value = systemEvent?.data["refusalId"];
@@ -55321,6 +56081,12 @@ var ARM_ANYWAY_REJECTION_COPY = {
 	used: "Already used",
 	"unknown-refusal": "This refusal is no longer current — arm again"
 };
+/** What a pressed Bypass that did nothing tells the person holding the phone. */
+var BYPASS_INPUT_REFUSAL_COPY = {
+	disarmed: "The alarm is disarmed — nothing to bypass",
+	stale: "The alarm was re-armed since this notification — nothing was bypassed",
+	full: "Too many inputs are bypassed already — disarm to reset them"
+};
 /**
 * What the sustained-state alerts run on when nothing wired the settings in.
 *
@@ -55706,9 +56472,6 @@ function renderAudioScope(devices, excluded) {
 	if (devices.length === 0) return excluded.length === 0 ? "@all" : `@all-except:${excluded.join("+")}`;
 	return devices.filter((id) => !excluded.includes(id)).join("+");
 }
-/** {@link NotificationCenter.reportedSensorMediaIgnored} cap, same shape as
-*  the dispatcher's own annotated-fallback memo. */
-var NC_SENSOR_MEDIA_IGNORED_MEMO_MAX = 5e3;
 /**
 * One KEPT member as the payload freezes it (§6.1): its latest name, its own first-matched
 * event identity (D694 — the event's STORED timestamp, never a clock), its qualifying
@@ -55769,9 +56532,6 @@ var NotificationCenter = class {
 	dispatcher;
 	deps;
 	now;
-	/** Rule ids whose stored (non-default) media policy has already been
-	*  reported as ignored at evaluation — ONE line per rule, not per fire. */
-	reportedSensorMediaIgnored = /* @__PURE__ */ new Set();
 	/** Samples the device-compat guard's "accepted unchecked" WARN per rule. */
 	deviceCompatWarnSampler = new NcDeviceCompatWarnSampler();
 	/**
@@ -56141,6 +56901,7 @@ var NotificationCenter = class {
 				targetId: input.targetId
 			}
 		});
+		const bypassable = rowBypassableInput(input.systemEvent);
 		const alarmButtons = alarmKind === null ? [] : buildAlarmButtons({
 			kind: alarmKind,
 			panel: panel === null ? null : {
@@ -56148,10 +56909,12 @@ var NotificationCenter = class {
 				availableModes: panel.availableModes()
 			},
 			...refusalId !== void 0 ? { refusalId } : {},
+			...bypassable !== void 0 ? { bypassable } : {},
 			labels: {
 				disarm: this.texts.text({ key: "button.alarm.disarm" }),
 				arm: (mode) => this.texts.text({ key: `button.alarm.arm.${mode}` }),
-				armAnyway: this.texts.text({ key: "button.alarm.armAnyway" })
+				armAnyway: this.texts.text({ key: "button.alarm.armAnyway" }),
+				bypassInput: this.texts.text({ key: "button.alarm.bypassInput" })
 			},
 			mintUrl: (button) => {
 				const id = (0, node_crypto.randomUUID)();
@@ -56188,6 +56951,16 @@ var NotificationCenter = class {
 								action: "disarm",
 								expiresAt
 							};
+							case "bypass-input": return {
+								...common,
+								action: "bypass-input",
+								ruleId: button.ruleId,
+								ruleName: button.ruleName,
+								inputDeviceId: button.inputDeviceId,
+								cameraId: button.cameraId,
+								notedAt: button.notedAt,
+								expiresAt
+							};
 						}
 					}
 				});
@@ -56375,6 +57148,7 @@ var NotificationCenter = class {
 		if (panel === null) throw new Error("this node has no alarm panel");
 		if (panel.deviceId !== grant.panelDeviceId) throw new Error("this button was minted for a different alarm panel");
 		if (grant.action === "arm-anyway") return this.applyGrantedArmAnyway(panel, grant);
+		if (grant.action === "bypass-input") return this.applyGrantedBypassInput(panel, grant);
 		if (this.deps.actuate === void 0) throw new Error("no actuator is wired on this node");
 		await this.actuateWithAttribution({
 			deviceId: panel.deviceId,
@@ -56411,6 +57185,32 @@ var NotificationCenter = class {
 				return;
 		}
 	}
+	/**
+	* "Bypass this input until disarm", from a trigger notification — the (rule,
+	* input) pair the grant froze, on the panel, in-process. The token is the
+	* whole of the authority (D47), exactly as for the Disarm beside it; the
+	* panel refuses a disarmed alarm and an arm session that is already over.
+	*/
+	async applyGrantedBypassInput(panel, grant) {
+		const outcome = panel.bypassInput({
+			ruleId: grant.ruleId,
+			ruleName: grant.ruleName,
+			deviceId: grant.inputDeviceId,
+			cameraId: grant.cameraId,
+			notedAt: grant.notedAt
+		});
+		if (outcome.outcome === "refused") throw new NcActionRefusedError(BYPASS_INPUT_REFUSAL_COPY[outcome.reason]);
+		this.logger.info("alarm input bypassed from a notification button", {
+			tags: { deviceId: grant.inputDeviceId },
+			meta: {
+				panelDeviceId: panel.deviceId,
+				ruleId: grant.ruleId,
+				rule: grant.ruleName,
+				outcome: outcome.outcome,
+				targetId: grant.targetId ?? null
+			}
+		});
+	}
 	/** The registry the action plane claims against. */
 	get actionTokenRegistry() {
 		return this.actionTokens;
@@ -57818,7 +58618,7 @@ var NotificationCenter = class {
 		const shown = this.unmutedCameras(cameraIds);
 		const involved = [sensorId, ...rowShown];
 		if (!this.rules.listEnabled("device-event").some((rule) => {
-			if (effectiveMediaPolicyForRule(rule).attach === "none") return false;
+			if (ruleShipsNoStill(rule)) return false;
 			if (!deviceEventRuleMayFireOnKind(rule, sensorKind, sensorRaised)) return false;
 			const excluded = rule.conditions.devicesExclude;
 			if (excluded !== void 0 && deviceScopeExcludes(excluded, {
@@ -57962,7 +58762,7 @@ var NotificationCenter = class {
 		const shelf = this.stills;
 		if (shelf === null || !this.evaluationActive) return void 0;
 		for (const rule of this.rules.listEnabled("immediate")) {
-			if (rule.media.attach === "none") continue;
+			if (ruleShipsNoStill(rule)) continue;
 			if (!(mode === "condition" ? rule.conditions.audio !== void 0 : rule.conditions.audio === void 0 && referencesAudioClass(rule.conditions.classes))) continue;
 			const devices = rule.conditions.devices;
 			if (devices !== void 0 && devices.length > 0 && !devices.includes(deviceId)) continue;
@@ -58134,7 +58934,7 @@ var NotificationCenter = class {
 	ruleWantsOccupancyStill(edge) {
 		const subject = occupancySubjectFromEdge(edge);
 		for (const rule of this.rules.listEnabled("device-event")) {
-			if (effectiveMediaPolicyForRule(rule).attach === "none") continue;
+			if (ruleShipsNoStill(rule)) continue;
 			const occ = rule.conditions.occupancy;
 			if (occ === void 0 || !matchesOccupancy(occ, subject)) continue;
 			const devices = rule.conditions.devices;
@@ -58430,6 +59230,10 @@ var NotificationCenter = class {
 					logger: this.logger,
 					by: caller.userId
 				});
+				guardRuleMedia(rule, {
+					logger: this.logger,
+					by: caller.userId
+				});
 				guardRuleDevicesExclude(rule, {
 					logger: this.logger,
 					by: caller.userId
@@ -58477,6 +59281,11 @@ var NotificationCenter = class {
 					by: caller.userId,
 					ruleId
 				});
+				guardPatchMedia(existing, patch, {
+					logger: this.logger,
+					by: caller.userId,
+					ruleId
+				});
 				guardPatchDevicesExclude(existing, patch, {
 					logger: this.logger,
 					by: caller.userId,
@@ -58873,6 +59682,49 @@ var NotificationCenter = class {
 					meta: { userId }
 				});
 			},
+			bypassInput: async ({ ruleId, deviceId }, userId) => {
+				const panel = requirePanel();
+				const rule = this.rules.get(ruleId) ?? null;
+				if (rule === null || !alarmRuleStillHasInput(rule, {
+					deviceId,
+					cameraId: deviceId
+				})) {
+					this.logger.info("alarm input bypass refused — not an input of an alarm rule", {
+						tags: { deviceId },
+						meta: {
+							userId,
+							ruleId,
+							panelDeviceId: panel.deviceId
+						}
+					});
+					return {
+						outcome: "refused",
+						reason: "not-an-input"
+					};
+				}
+				const outcome = panel.bypassInput({
+					ruleId,
+					ruleName: rule.name,
+					deviceId,
+					cameraId: deviceId
+				});
+				this.logger.info("alarm input bypass requested through the bridge", {
+					tags: { deviceId },
+					meta: {
+						userId,
+						ruleId,
+						rule: rule.name,
+						outcome: outcome.outcome
+					}
+				});
+				return outcome.outcome === "refused" ? {
+					outcome: "refused",
+					reason: outcome.reason
+				} : {
+					outcome: outcome.outcome,
+					reason: null
+				};
+			},
 			getConfig: () => this.alarmConfig(),
 			getSensors: (input) => this.alarmSensors(input),
 			setConfig: (patch) => this.setAlarmConfig(patch)
@@ -58949,6 +59801,8 @@ var NotificationCenter = class {
 			openings,
 			nonBlocking: panel.settings().nonBlocking,
 			exclusions: panel.exclusionPhases(),
+			bypasses: panel.inputBypasses(),
+			ruleName: (ruleId) => this.rules.get(ruleId)?.name,
 			name: this.deviceNameFromDirectory()
 		});
 	}
@@ -59265,7 +60119,7 @@ var NotificationCenter = class {
 		const subject = incoming.subject;
 		const alarmSource = subject.systemEvent?.alarmSource;
 		const sourceRule = alarmSource !== void 0 ? this.rules.get(alarmSource.ruleId) : null;
-		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, void 0) : { media: "none" };
+		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, ruleCropZoneIds(sourceRule)) : { media: "none" };
 		const mediaDeviceId = alarmSource?.deviceId ?? panel.deviceId;
 		const entries = targets.map((targetId) => ({
 			ruleId: NC_ALARM_ANNOUNCE_RULE_ID,
@@ -60105,7 +60959,7 @@ var NotificationCenter = class {
 					buttons: unresolvable.join(", ")
 				}
 			});
-			if (!noOwnerReported && kind === "device-event" && subject.trackId === void 0 && subject.linkedStills === void 0 && effectiveMediaPolicyForRule(rule).attach !== "none") {
+			if (!noOwnerReported && kind === "device-event" && subject.trackId === void 0 && subject.linkedStills === void 0 && !ruleShipsNoStill(rule)) {
 				noOwnerReported = true;
 				const linked = subject.linkedCameraIds;
 				const meta = {
@@ -60138,7 +60992,7 @@ var NotificationCenter = class {
 					meta
 				});
 			}
-			if (!noOwnerReported && (kind === "audio-window" || kind === "audio-event") && subject.trackId === void 0 && rule.media.attach !== "none") {
+			if (!noOwnerReported && (kind === "audio-window" || kind === "audio-event") && subject.trackId === void 0 && !ruleShipsNoStill(rule)) {
 				noOwnerReported = true;
 				this.logger.warn("audio match has no still owner — this notification ships text-only", {
 					tags: { deviceId: subject.deviceId },
@@ -60226,8 +61080,17 @@ var NotificationCenter = class {
 	* Materialise legacy inline `onTrigger` sequences into the shared store and
 	* rewrite each rule's actions to bindings + `buttons.sequenceId`. Runs on RAW
 	* rows before {@link NcRuleStore.load} so Zod never skips them.
+	*
+	* A rewrite of the LEGACY rules table only. A records-backed centre has no
+	* such table to read (no boot declares it; the adoption mapper read it once,
+	* after every earlier boot had already run this rewrite on it), so it skips —
+	* reading it anyway failed on every boot ("is not declared").
 	*/
 	async migrateLegacyRuleActions() {
+		if (this.deps.records !== void 0) {
+			this.logger.debug("legacy actions migration not run — rules live on records", { meta: { collection: NC_RULES_COLLECTION } });
+			return;
+		}
 		let rows;
 		try {
 			rows = await this.deps.store.query.query({
@@ -60505,24 +61368,6 @@ var NotificationCenter = class {
 			}
 		});
 	}
-	/**
-	* ONE line per rule id, the first time a SENSOR rule's stored media policy
-	* is about to be overridden by {@link effectiveMediaPolicyForRule}'s
-	* one-snapshot default (operator ruling, 2026-10-01). Never refuses the
-	* rule — it still loads and still fires — this only says the stored choice
-	* is not the one being used.
-	*/
-	warnSensorMediaIgnoredOnce(rule) {
-		if (mediaPolicyMatchesSensorDefault(rule.media)) return;
-		if (this.reportedSensorMediaIgnored.has(rule.id)) return;
-		if (this.reportedSensorMediaIgnored.size >= NC_SENSOR_MEDIA_IGNORED_MEMO_MAX) this.reportedSensorMediaIgnored.clear();
-		this.reportedSensorMediaIgnored.add(rule.id);
-		this.logger.info("sensor rule carries a media choice — ignored at evaluation, one snapshot is always attached", { meta: {
-			ruleId: rule.id,
-			rule: rule.name,
-			storedMedia: rule.media
-		} });
-	}
 	buildEntries(rule, subject, kind, matchedOn, userTargets = [], origin = "pipeline", cooldown, extras) {
 		const hasEventMedia = kind === "object-event" || kind === "package-event";
 		const isTrackScoped = kind === "object-event" || kind === "track-end";
@@ -60530,11 +61375,10 @@ var NotificationCenter = class {
 		const alarmSource = subject.systemEvent?.alarmSource;
 		const mediaRule = alarmSource !== void 0 ? this.rules.get(alarmSource.ruleId) ?? rule : rule;
 		const noMedia = isSystemEvent && alarmSource === void 0;
-		if (require_clip_model_registry.ruleKindOf(mediaRule) === "sensor") this.warnSensorMediaIgnoredOnce(mediaRule);
 		const direct = new Set(rule.targets.map((t) => t.targetId));
 		const renderedZones = notificationZones(rule, subject);
 		const confirm = frozenConfirmPolicy(rule, isSystemEvent);
-		const cropZoneIds = ruleCropZoneIds(rule);
+		const cropZoneIds = ruleCropZoneIds(mediaRule);
 		const allTargets = [...rule.targets, ...userTargets.filter((t) => !direct.has(t.targetId))];
 		const linkedOwners = !noMedia && subject.linkedStills !== void 0 ? linkedMediaOwners(subject.linkedStills, linkedCameraMode(mediaRule.media)) : void 0;
 		const groupV2 = extras?.groupV2 ?? (subject.systemEvent !== void 0 && !noMedia ? alarmIncidentGroup(subject.systemEvent, subject.timestamp) : void 0);
@@ -60896,6 +61740,11 @@ var NotificationCenter = class {
 	* read cannot answer for, or that reads unknown, changes nothing (D49).
 	* Never throws into the tick.
 	*/
+	pruneAlarmInputBypasses() {
+		const panel = this.alarmPanel;
+		if (panel === null || panel.inputBypasses().length === 0) return;
+		panel.pruneInputBypasses((entry) => alarmRuleStillHasInput(this.rules.get(entry.ruleId) ?? null, entry));
+	}
 	async observeAlarmOpenings() {
 		const panel = this.alarmPanel;
 		const read = this.deps.readDeviceOpenings;
@@ -61180,6 +62029,7 @@ var NotificationCenter = class {
 		await this.zoneOwners.refresh();
 		this.sceneStates.refresh();
 		await this.observeAlarmOpenings();
+		this.pruneAlarmInputBypasses();
 		await this.occupancyStore.pruneExcept(this.activeOccupancyKeys());
 		if (!this.pruneLedger.isLoaded()) await this.pruneLedger.load();
 		await this.pruner.reconcileDevices();
@@ -98789,6 +99639,14 @@ function planeRunsStationary(source) {
 //#endregion
 //#region src/pipeline-analytics/pipeline/suppressed-births.ts
 /**
+* How many rejected ids a device remembers AFTER the tracker stopped carrying
+* them. An id's `leaving` / zone-exit events fire for a track that is absent
+* from the frame by definition — the frame it is lost or a few frames later —
+* so the event path must still recognise it once `retain` dropped it. Track ids
+* are never reused; the bound only caps memory on a phantom-heavy camera.
+*/
+var RETIRED_REJECTIONS_PER_DEVICE = 256;
+/**
 * Memory of births the confirmation gate rejected, per device.
 *
 * The gate runs AFTER the TrackStore upsert, and it has to: the upsert's
@@ -98810,6 +99668,8 @@ function planeRunsStationary(source) {
 */
 var SuppressedBirthRegistry = class {
 	byDevice = /* @__PURE__ */ new Map();
+	/** Rejected ids the tracker no longer carries, oldest first (bounded). */
+	retired = /* @__PURE__ */ new Map();
 	/** Rejected ids whose per-frame skip has already been reported once. */
 	skipReported = /* @__PURE__ */ new Map();
 	/** Record that this birth was rejected; later frames must not re-upsert it. */
@@ -98825,6 +99685,14 @@ var SuppressedBirthRegistry = class {
 		return this.byDevice.get(deviceKey)?.has(trackId) === true;
 	}
 	/**
+	* True when an event naming this id must be dropped: the birth was rejected,
+	* whether the tracker still carries the id or already let it go. A rejected
+	* birth is a track that never existed — it has no `left`, no zone exit.
+	*/
+	suppressesEvents(deviceKey, trackId) {
+		return this.isRejected(deviceKey, trackId) || this.retired.get(deviceKey)?.has(trackId) === true;
+	}
+	/**
 	* True the FIRST time a rejected id's frame work is skipped (so the host logs
 	* one line per id, not one per frame); false afterwards.
 	*/
@@ -98842,7 +99710,9 @@ var SuppressedBirthRegistry = class {
 	* 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.
+	* that set can never be upserted again, so it leaves the live set — but it
+	* moves to the bounded retired memory, because its `leaving` / zone-exit
+	* events fire exactly when it is absent (`suppressesEvents`).
 	*/
 	retain(deviceKey, currentTrackIds) {
 		const reported = this.skipReported.get(deviceKey);
@@ -98852,9 +99722,26 @@ var SuppressedBirthRegistry = class {
 		}
 		const ids = this.byDevice.get(deviceKey);
 		if (!ids) return;
-		for (const id of ids) if (!currentTrackIds.has(id)) ids.delete(id);
+		for (const id of ids) {
+			if (currentTrackIds.has(id)) continue;
+			ids.delete(id);
+			this.retire(deviceKey, id);
+		}
 		if (ids.size === 0) this.byDevice.delete(deviceKey);
 	}
+	retire(deviceKey, trackId) {
+		let ids = this.retired.get(deviceKey);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			this.retired.set(deviceKey, ids);
+		}
+		ids.add(trackId);
+		while (ids.size > RETIRED_REJECTIONS_PER_DEVICE) {
+			const oldest = ids.values().next();
+			if (oldest.done === true) break;
+			ids.delete(oldest.value);
+		}
+	}
 	/** Rejected ids currently held for a device — diagnostics and tests. */
 	size(deviceKey) {
 		return this.byDevice.get(deviceKey)?.size ?? 0;
@@ -98863,6 +99750,7 @@ var SuppressedBirthRegistry = class {
 	clearDevice(deviceKey) {
 		this.byDevice.delete(deviceKey);
 		this.skipReported.delete(deviceKey);
+		this.retired.delete(deviceKey);
 	}
 };
 //#endregion
@@ -107133,6 +108021,10 @@ Object.freeze({
 			"resolution": "auto",
 			"maxPoints": 1e3
 		},
+		"queryMany": {
+			"resolution": "auto",
+			"maxPoints": 1e3
+		},
 		"queryNode": {
 			"resolution": "auto",
 			"maxPoints": 1e3
@@ -107191,7 +108083,7 @@ Object.freeze({
 		"createRule": { "rule": { "__nested__": {
 			"enabled": true,
 			"conditions": {},
-			"media": { "attach": "best" },
+			"media": {},
 			"throttle": {
 				"cooldownSec": 60,
 				"scope": "rule-device"
@@ -107202,7 +108094,7 @@ Object.freeze({
 		"previewStateSummary": { "rule": { "__nested__": {
 			"enabled": true,
 			"conditions": {},
-			"media": { "attach": "best" },
+			"media": {},
 			"throttle": {
 				"cooldownSec": 60,
 				"scope": "rule-device"
@@ -107213,7 +108105,7 @@ Object.freeze({
 			"rule": { "__nested__": {
 				"enabled": true,
 				"conditions": {},
-				"media": { "attach": "best" },
+				"media": {},
 				"throttle": {
 					"cooldownSec": 60,
 					"scope": "rule-device"
@@ -107406,7 +108298,6 @@ Object.freeze({
 	],
 	"load-contribution": ["list"],
 	"log-channels": ["list"],
-	"log-destination": ["query"],
 	"login-method": ["getLoginMethods"],
 	"mqtt-broker": ["listBrokers"],
 	"network-access": ["listEndpoints"],
@@ -107428,12 +108319,19 @@ Object.freeze({
 	"user-passkeys": ["listPasskeys"],
 	"videoclips": ["listClips", "listSources"]
 });
-Object.freeze({ "videoclips": [
-	"dialClipStream",
-	"getPlaybackOptions",
-	"offerClipBytes",
-	"readClipBytes"
-] });
+Object.freeze({
+	"log-destination": [
+		"cancelRead",
+		"describeRead",
+		"read"
+	],
+	"videoclips": [
+		"dialClipStream",
+		"getPlaybackOptions",
+		"offerClipBytes",
+		"readClipBytes"
+	]
+});
 /** cap name -> the numeric state field whose strict advance IS the cap's one-shot event. */
 var CAP_ADVANCE_FIELDS = Object.freeze({ "doorbell": "lastPressedAt" });
 Object.freeze({
@@ -117387,6 +118285,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 						}
 					}));
 				},
+				getTracksAt: async (deviceId, timestamp, toleranceMs) => {
+					const live = stores.trackStore.getActive(deviceId);
+					const persisted = await stores.trackStore.queryRecent({
+						deviceIds: [deviceId],
+						since: timestamp - toleranceMs,
+						limit: NC_TRACKS_AT_INSTANT_LIMIT
+					});
+					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId));
+				},
 				getDeviceName,
 				getDeviceLocation,
 				buildActions: (input) => this.notificationCenter?.mintButtons(input) ?? Promise.resolve([])
@@ -119752,12 +120659,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			zones: computeStationaryEntryZones(v, liveZones, trk.zoneMembershipMinOverlap),
 			standing: true
 		}));
+		const occupancyTracked = result.tracked.filter((t) => !this.suppressedBirths.isRejected(key, t.trackId));
 		this.zoneAnalytics?.recordFrame({
 			deviceId,
 			timestamp: result.timestamp,
 			frameWidth: result.frameWidth,
 			frameHeight: result.frameHeight,
-			tracked: stationaryAsTracked.length > 0 ? [...result.tracked, ...stationaryAsTracked] : result.tracked,
+			tracked: stationaryAsTracked.length > 0 ? [...occupancyTracked, ...stationaryAsTracked] : occupancyTracked,
 			zones: liveZones,
 			...stationaryViews.length > 0 ? { stationaryObjects: stationaryViews } : {}
 		});
@@ -120114,12 +121022,14 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				}
 			});
 		}
-		if (rejectedThisFrame.size > 0) result = {
+		const keptObjectEvents = this.dropSuppressedBirthEvents(deviceId, key, result.objectEvents);
+		const keptAppearanceEvents = this.dropSuppressedBirthEvents(deviceId, key, result.appearanceEvents);
+		if (rejectedThisFrame.size > 0 || keptObjectEvents !== result.objectEvents || keptAppearanceEvents !== result.appearanceEvents) result = {
 			...result,
 			tracked: result.tracked.filter((t) => !rejectedThisFrame.has(t.trackId)),
 			rawTrackedDetections: result.rawTrackedDetections.filter((rt) => !rejectedThisFrame.has(rt.trackId)),
-			objectEvents: result.objectEvents.filter((e) => e.trackId === void 0 || !rejectedThisFrame.has(e.trackId)),
-			appearanceEvents: result.appearanceEvents.filter((e) => e.trackId === void 0 || !rejectedThisFrame.has(e.trackId))
+			objectEvents: keptObjectEvents,
+			appearanceEvents: keptAppearanceEvents
 		};
 		if (currentTrackIds.size > 0) this.lastTrackActivityMs.set(deviceId, Date.now());
 		const stationarySettings = this.stationarySettingsFromCache(deviceId);
@@ -120579,6 +121489,35 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	* invented id would put `event:NaN` in a media key. A branch that accepts
 	* work and produces nothing must log it.
 	*/
+	/**
+	* The events of `drafts` whose track's birth the confirmation gate rejected,
+	* removed — the SAME array when none is, so a caller can tell. A rejected
+	* birth is a track that never existed: it has no event row, no media and no
+	* notification, on any frame. Each drop is logged (bounded by event rate):
+	* an accepted event that silently vanishes reads as "never happened" (D391).
+	*/
+	dropSuppressedBirthEvents(deviceId, key, drafts) {
+		const isSuppressed = (e) => e.trackId !== void 0 && this.suppressedBirths.suppressesEvents(key, e.trackId);
+		if (!drafts.some(isSuppressed)) return drafts;
+		const kept = [];
+		for (const e of drafts) {
+			if (!isSuppressed(e)) {
+				kept.push(e);
+				continue;
+			}
+			this.ctx.logger.info("object event dropped — the track birth was suppressed", {
+				tags: { deviceId },
+				meta: {
+					trackId: e.trackId,
+					className: e.className,
+					state: e.state,
+					zones: e.zones,
+					reason: "birth-suppressed"
+				}
+			});
+		}
+		return kept;
+	}
 	async persistObjectEvents(deviceId, drafts) {
 		if (drafts.length === 0) return [];
 		const store = this.eventStore;