@camstack/addon-post-analysis 1.2.280 → 1.2.282

package/dist/{dist-Z6AO1MsY.mjs → dist-C3zTKShG.mjs}

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 //#region ../types/dist/event-category-BVDXG4tB.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
@@ -5359,7 +5360,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).
@@ -7567,6 +7568,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 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'
@@ -18144,6 +18178,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),
@@ -18333,6 +18377,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. */
@@ -18466,6 +18524,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
@@ -18965,9 +19033,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",
@@ -19005,7 +19093,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({
@@ -19016,7 +19104,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({
@@ -19064,6 +19152,7 @@ var NcConditionDescriptorSchema = object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: _enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -19074,6 +19163,7 @@ var NcConditionDescriptorSchema = object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -19272,6 +19362,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",
@@ -19528,6 +19633,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",
@@ -19711,6 +19843,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.
@@ -19892,6 +20046,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.
 	*
@@ -20115,6 +20277,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
@@ -33169,7 +33340,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, {
@@ -44695,6 +44889,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -44863,6 +45063,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",
@@ -50479,6 +50685,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,
@@ -50540,6 +50993,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"];
@@ -51277,10 +51790,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.
@@ -51294,27 +51835,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`
@@ -52318,4 +52845,4 @@ function vectorDimFromBase64(encoded) {
 	return Math.floor(Buffer.from(encoded, "base64").byteLength / 4);
 }
 //#endregion
-export { RECORDING_SOURCE_CAMSTACK_ADDON as $, CamProfileSchema as $t, NC_SNOOZE_MAX_MINUTES as A, isScheduleActive as At, NcRuleUpdateInputSchema as B, readDeviceStateFrom as Bt, MAX_BIRTH_DECISION_RECORDS as C, faceGalleryCapability as Ct, NC_ALARM_SYSTEM_EVENT_KINDS as D, isEventOwnerType as Dt, MediaFileKindEnum as E, isDetectionMacroClass as Et, NcConditionDescriptorSchema as F, occupancyScope as Ft, NcSystemEventKindSchema as G, storageOccupancyCapability as Gt, NcSnoozeInputSchema as H, resolveLocationMode as Ht, NcRuleInputSchema as I, parseProcStatus as It, NcTemplatePreviewSchema as J, templateVarsFor as Jt, NcTaxonomySchema as K, subKindsOf as Kt, NcRulePatchSchema as L, pickClusterStepModels as Lt, NC_TEMPLATE_VARS as M, kebabToCamel as Mt, NcAlarmConfigSchema as N, mayWriteToLocation as Nt, NC_CONDITION_CATALOG as O, isKnownTemplateVar as Ot, NcAlarmSettingsPatchSchema as P, notificationRulesCapability as Pt, RECORDING_EXPORT_MAX_READ_BYTES as Q, BaseAddon as Qt, NcRuleSchema as R, pipelineAnalyticsCapability as Rt, MAX_ARCHIVED_DEBUG_NOTES as S, evictionPolicyOfLocation as St, MOTION_CLOSE_AFTER_MS as T, hfModelUrl as Tt, NcSnoozeSchema as U, resolvePoolMemoryPolicy as Ut, NcScheduleSchema as V, readTimelapseGeneratedAt as Vt, NcSnoozeSuppressedSchema as W, sceneMonitorCapability as Wt, OpsLogEntrySchema as X, zoneAnalyticsCapability as Xt, NcTemplateVarDescriptorSchema as Y, vectorDimFromBase64 as Yt, PoolMemoryWatchdog as Z, errMsg as Zt, FIRST_LEVEL_MACRO_CLASSES as _, string as _n, cosineSimilarity as _t, BirthDecisionRecordSchema as a, isDeviceScopedCap as an, SceneMonitorSchema as at, LabelAttributionSchema as b, encodeVectorBase64 as bt, CoverStateSchema as c, _enum as cn, TimelapseRulePatchSchema as ct, DEFAULT_TIMELAPSE_PREVIEW_TEXT as d, discriminatedUnion as dn, addonWidgetsSourceCapability as dt, DeviceType as en, RetrainStatusSchema as et, DETECTION_MACRO_CLASSES as f, literal as fn, alarmPanelCapability as ft, EVENT_OWNER_TYPES as g, record as gn, buildEventKindDescriptor as gt, EVENT_KIND_BY_CAP as h, partialRecord as hn, audioModeOf as ht, BaseDevice as i, hydrateSchema as in, SCENE_DIVERGED as it, NC_TAXONOMY as j, isSourceCap as jt, NC_DEFAULT_SNOOZE_MINUTES as k, isMediaOwnerType as kt, DEFAULT_EVENT_COLOR as l, array as ln, TimelapseRuleSchema as lt, DeclaredDevices as m, object as mn, audioMetricsCapability as mt, AlarmArmModeSchema as n, customAction as nn, SCENE_DEFAULT_ANCHOR_THRESHOLD as nt, CLUSTER_MODEL_SCOPED_STEPS as o, nodePin as on, TIMELAPSE_DENSE_FLOOR_SEC as ot, DETECTION_PIPELINE_CAP_NAME as p, number as pn, assertTimelapseCadences as pt, NcTemplatePreviewInputSchema as q, systemEventFilterApplies as qt, ArchivedDebugNoteSchema as r, defineCustomActions as rn, SCENE_DEFAULT_UNCOVERED_POLICY as rt, COCO_TO_MACRO as s, sleep as sn, TimelapseRuleInputSchema as st, AUDIO_MACRO_LABELS as t, createEvent as tn, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as tt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as u, boolean as un, TrackSourceSchema as ut, FULL_IMAGE_BBOX as v, unknown as vn, deriveRecordingMode as vt, MAX_BIRTH_LATENCY_PROXY_MS as w, failureContributionCapability as wt, LockStateSchema as x, evaluateSensorEdge as xt, FailureCounters as y, EventCategory as yn, embeddingEncoderCapability as yt, NcRuleTargetSchema as z, plateGalleryCapability as zt };
+export { PoolMemoryWatchdog as $, systemEventFamilyProblems as $t, NC_SENSOR_TRANSITION_KINDS as A, isEventOwnerType as At, NcRuleSchema as B, parseProcStatus as Bt, MAX_BIRTH_DECISION_RECORDS as C, partialRecord as Cn, encodeVectorBase64 as Ct, NC_ALARM_SYSTEM_EVENT_KINDS as D, EventCategory as Dn, failureContributionCapability as Dt, MediaFileKindEnum as E, unknown as En, faceGalleryCapability as Et, NcAlarmSettingsPatchSchema as F, isSystemDelivery as Ft, NcSnoozeSchema as G, readTimelapseGeneratedAt as Gt, NcRuleUpdateInputSchema as H, pipelineAnalyticsCapability as Ht, NcConditionDescriptorSchema as I, kebabToCamel as It, NcTaxonomySchema as J, ruleBelongsToAlarm as Jt, NcSnoozeSuppressedSchema as K, resolveLocationMode as Kt, NcConditionsSchema as L, mayWriteToLocation as Lt, NC_TAXONOMY as M, isMediaOwnerType as Mt, NC_TEMPLATE_VARS as N, isScheduleActive as Nt, NC_CONDITION_CATALOG as O, hfModelUrl as Ot, NcAlarmConfigSchema as P, isSourceCap as Pt, OpsLogEntrySchema as Q, subKindsOf as Qt, NcRuleInputSchema as R, notificationRulesCapability as Rt, MAX_ARCHIVED_DEBUG_NOTES as S, object as Sn, embeddingEncoderCapability as St, MOTION_CLOSE_AFTER_MS as T, string as Tn, evictionPolicyOfLocation as Tt, NcScheduleSchema as U, plateGalleryCapability as Ut, NcRuleTargetSchema as V, pickClusterStepModels as Vt, NcSnoozeInputSchema as W, readDeviceStateFrom as Wt, NcTemplatePreviewSchema as X, sensorRaisedOf as Xt, NcTemplatePreviewInputSchema as Y, sceneMonitorCapability as Yt, NcTemplateVarDescriptorSchema as Z, storageOccupancyCapability as Zt, FIRST_LEVEL_MACRO_CLASSES as _, array as _n, audioModeOf as _t, BirthDecisionRecordSchema as a, canonicalHash as an, SCENE_DEFAULT_UNCOVERED_POLICY as at, LabelAttributionSchema as b, literal as bn, deriveRecordingMode as bt, CoverStateSchema as c, DeviceType as cn, TIMELAPSE_DENSE_FLOOR_SEC as ct, DEFAULT_TIMELAPSE_PREVIEW_TEXT as d, defineCustomActions as dn, TimelapseRuleSchema as dt, systemEventFilterApplies as en, RECORDING_EXPORT_MAX_READ_BYTES as et, DETECTION_MACRO_CLASSES as f, hydrateSchema as fn, TrackSourceSchema as ft, EVENT_OWNER_TYPES as g, _enum as gn, audioMetricsCapability as gt, EVENT_KIND_BY_CAP as h, sleep as hn, assertTimelapseCadences as ht, BaseDevice as i, errMsg as in, SCENE_DEFAULT_ANCHOR_THRESHOLD as it, NC_SNOOZE_MAX_MINUTES as j, isKnownTemplateVar as jt, NC_DEFAULT_SNOOZE_MINUTES as k, isDetectionMacroClass as kt, DEFAULT_EVENT_COLOR as l, createEvent as ln, TimelapseRuleInputSchema as lt, DeclaredDevices as m, nodePin as mn, alarmPanelCapability as mt, AlarmArmModeSchema as n, vectorDimFromBase64 as nn, RetrainStatusSchema as nt, CLUSTER_MODEL_SCOPED_STEPS as o, BaseAddon as on, SCENE_DIVERGED as ot, DETECTION_PIPELINE_CAP_NAME as p, isDeviceScopedCap as pn, addonWidgetsSourceCapability as pt, NcSystemEventKindSchema as q, resolvePoolMemoryPolicy as qt, ArchivedDebugNoteSchema as r, zoneAnalyticsCapability as rn, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as rt, COCO_TO_MACRO as s, CamProfileSchema as sn, SceneMonitorSchema as st, AUDIO_MACRO_LABELS as t, templateVarsFor as tn, RECORDING_SOURCE_CAMSTACK_ADDON as tt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as u, customAction as un, TimelapseRulePatchSchema as ut, FULL_IMAGE_BBOX as v, boolean as vn, buildEventKindDescriptor as vt, MAX_BIRTH_LATENCY_PROXY_MS as w, record as wn, evaluateSensorEdge as wt, LockStateSchema as x, number as xn, describeSystemEventFamilyProblem as xt, FailureCounters as y, discriminatedUnion as yn, cosineSimilarity as yt, NcRulePatchSchema as z, occupancyScope as zt };