@camstack/addon-post-analysis 1.2.274 → 1.2.275

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-B9V4PRZO.js");
+const require_dist = require("../dist-Br0p61E2.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -1460,7 +1460,8 @@ var NcAlarmPanelDevice = class extends require_dist.BaseDevice {
 		return {
 			...this.readDelays(),
 			announceArm: this.config.get("announceArm"),
-			announceTargets: [...this.config.get("announceTargets")]
+			announceTargets: [...this.config.get("announceTargets")],
+			nonBlocking: []
 		};
 	}
 	/**
@@ -10822,6 +10823,23 @@ function requireCapCaller(method, caller) {
 	return caller;
 }
 //#endregion
+//#region src/notification-center/clock-text.ts
+/**
+* `{{time}}` — hours and minutes in the NOTIFICATION language.
+*
+* It used to be `toLocaleTimeString()` in the server's own locale, so an
+* Italian hub running an English container sent "8:05:13 PM" inside an
+* Italian sentence. The time zone is the host's unless a caller (a spec)
+* pins one.
+*/
+function ncClockText(language, atMs, timeZone) {
+	return new Intl.DateTimeFormat(language, {
+		hour: "2-digit",
+		minute: "2-digit",
+		...timeZone !== void 0 ? { timeZone } : {}
+	}).format(new Date(atMs));
+}
+//#endregion
 //#region src/notification-center/system-event-tap-url.ts
 /** The admin UI's own routes, as `packages/addon-admin-ui/src/App.tsx` declares them. */
 var ADMIN_ADDONS_PATH = "/system/addons";
