@camstack/addon-post-analysis 1.2.322 → 1.2.324

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as NC_ALARM_DELAY_MAX_SEC, $n as isEventOwnerType, $r as defineCustomActions, $t as SCENE_DEFAULT_QUIET_SECONDS, A as EMBEDDING_REQUIREMENTS_FAILED, An as consumableLowPercentOf, Ar as servedTemplateVars, At as NcRuleUpdateInputSchema, B as ListTrackRelationsInputSchema, Br as templateVarsFor, Bt as NcTemplateVarDescriptorSchema, C as DEFAULT_EVENT_COLOR, Cn as applyNonBlockingEdit, Cr as ruleBelongsToAlarm$1, Ct as NcAlarmSettingsPatchSchema, D as DeclaredDevices, Dn as audioModeOf, Dr as sceneMonitorCapability, Dt as NcRulePatchSchema, E as DETECTION_PIPELINE_CAP_NAME, En as audioMetricsCapability, Er as ruleKindOf, Et as NcRuleInputSchema, F as EXPORT_DENSE_MAX_RANGES, Fn as describeSystemEventDeliveryProblem, Fr as systemEventFamilyProblems, Ft as NcStateSummarySectionIdSchema, G as MAX_BIRTH_LATENCY_PROXY_MS, Gn as faceGalleryCapability, Gr as evaluateSensorEdge, Gt as RECORDING_SOURCE_CAMSTACK_ADDON, H as LockStateSchema, Hn as encodeVectorBase64, Hr as zoneAnalyticsCapability, Ht as OpsLogEntrySchema, I as FIRST_LEVEL_MACRO_CLASSES, In as describeSystemEventFamilyProblem, Ir as systemEventFilterApplies, It as NcSystemEventKindSchema, J as MOTION_CLOSE_AFTER_MS, Jn as gifFromMp4Args, Jr as errMsg, Jt as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, K as MAX_TRACK_PURITIES, Kn as failureContributionCapability, Kr as isSourceCap, Kt as RebuildObjectEmbeddingsRefusalSchema, L as FULL_IMAGE_BBOX, Lr as systemEventSummaryScheduleOf, Lt as NcTaxonomySchema, M as EVENT_DENSITY_BATCH_MAX, Mn as createAlarmProfile, Mr as subKindsOf, Mt as NcSnoozeInputSchema, N as EVENT_KIND_BY_CAP, Nn as deleteAlarmProfile, Nr as syncActiveAlarmProfileSettings, Nt as NcSnoozeSchema, O as DetectionSourceSchema, On as buildEventKindDescriptor, Or as secureActuationFor, Ot as NcRuleSchema, P as EVENT_OWNER_TYPES, Pn as deriveRecordingMode, Pr as systemEventDeliveryProblems, Pt as NcSnoozeSuppressedSchema, Q as NC_ALARM_DELAY_FIELDS, Qn as isDetectionMacroClass, Qr as customAction, Qt as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, R as FailureCounters, Rr as systemEventSummarySplitOf, Rt as NcTemplatePreviewInputSchema, S as CoverStateSchema, Si as EventCategory, Sn as applyModeDelaysEdits, St as NcAlarmSensorsSchema, T as DETECTION_MACRO_CLASSES, Tn as assertTimelapseCadences, Tr as ruleGroupingApplies, Tt as NcConditionsSchema, U as MAX_ARCHIVED_DEBUG_NOTES, Un as ensureAlarmProfiles, Ur as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, V as ListTrackRelationsResultSchema, Vr as vectorDimFromBase64, Vt as OPS_LOG_DEFAULT_LIMIT, W as MAX_BIRTH_DECISION_RECORDS, Wn as evictionPolicyOfLocation, Wr as canonicalHash, Wt as RECORDING_EXPORT_MAX_READ_BYTES, X as MotionTriggeredBySchema, Xn as isAudioClassName, Xr as CamProfileSchema, Xt as SCENE_DEFAULT_ANCHOR_THRESHOLD, Y as MediaFileKindEnum, Yn as isAlarmControllableCap, Yr as BaseAddon, Yt as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, Z as NC_ALARM_DEFAULT_PROFILE_ID, Zn as isDefaultAlarmProfileId, Zr as createEvent, Zt as SCENE_DEFAULT_CHECK_INTERVAL_SEC, _ as BaseDevice, _i as string, _n as activateAlarmProfile, _r as readTimelapseGeneratedAt, _t as NC_TANK_SYSTEM_EVENT_KINDS, a as CLIP_EMBEDDING_STEP_ID, ai as ZodObject, an as SetTrackPurityResultSchema, ar as isSystemEventSummaryRule, at as NC_CLIP_PRE_ROLL_DEFAULT_SEC, b as ClearTrackRelationInputSchema, bi as union, bn as alarmPanelCapability, br as resolveLocationMode, bt as NcAlarmConfigSchema, c as resolveClusterModelPin, ci as boolean, cn as TRACK_RELATIONS_DEFAULT_LIMIT, cr as mayWriteToLocation, ct as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, d as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, di as looseObject, dn as TimelapseRuleSchema, dr as occupancyScope, dt as NC_GROUPING_DEFAULT_SEC, ei as hydrateSchema, en as SCENE_DEFAULT_UNCOVERED_POLICY, er as isKnownTemplateVar, et as NC_ALARM_SYSTEM_EVENT_KINDS, f as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, fi as number, fn as TrackPuritySchema, ft as NC_GROUPING_MAX_SEC, g as BIRTH_DECISION_DEFAULT_LIMIT, gi as strictObject, gn as TrackSourceSchema, gr as readMotionTriggeredBy, gt as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, h as ArchivedDebugNoteSchema, hi as record, hn as TrackSideSchema, hr as readDeviceStateFrom, ht as NC_SNOOZE_MAX_MINUTES, ii as sleep$1, in as SetTrackPurityInputSchema, ir as isSystemDelivery, it as NC_CLIP_POST_ROLL_DEFAULT_SEC, j as EMBEDDING_REQUIREMENTS_UNAVAILABLE, jn as cosineSimilarity$1, jr as storageOccupancyCapability, jt as NcScheduleSchema, k as EMBEDDING_MODEL_FAILED, kn as cloneAlarmSettings, kr as sensorRaisedOf, kt as NcRuleTargetSchema, l as APPEARANCE_BIN_COUNT, li as discriminatedUnion, ln as TimelapseRuleInputSchema, lr as memoizePinnedFfmpeg, lt as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, m as AlarmArmModeSchema, mi as partialRecord, mn as TrackRelationSchema, mr as plateGalleryCapability, mt as NC_SENSOR_TRANSITION_KINDS, ni as nodePin, nn as SCENE_RESET_RECAPTURES, nr as isRetiredClearKey, nt as NC_AUDIO_CONFIRM_HITS_DEFAULT, o as FACE_EMBEDDING_STEP_ID, oi as _enum, on as SetTrackRelationInputSchema, or as isVectorIndexDimConflict, ot as NC_CLIP_RETENTION_MAX_SEC, p as AUDIO_MACRO_LABELS, pi as object, pn as TrackRelationKindSchema, pr as pipelineAnalyticsCapability, pt as NC_GROUPING_MIN_SEC, q as MAX_TRACK_RELATIONS, qn as gifDeriveSpeed, qr as DeviceType, qt as RetrainStatusSchema, rn as SceneMonitorSchema, rr as isScheduleActive, rt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, s as readClusterModelPinStrict, si as array, sn as TIMELAPSE_DENSE_FLOOR_SEC, sr as kebabToCamel, st as NC_CONDITION_CATALOG, t as BUILTIN_CLIP_MODELS, ti as isDeviceScopedCap, tn as SCENE_DIVERGED, tr as isMediaOwnerType, tt as NC_ALARM_TRIGGERED_MAX_SEC, u as APPEARANCE_BLOCKS, ui as literal, un as TimelapseRulePatchSchema, ur as notificationRulesCapability, ut as NC_DEFAULT_SNOOZE_MINUTES, v as BirthDecisionRecordSchema, vi as templateLiteral, vn as addonWidgetsSourceCapability, vr as renameAlarmProfile, vt as NC_TAXONOMY, w as DEFAULT_TIMELAPSE_PREVIEW_TEXT, wn as applySecureOnArmEdit, wr as ruleDeviceCompatCapQueries, wt as NcConditionDescriptorSchema, x as ClearTrackRelationResultSchema, xi as unknown, xn as applyBlockingEdit, xr as resolveModeDelays, xt as NcAlarmSensorsInputSchema, y as COCO_TO_MACRO, yi as tuple, yn as alarmDeviceSecureOnArm, yr as resolveClipSearchMinScore, yt as NC_TEMPLATE_VARS, z as LabelAttributionSchema, zn as embeddingRefusalOf, zr as templateCarriesSummary, zt as NcTemplatePreviewSchema } from "../clip-model-registry-CwK2SLQD.mjs";
+import { $ as NC_ALARM_DELAY_MAX_SEC, $n as gifFromMp4Args, $r as DeviceType, $t as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, A as EMBEDDING_REQUIREMENTS_FAILED, An as audioMetricsCapability, Ar as ruleDeviceCompatCapQueries, At as NcRulePatchSchema, B as ListTrackRelationsInputSchema, Bn as describeSystemEventFamilyProblem, Br as systemEventDeliveryProblems, Bt as NcSystemEventKindSchema, C as DEFAULT_EVENT_COLOR, Ci as string, Cn as alarmDeviceSecureOnArm, Cr as readTimelapseGeneratedAt, Ct as NcAlarmSettingsPatchSchema, D as DeclaredDevices, Di as unknown, Dn as applyNonBlockingEdit, Dr as resolveModeDelays, Dt as NcRuleActionSchema, E as DETECTION_PIPELINE_CAP_NAME, Ei as union, En as applyModeDelaysEdits, Er as resolveLocationMode, Et as NcLegacyRuleActionSequenceSchema, F as EXPORT_DENSE_MAX_RANGES, Fn as cosineSimilarity$1, Fr as sensorRaisedOf, Ft as NcSharedSequenceSchema, G as MAX_BIRTH_LATENCY_PROXY_MS, Gr as templateCarriesSummary, Gt as OPS_LOG_DEFAULT_LIMIT, H as LockStateSchema, Hr as systemEventFilterApplies, Ht as NcTemplatePreviewInputSchema, I as FIRST_LEVEL_MACRO_CLASSES, In as createAlarmProfile, Ir as servedTemplateVars, It as NcSnoozeInputSchema, J as MOTION_CLOSE_AFTER_MS, Jn as eventKindLabel, Jr as zoneAnalyticsCapability, Jt as RECORDING_EXPORT_MAX_READ_BYTES, K as MAX_TRACK_PURITIES, Kn as encodeVectorBase64, Kr as templateVarsFor, Kt as OpsLogEntrySchema, L as FULL_IMAGE_BBOX, Ln as deleteAlarmProfile, Lr as storageOccupancyCapability, Lt as NcSnoozeSchema, M as EVENT_DENSITY_BATCH_MAX, Mn as buildEventKindDescriptor, Mr as ruleKindOf, Mt as NcRuleTargetSchema, N as EVENT_KIND_BY_CAP, Nn as cloneAlarmSettings, Nr as sceneMonitorCapability, Nt as NcRuleUpdateInputSchema, O as DetectionSourceSchema, Oi as EventCategory, On as applySecureOnArmEdit, Ot as NcRuleActionsSchema, P as EVENT_OWNER_TYPES, Pn as consumableLowPercentOf, Pr as secureActuationFor, Pt as NcScheduleSchema, Q as NC_ALARM_DELAY_FIELDS, Qn as gifDeriveSpeed, Qr as isSourceCap, Qt as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, R as FailureCounters, Rn as deriveRecordingMode, Rr as subKindsOf, Rt as NcSnoozeSuppressedSchema, S as CoverStateSchema, Si as strictObject, Sn as addonWidgetsSourceCapability, Sr as readMotionTriggeredBy, St as NcAlarmSensorsSchema, T as DETECTION_MACRO_CLASSES, Ti as tuple, Tn as applyBlockingEdit, Tr as resolveClipSearchMinScore, Tt as NcConditionsSchema, U as MAX_ARCHIVED_DEBUG_NOTES, Un as embeddingRefusalOf, Ur as systemEventSummaryScheduleOf, Ut as NcTemplatePreviewSchema, V as ListTrackRelationsResultSchema, Vr as systemEventFamilyProblems, Vt as NcTaxonomySchema, W as MAX_BIRTH_DECISION_RECORDS, Wr as systemEventSummarySplitOf, Wt as NcTemplateVarDescriptorSchema, X as MotionTriggeredBySchema, Xn as faceGalleryCapability, Xr as canonicalHash, Xt as RebuildObjectEmbeddingsRefusalSchema, Y as MediaFileKindEnum, Yn as evictionPolicyOfLocation, Yr as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, Yt as RECORDING_SOURCE_CAMSTACK_ADDON, Z as NC_ALARM_DEFAULT_PROFILE_ID, Zn as failureContributionCapability, Zr as evaluateSensorEdge, Zt as RetrainStatusSchema, _ as BaseDevice, _i as looseObject, _n as TrackRelationKindSchema, _r as occupancyScope, _t as NC_TANK_SYSTEM_EVENT_KINDS, a as CLIP_EMBEDDING_STEP_ID, ai as defineCustomActions, an as SCENE_DIVERGED, ar as isEventOwnerType, at as NC_CLIP_PRE_ROLL_DEFAULT_SEC, b as ClearTrackRelationInputSchema, bi as partialRecord, bn as TrackSourceSchema, br as plateGalleryCapability, bt as NcAlarmConfigSchema, c as resolveClusterModelPin, ci as nodePin, cn as SetTrackPurityInputSchema, cr as isRetiredClearKey, ct as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, d as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, di as ZodObject, dn as TIMELAPSE_DENSE_FLOOR_SEC, dr as isSystemEventSummaryRule, dt as NC_GROUPING_DEFAULT_SEC, ei as errMsg, en as SCENE_DEFAULT_ANCHOR_THRESHOLD, er as isAlarmControllableCap, et as NC_ALARM_SYSTEM_EVENT_KINDS, f as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, fi as _enum, fn as TRACK_RELATIONS_DEFAULT_LIMIT, fr as isVectorIndexDimConflict, ft as NC_GROUPING_MAX_SEC, g as BIRTH_DECISION_DEFAULT_LIMIT, gi as literal, gn as TrackPuritySchema, gr as notificationRulesCapability, gt as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, h as ArchivedDebugNoteSchema, hi as discriminatedUnion, hn as TimelapseRuleSchema, hr as memoizePinnedFfmpeg, ht as NC_SNOOZE_MAX_MINUTES, ii as customAction, in as SCENE_DEFAULT_UNCOVERED_POLICY, ir as isEventKindLabelKey, it as NC_CLIP_POST_ROLL_DEFAULT_SEC, j as EMBEDDING_REQUIREMENTS_UNAVAILABLE, jn as audioModeOf, jr as ruleGroupingApplies, jt as NcRuleSchema, k as EMBEDDING_MODEL_FAILED, kn as assertTimelapseCadences, kr as ruleBelongsToAlarm$1, kt as NcRuleInputSchema, l as APPEARANCE_BIN_COUNT, ln as SetTrackPurityResultSchema, lr as isScheduleActive, lt as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, m as AlarmArmModeSchema, mi as boolean, mn as TimelapseRulePatchSchema, mr as mayWriteToLocation, mt as NC_SENSOR_TRANSITION_KINDS, ni as CamProfileSchema, nn as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, nr as isDefaultAlarmProfileId, nt as NC_AUDIO_CONFIRM_HITS_DEFAULT, o as FACE_EMBEDDING_STEP_ID, oi as hydrateSchema, on as SCENE_RESET_RECAPTURES, or as isKnownTemplateVar, ot as NC_CLIP_RETENTION_MAX_SEC, p as AUDIO_MACRO_LABELS, pi as array, pn as TimelapseRuleInputSchema, pr as kebabToCamel, pt as NC_GROUPING_MIN_SEC, q as MAX_TRACK_RELATIONS, qn as ensureAlarmProfiles, qr as vectorDimFromBase64, ri as createEvent, rn as SCENE_DEFAULT_QUIET_SECONDS, rr as isDetectionMacroClass, rt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, s as readClusterModelPinStrict, si as isDeviceScopedCap, sn as SceneMonitorSchema, sr as isMediaOwnerType, st as NC_CONDITION_CATALOG, t as BUILTIN_CLIP_MODELS, ti as BaseAddon, tn as SCENE_DEFAULT_CHECK_INTERVAL_SEC, tr as isAudioClassName, tt as NC_ALARM_TRIGGERED_MAX_SEC, u as APPEARANCE_BLOCKS, ui as sleep$1, un as SetTrackRelationInputSchema, ur as isSystemDelivery, ut as NC_DEFAULT_SNOOZE_MINUTES, v as BirthDecisionRecordSchema, vi as number, vn as TrackRelationSchema, vt as NC_TAXONOMY, w as DEFAULT_TIMELAPSE_PREVIEW_TEXT, wi as templateLiteral, wn as alarmPanelCapability, wr as renameAlarmProfile, wt as NcConditionDescriptorSchema, x as ClearTrackRelationResultSchema, xi as record, xn as activateAlarmProfile, xr as readDeviceStateFrom, xt as NcAlarmSensorsInputSchema, y as COCO_TO_MACRO, yi as object, yn as TrackSideSchema, yr as pipelineAnalyticsCapability, yt as NC_TEMPLATE_VARS, z as LabelAttributionSchema, zn as describeSystemEventDeliveryProblem, zr as syncActiveAlarmProfileSettings, zt as NcStateSummarySectionIdSchema } from "../clip-model-registry-CshjlVTF.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs$1 from "node:fs";
 import { createWriteStream, promises } from "node:fs";
