@camstack/addon-post-analysis 1.2.321 → 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-BCx3qCL5.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,
@@ -1948,6 +1948,21 @@ var ncAlarmPanelSchema = require_clip_model_registry.object({
 		exitDelaySec: require_clip_model_registry.number().optional(),
 		entryDelaySec: require_clip_model_registry.number().optional(),
 		triggeredDurationSec: require_clip_model_registry.number().optional()
+	})).default([]),
+	/**
+	* Active alarm configuration profile id. Empty / absent on a blob older than
+	* profiles → seeded to Default on first read via {@link ensureAlarmProfiles}.
+	*/
+	activeProfileId: require_clip_model_registry.string().default(require_clip_model_registry.NC_ALARM_DEFAULT_PROFILE_ID),
+	/**
+	* Named settings blobs. Loose on purpose — each profile's settings are
+	* re-validated through {@link settingsBlobFromPersisted} so a corrupt entry
+	* drops rather than taking down the panel.
+	*/
+	profiles: require_clip_model_registry.array(require_clip_model_registry.object({
+		id: require_clip_model_registry.string(),
+		name: require_clip_model_registry.string(),
+		settings: require_clip_model_registry.record(require_clip_model_registry.string(), require_clip_model_registry.unknown())
 	})).default([])
 });
 /**
@@ -1970,6 +1985,106 @@ function modeDeviceListFromPersisted(raw) {
 	return lists;
 }
 /**
+* Rebuild a trusted {@link NcAlarmSettings} from a persisted profile blob.
+* Unknown / corrupt fields fall back to system-safe empties via the flat-key
+* readers the panel already uses for the live settings.
+*/
+function settingsBlobFromPersisted(raw) {
+	const exit = typeof raw["exitDelaySec"] === "number" ? raw["exitDelaySec"] : DEFAULT_DELAYS.exitDelaySec;
+	const entry = typeof raw["entryDelaySec"] === "number" ? raw["entryDelaySec"] : DEFAULT_DELAYS.entryDelaySec;
+	const triggered = typeof raw["triggeredDurationSec"] === "number" ? raw["triggeredDurationSec"] : DEFAULT_DELAYS.triggeredDurationSec;
+	const announceTargets = Array.isArray(raw["announceTargets"]) ? raw["announceTargets"].filter((t) => typeof t === "string") : [];
+	const lists = (key) => {
+		const v = raw[key];
+		if (!Array.isArray(v)) return [];
+		const rows = [];
+		for (const item of v) {
+			if (typeof item !== "object" || item === null) continue;
+			const rec = item;
+			if (typeof rec["mode"] !== "string" || !Array.isArray(rec["deviceIds"])) continue;
+			rows.push({
+				mode: rec["mode"],
+				deviceIds: rec["deviceIds"].filter((id) => typeof id === "number")
+			});
+		}
+		return modeDeviceListFromPersisted(rows);
+	};
+	const modeDelaysRaw = Array.isArray(raw["modeDelays"]) ? raw["modeDelays"] : [];
+	const modeDelaysLoose = [];
+	for (const item of modeDelaysRaw) {
+		if (typeof item !== "object" || item === null) continue;
+		const rec = item;
+		if (typeof rec["mode"] !== "string") continue;
+		const entry = { mode: rec["mode"] };
+		if (typeof rec["exitDelaySec"] === "number") entry.exitDelaySec = rec["exitDelaySec"];
+		if (typeof rec["entryDelaySec"] === "number") entry.entryDelaySec = rec["entryDelaySec"];
+		if (typeof rec["triggeredDurationSec"] === "number") entry.triggeredDurationSec = rec["triggeredDurationSec"];
+		modeDelaysLoose.push(entry);
+	}
+	return {
+		exitDelaySec: Math.max(0, Math.min(600, Math.trunc(exit))),
+		entryDelaySec: Math.max(0, Math.min(600, Math.trunc(entry))),
+		triggeredDurationSec: Math.max(0, Math.min(3600, Math.trunc(triggered))),
+		announceTargets,
+		nonBlocking: lists("nonBlocking"),
+		blocking: lists("blocking"),
+		secureOnArmOff: lists("secureOnArmOff"),
+		modeDelays: modeDelaysFromPersisted(modeDelaysLoose).entries
+	};
+}
+function settingsToPersisted(settings) {
+	return {
+		exitDelaySec: settings.exitDelaySec,
+		entryDelaySec: settings.entryDelaySec,
+		triggeredDurationSec: settings.triggeredDurationSec,
+		announceTargets: [...settings.announceTargets],
+		nonBlocking: settings.nonBlocking.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		})),
+		blocking: settings.blocking.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		})),
+		secureOnArmOff: settings.secureOnArmOff.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		})),
+		modeDelays: settings.modeDelays.map((e) => ({ ...e }))
+	};
+}
+function profilesStateFromPersisted(activeId, rows, current) {
+	const profiles = rows.filter((r) => r.id.length > 0 && r.name.trim().length > 0).map((r) => ({
+		id: r.id,
+		name: r.name,
+		settings: settingsBlobFromPersisted(r.settings)
+	}));
+	return require_clip_model_registry.ensureAlarmProfiles(profiles.length > 0 ? {
+		activeId,
+		profiles
+	} : null, current);
+}
+function profilesToPersisted(state) {
+	return {
+		activeProfileId: state.activeId,
+		profiles: state.profiles.map((p) => ({
+			id: p.id,
+			name: p.name,
+			settings: settingsToPersisted(p.settings)
+		}))
+	};
+}
+function profilesViewOf(state) {
+	return {
+		activeId: state.activeId,
+		items: state.profiles.map((p) => ({
+			id: p.id,
+			name: p.name,
+			isDefault: require_clip_model_registry.isDefaultAlarmProfileId(p.id)
+		}))
+	};
+}
+/**
 * The log line for a trigger the state machine ignored, per state. `trigger`
 * ignores four: disarmed, arming (the exit delay), and pending / triggered
 * (already counting down or going off — a second sensor must not restart it).
@@ -2217,7 +2332,134 @@ var NcAlarmPanelDevice = class extends require_clip_model_registry.BaseDevice {
 				changed: membershipChanged
 			}
 		});
-		return this.settings();
+		const settled = this.settings();
+		await this.persistProfilesState(require_clip_model_registry.syncActiveAlarmProfileSettings(this.readProfilesState(), settled));
+		return settled;
+	}
+	/** Named profiles + which one is active — for {@link NcAlarmConfig.profiles}. */
+	profilesView() {
+		return profilesViewOf(this.readProfilesState());
+	}
+	/**
+	* Create a named profile (system defaults, or clone). Does not activate.
+	* `newId` is assigned by the caller (usually `randomUUID`).
+	*/
+	async createProfile(input) {
+		const result = require_clip_model_registry.createAlarmProfile(this.readProfilesState(), {
+			name: input.name,
+			id: input.newId,
+			source: input.source
+		});
+		if (result.kind === "refused") throw this.profilesRefuseError(result.reason, result.detail);
+		await this.persistProfilesState(result.state);
+		this.ctx.logger.info("alarm profile created", {
+			tags: { deviceId: this.id },
+			meta: {
+				profileId: input.newId,
+				name: input.name.trim(),
+				source: input.source.kind
+			}
+		});
+		return profilesViewOf(result.state);
+	}
+	async renameProfile(id, name) {
+		const result = require_clip_model_registry.renameAlarmProfile(this.readProfilesState(), {
+			id,
+			name
+		});
+		if (result.kind === "refused") throw this.profilesRefuseError(result.reason, result.detail);
+		await this.persistProfilesState(result.state);
+		this.ctx.logger.info("alarm profile renamed", {
+			tags: { deviceId: this.id },
+			meta: {
+				profileId: id,
+				name: name.trim()
+			}
+		});
+		return profilesViewOf(result.state);
+	}
+	/**
+	* Delete a non-default profile. If it was active, Default becomes active and
+	* its settings are applied to the flat keys (arm path).
+	*/
+	async deleteProfile(id) {
+		const before = this.readProfilesState();
+		const result = require_clip_model_registry.deleteAlarmProfile(before, id);
+		if (result.kind === "refused") throw this.profilesRefuseError(result.reason, result.detail);
+		const switched = before.activeId === id;
+		await this.persistProfilesState(result.state);
+		if (switched) {
+			const def = result.state.profiles.find((p) => p.id === require_clip_model_registry.NC_ALARM_DEFAULT_PROFILE_ID);
+			if (def !== void 0) await this.replaceFlatSettings(def.settings);
+		}
+		this.ctx.logger.info("alarm profile deleted", {
+			tags: { deviceId: this.id },
+			meta: {
+				profileId: id,
+				activatedDefault: switched
+			}
+		});
+		return profilesViewOf(result.state);
+	}
+	/**
+	* Make a profile active and apply its blob onto the flat settings the arm
+	* path reads.
+	*/
+	async activateProfile(id) {
+		const result = require_clip_model_registry.activateAlarmProfile(require_clip_model_registry.syncActiveAlarmProfileSettings(this.readProfilesState(), this.settings()), id);
+		if (result.kind === "refused") throw this.profilesRefuseError(result.reason, result.detail);
+		const next = result.state.profiles.find((p) => p.id === id);
+		if (next === void 0) throw this.profilesRefuseError("not-found", id);
+		await this.persistProfilesState(result.state);
+		await this.replaceFlatSettings(next.settings);
+		this.ctx.logger.info("alarm profile activated", {
+			tags: { deviceId: this.id },
+			meta: {
+				profileId: id,
+				name: next.name
+			}
+		});
+		return profilesViewOf(result.state);
+	}
+	readProfilesState() {
+		return profilesStateFromPersisted(this.config.get("activeProfileId"), this.config.get("profiles"), this.settings());
+	}
+	async persistProfilesState(state) {
+		const persisted = profilesToPersisted(state);
+		await Promise.all([this.config.set("activeProfileId", persisted.activeProfileId), this.config.set("profiles", persisted.profiles)]);
+	}
+	/** Write a full settings blob onto the flat keys the arm path reads. */
+	async replaceFlatSettings(settings) {
+		const blob = require_clip_model_registry.cloneAlarmSettings(settings);
+		await Promise.all([
+			this.config.set("exitDelaySec", blob.exitDelaySec),
+			this.config.set("entryDelaySec", blob.entryDelaySec),
+			this.config.set("triggeredDurationSec", blob.triggeredDurationSec),
+			this.config.set("announceTargets", [...blob.announceTargets]),
+			this.config.set("nonBlocking", blob.nonBlocking.map((l) => ({
+				mode: l.mode,
+				deviceIds: [...l.deviceIds]
+			}))),
+			this.config.set("blocking", blob.blocking.map((l) => ({
+				mode: l.mode,
+				deviceIds: [...l.deviceIds]
+			}))),
+			this.config.set("secureOnArmOff", blob.secureOnArmOff.map((l) => ({
+				mode: l.mode,
+				deviceIds: [...l.deviceIds]
+			}))),
+			this.config.set("modeDelays", blob.modeDelays.map((e) => ({ ...e })))
+		]);
+	}
+	profilesRefuseError(reason, detail) {
+		switch (reason) {
+			case "name-empty": return /* @__PURE__ */ new Error("alarm profile name must not be empty");
+			case "name-taken": return /* @__PURE__ */ new Error(`an alarm profile named '${detail ?? ""}' already exists`);
+			case "cannot-delete-default": return /* @__PURE__ */ new Error("the Default alarm profile cannot be deleted");
+			case "clone-source-missing": return /* @__PURE__ */ new Error(`alarm profile '${detail ?? ""}' was not found to clone`);
+			case "not-found": return /* @__PURE__ */ new Error(`alarm profile '${detail ?? ""}' was not found`);
+			default: return /* @__PURE__ */ new Error(`alarm profile operation refused (${reason})`);
+		}
 	}
 	/**
 	* Refuse a mode this panel does not offer — logged by reason, then thrown. A membership edit
@@ -2950,6 +3192,11 @@ function ncAlarmPanelPort(panel) {
 		deviceId: panel.id,
 		settings: () => panel.settings(),
 		applySettings: (patch) => panel.applySettings(patch),
+		profilesView: () => panel.profilesView(),
+		createProfile: (input) => panel.createProfile(input),
+		renameProfile: (id, name) => panel.renameProfile(id, name),
+		deleteProfile: (id) => panel.deleteProfile(id),
+		activateProfile: (id) => panel.activateProfile(id),
 		availableModes: () => NC_ALARM_MODES,
 		noteRuleTrigger: (source) => panel.noteRuleTrigger(source),
 		excludedDevices: () => panel.excludedDevices(),
@@ -4821,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) {
@@ -4829,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);
@@ -4858,7 +5137,7 @@ function ncSubjectText(texts, input) {
 		key: subjectLabelKey(input.labelKind),
 		vars: {
 			classNoun,
-			label: input.label
+			label: ncSubjectLabelText(texts, input.label, input.labelKind)
 		}
 	});
 }
@@ -8428,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.
 *
@@ -8465,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 } : {},
@@ -8486,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
@@ -8548,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 {
@@ -10837,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 } : {}
 	});
 }
 /**
@@ -12728,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) {
@@ -12744,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,
@@ -20086,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);
@@ -20199,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 {
-		...actions,
-		onTrigger: nextSequences,
-		...buttons !== void 0 ? { buttons: buttons.filter((button) => !removedNames.has(button.sequence)) } : {}
+		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 {
+		...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) {
@@ -24485,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, {
@@ -28626,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;
@@ -28638,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 = [];
@@ -28651,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);
@@ -28693,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",
@@ -28700,6 +29400,7 @@ var NcRuleActionRunner = class {
 				}
 			});
 			return {
+				id: sequence.id,
 				name: sequence.name,
 				ran: true,
 				stepsRun,
@@ -28711,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
@@ -28736,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
 /**
@@ -30582,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
 	};
@@ -36694,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. */
@@ -36932,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,
@@ -36942,7 +37659,7 @@ var NotificationCenter = class {
 						id,
 						ruleId: input.ruleId,
 						ruleName: input.ruleName,
-						sequence,
+						sequenceId,
 						deviceId: input.deviceId,
 						actionId,
 						targetId: input.targetId,
@@ -36954,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)();
@@ -37194,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",
@@ -37493,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`);
@@ -37621,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")
@@ -37887,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);
@@ -37948,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()),
@@ -39247,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)] }),
@@ -39304,7 +40052,18 @@ var NotificationCenter = class {
 			},
 			getAlarmConfig: async () => this.alarmConfig(),
 			getAlarmSensors: async (input) => this.alarmSensors(input),
-			setAlarmConfig: async ({ patch }) => this.setAlarmConfig(patch)
+			setAlarmConfig: async ({ patch }) => this.setAlarmConfig(patch),
+			createAlarmProfile: async ({ name, cloneFromId }) => this.mutateAlarmProfile((panel) => panel.createProfile({
+				name,
+				newId: (0, node_crypto.randomUUID)(),
+				source: cloneFromId === void 0 ? { kind: "defaults" } : {
+					kind: "clone",
+					fromId: cloneFromId
+				}
+			})),
+			renameAlarmProfile: async ({ id, name }) => this.mutateAlarmProfile((panel) => panel.renameProfile(id, name)),
+			deleteAlarmProfile: async ({ id }) => this.mutateAlarmProfile((panel) => panel.deleteProfile(id)),
+			activateAlarmProfile: async ({ id }) => this.mutateAlarmProfile((panel) => panel.activateProfile(id))
 		};
 	}
 	/**
@@ -39597,6 +40356,13 @@ var NotificationCenter = class {
 		});
 		return this.alarmConfig();
 	}
+	/** Profile CRUD — each mutation returns the whole config (settings applied). */
+	async mutateAlarmProfile(run) {
+		const panel = this.alarmPanel;
+		if (panel === null) throw new Error("this node has no alarm panel");
+		await run(panel);
+		return this.alarmConfig();
+	}
 	/**
 	* The panel as it is NOW — see `alarm-live.ts`.
 	*
@@ -39693,6 +40459,7 @@ var NotificationCenter = class {
 		return {
 			deviceId: panel.deviceId,
 			settings: panel.settings(),
+			profiles: panel.profilesView(),
 			live: await this.alarmLive(panel),
 			coverage: this.coverageFor(panel).map((c) => ({
 				...c,
@@ -40725,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: {
@@ -40852,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)
 		});
 	}
@@ -41769,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 },