@@ -12790,8 +12808,7 @@ var NcDispatcher = class {
 	async buildNotification(entry, target) {
 		const subject = entry.payload.subject;
 		const systemEvent = subject.systemEvent;
-		const displayDeviceId = systemEvent?.deviceId ?? subject.deviceId;
-		const deviceName = systemEvent !== void 0 && systemEvent.deviceId === void 0 ? "system" : await this.deps.getDeviceName(displayDeviceId).catch(() => null) ?? `camera ${displayDeviceId}`;
+		const deviceName = await notificationDeviceName(entry, this.deps.getDeviceName);
 		const alarmSource = systemEvent?.alarmSource;
 		const zoneLabels = systemEvent === void 0 ? await resolveZoneLabels(this.deps.getZoneNames, subject.deviceId, subject.zones) : alarmSource?.zones !== void 0 && alarmSource.zones.length > 0 ? await resolveZoneLabels(this.deps.getZoneNames, alarmSource.deviceId, alarmSource.zones) : [];
 		const vars = buildTemplateVars(this.texts, entry, deviceName, zoneLabels);
@@ -13545,17 +13562,25 @@ async function resolveZoneLabels(getZoneNames, deviceId, zoneIds) {
 function percentOf(confidence) {
 	return confidence !== void 0 ? `${Math.round(confidence * 100)}%` : "";
 }
+/** What `{{camera}}` renders on a system row that names no device. */
+var NC_DEVICELESS_CAMERA_NAME = "system";
 /**
-* The variable map ONE render pass sees: scalars, then the composites built
-* from them, then the params a system-event row froze at intake.
+* The name `{{camera}}` renders for a row — the ONE derivation, shared by the
+* dispatcher and the template-variable parity spec.
 *
-* The three groups are layered in that order deliberately. A composite
-* (`{{subject}}`, `{{inZones}}`, `{{op}}`) is a finished phrase and must not be
-* visible to the fragments it was built from — that is the depth bound, and it
-* is enforced by `text-compose.ts` never being handed this map. The frozen
-* params go last because they are the row's own truth about a system event and
-* outrank the live vocabulary for exactly those names.
+* A system row that names no device (a node, a backup, an update) renders the
+* filler {@link NC_DEVICELESS_CAMERA_NAME}: there is no camera to name, which
+* is why the catalog offers `{{camera}}` on a system rule only for the kinds
+* that carry a device (template-vars.ts). Everything else asks the directory,
+* and falls back to `camera <id>` when it cannot answer.
 */
+async function notificationDeviceName(entry, getDeviceName) {
+	const subject = entry.payload.subject;
+	const systemEvent = subject.systemEvent;
+	if (systemEvent !== void 0 && systemEvent.deviceId === void 0) return NC_DEVICELESS_CAMERA_NAME;
+	const displayDeviceId = systemEvent?.deviceId ?? subject.deviceId;
+	return await getDeviceName(displayDeviceId).catch(() => null) ?? `camera ${displayDeviceId}`;
+}
 /** Class composition of a group, busiest classes in first-seen order. */
 function classCounts(members) {
 	const counts = /* @__PURE__ */ new Map();
@@ -13565,7 +13590,18 @@ function classCounts(members) {
 		count
 	}));
 }
-function buildTemplateVars(texts, entry, deviceName, zoneLabels) {
+/**
+* The variable map ONE render pass sees: scalars, then the composites built
+* from them, then the params a system-event row froze at intake.
+*
+* The three groups are layered in that order deliberately. A composite
+* (`{{subject}}`, `{{inZones}}`, `{{op}}`) is a finished phrase and must not be
+* visible to the fragments it was built from — that is the depth bound, and it
+* is enforced by `text-compose.ts` never being handed this map. The frozen
+* params go last because they are the row's own truth about a system event and
+* outrank the live vocabulary for exactly those names.
+*/
+function buildTemplateVars(texts, entry, deviceName, zoneLabels, timeZone) {
 	const subject = entry.payload.subject;
 	const occupancy = subject.occupancy;
 	const systemEvent = subject.systemEvent;
@@ -13573,7 +13609,7 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels) {
 	const group = entry.payload.group;
 	return {
 		camera: deviceName,
-		class: detection?.className ?? subject.className,
+		class: detection?.className ?? (systemEvent !== void 0 ? "" : subject.className),
 		label: detection?.label ?? subject.label ?? "",
 		zones: zoneLabels.join(", "),
 		subject: detection?.className !== void 0 ? ncSubjectText(texts, {
@@ -13586,10 +13622,14 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels) {
 		}),
 		detectionSummary: group !== void 0 && group.members.length > 1 ? ncDetectionSummary(texts, classCounts(group.members)) : "",
 		inZones: ncInZonesText(texts, zoneLabels),
-		scope: occupancy?.zone ?? deviceName,
+		scope: occupancy !== void 0 ? occupancy.zone ?? deviceName : "",
 		zone: occupancy?.zone ?? zoneLabels[0] ?? "",
 		confidence: percentOf(detection?.confidence ?? subject.confidence),
-		time: new Date(subject.timestamp).toLocaleTimeString(),
+		time: ncClockText(texts.language, subject.timestamp, timeZone),
+		sounds: subject.audio?.labels.join(", ") ?? "",
+		hitPercent: subject.audio?.hitPercent !== void 0 ? `${Math.round(subject.audio.hitPercent)}` : "",
+		db: subject.audio?.peakDbfs !== void 0 ? `${Math.round(subject.audio.peakDbfs)}` : "",
+		eventType: subject.eventType ?? "",
 		rule: entry.payload.ruleName,
 		count: occupancy !== void 0 ? `${occupancy.count}` : group !== void 0 && group.members.length > 1 ? `${group.members.length}` : "",
 		capacity: occupancy !== void 0 ? `${occupancy.capacity}` : "",
@@ -17420,12 +17460,22 @@ var NcRuleStore = class {
 		await this.ledger.put(rule);
 		return rule;
 	}
-	/** Apply a partial patch. Immutable: returns the NEW rule object. */
-	async update(ruleId, patch) {
+	/**
+	* Apply a partial patch. Immutable: returns the NEW rule object.
+	*
+	* `clear` names optional fields to REMOVE before the merge — an omitted key
+	* keeps its stored value, so this is how an editor empties one. Setting and
+	* clearing the same key is a contradiction and is refused rather than
+	* resolved by ordering.
+	*/
+	async update(ruleId, patch, clear = []) {
 		const existing = this.ledger.get(ruleId);
 		if (!existing) throw new Error(`notification rule not found: ${ruleId}`);
+		const conflict = clear.find((key) => patch[key] !== void 0);
+		if (conflict !== void 0) throw new Error(`notification rule patch both sets and clears '${conflict}'`);
+		const cleared = new Set(clear);
 		const candidate = {
-			...existing,
+			...Object.fromEntries(Object.entries(existing).filter(([key]) => !cleared.has(key))),
 			...patch,
 			id: existing.id,
 			createdBy: existing.createdBy,
@@ -19333,13 +19383,18 @@ function clockOf$2(atMs) {
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
 /** Template vocabulary. Deliberately the SAME names the detection and timelapse
-*  bodies use (`rule`, `from`, `to`, `time`) plus the digest-only ones. */
-function templateVars$1(input) {
+*  bodies use (`rule`, `from`, `to`, `time`) plus the digest-only ones.
+*
+* Exported as `summaryTemplateVars` — not just an implementation detail of
+* {@link buildSummaryOutboxInputs} — so the parity spec
+* (`template-var-parity.spec.ts`) can assert this map directly against the
+* catalog, the same way `buildTemplateVars` is asserted for rule rows. */
+function summaryTemplateVars(input) {
 	return {
 		rule: input.ruleName,
 		from: clockOf$2(input.window.startMs),
 		to: clockOf$2(input.window.endMs),
-		time: clockOf$2(input.generatedAt),
+		time: ncClockText(input.texts.language, input.generatedAt),
 		events: String(input.tileCount),
 		cameras: String(input.cameraCount),
 		matched: String(input.matchedCount),
@@ -19446,7 +19501,7 @@ function summaryCaptionText(input) {
 * @returns rows ready for `NcOutbox.enqueue` — never sent from here.
 */
 function buildSummaryOutboxInputs(input) {
-	const vars = templateVars$1(input);
+	const vars = summaryTemplateVars(input);
 	const optedOut = new Set(input.disabledTargetIds ?? []);
 	const title = renderTemplate(input.template?.title, vars) ?? input.texts.text({
 		key: "summary.title",
@@ -21685,6 +21740,67 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 	return files;
 }
 //#endregion
+//#region src/notification-center/template-preview.ts
+/**
+* `previewTemplate` — render a rule's draft title/body against EXAMPLE values,
+* so an operator sees `{{scope}}: {{count}}/{{capacity}}` become
+* `Cancello: 3/2` before saving the rule, not after the first real event.
+*
+* Pure with respect to the caller: it never sends anything, and the only
+* side-channel it reads is the live `NcTextCatalog` handed in, so a preview
+* always speaks the hub's CURRENT language and CURRENT overrides — the same
+* words a delivered notification would use.
+*/
+/**
+* The instant `{{time}}` is previewed at — fixed, and in UTC, so the example
+* is the same on every host: "20:05" in Italian, "08:05 PM" in English.
+*/
+var PREVIEW_INSTANT_MS = Date.UTC(2026, 8, 24, 20, 5);
+var PREVIEW_TIME_ZONE = "UTC";
+/**
+* The example map: every declared example, with the COMPOSITES rendered by the
+* real composers so the preview speaks the hub's language exactly as a
+* delivered notification would.
+*/
+function exampleVars(texts) {
+	return {
+		...Object.fromEntries(require_dist.NC_TEMPLATE_VARS.filter((d) => d.dynamic === void 0).map((d) => [d.name, d.example])),
+		subject: ncSubjectText(texts, {
+			className: "person",
+			label: "Mario",
+			labelKind: "identity"
+		}),
+		inZones: ncInZonesText(texts, ["Cancello"]),
+		op: ncOccupancyOp(texts, true),
+		time: ncClockText(texts.language, PREVIEW_INSTANT_MS, PREVIEW_TIME_ZONE),
+		detectionSummary: ncDetectionSummary(texts, [{
+			className: "person",
+			count: 2
+		}, {
+			className: "car",
+			count: 1
+		}])
+	};
+}
+var DYNAMIC_EXAMPLE = "3";
+function previewTemplate(texts, input) {
+	const ctx = input.context;
+	const allowed = new Set(require_dist.templateVarsFor(ctx).map((d) => d.name));
+	const examples = exampleVars(texts);
+	const used = [input.template.title ?? "", input.template.body ?? ""].flatMap((t) => [...templatePlaceholders(t)]);
+	const unknown = [...new Set(used.filter((name) => !require_dist.isKnownTemplateVar(name, ctx)))];
+	const vars = {};
+	for (const name of used) {
+		if (!require_dist.isKnownTemplateVar(name, ctx)) continue;
+		vars[name] = allowed.has(name) ? examples[name] ?? "" : DYNAMIC_EXAMPLE;
+	}
+	return {
+		title: renderTemplate(input.template.title, vars),
+		body: renderTemplate(input.template.body, vars),
+		unknown
+	};
+}
+//#endregion
 //#region src/notification-center/text-catalog-view.ts
 /**
 * The text catalog, projected for an EDITOR — Phase 2's read model, pure.
@@ -22124,14 +22240,19 @@ function clockOf(atMs) {
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
 /** Template vocabulary. Deliberately the same NAMES the rule templates use
-*  (`camera`, `rule`, `time`) plus the timelapse-only ones. */
-function templateVars(input) {
+*  (`camera`, `rule`, `time`) plus the timelapse-only ones.
+*
+* Exported as `timelapseTemplateVars` — not just an implementation detail of
+* {@link buildTimelapseOutboxInputs} — so the parity spec
+* (`template-var-parity.spec.ts`) can assert this map directly against the
+* catalog, the same way `buildTemplateVars` is asserted for rule rows. */
+function timelapseTemplateVars(input) {
 	return {
 		camera: input.deviceName ?? `camera ${input.deviceId}`,
 		rule: input.ruleName,
 		from: clockOf(input.window.startMs),
 		to: clockOf(input.window.endMs),
-		time: clockOf(input.generatedAt),
+		time: ncClockText(input.texts.language, input.generatedAt),
 		coverage: String(input.coverage.percent),
 		events: String(input.denseRanges),
 		...detectionTemplateVars(input.texts, input.detections ?? NO_DETECTIONS)
@@ -22212,7 +22333,7 @@ function timelapseRecordId(deviceId, windowEndMs) {
 * @returns rows ready for `NcOutbox.enqueue` — never sent from here.
 */
 function buildTimelapseOutboxInputs(input) {
-	const vars = templateVars(input);
+	const vars = timelapseTemplateVars(input);
 	const optedOut = new Set(input.disabledTargetIds ?? []);
 	const title = renderTemplate(input.template?.title, vars) ?? input.texts.text({
 		key: "timelapse.title",
@@ -23195,7 +23316,8 @@ function consumablesSliceOf(event) {
 var NC_ALARM_SETTINGS_FALLBACK = {
 	...DEFAULT_DELAYS,
 	announceArm: false,
-	announceTargets: []
+	announceTargets: [],
+	nonBlocking: []
 };
 /**
 * How often the "matched NO rule" report may fire per device. Long enough that
@@ -24445,6 +24567,10 @@ var NotificationCenter = class NotificationCenter {
 	get textCatalogEditor() {
 		return this.textEditor;
 	}
+	/** The live catalog every producer renders with — the preview must use the same one. */
+	get textCatalog() {
+		return this.texts;
+	}
 	/**
 	* Produce the last closed window for one camera of one timelapse rule, now.
 	*
@@ -25307,17 +25433,19 @@ var NotificationCenter = class NotificationCenter {
 				} });
 				return { rule: created };
 			},
-			updateRule: async ({ ruleId, patch, caller }) => {
+			updateRule: async ({ ruleId, patch, clear, caller }) => {
 				if (patch.targets !== void 0) await this.validateTargetRefs(patch.targets.map((t) => t.targetId));
-				if (patch.targets !== void 0 || patch.targetUsers !== void 0) {
+				const clearsUsers = clear?.includes("targetUsers") ?? false;
+				if (patch.targets !== void 0 || patch.targetUsers !== void 0 || clearsUsers) {
 					const existing = this.rules.get(ruleId);
-					NotificationCenter.assertHasAddressee(patch.targets ?? existing?.targets ?? [], patch.targetUsers ?? existing?.targetUsers);
+					NotificationCenter.assertHasAddressee(patch.targets ?? existing?.targets ?? [], clearsUsers ? void 0 : patch.targetUsers ?? existing?.targetUsers);
 				}
 				const { disabledTargetIds: _optOut, ...safePatch } = patch;
-				const updated = await this.rules.update(ruleId, safePatch);
+				const updated = await this.rules.update(ruleId, safePatch, clear ?? []);
 				this.logger.info("notification rule updated", { meta: {
 					ruleId,
-					by: caller.userId
+					by: caller.userId,
+					...clear && clear.length > 0 ? { cleared: clear } : {}
 				} });
 				return { rule: updated };
 			},
@@ -25334,6 +25462,8 @@ var NotificationCenter = class NotificationCenter {
 				catalog: [...require_dist.NC_CONDITION_CATALOG],
 				taxonomy: require_dist.NC_TAXONOMY
 			}),
+			getTemplateCatalog: async () => ({ vars: [...require_dist.NC_TEMPLATE_VARS] }),
+			previewTemplate: async (input) => previewTemplate(this.texts, input),
 			getHistory: async ({ filter }) => {
 				const entries = await this.outbox.queryHistory({
 					...filter.ruleId !== void 0 ? { ruleId: filter.ruleId } : {},
@@ -26521,6 +26651,12 @@ var NotificationCenter = class NotificationCenter {
 					...subject.observedAt !== void 0 ? { observedAt: subject.observedAt } : {},
 					...subject.occupancy !== void 0 ? { occupancy: frozenOccupancy(rule, subject.occupancy) } : {},
 					...subject.packagePhase !== void 0 ? { packagePhase: subject.packagePhase } : {},
+					...subject.audioWindow !== void 0 ? { audio: {
+						labels: subject.audioWindow.labels,
+						...subject.audioWindow.mode === "level" ? { hitPercent: subject.audioWindow.hitPercent } : {},
+						...subject.audioWindow.peakDbfs !== void 0 ? { peakDbfs: subject.audioWindow.peakDbfs } : {}
+					} } : {},
+					...subject.eventType !== void 0 ? { eventType: subject.eventType } : {},
 					...subject.systemEvent !== void 0 ? { systemEvent: subject.systemEvent } : {}
 				}
 			};
@@ -27709,14 +27845,13 @@ var ncActions = require_dist.defineCustomActions({
 		catalog: require_dist.array(require_dist.NcConditionDescriptorSchema),
 		taxonomy: require_dist.NcTaxonomySchema
 	})),
+	"nc.getTemplateCatalog": require_dist.customAction(require_dist.object({}), require_dist.object({ vars: require_dist.array(require_dist.NcTemplateVarDescriptorSchema) })),
+	"nc.previewTemplate": require_dist.customAction(require_dist.NcTemplatePreviewInputSchema, require_dist.NcTemplatePreviewSchema, { kind: "mutation" }),
 	"nc.createRule": require_dist.customAction(require_dist.object({ rule: require_dist.NcRuleInputSchema }), require_dist.object({ rule: require_dist.NcRuleSchema }), {
 		kind: "mutation",
 		caller: "required"
 	}),
-	"nc.updateRule": require_dist.customAction(require_dist.object({
-		ruleId: require_dist.string(),
-		patch: require_dist.NcRulePatchSchema
-	}), require_dist.object({ rule: require_dist.NcRuleSchema }), {
+	"nc.updateRule": require_dist.customAction(require_dist.NcRuleUpdateInputSchema, require_dist.object({ rule: require_dist.NcRuleSchema }), {
 		kind: "mutation",
 		caller: "required"
 	}),
@@ -27735,14 +27870,17 @@ var ncActions = require_dist.defineCustomActions({
 	/**
 	* THE AI SECTION of the ordinary rules — read and write.
 	*
-	* A pair of its own rather than two more keys on `nc.createRule` /
-	* `nc.updateRule`, and that is the whole point of the design: those two
-	* validate against `NcRuleInputSchema` from `@camstack/types`, which the
-	* addon resolves from the `@camstack/server` closure at runtime — so a new
-	* key on them is SILENTLY STRIPPED at save until a framework train lands and
-	* is installed. These two validate against a schema that lives in the addon
-	* (`rule-ai.ts`), so a field added to it is live on the next
-	* `camstack deploy packages/addon-post-analysis`.
+	* A pair of its own rather than two more keys on the rule CRUD, and that is
+	* the whole point of the design. The addon builds self-contained and INLINES
+	* `@camstack/types`, so its own copy of `NcRuleInputSchema` is never the
+	* problem and nothing here fails at load. The coupling is the HUB: the cap
+	* route (`notificationRules.createRule` / `updateRule`, which the admin
+	* editor uses) validates input against the copy of `@camstack/types` that
+	* `@camstack/system` inlines (`bundleTypesMainEntry`), so a new key on
+	* `NcRuleInputSchema` is SILENTLY STRIPPED there until a `@camstack/server`
+	* release carrying it is installed. These two validate only here, against a
+	* schema that lives in the addon (`rule-ai.ts`), so a field added to it is
+	* live on the next `camstack deploy packages/addon-post-analysis`.
 	*
 	* Scoped exactly as the rule CRUD is: reading needs a rule the caller can
 	* SEE, writing needs one they own (admins bypass ownership, never the caller
@@ -28234,6 +28372,12 @@ function makeNcActionHandlers(deps) {
 			catalog: [...require_dist.NC_CONDITION_CATALOG],
 			taxonomy: require_dist.NC_TAXONOMY
 		}),
+		"nc.getTemplateCatalog": async () => ({ vars: [...require_dist.NC_TEMPLATE_VARS] }),
+		"nc.previewTemplate": async (input) => {
+			const texts = deps.previewTexts;
+			if (texts === void 0) throw new Error("nc.previewTemplate: text catalog not wired");
+			return previewTemplate(texts, input);
+		},
 		"nc.createRule": async (input, caller) => {
 			const c = requireCaller$1(caller);
 			const parsed = require_dist.NcRuleInputSchema.parse(input.rule);
@@ -28254,10 +28398,11 @@ function makeNcActionHandlers(deps) {
 			const patch = require_dist.NcRulePatchSchema.parse(input.patch);
 			if (patch.targets !== void 0) await assertTargetsOwned(patch.targets.map((t) => t.targetId), c);
 			const { ownerUserId: _owner, disabledTargetIds: _optOut, ...safe } = patch;
-			const rule = await deps.ruleStore.update(input.ruleId, safe);
+			const rule = await deps.ruleStore.update(input.ruleId, safe, input.clear ?? []);
 			deps.logger.info("nc rule updated", { meta: {
 				ruleId: rule.id,
-				owner: c.userId
+				owner: c.userId,
+				...input.clear && input.clear.length > 0 ? { cleared: input.clear } : {}
 			} });
 			return { rule };
 		},
@@ -71738,9 +71883,111 @@ async function projectSensorMarkers(deps, data, timestamp) {
 	}
 	return landed;
 }
+//#endregion
+//#region src/pipeline-analytics/services/sensor-transition-gate.ts
+/**
+* The gate between "a `DeviceStateChanged` arrived for a mapped sensor cap"
+* and "the sensor actually CHANGED".
+*
+* ## What this fixes
+*
+* `handleSensorStateChanged` treated the ARRIVAL of the bus event as the
+* assertion, and never looked at the slice. It cannot: the kernel mirror
+* (`device-state-mirror.ts` `applySingleCapUpdate`) diffs the whole SLICE, and
+* a contact slice carries `lastChangedAt` beside `entryOpen`. Anything that
+* moves the timestamp without moving the boolean is a `DeviceStateChanged`,
+* and downstream it became a `SensorEvent` row and a synthetic `contact` track
+* on the linked camera's timeline.
+*
+* Measured on camera 615 / contact sensor 4131, 2026-08-29→30: **30 of 35**
+* contact events were one of two non-events.
+*
+*  - The RECOVERY family. The Zigbee entity flaps `off → unavailable → off`
+*    (03:22:37→03:23:28, 03:56:51→03:58:19, 04:40:05→04:45:45). The HA
+*    provider drops the `unavailable` push and writes the recovery, whose
+*    `entryOpen` is still `false` and whose `lastChangedAt` is HA's fresh
+*    `last_changed`. The mirror diffs, and emits.
+*  - The COLD-SLICE family. `HaBinarySensorDevice`'s constructor writes
+*    `{ entryOpen: false, lastChangedAt: 0 }` on every device rebuild; the
+*    real state lands seconds later with a `lastChangedAt` hours old. Two
+*    emissions, no transition.
+*
+* ## Why the predicate is imported and not written here
+*
+* `evaluateSensorEdge` (`@camstack/types`) is already THE edge predicate: the
+* virtual doorbell feeds it (`builtins/doorbell/trigger-engine.ts`) and so does
+* the recorder's sensor trigger (`addon-pipeline` `recorder/sensor-trigger.ts`).
+* Post-analysis was the third consumer of the same bus event and the only one
+* that did not. A second predicate here would diverge on the first cap added —
+* the exact failure [D62](../../../../../docs/decisions/adr-0062.md) names.
+*
+* ## Where it deliberately differs from the other two
+*
+* The doorbell and the recorder want the RISING edge only. A timeline marker
+* is not a doorbell: a door CLOSING is an event an operator wants to see, and
+* the taxonomy has one `contact` kind for both directions. So this gate accepts
+* `edge: 'rising'` **and** the `falling-edge` verdict, and rejects only the
+* verdicts that mean "nothing moved" — which is precisely the 30.
+*
+* ## Caps with no boolean level pass through untouched
+*
+* `EVENT_KIND_BY_CAP` covers sixteen caps; `SOURCE_CAP_ACTIVE_FIELD` covers the
+* ten that have a boolean whose edge means something. `doorbell`, `button`,
+* `lock-control`, `presence`, `enum-sensor` and `event-emitter` are NOT levels
+* — their ARRIVAL is the event, and three presses in a row are three markers.
+* Gating them would re-ship the failure of 2026-08-08, when camera 615's press
+* produced a row, a ring, a matched rule and no marker.
+*
+* ## A cover is a level whose level is a WORD
+*
+* `cover` is the sixteenth cap, and it is neither of the above. Its level is
+* the `state` word (`open`, `opening`, `closing`, `closed`, `stopped`), and its
+* slice also carries `position`, which ticks all the way through a travel and
+* is republished unchanged by providers that poll. Passed through, every tick
+* and every republish would write a sensor-event row per linked camera and an
+* NC evaluation — so it transitions on the WORD only (`WORD_LEVEL_FIELD`):
+* `closed → opening → open` is two events, a position tick or a same-word
+* republish is a `no-change` drop.
+*
+* Its FIRST sighting follows the booleans' rule (`evaluateSensorEdge`), with
+* `closed` as the inactive word: `closed` seeds the baseline and is dropped
+* (`baseline-seeded-inactive`); any other word is an EVENT when the slice's
+* `lastChangedAt` clears the same floor, `max(startedAt, now - freshness)`,
+* and is otherwise seeded and dropped (`baseline-seeded-stale-active`). It has
+* to emit: after a runner respawn the memory is empty and the next slice is
+* usually the next REAL change, and on a two-word cover (Velux, most HA
+* covers: `closed`/`open` only) seeding it would lose the whole opening.
+*
+* Residual edges, both erring towards silence on the ambiguous case like the
+* booleans do: a cover that was already open and whose `lastChangedAt` is
+* older than the floor is not reported (a respawn cannot tell it from a
+* hydration); and a first sighting whose `lastChangedAt` is fresh only
+* because a POSITION tick moved it (the slice timestamp is not the word's)
+* is reported once as if the word had just changed. The alarm needs covers
+* to be eventful to see one open (D630).
+*
+* ## Nothing here logs, and no drop is silent
+*
+* The gate is pure towards the world (no bus, no logger, no clock of its own —
+* the caller brings `now`), like the recorder's router. But it sits on a path
+* that carries every camera's native `motion` slice at motion rate — ~0.6/s
+* fleet-wide — so a line per drop would be its own outage. It accumulates
+* instead, per `(deviceId, capName, reason)`, and the caller drains one summary
+* per window. A `debug` at 3.3/s that nobody read is how a 100 %-rejection
+* regime survived three months here.
+*/
+/**
+* Caps whose level is a string word rather than a boolean: cap → slice field.
+* See "A cover is a level whose level is a WORD" above.
+*/
+var WORD_LEVEL_FIELD = { cover: "state" };
+/** The word a word-level cap rests in — its `false`, for the first-sighting rule. */
+var WORD_LEVEL_INACTIVE = { cover: "closed" };
 var SensorTransitionGate = class {
 	/** Last observed boolean, keyed by `${deviceId}:${capName}`. */
 	lastValues = /* @__PURE__ */ new Map();
+	/** Last observed word of a word-level cap, keyed by `${deviceId}:${capName}`. */
+	lastWords = /* @__PURE__ */ new Map();
 	/** Drops since the window opened, keyed by `${deviceId}:${capName}:${reason}`. */
 	drops = /* @__PURE__ */ new Map();
 	windowStartedAt;
@@ -71758,10 +72005,13 @@ var SensorTransitionGate = class {
 	/**
 	* Feed one `DeviceStateChanged` slice for a cap `EVENT_KIND_BY_CAP` maps.
 	*
-	* A cap with no boolean level passes through unconditionally. A cap that HAS
-	* one passes only when its boolean moved — in either direction.
+	* A cap with no level passes through unconditionally. A cap that HAS one
+	* passes only when its level moved — a boolean in either direction, or a
+	* word-level cap's word changing.
 	*/
 	observe(deviceId, capName, slice) {
+		const wordField = WORD_LEVEL_FIELD[capName];
+		if (wordField !== void 0) return this.observeWord(deviceId, capName, slice, wordField);
 		if (!require_dist.isSourceCap(capName)) return { changed: true };
 		const key = `${deviceId}:${capName}`;
 		const verdict = require_dist.evaluateSensorEdge({
@@ -71799,6 +72049,40 @@ var SensorTransitionGate = class {
 		this.drops.clear();
 		return out;
 	}
+	/**
+	* A word-level cap: a transition is the word changing. The memory is
+	* written only when the slice CARRIED a word, for the same reason as the
+	* booleans — a malformed slice must not become a baseline.
+	*/
+	observeWord(deviceId, capName, slice, wordField) {
+		const raw = slice[wordField];
+		if (typeof raw !== "string" || raw.length === 0) return this.drop(deviceId, capName, "non-word-value");
+		const key = `${deviceId}:${capName}`;
+		const prior = this.lastWords.get(key);
+		this.lastWords.set(key, raw);
+		if (prior === void 0) return this.firstWordSighting(deviceId, capName, slice, raw);
+		if (prior === raw) return this.drop(deviceId, capName, "no-change");
+		return { changed: true };
+	}
+	/**
+	* The booleans' first-sighting rule, on a word: the resting word seeds; any
+	* other word is an event only when the slice's own `lastChangedAt` clears
+	* the SAME floor `evaluateSensorEdge` uses, from the same two knobs.
+	*/
+	firstWordSighting(deviceId, capName, slice, word) {
+		if (word === WORD_LEVEL_INACTIVE[capName]) return this.drop(deviceId, capName, "baseline-seeded-inactive");
+		const changedAt = slice["lastChangedAt"];
+		const floor = Math.max(this.startedAtMs, this.now() - this.freshnessMs);
+		if (!(typeof changedAt === "number" && Number.isFinite(changedAt) && changedAt > 0 && changedAt >= floor)) return this.drop(deviceId, capName, "baseline-seeded-stale-active");
+		return { changed: true };
+	}
+	drop(deviceId, capName, reason) {
+		this.noteDrop(deviceId, capName, reason);
+		return {
+			changed: false,
+			reason
+		};
+	}
 	noteDrop(deviceId, capName, reason) {
 		const key = `${deviceId}:${capName}:${reason}`;
 		const prior = this.drops.get(key);
@@ -78385,6 +78669,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				runNow: (input) => center.runSummaryNow(input)
 			},
 			texts: center.textCatalogEditor,
+			previewTexts: center.textCatalog,
 			...this.ncArtifactIndex !== null ? { artifacts: this.ncArtifactIndex } : {},
 			artifactShelf: { remove: async (id) => await this.ncArtifactStore?.remove(id) ?? false },
 			ruleStatus: {
@@ -85224,7 +85509,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* A cap with no boolean level (`doorbell`, `button`, `lock-control`,
 	* `presence`, `enum-sensor`, `event-emitter`) always passes — its ARRIVAL is
 	* the event, and gating it would re-ship the silence of 2026-08-08. A cap
-	* that HAS one passes only when the boolean moved, in either direction.
+	* that HAS one passes only when the boolean moved, in either direction — or,
+	* for `cover`, whose level is its `state` word, only when the word changed
+	* (a position tick or a same-word republish is a drop).
 	*
 	* A slice that is not an object at all is refused rather than defaulted to
 	* `{}`: `evaluateSensorEdge` would read `non-boolean-value` from an empty