@camstack/addon-post-analysis 1.2.322 → 1.2.324

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-BFLeI0dr.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -484,26 +484,37 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 	};
 }
 /**
-* "Attivi: 2 — Bypassati: Finestra veranda."
+* "Attivi: Porta retro, Cancello — Bypassati: Finestra veranda."
 *
-* The bypassed sensors are named and the armed ones are COUNTED, not listed:
-* this sentence's subject is the exception, and burying it under thirteen
-* camera names is how an operator stops reading the arm notification. The
-* count pluralises on what IS armed, like every other arm variant.
+* Both halves are named: the bypassed sensors are why the operator pressed
+* Arm anyway, and the remaining ones are what is still promised. An
+* all-devices mode has no finite list to name — it uses a dedicated key.
 */
 function armedWithBypass(coverage, bypassed, deviceName) {
 	const skipped = new Set(coverage.skippedDevices.map((s) => s.deviceId));
 	const excluded = new Set(bypassed);
-	const armed = coverage.allDevices ? coverage.ruleCount : coverage.deviceIds.filter((id) => !skipped.has(id) && !excluded.has(id)).length;
+	const bypassedNames = bypassed.map(deviceName).join(", ");
+	if (coverage.allDevices) return {
+		bodyKey: "alarm.arm.body.bypassedAll",
+		textParams: {
+			rules: `${coverage.ruleCount}`,
+			mode: coverage.mode,
+			bypassedNames
+		},
+		textCount: coverage.ruleCount
+	};
+	const armedIds = coverage.deviceIds.filter((id) => !skipped.has(id) && !excluded.has(id));
+	const names = armedIds.map(deviceName).join(", ");
 	return {
 		bodyKey: "alarm.arm.body.bypassed",
 		textParams: {
 			rules: `${coverage.ruleCount}`,
 			mode: coverage.mode,
-			devices: `${armed}`,
-			bypassedNames: bypassed.map(deviceName).join(", ")
+			devices: `${armedIds.length}`,
+			names,
+			bypassedNames
 		},
-		textCount: armed
+		textCount: armedIds.length
 	};
 }
 /**
@@ -945,7 +956,7 @@ function grantMeta(grant) {
 			...common,
 			ruleId: grant.ruleId,
 			rule: grant.ruleName,
-			sequence: grant.sequence
+			sequenceId: grant.sequenceId
 		};
 		case "snooze": return {
 			...common,
@@ -1098,10 +1109,11 @@ var NcActionPlane = class {
 * Anything short of fully secure is open: a cover stopped half-way, a lock that
 * jammed, a cover still closing when the arm is decided, a switch that is on.
 *
-* PRECEDENCE, when one device carries more than one opening slice: `contact`
-* first, then `cover`, then `lock-control`, then `switch`. The contact is the
-* physical truth about the opening — a reed switch on the frame says the window
-* is open even when the motor's last reported word says `closed`.
+* PRECEDENCE, when one device carries more than one opening slice: any OPEN
+* reading wins over a secure one (a reed that says open beats a motor that
+* still says `closed`). Among opens, a controllable cap (`cover` / `lock-control`
+* / `switch`) wins so secure-on-arm knows what to actuate; among secures the
+* contact wins as the physical "closed" when the motor has not moved yet.
 */
 /** The one state word, per cap, that counts as secure. Everything else is open. */
 var COVER_SECURE = "closed";
