@camstack/addon-post-analysis 1.2.322 → 1.2.323

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-BFbP9U7z.js");
+const require_clip_model_registry = require("../clip-model-registry-8IMzj7jJ.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -945,7 +945,7 @@ function grantMeta(grant) {
 			...common,
 			ruleId: grant.ruleId,
 			rule: grant.ruleName,
-			sequence: grant.sequence
+			sequenceId: grant.sequenceId
 		};
 		case "snooze": return {
 			...common,
@@ -5068,6 +5068,27 @@ function planDenseRanges(input) {
 }
 //#endregion
 //#region src/notification-center/text-compose.ts
+/**
+* The COMPOSITE variables — phrases assembled from catalog fragments before
+* the one and only render pass.
+*
+* A notification body is not a sentence with slots. "person (John) on Front
+* door in gate" contains three sub-phrases whose SHAPE differs per language
+* and whose presence is conditional: the label parentheses, the zone clause,
+* the plural noun. Expressing that with `{{class}}{{label}}{{zones}}` and
+* three scalars pushes the grammar into the template, where a translator
+* cannot fix it. So each becomes ONE variable — `{{subject}}`, `{{inZones}}`,
+* `{{op}}`, `{{detectionSummary}}` — composed here from its own keys and handed
+* to {@link renderTemplate} as a finished string.
+*
+* **Fragments see the SCALARS only.** Never the composites. That is what makes
+* the depth exactly one and not "one so far": a fragment key edited to say
+* `{{inZones}}` renders empty rather than starting a second round, and
+* `renderTemplate` never re-scans what it inserted, so a composite's own value
+* is printed verbatim whatever it contains.
+*
+* Pure: a catalog in, a string out. No clock, no store, no I/O.
+*/
 /** One normalisation, used on both sides of every class lookup — a pipeline
 *  that emitted `Person` must find the key written `class.person`. */
 function normaliseClass(className) {
@@ -5076,24 +5097,35 @@ function normaliseClass(className) {
 /**
 * The noun for a class, in the count's plural category.
 *
-* A class no locale names falls through to `class.other`, which prints the RAW
-* name: a custom model's class must appear in the sentence rather than vanish
-* out of it, and a missing translation is a smaller defect than a missing
-* detection.
+* Lookup order: the NC text catalog (`class.*`, plural-aware) → the shared
+* {@link eventKindLabel} map (viewer filters / EVENT_TAXONOMY) → `class.other`
+* with the RAW wire id. A custom model class must still appear rather than
+* vanish; a missing translation is a smaller defect than a missing detection.
 */
 function ncClassNoun(texts, className, count) {
-	const key = `class.${normaliseClass(className)}`;
+	const normalised = normaliseClass(className);
+	const key = `class.${normalised}`;
 	if (texts.has(key)) return texts.text({
 		key,
 		count,
 		vars: { name: className }
 	});
+	if (require_clip_model_registry.isEventKindLabelKey(normalised)) return require_clip_model_registry.eventKindLabel(normalised, texts.language);
 	return texts.text({
 		key: "class.other",
 		count,
 		vars: { name: className }
 	});
 }
+/**
+* The parenthetical half of a labelled subject: a recognised person or plate
+* is printed verbatim; a classification (species, COCO sub, …) goes through
+* the shared event-kind map so "animal (cat)" becomes "animale (Gatto)".
+*/
+function ncSubjectLabelText(texts, label, labelKind) {
+	if (labelKind === "identity" || labelKind === "plate") return label;
+	return require_clip_model_registry.eventKindLabel(label, texts.language);
+}
 /** `person (John)` / `persona (John)` — the thing the notification is about. */
 function ncSubjectText(texts, input) {
 	const classNoun = ncClassNoun(texts, input.className, 1);
@@ -5105,7 +5137,7 @@ function ncSubjectText(texts, input) {
 		key: subjectLabelKey(input.labelKind),
 		vars: {
 			classNoun,
-			label: input.label
+			label: ncSubjectLabelText(texts, input.label, input.labelKind)
 		}
 	});
 }
@@ -8675,31 +8707,48 @@ function replaceConditionReferences(monitor, condition, reference) {
 /** The cap whose presence in a sequence makes the rule the alarm's trigger. */
 var ALARM_PANEL_CAP$1 = "alarm-panel";
 var ALARM_KINDS = new Set(require_clip_model_registry.NC_ALARM_SYSTEM_EVENT_KINDS);
-function actuatesAlarmPanel(sequences) {
-	for (const sequence of sequences) for (const step of sequence.actions) if (step.kind === "cap" && step.cap === ALARM_PANEL_CAP$1) return true;
+function stepActuatesAlarm(step) {
+	return step.kind === "cap" && step.cap === ALARM_PANEL_CAP$1;
+}
+function bindingActuatesAlarm(binding, sequenceActionsOf) {
+	if (binding.kind === "do") return stepActuatesAlarm(binding.action);
+	const steps = sequenceActionsOf?.(binding.sequenceId);
+	if (steps === void 0) return false;
+	return steps.some(stepActuatesAlarm);
+}
+function actionsActuateAlarm(rule, sequenceActionsOf) {
+	const actions = rule.actions;
+	if (actions === void 0) return false;
+	const hooks = [
+		actions.onActivation,
+		actions.onDeactivation,
+		actions.onTrigger,
+		actions.onTriggerOff
+	];
+	for (const bindings of hooks) for (const binding of bindings ?? []) if (bindingActuatesAlarm(binding, sequenceActionsOf)) return true;
+	for (const button of actions.buttons ?? []) {
+		const steps = sequenceActionsOf?.(button.sequenceId);
+		if (steps !== void 0 && steps.some(stepActuatesAlarm)) return true;
+	}
 	return false;
 }
 /**
 * May a snooze window silence this rule?
 *
-* `true` = never. Deliberately answered from the rule alone: the gate reads it
-* on the delivery path, where a fallible lookup would be a read that can
-* DESTROY the exemption (D49) — and the failure direction of this one is
-* silencing an alarm.
+* `true` = never. Deliberately answered from the rule alone (plus an optional
+* sequence lookup): the gate reads it on the delivery path, where a fallible
+* lookup would be a read that can DESTROY the exemption (D49) — and the
+* failure direction of this one is silencing an alarm. A missing sequence
+* lookup means sequence-ref bindings cannot prove exemption; Do bindings and
+* system-event kinds still can.
 */
-function isSnoozeExempt(rule) {
+function isSnoozeExempt(rule, sequenceActionsOf) {
 	const kinds = rule.conditions.systemEvent?.kinds ?? [];
 	for (const kind of kinds) if (ALARM_KINDS.has(kind)) return true;
-	return actuatesAlarmPanel(rule.actions?.onTrigger ?? []);
+	return actionsActuateAlarm(rule, sequenceActionsOf);
 }
 //#endregion
 //#region src/notification-center/action-buttons.ts
-/** Sequence names the rule actually declares. A button may only name one. */
-function declaredSequences(actions) {
-	const names = /* @__PURE__ */ new Set();
-	for (const sequence of actions.onTrigger ?? []) names.add(sequence.name);
-	return names;
-}
 /**
 * Build the notification's buttons.
 *
@@ -8712,18 +8761,18 @@ function buildActionButtons(input) {
 	if (actions === void 0) return [];
 	const buttons = actions.buttons ?? [];
 	if (buttons.length === 0) return [];
-	const known = declaredSequences(actions);
+	const known = input.knownSequenceIds;
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
 	for (const button of buttons) {
-		if (!known.has(button.sequence)) continue;
+		if (!known.has(button.sequenceId)) continue;
 		if (seen.has(button.id)) continue;
 		seen.add(button.id);
 		out.push({
 			id: button.id,
 			label: button.label,
 			url: input.mintUrl({
-				sequence: button.sequence,
+				sequenceId: button.sequenceId,
 				actionId: button.id
 			}),
 			...button.icon !== void 0 ? { icon: button.icon } : {},
@@ -8733,18 +8782,17 @@ function buildActionButtons(input) {
 	return out;
 }
 /**
-* Which of a rule's buttons name a sequence it does not have.
+* Which of a rule's buttons name a sequence that is not known.
 *
 * Exported so the caller can LOG the drop. A button silently missing from a
 * notification is the exact shape of failure this repo keeps paying for — the
 * operator authored it, it never appeared, and nothing said why.
 */
-function unresolvableButtons(actions) {
+function unresolvableButtons(actions, knownSequenceIds) {
 	if (actions === void 0) return [];
 	const buttons = actions.buttons ?? [];
 	if (buttons.length === 0) return [];
-	const known = declaredSequences(actions);
-	return buttons.filter((b) => !known.has(b.sequence)).map((b) => `${b.id}→${b.sequence}`);
+	return buttons.filter((b) => !knownSequenceIds.has(b.sequenceId)).map((b) => `${b.id}→${b.sequenceId}`);
 }
 /** How many snooze choices one notification may carry. The schema caps the
 *  authored list at 4; this is the same bound applied to a stored rule that
@@ -8795,7 +8843,7 @@ function snoozeChoices(options) {
 * attention than the notification did.
 */
 function buildSnoozeButtons(input) {
-	if (isSnoozeExempt(input.rule)) return [];
+	if (isSnoozeExempt(input.rule, input.sequenceActionsOf)) return [];
 	return snoozeChoices(input.rule.snoozeOptions).map((minutes) => {
 		const actionId = snoozeButtonId(minutes);
 		return {
@@ -11084,10 +11132,11 @@ function matchesIdentityScope(subject, scope) {
 * Derived, never a stored flag: both rule editors prune condition keys to the
 * catalog on save, so a new key would be dropped by the first edit.
 */
-function ruleBelongsToAlarm(rule) {
+function ruleBelongsToAlarm(rule, sequenceActionsOf) {
 	return require_clip_model_registry.ruleBelongsToAlarm({
 		conditions: rule.conditions,
-		...rule.actions?.onTrigger !== void 0 ? { onTrigger: rule.actions.onTrigger } : {}
+		...rule.actions !== void 0 ? { actions: rule.actions } : {},
+		...sequenceActionsOf !== void 0 ? { sequenceActionsOf } : {}
 	});
 }
 /**
@@ -12975,7 +13024,7 @@ function deriveTankBand(reading) {
 		case null: return null;
 	}
 }
-function isRecord$7(value) {
+function isRecord$9(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function tankStatusOf(value) {
@@ -12991,11 +13040,11 @@ function vacuumTanksOf(data) {
 	if (data["capName"] !== "vacuum-control") return null;
 	const deviceId = data["deviceId"];
 	const slice = data["slice"];
-	if (typeof deviceId !== "number" || !isRecord$7(slice)) return null;
+	if (typeof deviceId !== "number" || !isRecord$9(slice)) return null;
 	const tanks = [];
 	for (const key of NC_TANK_KEYS) {
 		const raw = slice[key];
-		if (!isRecord$7(raw)) continue;
+		if (!isRecord$9(raw)) continue;
 		const level = raw["level"];
 		tanks.push({
 			key,
@@ -20333,6 +20382,350 @@ var NcDeviceMuteStore = class {
 	}
 };
 //#endregion
+//#region src/notification-center/migrate-legacy-actions.ts
+function isRecord$8(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A legacy inline sequence row — detected by `name` + `actions` + `enabled`. */
+function asLegacySequence(value) {
+	const parsed = require_clip_model_registry.NcLegacyRuleActionSequenceSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+/**
+* True when `onTrigger` still looks like the pre-shared-sequence array of
+* named sequences (not an array of `{ kind: 'sequence' | 'do', … }` bindings).
+*/
+function onTriggerLooksLegacy(onTrigger) {
+	if (!Array.isArray(onTrigger) || onTrigger.length === 0) return false;
+	const first = onTrigger[0];
+	if (!isRecord$8(first)) return false;
+	if (first["kind"] === "sequence" || first["kind"] === "do") return false;
+	return asLegacySequence(first) !== null;
+}
+function legacyButtonSequenceName(button) {
+	if (!isRecord$8(button)) return null;
+	const name = button["sequence"];
+	return typeof name === "string" && name.length > 0 ? name : null;
+}
+/**
+* Rewrite a raw `actions` block. Returns the (possibly unchanged) new-shape
+* actions and whether anything was materialised into the sequence store.
+*/
+async function migrateLegacyRuleActions(actions, createSequence) {
+	if (actions === void 0 || actions === null) return {
+		actions: void 0,
+		migrated: false
+	};
+	if (!isRecord$8(actions)) return {
+		actions: void 0,
+		migrated: false
+	};
+	if (!onTriggerLooksLegacy(actions["onTrigger"]) && actions["sequence"] === void 0) {
+		const buttons = actions["buttons"];
+		if (!(Array.isArray(buttons) && buttons.some((b) => legacyButtonSequenceName(b) !== null))) {
+			const parsed = require_clip_model_registry.NcRuleActionsSchema.safeParse(actions);
+			if (parsed.success) return {
+				actions: parsed.data,
+				migrated: false
+			};
+			return {
+				actions: void 0,
+				migrated: false
+			};
+		}
+	}
+	const legacySequences = [];
+	const onTriggerRaw = actions["onTrigger"];
+	if (Array.isArray(onTriggerRaw)) for (const entry of onTriggerRaw) {
+		const seq = asLegacySequence(entry);
+		if (seq !== null) legacySequences.push(seq);
+	}
+	const nameToId = /* @__PURE__ */ new Map();
+	for (const sequence of legacySequences) {
+		const key = sequence.name.trim();
+		if (key === "" || nameToId.has(key)) continue;
+		const created = await createSequence({
+			name: sequence.name,
+			...sequence.minDelaySec !== void 0 ? { minDelaySec: sequence.minDelaySec } : {},
+			actions: [...sequence.actions]
+		});
+		nameToId.set(key, created.id);
+	}
+	const onTriggerBindings = [];
+	for (const sequence of legacySequences) {
+		if (!sequence.enabled) continue;
+		const id = nameToId.get(sequence.name.trim());
+		if (id === void 0) continue;
+		onTriggerBindings.push({
+			kind: "sequence",
+			sequenceId: id
+		});
+	}
+	const buttonsRaw = actions["buttons"];
+	const buttons = [];
+	if (Array.isArray(buttonsRaw)) for (const button of buttonsRaw) {
+		if (!isRecord$8(button)) continue;
+		const id = typeof button["id"] === "string" ? button["id"] : "";
+		const label = typeof button["label"] === "string" ? button["label"] : "";
+		if (id === "" || label === "") continue;
+		const existingId = typeof button["sequenceId"] === "string" && button["sequenceId"].length > 0 ? button["sequenceId"] : void 0;
+		const legacyName = legacyButtonSequenceName(button);
+		const sequenceId = existingId ?? (legacyName !== null ? nameToId.get(legacyName.trim()) : void 0);
+		if (sequenceId === void 0) continue;
+		buttons.push({
+			id,
+			label,
+			sequenceId,
+			...typeof button["icon"] === "string" ? { icon: button["icon"] } : {},
+			...typeof button["destructive"] === "boolean" ? { destructive: button["destructive"] } : {}
+		});
+	}
+	const next = {
+		...Array.isArray(actions["onActivation"]) ? { onActivation: actions["onActivation"] } : {},
+		...Array.isArray(actions["onDeactivation"]) ? { onDeactivation: actions["onDeactivation"] } : {},
+		...onTriggerBindings.length > 0 ? { onTrigger: onTriggerBindings } : {},
+		...Array.isArray(actions["onTriggerOff"]) ? { onTriggerOff: actions["onTriggerOff"] } : {},
+		...buttons.length > 0 ? { buttons } : {}
+	};
+	const parsed = require_clip_model_registry.NcRuleActionsSchema.safeParse(next);
+	if (!parsed.success) return {
+		actions: void 0,
+		migrated: true
+	};
+	return {
+		actions: (parsed.data.onActivation?.length ?? 0) === 0 && (parsed.data.onDeactivation?.length ?? 0) === 0 && (parsed.data.onTrigger?.length ?? 0) === 0 && (parsed.data.onTriggerOff?.length ?? 0) === 0 && (parsed.data.buttons?.length ?? 0) === 0 ? void 0 : parsed.data,
+		migrated: true
+	};
+}
+//#endregion
+//#region src/notification-center/sequence-store.ts
+/**
+* Shared action sequences for the notification centre.
+*
+* A sequence is a named, ordered run of steps (`wait` | `cap`) with its own
+* throttle. Rules and notification buttons bind to it by id — never by copying
+* the steps inline — so two rules that open the same gate share one budget and
+* one authoring surface.
+*
+* Mirrors {@link NcDeviceMuteStore}: declare the collection, mirror into RAM,
+* write-through so a failed persist never leaves a phantom sequence the next
+* boot will not know.
+*/
+/**
+* @durable class=config owner=notification-center
+*   write="an admin creates/edits/deletes a shared sequence via
+*     `notificationRules.createSequence` / `updateSequence` / `deleteSequence`,
+*     or the one-shot boot migration that materialises legacy inline sequences"
+*   retention="none — a row goes only when an admin deletes it. Bounded by the
+*     sequence set a human is willing to author."
+*/
+var NC_SEQUENCES_COLLECTION = "notification-center:sequences";
+var NC_SEQUENCES_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "minDelaySec",
+		type: "INTEGER"
+	},
+	{
+		name: "actions",
+		type: "JSON",
+		notNull: true
+	},
+	{
+		name: "createdAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+function isRecord$7(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseActions(raw) {
+	if (!Array.isArray(raw) || raw.length === 0) return null;
+	const out = [];
+	for (const entry of raw) {
+		const parsed = require_clip_model_registry.NcRuleActionSchema.safeParse(entry);
+		if (!parsed.success) return null;
+		out.push(parsed.data);
+	}
+	return out;
+}
+function rowToSequence(data) {
+	const id = data["id"];
+	const name = data["name"];
+	if (typeof id !== "string" || id.length === 0) return null;
+	if (typeof name !== "string" || name.length === 0) return null;
+	const actions = parseActions(data["actions"]);
+	if (actions === null) return null;
+	const minDelayRaw = data["minDelaySec"];
+	const minDelaySec = typeof minDelayRaw === "number" && Number.isInteger(minDelayRaw) ? minDelayRaw : void 0;
+	const candidate = {
+		id,
+		name,
+		...minDelaySec !== void 0 ? { minDelaySec } : {},
+		actions: [...actions]
+	};
+	const parsed = require_clip_model_registry.NcSharedSequenceSchema.safeParse(candidate);
+	return parsed.success ? parsed.data : null;
+}
+var NcSequenceStore = class {
+	byId = /* @__PURE__ */ new Map();
+	store;
+	logger;
+	now;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: NC_SEQUENCES_COLLECTION,
+			columns: [...NC_SEQUENCES_COLUMNS]
+		});
+	}
+	/**
+	* (Re)hydrate. A failed load KEEPS what is already in memory — dropping every
+	* sequence on a transient store error would leave every button and binding
+	* pointing at nothing until the next successful load.
+	*/
+	async load() {
+		try {
+			const rows = await this.store.query.query({
+				collection: NC_SEQUENCES_COLLECTION,
+				filter: { limit: 1e4 }
+			});
+			const next = /* @__PURE__ */ new Map();
+			let skipped = 0;
+			for (const row of rows) {
+				if (!isRecord$7(row.data)) {
+					skipped += 1;
+					continue;
+				}
+				const sequence = rowToSequence(row.data);
+				if (sequence === null) {
+					skipped += 1;
+					continue;
+				}
+				next.set(sequence.id, sequence);
+			}
+			this.byId.clear();
+			for (const [id, sequence] of next) this.byId.set(id, sequence);
+			if (skipped > 0) this.logger.warn("sequence rows skipped as malformed — bindings to them will miss", { meta: { skipped } });
+		} catch (err) {
+			this.logger.warn("sequence load failed — keeping the sequences already in memory", { meta: {
+				error: String(err),
+				sequences: this.byId.size
+			} });
+		}
+	}
+	list() {
+		return [...this.byId.values()].toSorted((a, b) => a.name.localeCompare(b.name));
+	}
+	get(sequenceId) {
+		return this.byId.get(sequenceId) ?? null;
+	}
+	/** Hot-path existence check for button minting. */
+	has(sequenceId) {
+		return this.byId.has(sequenceId);
+	}
+	knownIds() {
+		return new Set(this.byId.keys());
+	}
+	async create(input) {
+		const now = this.now();
+		const sequence = {
+			id: (0, node_crypto.randomUUID)(),
+			name: input.name,
+			...input.minDelaySec !== void 0 ? { minDelaySec: input.minDelaySec } : {},
+			actions: [...input.actions]
+		};
+		await this.persist(sequence, now, now);
+		this.byId.set(sequence.id, sequence);
+		return sequence;
+	}
+	/**
+	* Create with a CALLER-chosen id — used by the legacy migration so a rewrite
+	* can name the sequence before rewriting the rule that points at it.
+	*/
+	async createWithId(sequence) {
+		const now = this.now();
+		const stored = {
+			id: sequence.id,
+			name: sequence.name,
+			...sequence.minDelaySec !== void 0 ? { minDelaySec: sequence.minDelaySec } : {},
+			actions: [...sequence.actions]
+		};
+		await this.persist(stored, now, now);
+		this.byId.set(stored.id, stored);
+		return stored;
+	}
+	async update(sequenceId, input) {
+		if (this.byId.get(sequenceId) === void 0) throw new Error(`sequence ${sequenceId} does not exist`);
+		const now = this.now();
+		const sequence = {
+			id: sequenceId,
+			name: input.name,
+			...input.minDelaySec !== void 0 ? { minDelaySec: input.minDelaySec } : {},
+			actions: [...input.actions]
+		};
+		const createdAt = await this.readCreatedAt(sequenceId, now);
+		await this.persist(sequence, createdAt, now);
+		this.byId.set(sequenceId, sequence);
+		return sequence;
+	}
+	async delete(sequenceId) {
+		await this.store.delete.mutate({
+			collection: NC_SEQUENCES_COLLECTION,
+			key: sequenceId
+		});
+		this.byId.delete(sequenceId);
+	}
+	async readCreatedAt(sequenceId, fallback) {
+		try {
+			const raw = (await this.store.query.query({
+				collection: NC_SEQUENCES_COLLECTION,
+				filter: {
+					where: { id: sequenceId },
+					limit: 1
+				}
+			}))[0]?.data["createdAt"];
+			return typeof raw === "number" && Number.isFinite(raw) ? raw : fallback;
+		} catch {
+			return fallback;
+		}
+	}
+	async persist(sequence, createdAt, updatedAt) {
+		await this.store.set.mutate({
+			collection: NC_SEQUENCES_COLLECTION,
+			key: sequence.id,
+			value: {
+				id: sequence.id,
+				name: sequence.name,
+				...sequence.minDelaySec !== void 0 ? { minDelaySec: sequence.minDelaySec } : {},
+				actions: sequence.actions,
+				createdAt,
+				updatedAt
+			}
+		});
+	}
+};
+//#endregion
 //#region src/notification-center/device-prune.ts
 function judgeList(list, isDead) {
 	const dead = list.filter(isDead);
@@ -20446,58 +20839,49 @@ function pruneRuleConditions(conditions, isDead, notes) {
 	if (sceneDevice !== void 0 && isDead(sceneDevice)) notes.kept("conditions.scene", [String(sceneDevice)]);
 	return changed ? next : null;
 }
-/** A sequence's device steps, dead ones dropped. `null` when none was dead. */
-function pruneSequence(sequence, isDead) {
-	const dead = [];
-	const kept = sequence.actions.filter((step) => {
-		if (step.kind !== "cap" || !isDead(step.deviceId)) return true;
-		dead.push(step.deviceId);
-		return false;
-	});
-	if (dead.length === 0) return null;
-	const anyDeviceStep = kept.some((step) => step.kind === "cap");
-	const [first, ...rest] = kept;
-	if (!anyDeviceStep || first === void 0) return {
-		next: "removed",
-		dead
-	};
-	return {
-		next: {
-			...sequence,
-			actions: [first, ...rest]
-		},
-		dead
+/** A Do binding whose device is dead is dropped; sequence refs are left alone
+*  (shared sequences are pruned on their own store, not per-rule). */
+function pruneHookBindings(bindings, field, isDead, notes) {
+	if (bindings === void 0) return {
+		next: void 0,
+		changed: false
 	};
-}
-/** The actions after a device prune — `null` when no step moved. */
-function pruneRuleActions(actions, isDead, notes) {
-	const sequences = actions.onTrigger;
-	if (sequences === void 0) return null;
+	const kept = [];
 	let changed = false;
-	const removedNames = /* @__PURE__ */ new Set();
-	const nextSequences = [];
-	for (const sequence of sequences) {
-		const pruned = pruneSequence(sequence, isDead);
-		if (pruned === null) {
-			nextSequences.push(sequence);
+	for (const binding of bindings) {
+		if (binding.kind === "sequence") {
+			kept.push(binding);
 			continue;
 		}
-		changed = true;
-		const field = `actions.onTrigger.${sequence.name}`;
-		if (pruned.next === "removed") {
-			removedNames.add(sequence.name);
-			notes.removed(field, deviceSubjects(pruned.dead), "sequence-removed");
-		} else {
-			nextSequences.push(pruned.next);
-			notes.removed(field, deviceSubjects(pruned.dead));
+		if (binding.action.kind === "cap" && isDead(binding.action.deviceId)) {
+			changed = true;
+			notes.removed(field, deviceSubjects([binding.action.deviceId]), "binding-removed");
+			continue;
 		}
+		kept.push(binding);
 	}
-	if (!changed) return null;
-	const buttons = actions.buttons;
+	if (!changed) return {
+		next: bindings,
+		changed: false
+	};
+	return {
+		next: kept.length > 0 ? kept : void 0,
+		changed: true
+	};
+}
+/** The actions after a device prune — `null` when no binding moved. */
+function pruneRuleActions(actions, isDead, notes) {
+	const onActivation = pruneHookBindings(actions.onActivation, "actions.onActivation", isDead, notes);
+	const onDeactivation = pruneHookBindings(actions.onDeactivation, "actions.onDeactivation", isDead, notes);
+	const onTrigger = pruneHookBindings(actions.onTrigger, "actions.onTrigger", isDead, notes);
+	const onTriggerOff = pruneHookBindings(actions.onTriggerOff, "actions.onTriggerOff", isDead, notes);
+	if (!onActivation.changed && !onDeactivation.changed && !onTrigger.changed && !onTriggerOff.changed) return null;
 	return {
-		...actions,
-		onTrigger: nextSequences,
-		...buttons !== void 0 ? { buttons: buttons.filter((button) => !removedNames.has(button.sequence)) } : {}
+		...onActivation.next !== void 0 ? { onActivation: [...onActivation.next] } : {},
+		...onDeactivation.next !== void 0 ? { onDeactivation: [...onDeactivation.next] } : {},
+		...onTrigger.next !== void 0 ? { onTrigger: [...onTrigger.next] } : {},
+		...onTriggerOff.next !== void 0 ? { onTriggerOff: [...onTriggerOff.next] } : {},
+		...actions.buttons !== void 0 ? { buttons: actions.buttons } : {}
 	};
 }
 function planRuleDevices(rule, isDead, guard) {
@@ -24732,6 +25116,10 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels, timeZone) {
 	return {
 		camera: deviceName,
 		class: detection?.className ?? (systemEvent !== void 0 ? "" : subject.className),
+		classLabel: (() => {
+			const wire = detection?.className ?? (systemEvent !== void 0 ? "" : subject.className);
+			return wire.length === 0 ? "" : require_clip_model_registry.eventKindLabel(wire, texts.language);
+		})(),
 		label: detection?.label ?? subject.label ?? "",
 		zones: zoneLabels.join(", "),
 		subject: detection?.className !== void 0 ? ncSubjectText(texts, {
@@ -28873,9 +29261,32 @@ function lastRunRow(data) {
 }
 //#endregion
 //#region src/notification-center/rule-actions.ts
+function wrapDo(action) {
+	const name = action.kind === "wait" ? `wait ${String(action.seconds)}s` : `${action.cap}.${action.method}`;
+	return {
+		id: `do:${name}`,
+		name,
+		enabled: true,
+		actions: [action],
+		throttle: false
+	};
+}
+function resolveBinding(binding, lookup) {
+	if (binding.kind === "do") return wrapDo(binding.action);
+	const sequence = lookup(binding.sequenceId);
+	if (sequence === null) return { missing: binding.sequenceId };
+	return {
+		id: sequence.id,
+		name: sequence.name,
+		enabled: true,
+		...sequence.minDelaySec !== void 0 ? { minDelaySec: sequence.minDelaySec } : {},
+		actions: sequence.actions,
+		throttle: true
+	};
+}
 var NcRuleActionRunner = class {
 	deps;
-	/** Last run per `${ruleId}:${sequenceName}` — the throttle's memory. */
+	/** Last run per `sequenceId` — the throttle's memory (shared across rules). */
 	lastRunAt = /* @__PURE__ */ new Map();
 	now;
 	sleep;
@@ -28885,11 +29296,49 @@ var NcRuleActionRunner = class {
 		this.sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
 	}
 	/**
-	* Run every enabled sequence, in order.
+	* Resolve bindings via the sequence store and run each, in order.
 	*
 	* Never throws: an actuation that fails must not cost the NOTIFICATION about
-	* the very same event. The operator finds out from the log and from the
-	* device not having moved — not from silence on both.
+	* the very same event.
+	*/
+	async runBindings(input) {
+		const sequences = [];
+		const missing = [];
+		for (const binding of input.bindings) {
+			const resolved = resolveBinding(binding, input.lookup);
+			if ("missing" in resolved) {
+				this.deps.logger.warn("rule action binding skipped — sequence missing", {
+					tags: { deviceId: input.deviceId },
+					meta: {
+						ruleId: input.ruleId,
+						sequenceId: resolved.missing
+					}
+				});
+				missing.push({
+					id: resolved.missing,
+					name: resolved.missing,
+					ran: false,
+					stepsRun: 0,
+					skippedReason: "missing"
+				});
+				continue;
+			}
+			sequences.push(resolved);
+		}
+		const ran = await this.run({
+			ruleId: input.ruleId,
+			ruleName: input.ruleName,
+			deviceId: input.deviceId,
+			sequences,
+			...input.origin !== void 0 ? { origin: input.origin } : {}
+		});
+		return [...missing, ...ran];
+	}
+	/**
+	* Run every enabled sequence, in order.
+	*
+	* Prefer {@link runBindings} at call sites that hold bindings. This remains
+	* for button grants (force-enabled shared sequence) and tests.
 	*/
 	async run(input) {
 		const out = [];
@@ -28898,38 +29347,41 @@ var NcRuleActionRunner = class {
 	}
 	async runOne(input, sequence) {
 		if (!sequence.enabled) return {
+			id: sequence.id,
 			name: sequence.name,
 			ran: false,
 			stepsRun: 0,
 			skippedReason: "disabled"
 		};
 		if (sequence.actions.length === 0) return {
+			id: sequence.id,
 			name: sequence.name,
 			ran: false,
 			stepsRun: 0,
 			skippedReason: "empty"
 		};
-		const key = `${input.ruleId}:${sequence.name}`;
 		const now = this.now();
-		const minDelayMs = (sequence.minDelaySec ?? 0) * 1e3;
-		const last = this.lastRunAt.get(key);
+		const minDelayMs = sequence.throttle ? (sequence.minDelaySec ?? 0) * 1e3 : 0;
+		const last = this.lastRunAt.get(sequence.id);
 		if (minDelayMs > 0 && last !== void 0 && now - last < minDelayMs) {
 			this.deps.logger.debug("rule action sequence throttled", {
 				tags: { deviceId: input.deviceId },
 				meta: {
 					ruleId: input.ruleId,
+					sequenceId: sequence.id,
 					sequence: sequence.name,
 					sinceLastMs: now - last
 				}
 			});
 			return {
+				id: sequence.id,
 				name: sequence.name,
 				ran: false,
 				stepsRun: 0,
 				skippedReason: "throttled"
 			};
 		}
-		this.lastRunAt.set(key, now);
+		if (sequence.throttle) this.lastRunAt.set(sequence.id, now);
 		let stepsRun = 0;
 		for (const [index, action] of sequence.actions.entries()) try {
 			await this.step(action, input.origin);
@@ -28940,6 +29392,7 @@ var NcRuleActionRunner = class {
 				meta: {
 					ruleId: input.ruleId,
 					rule: input.ruleName,
+					sequenceId: sequence.id,
 					sequence: sequence.name,
 					step: index,
 					action: action.kind === "cap" ? `${action.cap}.${action.method}` : "wait",
@@ -28947,6 +29400,7 @@ var NcRuleActionRunner = class {
 				}
 			});
 			return {
+				id: sequence.id,
 				name: sequence.name,
 				ran: true,
 				stepsRun,
@@ -28958,11 +29412,13 @@ var NcRuleActionRunner = class {
 			meta: {
 				ruleId: input.ruleId,
 				rule: input.ruleName,
+				sequenceId: sequence.id,
 				sequence: sequence.name,
 				steps: stepsRun
 			}
 		});
 		return {
+			id: sequence.id,
 			name: sequence.name,
 			ran: true,
 			stepsRun
@@ -28983,6 +29439,17 @@ var NcRuleActionRunner = class {
 		});
 	}
 };
+/** Force-enable a shared sequence for a button tap (always runs, still throttled). */
+function asForcedSequence(sequence) {
+	return {
+		id: sequence.id,
+		name: sequence.name,
+		enabled: true,
+		...sequence.minDelaySec !== void 0 ? { minDelaySec: sequence.minDelaySec } : {},
+		actions: sequence.actions,
+		throttle: true
+	};
+}
 //#endregion
 //#region src/notification-center/rule-ai-analyst.ts
 /**
@@ -30829,7 +31296,7 @@ function snoozeVerdict(input, deps) {
 	});
 	if (active === null) return { kind: "clear" };
 	const rule = deps.ruleFor(input.ruleId);
-	if (rule !== null && isSnoozeExempt(rule)) return {
+	if (rule !== null && isSnoozeExempt(rule, deps.sequenceActionsOf)) return {
 		kind: "exempt",
 		snooze: active
 	};
@@ -36941,6 +37408,8 @@ var NotificationCenter = class {
 	snoozes;
 	/** The permanent per-camera notification off switch — see `device-mute-store.ts`. */
 	deviceMutes;
+	/** Shared action sequences rules and buttons bind to by id. */
+	sequences;
 	/** The durable episode rows behind the sustained-state alerts. */
 	alertStore;
 	/** Battery band → notification, and the reminder sweep. */
@@ -37179,7 +37648,8 @@ var NotificationCenter = class {
 		const drafts = [];
 		const sequenceButtons = this.actionRunner === null || stored === null ? [] : buildActionButtons({
 			actions: stored.actions,
-			mintUrl: ({ sequence, actionId }) => {
+			knownSequenceIds: this.sequences.knownIds(),
+			mintUrl: ({ sequenceId, actionId }) => {
 				const id = (0, node_crypto.randomUUID)();
 				drafts.push({
 					id,
@@ -37189,7 +37659,7 @@ var NotificationCenter = class {
 						id,
 						ruleId: input.ruleId,
 						ruleName: input.ruleName,
-						sequence,
+						sequenceId,
 						deviceId: input.deviceId,
 						actionId,
 						targetId: input.targetId,
@@ -37201,6 +37671,7 @@ var NotificationCenter = class {
 		});
 		const snoozeButtons = input.ownerUserId === void 0 || stored === null ? [] : buildSnoozeButtons({
 			rule: stored,
+			sequenceActionsOf: this.sequenceActionsOf,
 			label: (minutes) => this.snoozeButtonLabel(minutes),
 			mintUrl: ({ actionId, minutes }) => {
 				const id = (0, node_crypto.randomUUID)();
@@ -37441,7 +37912,7 @@ var NotificationCenter = class {
 	*/
 	async applyGrantedSnooze(grant) {
 		const rule = this.rules.get(grant.ruleId);
-		if (rule !== null && isSnoozeExempt(rule)) throw new Error(`"${grant.ruleName}" is an alarm rule and cannot be snoozed`);
+		if (rule !== null && isSnoozeExempt(rule, this.sequenceActionsOf)) throw new Error(`"${grant.ruleName}" is an alarm rule and cannot be snoozed`);
 		const snooze = await this.snoozes.create({
 			userId: grant.userId,
 			scope: "device",
@@ -37740,16 +38211,13 @@ var NotificationCenter = class {
 		if (this.actionRunner === null) throw new Error("no actuator is wired on this node");
 		const rule = this.rules.get(grant.ruleId);
 		if (rule === null) throw new Error(`rule ${grant.ruleId} no longer exists`);
-		const sequence = (rule.actions?.onTrigger ?? []).find((s) => s.name === grant.sequence);
-		if (sequence === void 0) throw new Error(`sequence "${grant.sequence}" no longer exists on rule ${rule.name}`);
+		const sequence = this.sequences.get(grant.sequenceId);
+		if (sequence === null) throw new Error(`sequence "${grant.sequenceId}" no longer exists`);
 		const [outcome] = await this.actionRunner.run({
 			ruleId: rule.id,
 			ruleName: rule.name,
 			deviceId: grant.deviceId,
-			sequences: [{
-				...sequence,
-				enabled: true
-			}]
+			sequences: [asForcedSequence(sequence)]
 		});
 		if (outcome === void 0) throw new Error("the sequence did not run");
 		if (outcome.failedAt !== void 0) throw new Error(`step ${String(outcome.failedAt)} of "${sequence.name}" failed`);
@@ -37868,6 +38336,11 @@ var NotificationCenter = class {
 			logger: this.logger.child("device-mute"),
 			...deps.now !== void 0 ? { now: deps.now } : {}
 		});
+		this.sequences = new NcSequenceStore({
+			store: deps.store,
+			logger: this.logger.child("sequences"),
+			...deps.now !== void 0 ? { now: deps.now } : {}
+		});
 		this.alertStore = new NcAlertStore({
 			store: deps.store,
 			logger: this.logger.child("device-alerts")
@@ -38134,6 +38607,7 @@ var NotificationCenter = class {
 		await NcStateSummaryService.declare(store);
 		await NcSnoozeStore.declare(store);
 		await NcDeviceMuteStore.declare(store);
+		await NcSequenceStore.declare(store);
 		await TimelapseStore.declare(store);
 		await NcSummaryStore.declare(store);
 		await NcCalendarEventsStore.declare(store);
@@ -38195,6 +38669,8 @@ var NotificationCenter = class {
 				sinceStartMs: now - t0
 			} });
 		};
+		await timed("sequences", () => this.sequences.load());
+		await timed("migrateLegacyActions", () => this.migrateLegacyRuleActions());
 		await Promise.all([
 			timed("texts", () => this.reloadTexts()),
 			timed("rules", () => this.rules.load()),
@@ -39494,7 +39970,32 @@ var NotificationCenter = class {
 				return { success: true };
 			},
 			setRuleEnabled: async ({ ruleId, enabled }) => {
-				await this.rules.setEnabled(ruleId, enabled);
+				const updated = await this.rules.setEnabled(ruleId, enabled);
+				const bindings = enabled ? updated.actions?.onActivation : updated.actions?.onDeactivation;
+				if (bindings !== void 0 && bindings.length > 0 && this.actionRunner !== null) this.actionRunner.runBindings({
+					ruleId: updated.id,
+					ruleName: updated.name,
+					deviceId: this.deviceIdForRuleActions(updated),
+					bindings,
+					lookup: (id) => this.sequences.get(id)
+				});
+				return { success: true };
+			},
+			listSequences: async () => ({ sequences: [...this.sequences.list()] }),
+			getSequence: async ({ sequenceId }) => ({ sequence: this.sequences.get(sequenceId) }),
+			createSequence: async ({ sequence }) => {
+				const created = await this.sequences.create(sequence);
+				this.logger.info("notification sequence created", { meta: { sequenceId: created.id } });
+				return { sequence: created };
+			},
+			updateSequence: async ({ sequenceId, sequence }) => {
+				const updated = await this.sequences.update(sequenceId, sequence);
+				this.logger.info("notification sequence updated", { meta: { sequenceId } });
+				return { sequence: updated };
+			},
+			deleteSequence: async ({ sequenceId }) => {
+				await this.sequences.delete(sequenceId);
+				this.logger.info("notification sequence deleted", { meta: { sequenceId } });
 				return { success: true };
 			},
 			testRule: async ({ rule, lookbackMinutes }) => ({ results: [...await this.dryRun(rule, lookbackMinutes)] }),
@@ -40991,7 +41492,7 @@ var NotificationCenter = class {
 					} : {}
 				}
 			});
-			const unresolvable = unresolvableButtons(rule.actions);
+			const unresolvable = unresolvableButtons(rule.actions, this.sequences.knownIds());
 			if (unresolvable.length > 0) this.logger.warn("rule buttons reference sequences that do not exist — not sent", {
 				tags: { deviceId: subject.deviceId },
 				meta: {
@@ -41118,20 +41619,85 @@ var NotificationCenter = class {
 		return this.groupStore.list(query);
 	}
 	/**
-	* Run this rule's `onTrigger` sequences for this match.
+	* Materialise legacy inline `onTrigger` sequences into the shared store and
+	* rewrite each rule's actions to bindings + `buttons.sequenceId`. Runs on RAW
+	* rows before {@link NcRuleStore.load} so Zod never skips them.
+	*/
+	async migrateLegacyRuleActions() {
+		let rows;
+		try {
+			rows = await this.deps.store.query.query({
+				collection: NC_RULES_COLLECTION,
+				filter: { limit: 1e4 }
+			});
+		} catch (err) {
+			this.logger.warn("legacy actions migration skipped — could not read rules", { meta: { error: String(err) } });
+			return;
+		}
+		let migrated = 0;
+		for (const row of rows) {
+			const ruleBlob = row.data["rule"];
+			if (typeof ruleBlob !== "object" || ruleBlob === null || Array.isArray(ruleBlob)) continue;
+			const rule = { ...ruleBlob };
+			const ruleId = typeof rule["id"] === "string" ? rule["id"] : void 0;
+			if (ruleId === void 0) continue;
+			const result = await migrateLegacyRuleActions(rule["actions"], async (input) => {
+				return { id: (await this.sequences.create(input)).id };
+			});
+			if (!result.migrated) continue;
+			if (result.actions !== void 0) rule["actions"] = result.actions;
+			else delete rule["actions"];
+			const { id: _rowId, ...columns } = row.data;
+			await this.deps.store.set.mutate({
+				collection: NC_RULES_COLLECTION,
+				key: ruleId,
+				value: {
+					...columns,
+					rule
+				}
+			});
+			migrated += 1;
+		}
+		if (migrated > 0) this.logger.info("migrated legacy inline rule actions into shared sequences", { meta: {
+			rules: migrated,
+			sequences: this.sequences.list().length
+		} });
+	}
+	/**
+	* True when this match is a clear / leave edge — the subject for
+	* `onTriggerOff`. Raise / enter / ordinary matches use `onTrigger`.
+	*/
+	isTriggerOffSubject(subject) {
+		if (subject.sensorRaised === false) return true;
+		if (subject.occupancy !== void 0 && subject.occupancy.occupied === false) return true;
+		return false;
+	}
+	/** Device id for activation/deactivation log tags — first scoped device, else 0. */
+	deviceIdForRuleActions(rule) {
+		const devices = rule.conditions.devices;
+		if (devices !== void 0 && devices.length > 0) {
+			const first = devices[0];
+			if (first !== void 0) return first;
+		}
+		return 0;
+	}
+	sequenceActionsOf = (sequenceId) => this.sequences.get(sequenceId)?.actions;
+	/**
+	* Run this rule's onTrigger / onTriggerOff bindings for this match.
 	*
 	* Called BEFORE the cooldown gate — see the call site for why. Everything
 	* here is fire-and-forget and nothing may throw into the evaluation.
 	*/
 	runRuleActions(rule, subject, kind, controls) {
-		const sequences = rule.actions?.onTrigger;
-		if (sequences === void 0 || sequences.length === 0) return;
 		if (this.actionRunner === null || controls.runActions === false) return;
-		this.actionRunner.run({
+		const bindings = this.isTriggerOffSubject(subject) ? rule.actions?.onTriggerOff : rule.actions?.onTrigger;
+		if (bindings === void 0 || bindings.length === 0) return;
+		this.actionRunner.runBindings({
 			ruleId: rule.id,
 			ruleName: rule.name,
 			deviceId: subject.deviceId,
-			sequences,
+			bindings,
+			lookup: (id) => this.sequences.get(id),
 			origin: fireRefFor(rule, subject, kind)
 		});
 	}
@@ -42035,7 +42601,8 @@ var NotificationCenter = class {
 	snoozeDecision(input) {
 		const verdict = snoozeVerdict(input, {
 			activeFor: (query) => this.snoozes.activeFor(query),
-			ruleFor: (ruleId) => this.rules.get(ruleId)
+			ruleFor: (ruleId) => this.rules.get(ruleId),
+			sequenceActionsOf: this.sequenceActionsOf
 		});
 		if (verdict.kind === "exempt") this.logger.info("snooze does not apply — alarm rules are never silenced", {
 			tags: { deviceId: input.deviceId },