@camstack/addon-post-analysis 1.2.280 → 1.2.282

package/dist/{dist-VeiAavYR.js → dist-D0zzdvSd.js}

@@ -29,6 +29,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+let node_crypto = require("node:crypto");
 //#region ../types/dist/event-category-BVDXG4tB.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
@@ -5390,7 +5391,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-D_4W7xuQ.mjs
+//#region ../types/dist/sleep-DU7mu4wb.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7598,6 +7599,39 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 //#endregion
+//#region ../types/dist/canonical-hash-CPK2Dy60.mjs
+/**
+* Deterministic SHA-256 hash of an arbitrary serialisable value. The
+* canonical form sorts object keys alphabetically at every depth so two
+* structurally-equal inputs with different key insertion orders produce
+* the same hash. Returns a 64-char lowercase hex digest.
+*
+* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
+* accessory-rebuild work when the upstream shape is byte-identical to
+* the last applied state — preventing user-visible "re-discovery"
+* notifications on every addon-runner respawn. Each respawn re-fires
+* `DeviceBindingsChanged` for every cap registration, which without
+* this guard would propagate redundant pushes.
+*
+* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
+* subscription. The proper fix is a single "device ready" lifecycle
+* barrier so exports react only when the full cap set has landed —
+* tracked separately for post-HA-integration work.
+*/
+function canonicalHash(value) {
+	const canonical = JSON.stringify(value, replaceWithSortedKeys);
+	return (0, node_crypto.createHash)("sha256").update(canonical ?? "").digest("hex");
+}
+function replaceWithSortedKeys(_key, value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const obj = value;
+		const out = {};
+		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
+		return out;
+	}
+	return value;
+}
+//#endregion
 //#region ../types/dist/err-msg-IQTHeDzc.mjs
 /**
 import { errMsg } from '@camstack/types'
@@ -18175,6 +18209,16 @@ var NcCrossingSchema = _enum([
 	"exit",
 	"any"
 ]);
+/**
+* Which edge of a BOOLEAN sensor fires a device-event rule (D640).
+*  - `raised`  — the sensor went high: water detected, smoke, open, tampered.
+*  - `cleared` — it went back: dry, clear, closed.
+*  - absent    — both edges, which is what every rule authored before this did.
+*
+* There is no third member for "both": absence already says it, and a value
+* that means the same as absence is a second way to write one rule.
+*/
+var NcSensorTransitionSchema = _enum(["raised", "cleared"]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = object({
 	ids: array(string().min(1)).min(1),
@@ -18364,6 +18408,20 @@ var NcConditionsSchema = object({
 	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: array(number()).optional(),
+	/**
+	* Device EXCLUSION (D641) — "every device except these". Judged on the SAME
+	* subject ids {@link devices} is judged on (the camera, the sensor that
+	* fired, a linked set's sensor and row cameras), so a sensor fanned out per
+	* linked camera is excluded exactly where an include would have tested it.
+	* `min(1)`: an empty exclusion excludes nothing and is written as absent.
+	*
+	* Not for `system-event` rules — those carry their own
+	* `systemEvent.excludeDeviceIds` (D636), and the hub refuses this key there.
+	* Editors present the two lists as ONE field (All | Only these | All except
+	* these); the engine evaluates each independently, so a legacy rule
+	* carrying both still means "these, minus those".
+	*/
+	devicesExclude: array(number()).min(1).optional(),
 	/** Detector class names (any overlap with the record's class set). */
 	classes: array(string().min(1)).optional(),
 	/** Veto classes — any overlap fails the rule. */
@@ -18497,6 +18555,16 @@ var NcConditionsSchema = object({
 	*/
 	sensorKinds: array(string().min(1)).optional(),
 	/**
+	* DEVICE-EVENT only (D640). Fire on one edge of a boolean sensor —
+	* {@link NcSensorTransitionSchema}. Which field of the slice means "raised"
+	* is `@camstack/types` → `notification/sensor-raised.ts`. A reading the
+	* engine cannot place (a kind with no raise, an unreadable slice) PASSES:
+	* the condition fails open towards notifying, never towards silence. Editors
+	* offer it only when every chosen {@link sensorKinds} member has a raise
+	* (`sensorTransitionOffered`), and the hub refuses it on any other delivery.
+	*/
+	sensorTransition: NcSensorTransitionSchema.optional(),
+	/**
 	* PACKAGE-EVENT only. Which package phase fires the rule — `delivered`
 	* (a parked parcel appeared), `picked-up` (it departed), or `both`. Fails
 	* when the subject's phase does not match (a subject always carries a phase
@@ -18996,9 +19064,29 @@ var NcTestResultSchema = object({
 	className: string().optional(),
 	label: string().optional()
 });
-/** The five rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts`
-*  is the same union; the template-vars spec pins the two together. */
+/** The rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts` is the
+*  same union; the template-vars spec pins the two together. `mixed` is DERIVED
+*  (a stored system rule whose kinds span families, D637) and never authored. */
 var NcRuleKindSchema = _enum([
+	"detection",
+	"sensor",
+	"occupancy",
+	"sound",
+	"device-events",
+	"system",
+	"alarm",
+	"mixed"
+]);
+/**
+* The kinds a SERVED template-variable descriptor may name: the five that
+* existed before D637, frozen. `getTemplateCatalog` ships `kinds` to every
+* installed viewer, and a viewer at `@camstack/types` 1.2.25x parses them with a
+* strict five-member enum — one `device-events` in one descriptor fails the
+* whole catalog parse. So the WIRE says `system`, and the MATCH widens it:
+* `templateVarKindApplies` reads a `system` descriptor as applying to every
+* system rule kind (`device-events`, `system`, `alarm`, `mixed`).
+*/
+var NcTemplateVarKindSchema = _enum([
 	"detection",
 	"sensor",
 	"occupancy",
@@ -19036,7 +19124,7 @@ var NcTemplateVarGroupSchema = _enum([
 *
 * `families` / `fields` / `kinds` / `deliveries` / `systemEventKinds` say WHERE
 * it has a value; absent = no restriction on that axis. `systemEventKinds` is
-* read only for a `system` rule. `dynamic` declares a FAMILY of names
+* read only for a system-event rule (any family, or `mixed`). `dynamic` declares a FAMILY of names
 * (`count_<class>`): the descriptor's `name` is the example member.
 */
 var NcTemplateVarDescriptorSchema = object({
@@ -19047,7 +19135,7 @@ var NcTemplateVarDescriptorSchema = object({
 	group: NcTemplateVarGroupSchema,
 	families: array(NcTemplateFamilySchema).min(1),
 	fields: array(NcTemplateFieldSchema).optional(),
-	kinds: array(NcRuleKindSchema).optional(),
+	kinds: array(NcTemplateVarKindSchema).optional(),
 	deliveries: array(NcDeliverySchema).optional(),
 	systemEventKinds: array(NcSystemEventKindSchema).optional(),
 	dynamic: object({
@@ -19095,6 +19183,7 @@ var NcConditionDescriptorSchema = object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: _enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -19105,6 +19194,7 @@ var NcConditionDescriptorSchema = object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -19303,6 +19393,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Restrict the rule to these devices; absent = all devices. A sensor event matches either the SENSOR that fired or the camera it is attributed to, so a rule may name either one."
 	},
+	{
+		id: "devicesExclude",
+		group: "scope",
+		label: "Excluded devices",
+		valueType: "deviceIdExcludeList",
+		operator: "notIn",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P1",
+		description: "Every device except these. Judged on the same device ids as Devices: a sensor event is excluded by the SENSOR that fired or by the camera it is attributed to."
+	},
 	{
 		id: "classes",
 		group: "class",
@@ -19559,6 +19664,33 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Raw device event-type tokens (e.g. doorbell press / press_long) from the event-emitter slice; absent on doorbell-pulse / passive sensors."
 	},
+	{
+		id: "sensorTransition",
+		group: "device",
+		label: "Notify when",
+		valueType: "sensorTransition",
+		options: [
+			{
+				value: "",
+				label: "It triggers and when it clears",
+				hint: "Every change: water detected, and back to dry."
+			},
+			{
+				value: "raised",
+				label: "Only when it triggers",
+				hint: "Water detected, smoke, a contact opening — never the return to normal."
+			},
+			{
+				value: "cleared",
+				label: "Only when it clears",
+				hint: "Back to dry, smoke gone, a contact closing — never the alert itself."
+			}
+		],
+		operator: "in",
+		appliesTo: ["device-event"],
+		phase: "P2",
+		description: "Fire on one edge of a boolean sensor. Offered only when every chosen sensor kind raises and clears; a reading that cannot be placed still notifies."
+	},
 	{
 		id: "packagePhase",
 		group: "package",
@@ -19742,6 +19874,28 @@ var NcHistoryFilterSchema = object({
 	limit: number().int().min(1).max(500).default(100)
 });
 /**
+* Every rule's last run, in one answer.
+*
+* A rule ABSENT from `runs` produced no delivery inside `horizonMs` — how far
+* back this answer looked, in ms before the hub's now. It is the outbox prune
+* window (7 days by default, operator-configurable), NARROWED when the read hit
+* its row bound: the answer never claims a window it did not read. `null` means
+* the operator keeps the outbox forever AND the read reached its end, so absent
+* means "never on record". A UI derives its "not in the last N days" from this
+* value, never from a constant — and only when the call ANSWERED (D315).
+*/
+var NcRuleLastRunsSchema = object({
+	runs: array(object({
+		ruleId: string(),
+		/** Fire time of the newest row (`createdAt`, epoch ms). */
+		lastAt: number(),
+		status: NcHistoryStatusSchema,
+		/** The camera/device of that row (a digest row files under its first camera). */
+		deviceId: number()
+	})),
+	horizonMs: number().nonnegative().nullable()
+});
+/**
 * What a snooze covers. Broader scopes win when several overlap, so one window
 * leaves ONE digest rather than a rule snooze and a whole-feed snooze both
 * summarising the same silence.
@@ -19923,6 +20077,14 @@ var NcAlarmModeCoverageSchema = object({
 	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
 	deviceIds: array(number().int()),
 	/**
+	* D641: the ids NOT covered although `allDevices` is true — every unscoped
+	* covering rule EXCLUDES them (`conditions.devicesExclude`) and no named rule
+	* covers them. Always `[]` when `allDevices` is false. Excluded by the rules,
+	* which is not the same as skipped by a switch: never in `skippedDevices`.
+	* Defaulted so an answer computed before this field parses as "none".
+	*/
+	allDevicesExcept: array(number().int()).default([]),
+	/**
 	* Devices this mode NAMES but cannot actually arm, each with the switch that
 	* excludes it.
 	*
@@ -20146,6 +20308,15 @@ var notificationRulesCapability = {
 		*/
 		getHistory: method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }),
 		/**
+		* The newest delivery of every rule, in ONE bounded read of the outbox —
+		* the "Last run" column. Never a `getHistory` per rule. A rule with no
+		* delivery inside `horizonMs` is absent from `runs`; see
+		* {@link NcRuleLastRunsSchema} for what absent means. A store that cannot
+		* answer FAILS the call rather than answering "nothing ran". Admin-only,
+		* like `getHistory`, of which it is a projection.
+		*/
+		getRuleLastRuns: method(object({}), NcRuleLastRunsSchema, { auth: "admin" }),
+		/**
 		* Mint a fresh, externally-reachable URL for one artefact a history row
 		* named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
 		* signed-link mechanism the dispatcher uses to attach media to an
@@ -33200,7 +33371,30 @@ var RenameNodeResultSchema = object({
 	nodeId: string(),
 	name: string()
 });
-method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }), method(NodeAddonInputSchema, SuccessSchema, {
+/**
+* The cheap node list. A consumer's rule for a STORED node id (a rule's
+* `nodeIds`) that is missing from `nodes`, whatever `complete` says: render it
+* as a removable chip labelled unknown, never drop it (D49). Even a complete
+* list omits a node that joined and left between two history captures, so a
+* missing id means "not known to the hub", never "removed". Only the operator
+* removes it.
+*
+* `complete` changes only the WORDING: `false` = no history read has ever
+* answered, so the list may be missing offline nodes the hub does know (D315).
+*
+* `name` is the history row's name (≤ 30 s behind a rename), or the id when
+* the history has none.
+*/
+var NodeDirectorySchema = object({
+	nodes: array(object({
+		id: string(),
+		name: string(),
+		isHub: boolean(),
+		isOnline: boolean()
+	})).readonly(),
+	complete: boolean()
+});
+method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }), method(_void(), NodeDirectorySchema, { auth: "admin" }), method(NodeAddonInputSchema, SuccessSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(NodeAddonInputSchema, SuccessSchema, {
@@ -44726,6 +44920,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -44894,6 +45094,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getRuleLastRuns": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getTemplateCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -50510,6 +50716,253 @@ function audioModeOf(value) {
 	return null;
 }
 new Set(["devices", "classes"]);
+/** Every filter, for the callers that must cover all four (guards, tests). */
+var NC_SYSTEM_EVENT_FILTER_KEYS = [
+	"deviceIds",
+	"deviceTypes",
+	"nodeIds",
+	"packageNames"
+];
+/**
+* Does `filter` say anything about `kind`?
+*
+* `false` means the filter is not part of this kind's vocabulary: the engine
+* ignores it and an editor hides its input. It never means "excluded".
+*/
+function systemEventFilterApplies(kind, filter) {
+	switch (filter) {
+		case "deviceIds": return kind.startsWith("device-") || kind.startsWith("stream-") || kind === "detection-blind" || kind === "alarm-triggered";
+		case "deviceTypes": return kind.startsWith("device-") || kind === "detection-blind";
+		case "nodeIds": return kind.startsWith("node-") || kind === "addon-crash-loop" || kind === "addon-update-available" || kind === "addon-updated" || kind === "server-update-available" || kind === "wrapper-update-available" || kind === "server-updated";
+		case "packageNames": return kind.endsWith("update-available") || kind === "addon-updated" || kind === "server-updated";
+	}
+}
+/**
+* WHICH FAMILY every system-event kind belongs to, and which narrowing filters
+* each family may carry: one table, read by the hub validator, by `ruleKindOf`
+* and by both rule editors (D637).
+*
+* A system rule used to be one editor for thirty-one kinds and five filters.
+* "Eventi di sistema" carried battery kinds under a liveness `deviceTypes` filter
+* and went silent for two weeks (D636). The three families are three questions:
+* about devices, about the installation, and about the alarm panel. A rule
+* answers one of them. The engine never needed to know, and it still does not:
+* a mixed stored rule keeps firing. Only AUTHORING is strict.
+*
+* The legacy `camera-*` tail has no family (`null`). It is parsed, never produced,
+* never offered.
+*/
+var NC_SYSTEM_EVENT_FAMILIES = [
+	"device-events",
+	"system",
+	"alarm"
+];
+function isSystemEventFamily(value) {
+	return NC_SYSTEM_EVENT_FAMILIES.some((family) => family === value);
+}
+/** Total over the enum: a kind added to the cap without a family fails tsc here. */
+var NC_SYSTEM_EVENT_FAMILY = {
+	"device-online": "device-events",
+	"device-offline": "device-events",
+	"device-disabled": "device-events",
+	"device-enabled": "device-events",
+	"device-battery-low": "device-events",
+	"device-battery-normal": "device-events",
+	"device-consumable-low": "device-events",
+	"device-consumable-normal": "device-events",
+	"stream-online": "device-events",
+	"stream-offline": "device-events",
+	"detection-blind": "device-events",
+	"node-online": "system",
+	"node-offline": "system",
+	"node-inference-unavailable": "system",
+	"addon-crash-loop": "system",
+	"addon-update-available": "system",
+	"addon-updated": "system",
+	"server-update-available": "system",
+	"server-updated": "system",
+	"wrapper-update-available": "system",
+	"backup-completed": "system",
+	"export-completed": "system",
+	"alarm-triggered": "alarm",
+	"alarm-armed": "alarm",
+	"alarm-disarmed": "alarm",
+	"alarm-arming": "alarm",
+	"alarm-arm-refused": "alarm",
+	"alarm-pending": "alarm",
+	"alarm-rearmed": "alarm",
+	"alarm-sensor-bypass": "alarm",
+	"alarm-check-failed": "alarm",
+	"camera-online": null,
+	"camera-offline": null,
+	"camera-disabled": null,
+	"camera-enabled": null
+};
+new Map(Object.entries(NC_SYSTEM_EVENT_FAMILY));
+var NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS = [...NC_SYSTEM_EVENT_FILTER_KEYS, "excludeDeviceIds"];
+/**
+* The filters a family may carry. The four base filters are the union of
+* `systemEventFilterApplies` over the family's kinds (the spec pins that
+* equality). `excludeDeviceIds` is a device-events filter only: an alarm is
+* narrowed to the camera that triggered it and excludes nothing.
+*/
+var NC_SYSTEM_EVENT_FAMILY_FILTERS = {
+	"device-events": [
+		"deviceIds",
+		"excludeDeviceIds",
+		"deviceTypes"
+	],
+	system: ["nodeIds", "packageNames"],
+	alarm: ["deviceIds"]
+};
+var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
+	{
+		id: "device-state",
+		family: "device-events",
+		label: "Device state",
+		kinds: [
+			"device-offline",
+			"device-online",
+			"device-disabled",
+			"device-enabled"
+		]
+	},
+	{
+		id: "streams",
+		family: "device-events",
+		label: "Streams",
+		kinds: ["stream-offline", "stream-online"]
+	},
+	{
+		id: "battery",
+		family: "device-events",
+		label: "Battery",
+		kinds: ["device-battery-low", "device-battery-normal"]
+	},
+	{
+		id: "consumables",
+		family: "device-events",
+		label: "Consumables",
+		kinds: ["device-consumable-low", "device-consumable-normal"]
+	},
+	{
+		id: "detection-blind",
+		family: "device-events",
+		label: "Detecting nothing",
+		kinds: ["detection-blind"]
+	},
+	{
+		id: "nodes",
+		family: "system",
+		label: "Nodes",
+		kinds: [
+			"node-offline",
+			"node-online",
+			"node-inference-unavailable"
+		]
+	},
+	{
+		id: "addons",
+		family: "system",
+		label: "Addons",
+		kinds: [
+			"addon-crash-loop",
+			"addon-update-available",
+			"addon-updated"
+		]
+	},
+	{
+		id: "updates",
+		family: "system",
+		label: "Server & container updates",
+		kinds: [
+			"server-update-available",
+			"server-updated",
+			"wrapper-update-available"
+		]
+	},
+	{
+		id: "backups-exports",
+		family: "system",
+		label: "Backups & exports",
+		kinds: ["backup-completed", "export-completed"]
+	},
+	{
+		id: "alarm",
+		family: "alarm",
+		label: "Alarm",
+		kinds: NC_ALARM_SYSTEM_EVENT_KINDS
+	}
+];
+function systemEventKindsOfFamily(family) {
+	return NC_SYSTEM_EVENT_KIND_GROUP_SPECS.filter((g) => g.family === family).flatMap((g) => g.kinds);
+}
+/**
+* Why the hub refuses this condition on a new or updated rule. Empty = accepted.
+* Families are reported in `NC_SYSTEM_EVENT_FAMILIES` order, and filters in
+* `NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS` order, so a refusal reads the same
+* every time.
+*/
+function systemEventFamilyProblems(condition) {
+	if (condition === void 0 || condition.kinds.length === 0) return [{ code: "no-kinds" }];
+	const problems = [];
+	const present = /* @__PURE__ */ new Set();
+	for (const kind of condition.kinds) {
+		const family = NC_SYSTEM_EVENT_FAMILY[kind];
+		if (family === null) problems.push({
+			code: "legacy-kind",
+			kind
+		});
+		else present.add(family);
+	}
+	const families = NC_SYSTEM_EVENT_FAMILIES.filter((f) => present.has(f));
+	if (families.length > 1) problems.push({
+		code: "mixed-families",
+		families
+	});
+	const [family] = families;
+	if (families.length !== 1 || family === void 0) return problems;
+	const allowed = NC_SYSTEM_EVENT_FAMILY_FILTERS[family];
+	for (const filter of NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS) if (condition[filter] !== void 0 && !allowed.includes(filter)) problems.push({
+		code: "filter-outside-family",
+		filter,
+		family
+	});
+	return problems;
+}
+function describeSystemEventFamilyProblem(problem) {
+	switch (problem.code) {
+		case "no-kinds": return "a system-event rule needs at least one event kind";
+		case "legacy-kind": return `'${problem.kind}' is a legacy kind and cannot be authored`;
+		case "mixed-families": return `event kinds span ${problem.families.join(" + ")} — one rule per family`;
+		case "filter-outside-family": return `filter '${problem.filter}' is not allowed on a ${problem.family} rule`;
+	}
+}
+/** Every kind a `system-event` rule can derive — the three families and `mixed`. */
+var NC_SYSTEM_RULE_KINDS = [
+	"device-events",
+	"system",
+	"alarm",
+	"mixed"
+];
+/** Is this a kind a `system-event` rule derives (any family, or `mixed`)? */
+function isSystemRuleKind(kind) {
+	return NC_SYSTEM_RULE_KINDS.some((k) => k === kind);
+}
+/** The family a kind authors, or undefined (a camera kind, or `mixed`). */
+function systemFamilyOfKind(kind) {
+	return isSystemEventFamily(kind) ? kind : void 0;
+}
+/** The delivery a system rule rides — named once, compared everywhere. */
+var NC_SYSTEM_DELIVERY = "system-event";
+/**
+* Is this a SYSTEM rule — one about the installation rather than about anything
+* a camera saw? Takes a plain `string` so a rule carrying a delivery this build
+* has never heard of still gets an answer instead of a type error.
+*/
+function isSystemDelivery(delivery) {
+	return delivery === NC_SYSTEM_DELIVERY;
+}
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
 var WEEKDAY_TO_DAY = {
 	Sun: 0,
@@ -50571,6 +51024,66 @@ function isScheduleActive(schedule, atMs) {
 	}
 	return schedule.invert === true ? !inside : inside;
 }
+var ARMED_WORD_PREFIX = "armed_";
+var ALARM_PANEL_CAP = "alarm-panel";
+var ALARM_PANEL_TRIGGER_METHOD = "trigger";
+/**
+* A rule belongs to the alarm when its `deviceState` gate names ANY device's
+* `armed_*` word, or an ENABLED `onTrigger` sequence pulls the alarm panel's
+* trigger (D630).
+*/
+function ruleBelongsToAlarm(rule) {
+	if ((rule.conditions.deviceState?.states ?? []).some((s) => s.trim().toLowerCase().startsWith(ARMED_WORD_PREFIX))) return true;
+	return (rule.onTrigger ?? []).some((sequence) => sequence.enabled && sequence.actions.some((step) => step.kind === "cap" && step.cap === ALARM_PANEL_CAP && step.method === ALARM_PANEL_TRIGGER_METHOD));
+}
+/**
+* WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
+* persists (D640 "a sensor rule fires on the raise, the clear, or both").
+*
+* A device-event rule over a flood sensor notified on BOTH edges: water
+* detected, and back to dry. `NcConditions.sensorTransition` lets the rule
+* name one edge; this file answers, for one `SensorEvent`, which edge it is.
+*
+* NOT A SECOND TABLE. The "which boolean of this cap counts as HIGH" question
+* already has one answer, `SOURCE_CAP_ACTIVE_FIELD`
+* (`catalogs/sensor-active-state.ts`, the doorbell's and the recorder's edge
+* table), and a sensor event names its kind, not its cap. So the table here is
+* DERIVED: event kind → cap (`EVENT_KIND_BY_CAP`) → that cap's active field.
+* Only kinds whose taxonomy category is `sensor` take part — a switch has an
+* `on` boolean too, but "it triggers / it clears" is not a sentence about a
+* light, and offering it there would be a knob with a misleading label.
+* `presence` is a WORD (`home` / `not_home` / a zone), not a boolean, and is
+* absent from the source table, so it is absent here.
+*
+* `undefined` = never guessed: a kind with no raise (a doorbell press, a
+* button, a cover), or a slice whose field is missing or not a boolean. The
+* engine then does NOT filter — a flood alert must not go silent because one
+* read came back unreadable (the same stance as the alarm's `sensorEdgeOf`).
+*
+* Pure, RN-safe: the viewer imports the support rule from here.
+*/
+/** Event kind → the boolean field of its cap slice that means "raised". */
+var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.entries(EVENT_KIND_BY_CAP).flatMap(([capName, descriptor]) => {
+	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
+	if (field === void 0 || descriptor.category !== "sensor") return [];
+	return [[descriptor.kind, field]];
+})));
+/** The sensor kinds `sensorTransition` means something for. */
+var NC_SENSOR_TRANSITION_KINDS = Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
+function normaliseKind(kind) {
+	return kind.trim().toLowerCase();
+}
+/**
+* true = the sensor is raised (water, smoke, open, tampered…), false = it
+* cleared, undefined = this kind has no raise or the slice cannot say.
+*/
+function sensorRaisedOf(kind, value) {
+	if (value === null) return void 0;
+	const field = NC_SENSOR_RAISED_FIELD_BY_KIND[normaliseKind(kind)];
+	if (field === void 0) return void 0;
+	const raw = Object.entries(value).find(([key]) => key === field)?.[1];
+	return typeof raw === "boolean" ? raw : void 0;
+}
 var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
 var BATTERY = ["device-battery-low", "device-battery-normal"];
@@ -51308,10 +51821,38 @@ var CAPTION_VARS = {
 function onAxis(declared, asked) {
 	return declared === void 0 || asked === void 0 || declared.includes(asked);
 }
-function onSystemAxis(d, ctx) {
-	if (ctx.kind !== "system" || d.systemEventKinds === void 0) return true;
+/**
+* Does a descriptor declared for `declared` kinds have a value for a rule of
+* `kind`?
+*
+* `system` on the WIRE stands for every system rule kind (D637): the served
+* catalog keeps the five pre-D637 tokens so installed viewers still parse it
+* (`NcTemplateVarKindSchema`), and the family split lives here, in the match.
+* Exported so the admin's local interpreter of the served catalog asks the
+* same question instead of restating it.
+*/
+function templateVarKindApplies(declared, kind) {
+	if (declared === void 0 || kind === void 0) return true;
+	if (declared.some((k) => k === kind)) return true;
+	return isSystemRuleKind(kind) && declared.includes("system");
+}
+/**
+* Is a descriptor that names `systemEventKinds` on the event-kind axis of a
+* system rule? Read only for a system rule kind; any other kind ignores it.
+*
+* Event kinds chosen: the descriptor must speak about one of them. None chosen
+* yet: a FAMILY kind watches its own family's event kinds (a device-events rule
+* is never offered the alarm's `{{mode}}`), and `mixed` watches all of them.
+*/
+function templateVarSystemEventApplies(d, ctx) {
+	if (!isSystemRuleKind(ctx.kind) || d.systemEventKinds === void 0) return true;
+	const declared = d.systemEventKinds;
 	const asked = ctx.systemEventKinds ?? [];
-	return asked.length === 0 || asked.some((k) => d.systemEventKinds?.includes(k) === true);
+	if (asked.length > 0) return asked.some((k) => declared.includes(k));
+	const family = ctx.kind === void 0 ? void 0 : systemFamilyOfKind(ctx.kind);
+	if (family === void 0) return true;
+	const own = systemEventKindsOfFamily(family);
+	return declared.some((k) => own.includes(k));
 }
 /**
 * The variables that have a value in `ctx`, in catalog order. Pure.
@@ -51325,27 +51866,13 @@ function templateVarsFor(ctx) {
 		const allowed = CAPTION_VARS[ctx.field];
 		return NC_TEMPLATE_VARS.filter((d) => d.families.includes(ctx.family) && allowed.includes(d.name) && d.dynamic === void 0);
 	}
-	return NC_TEMPLATE_VARS.filter((d) => d.families.includes(ctx.family) && onAxis(d.fields, ctx.field) && onAxis(d.kinds, ctx.kind) && onAxis(d.deliveries, ctx.delivery) && onSystemAxis(d, ctx));
+	return NC_TEMPLATE_VARS.filter((d) => d.families.includes(ctx.family) && onAxis(d.fields, ctx.field) && templateVarKindApplies(d.kinds, ctx.kind) && onAxis(d.deliveries, ctx.delivery) && templateVarSystemEventApplies(d, ctx));
 }
 /** True when `name` is supplied in `ctx`, dynamic families (`count_<class>`) included. */
 function isKnownTemplateVar(name, ctx) {
 	return templateVarsFor(ctx).some((d) => d.dynamic !== void 0 ? name.startsWith(d.dynamic.prefix) && name.length > d.dynamic.prefix.length : d.name === name);
 }
 /**
-* Does `filter` say anything about `kind`?
-*
-* `false` means the filter is not part of this kind's vocabulary: the engine
-* ignores it and an editor hides its input. It never means "excluded".
-*/
-function systemEventFilterApplies(kind, filter) {
-	switch (filter) {
-		case "deviceIds": return kind.startsWith("device-") || kind.startsWith("stream-") || kind === "detection-blind" || kind === "alarm-triggered" || kind === "export-completed";
-		case "deviceTypes": return kind.startsWith("device-") || kind === "detection-blind";
-		case "nodeIds": return kind.startsWith("node-") || kind === "addon-crash-loop" || kind === "addon-update-available" || kind === "addon-updated" || kind === "server-update-available" || kind === "wrapper-update-available" || kind === "server-updated";
-		case "packageNames": return kind.endsWith("update-available") || kind === "addon-updated" || kind === "server-updated";
-	}
-}
-/**
 * TimelapseRule — the STANDALONE scheduled timelapse producer's rule model.
 *
 * Spec: `docs/superpowers/specs/2026-07-24-nc-occupancy-timelapse-design.md`
@@ -52547,6 +53074,12 @@ Object.defineProperty(exports, "NC_DEFAULT_SNOOZE_MINUTES", {
 		return NC_DEFAULT_SNOOZE_MINUTES;
 	}
 });
+Object.defineProperty(exports, "NC_SENSOR_TRANSITION_KINDS", {
+	enumerable: true,
+	get: function() {
+		return NC_SENSOR_TRANSITION_KINDS;
+	}
+});
 Object.defineProperty(exports, "NC_SNOOZE_MAX_MINUTES", {
 	enumerable: true,
 	get: function() {
@@ -52583,6 +53116,12 @@ Object.defineProperty(exports, "NcConditionDescriptorSchema", {
 		return NcConditionDescriptorSchema;
 	}
 });
+Object.defineProperty(exports, "NcConditionsSchema", {
+	enumerable: true,
+	get: function() {
+		return NcConditionsSchema;
+	}
+});
 Object.defineProperty(exports, "NcRuleInputSchema", {
 	enumerable: true,
 	get: function() {
@@ -52823,6 +53362,12 @@ Object.defineProperty(exports, "buildEventKindDescriptor", {
 		return buildEventKindDescriptor;
 	}
 });
+Object.defineProperty(exports, "canonicalHash", {
+	enumerable: true,
+	get: function() {
+		return canonicalHash;
+	}
+});
 Object.defineProperty(exports, "cosineSimilarity", {
 	enumerable: true,
 	get: function() {
@@ -52853,6 +53398,12 @@ Object.defineProperty(exports, "deriveRecordingMode", {
 		return deriveRecordingMode;
 	}
 });
+Object.defineProperty(exports, "describeSystemEventFamilyProblem", {
+	enumerable: true,
+	get: function() {
+		return describeSystemEventFamilyProblem;
+	}
+});
 Object.defineProperty(exports, "discriminatedUnion", {
 	enumerable: true,
 	get: function() {
@@ -52955,6 +53506,12 @@ Object.defineProperty(exports, "isSourceCap", {
 		return isSourceCap;
 	}
 });
+Object.defineProperty(exports, "isSystemDelivery", {
+	enumerable: true,
+	get: function() {
+		return isSystemDelivery;
+	}
+});
 Object.defineProperty(exports, "kebabToCamel", {
 	enumerable: true,
 	get: function() {
@@ -53063,12 +53620,24 @@ Object.defineProperty(exports, "resolvePoolMemoryPolicy", {
 		return resolvePoolMemoryPolicy;
 	}
 });
+Object.defineProperty(exports, "ruleBelongsToAlarm", {
+	enumerable: true,
+	get: function() {
+		return ruleBelongsToAlarm;
+	}
+});
 Object.defineProperty(exports, "sceneMonitorCapability", {
 	enumerable: true,
 	get: function() {
 		return sceneMonitorCapability;
 	}
 });
+Object.defineProperty(exports, "sensorRaisedOf", {
+	enumerable: true,
+	get: function() {
+		return sensorRaisedOf;
+	}
+});
 Object.defineProperty(exports, "sleep", {
 	enumerable: true,
 	get: function() {
@@ -53093,6 +53662,12 @@ Object.defineProperty(exports, "subKindsOf", {
 		return subKindsOf;
 	}
 });
+Object.defineProperty(exports, "systemEventFamilyProblems", {
+	enumerable: true,
+	get: function() {
+		return systemEventFamilyProblems;
+	}
+});
 Object.defineProperty(exports, "systemEventFilterApplies", {
 	enumerable: true,
 	get: function() {