@camstack/addon-post-analysis 1.2.279 → 1.2.281

package/dist/{dist-D0jvZ8dq.mjs → dist-DkERzZfY.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";
@@ -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'
@@ -15361,18 +15395,30 @@ var LlmErrorCodeSchema = _enum([
 	"budget-exceeded",
 	"adapter-error"
 ]);
-var LlmGenerateResultSchema = discriminatedUnion("ok", [object({
+var LlmGenerateOkSchema = object({
 	ok: literal(true),
 	text: string(),
 	model: string(),
 	usage: LlmUsageSchema,
 	truncated: boolean(),
 	latencyMs: number()
-}), object({
+});
+/**
+* WHO refused, on a `refusal`. `guardrail` = a safety filter in front of the
+* model rejected the request before it answered (Apple Foundation Models
+* refuses surveillance-framed prompts in 0.1 s); `model` = the model itself
+* declined. They are different faults: a guardrail refusal is a property of
+* the BACKEND, so the provider falls back to the next profile; a model refusal
+* is an answer. Absent on every other code, and on a refusal a wire cannot
+* attribute.
+*/
+var LlmRefusalSourceSchema = _enum(["guardrail", "model"]);
+var LlmGenerateResultSchema = discriminatedUnion("ok", [LlmGenerateOkSchema, object({
 	ok: literal(false),
 	code: LlmErrorCodeSchema,
 	message: string(),
-	retryAfterMs: number().optional()
+	retryAfterMs: number().optional(),
+	refusalSource: LlmRefusalSourceSchema.optional()
 })]);
 /**
 * `Uint8Array` is the sanctioned binary convention — superjson + the UDS
@@ -15602,12 +15648,78 @@ var LlmRuntimeDiskUsageSchema = object({
 	modelsBytes: number(),
 	freeBytes: number().optional()
 });
-method(LlmGenerateBaseInputSchema.extend({
+var LlmRuntimeCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
 	images: array(LlmImageSchema).optional(),
 	runtime: ManagedRuntimeConfigSchema,
 	/** The managed profile's timeout, threaded by the hub provider. */
 	timeoutMs: number().int().positive().optional()
-}), LlmGenerateResultSchema, {
+});
+/**
+* Why Apple Foundation Models cannot run on a node that has it in principle.
+* The first three are Apple's own `UnavailableReason`s, verbatim; the rest are
+* ours: the OS predates the framework (macOS < 26), the helper binary is not
+* in the installed addon, or it crashed past the respawn bound.
+*/
+var AppleFmUnavailableReasonSchema = _enum([
+	"deviceNotEligible",
+	"appleIntelligenceNotEnabled",
+	"modelNotReady",
+	"osTooOld",
+	"helperMissing",
+	"helperCrashed"
+]);
+/**
+* Apple Foundation Models on ONE node — four states, never a boolean (D315).
+*
+*   - `available`            — the helper probed it; what it CAN do is reported
+*                              here (`imageInput`, `contextSize`, languages),
+*                              never typed by an operator.
+*   - `unavailable`          — a known absence, with the reason to act on.
+*   - `unsupported-platform` — not a Mac; there is nothing to enable.
+*   - `unknown`              — the probe did not answer (not yet run, timed
+*                              out, helper crashed mid-probe). A failed
+*                              measurement is NEVER `unavailable` (D393).
+*/
+var AppleFmAvailabilitySchema = discriminatedUnion("state", [
+	object({
+		state: literal("available"),
+		osVersion: string(),
+		/** Tokens, as the framework reports it. Read at runtime, never assumed. */
+		contextSize: number().int().positive(),
+		/** BCP-47-ish tags (`it-IT`) of the languages the model supports. */
+		languages: array(string()),
+		/** Whether prompts may carry images. `false` on a macOS 26 build. */
+		imageInput: boolean()
+	}),
+	object({
+		state: literal("unavailable"),
+		reason: AppleFmUnavailableReasonSchema,
+		osVersion: string().nullable(),
+		detail: string()
+	}),
+	object({
+		state: literal("unsupported-platform"),
+		platform: string()
+	}),
+	object({
+		state: literal("unknown"),
+		error: string()
+	})
+]);
+/**
+* A generation on the node's Apple Foundation Models helper. A separate verb
+* from `complete`, whose `runtime` is a llama.cpp config: overloading it would
+* drag a GGUF model reference into a backend that has none. `images` is part
+* of the contract so vision needs no cap change later; a node whose model has
+* no image input REFUSES them (`unavailable`), never drops them.
+*/
+var LlmRuntimeAppleCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
+	images: array(LlmImageSchema).optional(),
+	/** The profile's timeout, threaded by the hub provider. */
+	timeoutMs: number().int().positive().optional()
+});
+var LlmRuntimeCancelInputSchema = object({ requestId: string() });
+method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, {
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
@@ -15625,7 +15737,14 @@ method(LlmGenerateBaseInputSchema.extend({
 }), method(object({ file: string() }), _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), array(LlmNodeModelSchema), { auth: "admin" }), method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" });
+}), method(object({}), array(LlmNodeModelSchema), { auth: "admin" }), method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" }), method(LlmRuntimeCancelInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), AppleFmAvailabilitySchema, { auth: "admin" }), method(LlmRuntimeAppleCompleteInputSchema, LlmGenerateResultSchema, {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
+});
 /**
 * `llm` — consumer-facing LLM surface (spec §1-§3). Collection-mode: array
 * methods concat-fan across providers; single-row methods route to ONE
@@ -15642,7 +15761,8 @@ var LlmProfileKindSchema = _enum([
 	"openai",
 	"anthropic",
 	"google",
-	"managed-local"
+	"managed-local",
+	"apple-foundation"
 ]);
 var LlmProfileSchema = object({
 	id: string(),
@@ -15700,7 +15820,14 @@ var LlmProfileSchema = object({
 	toolsEnabled: boolean().default(false),
 	extraHeaders: record(string(), string()).optional(),
 	/** kind === 'managed-local' only (spec §4). */