@@ -1214,6 +1226,11 @@ function readSwitch(runtime) {
 }
 /** D630's table over one device's runtime slices — see the header for the three answers. */
 function alarmOpeningFrom(runtime) {
+	let openControllable = null;
+	let openAny = null;
+	let secureContact = null;
+	let secureControllable = null;
+	let secureAny = null;
 	let firstUnknown = null;
 	for (const read of [
 		readContact(runtime),
@@ -1221,10 +1238,21 @@ function alarmOpeningFrom(runtime) {
 		readLock(runtime),
 		readSwitch(runtime)
 	]) {
-		if (read.kind === "reading") return read;
-		if (read.kind === "unknown" && firstUnknown === null) firstUnknown = read;
+		if (read.kind === "unknown") {
+			if (firstUnknown === null) firstUnknown = read;
+			continue;
+		}
+		if (read.kind !== "reading") continue;
+		if (read.reading === "open") {
+			if (require_clip_model_registry.isAlarmControllableCap(read.cap) && openControllable === null) openControllable = read;
+			if (openAny === null) openAny = read;
+			continue;
+		}
+		if (read.cap === "contact" && secureContact === null) secureContact = read;
+		if (require_clip_model_registry.isAlarmControllableCap(read.cap) && secureControllable === null) secureControllable = read;
+		if (secureAny === null) secureAny = read;
 	}
-	return firstUnknown ?? NOT_OPENING;
+	return openControllable ?? openAny ?? secureContact ?? secureControllable ?? secureAny ?? firstUnknown ?? NOT_OPENING;
 }
 /**
 * The sensor-event kind (`CAP_TO_KIND` in `@camstack/types`) → the cap whose
@@ -2750,12 +2778,6 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 				error: String(err)
 			};
 		}
-		const toSecure = openings.open.filter((d) => require_clip_model_registry.alarmDeviceSecureOnArm({
-			controllable: d.controllable,
-			deviceId: d.deviceId,
-			secureOnArmOff: this.secureOnArmOffFor(mode)
-		}));
-		if (toSecure.length > 0) this.armGuard?.secureOnArm(toSecure);
 		const verdict = decideArm({
 			mode,
 			open: openings.open,
@@ -2763,6 +2785,14 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 			blocking: this.blockingFor(mode),
 			...acknowledged !== void 0 ? { acknowledged } : {}
 		});
+		if (verdict.kind === "arm") {
+			const toSecure = openings.open.filter((d) => require_clip_model_registry.alarmDeviceSecureOnArm({
+				controllable: d.controllable,
+				deviceId: d.deviceId,
+				secureOnArmOff: this.secureOnArmOffFor(mode)
+			}));
+			if (toSecure.length > 0) this.armGuard?.secureOnArm(toSecure);
+		}
 		return {
 			kind: "read",
 			openings,
@@ -2971,6 +3001,7 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 	status(now = Date.now()) {
 		return {
 			state: stateAt(this.machine, now),
+			targetMode: armModeOf(this.machine.target, NC_ALARM_MODES),
 			availableModes: [...NC_ALARM_MODES],
 			requiresCode: false,
 			lastChangedAt: this.machine.changedAt
@@ -5068,6 +5099,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 +5128,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 +5168,7 @@ function ncSubjectText(texts, input) {
 		key: subjectLabelKey(input.labelKind),
 		vars: {
 			classNoun,
-			label: input.label
+			label: ncSubjectLabelText(texts, input.label, input.labelKind)
 		}
 	});
 }
@@ -8675,31 +8738,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 +8792,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 +8813,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 +8874,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 +11163,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 } : {}
 	});
 }
 /**
@@ -12862,7 +12942,7 @@ function incomingFromAlarmTransition(input) {
 	const kind = transition.kind;
 	const keys = alarmTextKeys(transition, input.body);
 	const sensor = transition.sensor;
-	const alarmSource = kind === "alarm-triggered" ? source : void 0;
+	const alarmSource = (kind === "alarm-triggered" || kind === "alarm-pending") && source !== void 0 ? source : void 0;
 	const facts = {
 		eventId: `alarm:${kind}:${String(transition.at)}${sensor !== void 0 ? `:${String(sensor.deviceId)}` : ""}${transition.refusalId !== void 0 ? `:${transition.refusalId}` : ""}`,
 		timestamp: transition.at,
@@ -12975,7 +13055,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 +13071,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,
@@ -14516,7 +14596,7 @@ var en_default = {
 	"snooze.scope.anyRule": "A rule",
 	"snooze.scope.rule": "“{{rule}}”",
 	"alarm.arm.body.allDevices": "Active: all devices",
-	"alarm.arm.body.allDevicesExcept": "Active: all devices except {{count}}: {{names}}",
+	"alarm.arm.body.allDevicesExcept": "Active: all devices except {{names}}",
 	"alarm.arm.body.noDevices": "Active: no device restriction",
 	"alarm.arm.body.devices": "Active: {{names}}",
 	"alarm.arm.body.devicesSkipped": "Active: {{names}}\nExcluded: {{skippedNames}}",
@@ -14526,7 +14606,8 @@ var en_default = {
 	"alarm.arming.body.uncovered": "Active: none — no rule uses this mode",
 	"alarm.arming.body.allSkipped": "Active: none\nExcluded: {{names}}",
 	"alarm.arming.body.skipped": "Excluded: {{names}}",
-	"alarm.arm.body.bypassed": "Active: {{devices}}\nBypassed: {{bypassedNames}}",
+	"alarm.arm.body.bypassed": "Active: {{names}}\nBypassed: {{bypassedNames}}",
+	"alarm.arm.body.bypassedAll": "Active: all devices\nBypassed: {{bypassedNames}}",
 	"alarm.arming.body.bypassed": "Bypassed: {{bypassedNames}}",
 	"alarm.armRefused.body": "Open: {{names}}",
 	"alarm.armRefused.body.hint": "Open: {{names}}\nTap “Arm anyway” to arm with them excluded.",
@@ -14843,7 +14924,7 @@ var it_default = {
 	"snooze.scope.anyRule": "Una regola",
 	"snooze.scope.rule": "“{{rule}}”",
 	"alarm.arm.body.allDevices": "Attivi: tutti i dispositivi",
-	"alarm.arm.body.allDevicesExcept": "Attivi: tutti i dispositivi tranne {{count}}: {{names}}",
+	"alarm.arm.body.allDevicesExcept": "Attivi: tutti i dispositivi tranne {{names}}",
 	"alarm.arm.body.noDevices": "Attivi: nessuna restrizione",
 	"alarm.arm.body.devices": "Attivi: {{names}}",
 	"alarm.arm.body.devicesSkipped": "Attivi: {{names}}\nEsclusi: {{skippedNames}}",
@@ -14853,7 +14934,8 @@ var it_default = {
 	"alarm.arming.body.uncovered": "Attivi: nessuno — nessuna regola usa questa modalità",
 	"alarm.arming.body.allSkipped": "Attivi: nessuno\nEsclusi: {{names}}",
 	"alarm.arming.body.skipped": "Esclusi: {{names}}",
-	"alarm.arm.body.bypassed": "Attivi: {{devices}}\nBypassati: {{bypassedNames}}",
+	"alarm.arm.body.bypassed": "Attivi: {{names}}\nBypassati: {{bypassedNames}}",
+	"alarm.arm.body.bypassedAll": "Attivi: tutti i dispositivi\nBypassati: {{bypassedNames}}",
 	"alarm.arming.body.bypassed": "Bypassati: {{bypassedNames}}",
 	"alarm.armRefused.body": "Aperti: {{names}}",
 	"alarm.armRefused.body.hint": "Aperti: {{names}}\nTocca “Arma comunque” per armare escludendoli.",
@@ -20333,6 +20415,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 +20872,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 +25149,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 +29294,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 +29329,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 +29380,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 +29425,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 +29433,7 @@ var NcRuleActionRunner = class {
 				}
 			});
 			return {
+				id: sequence.id,
 				name: sequence.name,
 				ran: true,
 				stepsRun,
@@ -28958,11 +29445,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 +29472,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 +31329,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
 	};
@@ -36630,13 +37130,16 @@ function frozenOccupancy(rule, occ) {
 function fireRefFor(rule, subject, kind) {
 	const hasEventMedia = kind === "object-event" || kind === "package-event";
 	const className = subject.classNames[0];
+	const linkedOwners = subject.trackId === void 0 && subject.linkedStills !== void 0 ? linkedMediaOwners(subject.linkedStills, linkedCameraMode(rule.media)) : void 0;
+	const trackId = subject.trackId ?? linkedOwners?.trackId;
 	return {
 		ruleId: rule.id,
 		ruleName: rule.name,
 		deviceId: subject.deviceId,
 		...subject.sourceDeviceId !== void 0 ? { sourceDeviceId: subject.sourceDeviceId } : {},
 		recordId: subject.recordId,
-		...subject.trackId !== void 0 ? { trackId: subject.trackId } : {},
+		...trackId !== void 0 ? { trackId } : {},
+		...linkedOwners !== void 0 && linkedOwners.extraStills.length > 0 ? { extraStills: linkedOwners.extraStills.map((x) => ({ ...x })) } : {},
 		...hasEventMedia ? { eventId: subject.recordId } : {},
 		timestamp: subject.timestamp,
 		...className !== void 0 ? { className } : {},
@@ -36941,6 +37444,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 +37684,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 +37695,7 @@ var NotificationCenter = class {
 						id,
 						ruleId: input.ruleId,
 						ruleName: input.ruleName,
-						sequence,
+						sequenceId,
 						deviceId: input.deviceId,
 						actionId,
 						targetId: input.targetId,
@@ -37201,6 +37707,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 +37948,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 +38247,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 +38372,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 +38643,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 +38705,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 +40006,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)] }),
@@ -40228,10 +40765,11 @@ var NotificationCenter = class {
 		const alarmSource = subject.systemEvent?.alarmSource;
 		const sourceRule = alarmSource !== void 0 ? this.rules.get(alarmSource.ruleId) : null;
 		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, void 0) : { media: "none" };
+		const mediaDeviceId = alarmSource?.deviceId ?? panel.deviceId;
 		const entries = targets.map((targetId) => ({
 			ruleId: NC_ALARM_ANNOUNCE_RULE_ID,
 			targetId,
-			deviceId: panel.deviceId,
+			deviceId: mediaDeviceId,
 			recordKind: "system-event",
 			recordId: subject.recordId,
 			payload: {
@@ -40240,8 +40778,9 @@ var NotificationCenter = class {
 				priority: 2,
 				...media,
 				subject: {
-					deviceId: panel.deviceId,
+					deviceId: mediaDeviceId,
 					...alarmSource?.trackId !== void 0 ? { trackId: alarmSource.trackId } : {},
+					...alarmSource?.extraStills !== void 0 && alarmSource.extraStills.length > 0 ? { extraStills: alarmSource.extraStills.map((x) => ({ ...x })) } : {},
 					...alarmSource?.eventId !== void 0 ? { eventId: alarmSource.eventId } : {},
 					className: "alarm",
 					zones: [],
@@ -40991,7 +41530,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 +41657,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)
 		});
 	}
@@ -41261,7 +41865,10 @@ var NotificationCenter = class {
 				...target.params !== void 0 ? { params: target.params } : {},
 				subject: {
 					deviceId: subject.deviceId,
-					...alarmSource?.trackId !== void 0 ? { trackId: alarmSource.trackId } : linkedOwners !== void 0 ? {
+					...alarmSource?.trackId !== void 0 ? {
+						trackId: alarmSource.trackId,
+						...alarmSource.extraStills !== void 0 && alarmSource.extraStills.length > 0 ? { extraStills: alarmSource.extraStills.map((x) => ({ ...x })) } : {}
+					} : linkedOwners !== void 0 ? {
 						trackId: linkedOwners.trackId,
 						...linkedOwners.extraStills.length > 0 ? { extraStills: linkedOwners.extraStills.map((x) => ({ ...x })) } : {},
 						analysisTiles: linkedOwners.analysisTiles.map((x) => ({ ...x }))
@@ -42035,7 +42642,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 },