@@ -477,26 +477,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
 	};
 }
 /**
@@ -938,7 +949,7 @@ function grantMeta(grant) {
 			...common,
 			ruleId: grant.ruleId,
 			rule: grant.ruleName,
-			sequence: grant.sequence
+			sequenceId: grant.sequenceId
 		};
 		case "snooze": return {
 			...common,
@@ -1091,10 +1102,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";
@@ -1207,6 +1219,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),
@@ -1214,10 +1231,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 (isAlarmControllableCap(read.cap) && openControllable === null) openControllable = read;
+			if (openAny === null) openAny = read;
+			continue;
+		}
+		if (read.cap === "contact" && secureContact === null) secureContact = read;
+		if (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
@@ -2743,12 +2771,6 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 				error: String(err)
 			};
 		}
-		const toSecure = openings.open.filter((d) => 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,
@@ -2756,6 +2778,14 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 			blocking: this.blockingFor(mode),
 			...acknowledged !== void 0 ? { acknowledged } : {}
 		});
+		if (verdict.kind === "arm") {
+			const toSecure = openings.open.filter((d) => alarmDeviceSecureOnArm({
+				controllable: d.controllable,
+				deviceId: d.deviceId,
+				secureOnArmOff: this.secureOnArmOffFor(mode)
+			}));
+			if (toSecure.length > 0) this.armGuard?.secureOnArm(toSecure);
+		}
 		return {
 			kind: "read",
 			openings,
@@ -2964,6 +2994,7 @@ var NcAlarmPanelDevice = class extends 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
@@ -5060,6 +5091,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) {
@@ -5068,24 +5120,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 (isEventKindLabelKey(normalised)) return 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 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);
@@ -5097,7 +5160,7 @@ function ncSubjectText(texts, input) {
 		key: subjectLabelKey(input.labelKind),
 		vars: {
 			classNoun,
-			label: input.label
+			label: ncSubjectLabelText(texts, input.label, input.labelKind)
 		}
 	});
 }
@@ -8667,31 +8730,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(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.
 *
@@ -8704,18 +8784,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 } : {},
@@ -8725,18 +8805,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
@@ -8787,7 +8866,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 {
@@ -11076,10 +11155,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 ruleBelongsToAlarm$1({
 		conditions: rule.conditions,
-		...rule.actions?.onTrigger !== void 0 ? { onTrigger: rule.actions.onTrigger } : {}
+		...rule.actions !== void 0 ? { actions: rule.actions } : {},
+		...sequenceActionsOf !== void 0 ? { sequenceActionsOf } : {}
 	});
 }
 /**
@@ -12854,7 +12934,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,
@@ -12967,7 +13047,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) {
@@ -12983,11 +13063,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,
@@ -14508,7 +14588,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}}",
@@ -14518,7 +14598,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.",
@@ -14835,7 +14916,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}}",
@@ -14845,7 +14926,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.",
@@ -20310,6 +20392,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 = 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 = 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 = 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 = 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 = 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: 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);
@@ -20423,58 +20849,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) {
@@ -24709,6 +25126,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 ? "" : eventKindLabel(wire, texts.language);
+		})(),
 		label: detection?.label ?? subject.label ?? "",
 		zones: zoneLabels.join(", "),
 		subject: detection?.className !== void 0 ? ncSubjectText(texts, {
@@ -28850,9 +29271,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;
@@ -28862,11 +29306,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 = [];
@@ -28875,38 +29357,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);
@@ -28917,6 +29402,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",
@@ -28924,6 +29410,7 @@ var NcRuleActionRunner = class {
 				}
 			});
 			return {
+				id: sequence.id,
 				name: sequence.name,
 				ran: true,
 				stepsRun,
@@ -28935,11 +29422,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
@@ -28960,6 +29449,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
 /**
@@ -30806,7 +31306,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
 	};
@@ -36607,13 +37107,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 } : {},
@@ -36918,6 +37421,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. */
@@ -37156,7 +37661,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 = randomUUID();
 				drafts.push({
 					id,
@@ -37166,7 +37672,7 @@ var NotificationCenter = class {
 						id,
 						ruleId: input.ruleId,
 						ruleName: input.ruleName,
-						sequence,
+						sequenceId,
 						deviceId: input.deviceId,
 						actionId,
 						targetId: input.targetId,
@@ -37178,6 +37684,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 = randomUUID();
@@ -37418,7 +37925,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",
@@ -37717,16 +38224,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`);
@@ -37845,6 +38349,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")
@@ -38111,6 +38620,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);
@@ -38172,6 +38682,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()),
@@ -39471,7 +39983,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)] }),
@@ -40205,10 +40742,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: {
@@ -40217,8 +40755,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: [],
@@ -40968,7 +41507,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: {
@@ -41095,20 +41634,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)
 		});
 	}
@@ -41238,7 +41842,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 }))
@@ -42012,7 +42619,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 },