-	runtime: ManagedRuntimeConfigSchema.optional()
+	runtime: ManagedRuntimeConfigSchema.optional(),
+	/**
+	* kind === 'apple-foundation' only: WHERE it runs — the only thing there is
+	* to configure (no key, no URL, no download; `model` is `apple-system`).
+	* `supportsVision` on such a row is stamped by the provider from the node's
+	* reported `imageInput`, never taken from the operator (D62).
+	*/
+	appleFoundation: object({ nodeId: string() }).optional()
 });
 /** ConfigUISchema tree passed through untyped on the wire (the
 *  notification-output `ConfigSchemaPassthrough` precedent at
@@ -15782,7 +15909,9 @@ var LlmRuntimeNodeSchema = object({
 	reachable: boolean(),
 	status: LlmRuntimeStatusSchema.optional(),
 	disk: LlmRuntimeDiskUsageSchema.optional(),
-	error: string().optional()
+	error: string().optional(),
+	/** Absent = the node did not answer the question (render as unknown). */
+	apple: AppleFmAvailabilitySchema.optional()
 });
 var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: array(LlmImageSchema).min(1) });
 var ProfileRefInputSchema = object({
@@ -18870,9 +18999,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",
@@ -18910,7 +19059,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({
@@ -18921,7 +19070,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({
@@ -33074,7 +33223,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, {
@@ -43904,12 +44076,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.appleAvailability": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.cancel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.complete": {
 		capName: "llm-runtime",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.completeApple": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.deleteModel": {
 		capName: "llm-runtime",
 		capScope: "system",
@@ -44582,6 +44772,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -50366,6 +50562,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,
@@ -51164,10 +51607,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.
@@ -51181,27 +51652,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`
@@ -52205,4 +52662,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 { RECORDING_EXPORT_MAX_READ_BYTES as $, vectorDimFromBase64 as $t, NC_SNOOZE_MAX_MINUTES as A, isKnownTemplateVar as At, NcRuleTargetSchema as B, pickClusterStepModels as Bt, MAX_BIRTH_DECISION_RECORDS as C, unknown as Cn, evaluateSensorEdge as Ct, NC_ALARM_SYSTEM_EVENT_KINDS as D, hfModelUrl as Dt, MediaFileKindEnum as E, failureContributionCapability as Et, NcConditionDescriptorSchema as F, kebabToCamel as Ft, NcSnoozeSuppressedSchema as G, resolveLocationMode as Gt, NcScheduleSchema as H, plateGalleryCapability as Ht, NcConditionsSchema as I, mayWriteToLocation as It, NcTemplatePreviewInputSchema as J, storageOccupancyCapability as Jt, NcSystemEventKindSchema as K, resolvePoolMemoryPolicy as Kt, NcRuleInputSchema as L, notificationRulesCapability as Lt, NC_TEMPLATE_VARS as M, isScheduleActive as Mt, NcAlarmConfigSchema as N, isSourceCap as Nt, NC_CONDITION_CATALOG as O, isDetectionMacroClass as Ot, NcAlarmSettingsPatchSchema as P, isSystemDelivery as Pt, PoolMemoryWatchdog as Q, templateVarsFor as Qt, NcRulePatchSchema as R, occupancyScope as Rt, MAX_ARCHIVED_DEBUG_NOTES as S, string as Sn, encodeVectorBase64 as St, MOTION_CLOSE_AFTER_MS as T, faceGalleryCapability as Tt, NcSnoozeInputSchema as U, readDeviceStateFrom as Ut, NcRuleUpdateInputSchema as V, pipelineAnalyticsCapability as Vt, NcSnoozeSchema as W, readTimelapseGeneratedAt as Wt, NcTemplateVarDescriptorSchema as X, systemEventFamilyProblems as Xt, NcTemplatePreviewSchema as Y, subKindsOf as Yt, OpsLogEntrySchema as Z, systemEventFilterApplies as Zt, FIRST_LEVEL_MACRO_CLASSES as _, literal as _n, buildEventKindDescriptor as _t, BirthDecisionRecordSchema as a, DeviceType as an, SCENE_DIVERGED as at, LabelAttributionSchema as b, partialRecord as bn, describeSystemEventFamilyProblem as bt, CoverStateSchema as c, defineCustomActions as cn, TimelapseRuleInputSchema as ct, DEFAULT_TIMELAPSE_PREVIEW_TEXT as d, nodePin as dn, TrackSourceSchema as dt, zoneAnalyticsCapability as en, RECORDING_SOURCE_CAMSTACK_ADDON as et, DETECTION_MACRO_CLASSES as f, sleep as fn, addonWidgetsSourceCapability as ft, EVENT_OWNER_TYPES as g, discriminatedUnion as gn, audioModeOf as gt, EVENT_KIND_BY_CAP as h, boolean as hn, audioMetricsCapability as ht, BaseDevice as i, CamProfileSchema as in, SCENE_DEFAULT_UNCOVERED_POLICY as it, NC_TAXONOMY as j, isMediaOwnerType as jt, NC_DEFAULT_SNOOZE_MINUTES as k, isEventOwnerType as kt, DEFAULT_EVENT_COLOR as l, hydrateSchema as ln, TimelapseRulePatchSchema as lt, DeclaredDevices as m, array as mn, assertTimelapseCadences as mt, AlarmArmModeSchema as n, canonicalHash as nn, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as nt, CLUSTER_MODEL_SCOPED_STEPS as o, createEvent as on, SceneMonitorSchema as ot, DETECTION_PIPELINE_CAP_NAME as p, _enum as pn, alarmPanelCapability as pt, NcTaxonomySchema as q, sceneMonitorCapability as qt, ArchivedDebugNoteSchema as r, BaseAddon as rn, SCENE_DEFAULT_ANCHOR_THRESHOLD as rt, COCO_TO_MACRO as s, customAction as sn, TIMELAPSE_DENSE_FLOOR_SEC as st, AUDIO_MACRO_LABELS as t, errMsg as tn, RetrainStatusSchema as tt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as u, isDeviceScopedCap as un, TimelapseRuleSchema as ut, FULL_IMAGE_BBOX as v, number as vn, cosineSimilarity as vt, MAX_BIRTH_LATENCY_PROXY_MS as w, EventCategory as wn, evictionPolicyOfLocation as wt, LockStateSchema as x, record as xn, embeddingEncoderCapability as xt, FailureCounters as y, object as yn, deriveRecordingMode as yt, NcRuleSchema as z, parseProcStatus as zt };