@camstack/addon-post-analysis 1.2.25 → 1.2.27

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Bi1fiPc0.js");
+const require_dist = require("../dist-Be0WkqVJ.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
@@ -347,6 +347,323 @@ function mimeFromExtension(file) {
 	return "application/octet-stream";
 }
 //#endregion
+//#region src/notification-center/alarm/alarm-state-machine.ts
+var DISARMED = {
+	target: "disarmed",
+	fired: false,
+	changedAt: 0
+};
+function armedState(mode) {
+	return `armed_${mode}`;
+}
+/**
+* The state to report at `now`.
+*
+* A comparison, not a job: nothing has to run for the exit delay to end. A
+* caller that stops ticking stops NOTIFYING about the change, but the panel's
+* answer is still correct the moment anyone asks.
+*/
+function stateAt(m, now) {
+	if (m.fired) return "triggered";
+	if (m.triggerAt !== void 0) return now >= m.triggerAt ? "triggered" : "pending";
+	if (m.armedAt !== void 0) return now >= m.armedAt ? m.target : "arming";
+	return m.target;
+}
+/** Whether the panel is armed enough for a trigger to matter. */
+function isArmed(m, now) {
+	const s = stateAt(m, now);
+	return s.startsWith("armed_") || s === "pending" || s === "triggered";
+}
+/**
+* Arm into `mode`. An exit delay of 0 arms immediately — some modes (`home`)
+* legitimately have none, because nobody is leaving.
+*/
+function arm(mode, delays, now) {
+	const target = armedState(mode);
+	if (delays.exitDelaySec <= 0) return {
+		target,
+		fired: false,
+		changedAt: now
+	};
+	return {
+		target,
+		armedAt: now + delays.exitDelaySec * 1e3,
+		fired: false,
+		changedAt: now
+	};
+}
+/**
+* Disarm, from ANY state — including mid-arming and mid-pending.
+*
+* Cancelling a pending entry is the single most-used transition in a real
+* alarm (walking in and typing the code), and it must CANCEL rather than
+* queue: a disarm that let the pending timer still fire would set the alarm off
+* behind the operator.
+*/
+function disarm(now) {
+	return {
+		...DISARMED,
+		changedAt: now
+	};
+}
+/**
+* Something matched while armed.
+*
+* Starts the entry delay, or fires at once when there is none. A trigger while
+* DISARMED is ignored — the panel is the gate, and a rule that fires while
+* disarmed is a notification, not a break-in.
+*
+* A second trigger during `pending` does NOT restart the countdown: an
+* intruder walking past two sensors would otherwise postpone the alarm.
+*/
+function trigger(m, delays, now) {
+	if (!isArmed(m, now)) return m;
+	if (m.fired || m.triggerAt !== void 0) return m;
+	if (delays.entryDelaySec <= 0) return {
+		...m,
+		fired: true,
+		changedAt: now
+	};
+	return {
+		...m,
+		triggerAt: now + delays.entryDelaySec * 1e3,
+		changedAt: now
+	};
+}
+/**
+* Settle the machine so a stored value never depends on when it is read.
+*
+* `stateAt` already answers correctly from an unsettled value; this is what a
+* caller persists after a tick, so `fired` becomes true in the record rather
+* than only in the reading of it.
+*/
+function settle(m, now) {
+	if (m.triggerAt !== void 0 && now >= m.triggerAt) return {
+		target: m.target,
+		fired: true,
+		changedAt: m.triggerAt
+	};
+	if (m.armedAt !== void 0 && now >= m.armedAt) return {
+		target: m.target,
+		fired: m.fired,
+		changedAt: m.armedAt
+	};
+	return m;
+}
+//#endregion
+//#region src/notification-center/alarm/alarm-panel-device.ts
+/**
+* The Notification Center's own alarm panel.
+*
+* A REAL device, not a special case: it carries `alarm-panel` natively, so the
+* `deviceState` rule gate reads it through `loadRuntimeState` exactly like a
+* switch or a contact, and both exporters see it through their ordinary
+* device mapping. Nothing had to learn about alarms.
+*
+* It needed no new addon and no base-class change either — the wiring already
+* existed and was simply never used this way: `ctx.kernel.devices.create()` is
+* on EVERY addon's kernel services, not only a `BaseDeviceProvider`'s, and
+* `integrations.create` gives it a fixed home to hang from.
+*
+* The lifecycle lives in {@link ../alarm-state-machine.js} as pure functions.
+* This class is the thin part: persist the machine, publish the derived state,
+* and re-publish when a delay elapses.
+*/
+/** Every arm mode a camstack-owned panel offers. */
+var MODES = [
+	"home",
+	"away",
+	"night"
+];
+/**
+* Defaults an operator can change per panel. `home` has no exit delay on
+* purpose — nobody is leaving — but the shared value is applied to every mode
+* until per-mode delays are asked for.
+*/
+var DEFAULT_DELAYS = {
+	exitDelaySec: 30,
+	entryDelaySec: 20
+};
+/**
+* How often the panel re-publishes while a delay is running.
+*
+* The state is computed from an INSTANT, so this tick only decides how quickly
+* the change is ANNOUNCED — a missed tick can never leave the panel stuck in
+* `arming`. One second is what makes a countdown look like a countdown.
+*/
+var TICK_MS = 1e3;
+/**
+* The panel's persisted config: the delays an operator tunes, and the machine
+* itself. The machine is persisted because the alternative is an alarm that
+* disarms itself on every deploy.
+*/
+var ncAlarmPanelSchema = require_dist.object({
+	exitDelaySec: require_dist.number().int().min(0).max(600).default(DEFAULT_DELAYS.exitDelaySec),
+	entryDelaySec: require_dist.number().int().min(0).max(600).default(DEFAULT_DELAYS.entryDelaySec),
+	machine: require_dist.record(require_dist.string(), require_dist.unknown()).optional()
+});
+var NcAlarmPanelDevice = class extends require_dist.BaseDevice {
+	features = [];
+	machine = DISARMED;
+	delays = DEFAULT_DELAYS;
+	ticker = null;
+	constructor(ctx) {
+		super(ctx, ncAlarmPanelSchema, { type: ctx.deviceMeta.type });
+		this.delays = {
+			exitDelaySec: this.config.get("exitDelaySec"),
+			entryDelaySec: this.config.get("entryDelaySec")
+		};
+		this.restore();
+		this.registerAlarmCap();
+		this.publish();
+	}
+	/** Fire a trigger at the panel. Called by the notification center when a rule
+	*  that arms the alarm matches. Ignored unless the panel is armed. */
+	onRuleTriggered(now = Date.now()) {
+		const next = trigger(this.machine, this.delays, now);
+		if (next === this.machine) return;
+		this.machine = next;
+		this.publish(now);
+	}
+	/** Current lifecycle word — what the `deviceState` gate compares against. */
+	currentState(now = Date.now()) {
+		return stateAt(this.machine, now);
+	}
+	/** Stop the countdown when the device goes away. The state itself is
+	*  persisted, so nothing is lost — only the announcements stop. */
+	stopCountdown() {
+		this.stopTicking();
+	}
+	registerAlarmCap() {
+		this.ctx.registerNativeCap(require_dist.alarmPanelCapability, {
+			getStatus: async () => this.status(),
+			arm: async ({ mode }) => {
+				this.machine = arm(mode, this.delays, Date.now());
+				this.publish();
+			},
+			disarm: async () => {
+				this.machine = disarm(Date.now());
+				this.publish();
+			},
+			trigger: async () => {
+				this.machine = {
+					...this.machine,
+					fired: true,
+					changedAt: Date.now()
+				};
+				this.publish();
+			}
+		});
+	}
+	status(now = Date.now()) {
+		return {
+			state: stateAt(this.machine, now),
+			availableModes: [...MODES],
+			requiresCode: false,
+			lastChangedAt: this.machine.changedAt
+		};
+	}
+	/**
+	* Write the slice and keep ticking while a delay is running.
+	*
+	* `settle` is applied first so the PERSISTED machine does not depend on when
+	* it is next read — a hub restarted mid-`pending` comes back already fired,
+	* rather than fired only once somebody looks.
+	*/
+	publish(now = Date.now()) {
+		this.machine = settle(this.machine, now);
+		this.runtimeState.setCapState("alarm-panel", this.status(now));
+		this.persist();
+		if (this.machine.armedAt !== void 0 || this.machine.triggerAt !== void 0) this.startTicking();
+		else this.stopTicking();
+	}
+	startTicking() {
+		if (this.ticker !== null) return;
+		this.ticker = setInterval(() => this.publish(), TICK_MS);
+		this.ticker.unref?.();
+	}
+	stopTicking() {
+		if (this.ticker === null) return;
+		clearInterval(this.ticker);
+		this.ticker = null;
+	}
+	/** The machine rides the device's own config blob — it is small, and it must
+	*  survive a restart or the alarm disarms itself on every deploy. */
+	persist() {
+		this.config.set("machine", { ...this.machine });
+	}
+	restore() {
+		const raw = this.config.get("machine");
+		if (raw === null || typeof raw !== "object") return;
+		const m = raw;
+		if (typeof m.target !== "string" || typeof m.changedAt !== "number") return;
+		this.machine = {
+			target: m.target,
+			...typeof m.armedAt === "number" ? { armedAt: m.armedAt } : {},
+			...typeof m.triggerAt === "number" ? { triggerAt: m.triggerAt } : {},
+			fired: m.fired === true,
+			changedAt: m.changedAt
+		};
+	}
+};
+//#endregion
+//#region src/notification-center/alarm/ensure-alarm-panel.ts
+/**
+* Bring the Notification Center's alarm panel into existence, once.
+*
+* Two idempotent steps — a fixed integration to hang from, and one device under
+* it. Both are `get-or-create`, because this runs on every boot and an operator
+* must never end up with a second panel after a restart.
+*
+* The integration is FIXED: it exists because the addon says so, not because an
+* operator added it, and there is no add/delete flow for it. That is the whole
+* meaning of "a system integration" here — the same `integrations` row every
+* provider uses, created by its owner instead of by a form.
+*/
+/** Stable id of the one panel. Never derived from a name — a rename must not
+*  mint a second device. */
+var NC_ALARM_STABLE_ID = "nc-alarm-panel";
+var NC_ALARM_DEVICE_NAME = "Alarm";
+/**
+* Idempotent. Returns the ids either way so the caller can hold onto the panel.
+*
+* Failures are the CALLER's to handle: a hub whose alarm could not be created
+* should say so loudly and keep notifying, not fail to boot — but that decision
+* does not belong in here.
+*/
+async function ensureAlarmPanel(deps) {
+	const integration = await deps.getIntegration(deps.addonId) ?? await deps.createIntegration({
+		addonId: deps.addonId,
+		name: deps.integrationName
+	});
+	const existingDevice = await deps.findDeviceByStableId(NC_ALARM_STABLE_ID);
+	if (existingDevice !== null) return {
+		integrationId: integration.id,
+		deviceId: existingDevice.id,
+		created: false
+	};
+	const device = await deps.createDevice({
+		stableId: NC_ALARM_STABLE_ID,
+		integrationId: integration.id,
+		name: NC_ALARM_DEVICE_NAME
+	});
+	deps.logger.info("alarm panel created", {
+		tags: { deviceId: device.id },
+		meta: {
+			integrationId: integration.id,
+			stableId: NC_ALARM_STABLE_ID
+		}
+	});
+	return {
+		integrationId: integration.id,
+		deviceId: device.id,
+		created: true
+	};
+}
+/** The device class + type the caller passes to `kernel.devices.create`. */
+var NC_ALARM_DEVICE_CLASS = NcAlarmPanelDevice;
+var NC_ALARM_DEVICE_TYPE = require_dist.DeviceType.AlarmPanel;
+//#endregion
 //#region src/pipeline-analytics/videoclips-provider.ts
 var SOURCE = "analytics";
 function clipIdFor(eventId, startMs, endMs) {
@@ -4758,17 +5075,7 @@ function referencesAudioClass(classes) {
 	if (classes === void 0) return false;
 	return classes.some((c) => c.trim().toLowerCase().startsWith("audio-"));
 }
-/**
-* Evaluate one rule against one subject. The rule's `delivery` must match
-* the subject kind (`immediate` ↔ `object-event`, `track-end` ↔
-* `track-end`) — a mismatch fails with `'delivery'`. Schedule is evaluated
-* at the SUBJECT timestamp (the persist moment), so boot-time reconcile of
-* missed records applies the schedule the record lived under.
-*
-* Throttle/cooldown is deliberately NOT part of this function — cooldown
-* is stateful; see {@link cooldownKey} / {@link isCoolingDown}.
-*/
-function evaluateRule(rule, subject) {
+function evaluateRule(rule, subject, deviceState) {
 	if (subject.kind === "occupancy-event") {
 		if (rule.delivery !== "device-event") return fail("delivery");
 		const occ = rule.conditions.occupancy;
@@ -4783,6 +5090,11 @@ function evaluateRule(rule, subject) {
 		if (rule.conditions.occupancy !== void 0) return fail("occupancy");
 	}
 	const c = rule.conditions;
+	if (c.deviceState !== void 0) {
+		const current = deviceState?.(c.deviceState.deviceId);
+		if (current === void 0) return fail("deviceState");
+		if (!toLowerSet(c.deviceState.states).has(current.trim().toLowerCase())) return fail("deviceState");
+	}
 	if (c.devices !== void 0 && c.devices.length > 0 && !c.devices.includes(subject.deviceId)) return fail("devices");
 	if (c.source !== void 0 && c.source !== "any") {
 		if ((subject.source ?? "pipeline") !== c.source) return fail("source");
@@ -6411,6 +6723,117 @@ function rowToEntry$1(id, data) {
 	};
 }
 //#endregion
+//#region src/notification-center/rule-actions.ts
+var NcRuleActionRunner = class {
+	deps;
+	/** Last run per `${ruleId}:${sequenceName}` — the throttle's memory. */
+	lastRunAt = /* @__PURE__ */ new Map();
+	now;
+	sleep;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? (() => Date.now());
+		this.sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+	}
+	/**
+	* Run every enabled sequence, 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.
+	*/
+	async run(input) {
+		const out = [];
+		for (const sequence of input.sequences) out.push(await this.runOne(input, sequence));
+		return out;
+	}
+	async runOne(input, sequence) {
+		if (!sequence.enabled) return {
+			name: sequence.name,
+			ran: false,
+			stepsRun: 0,
+			skippedReason: "disabled"
+		};
+		if (sequence.actions.length === 0) return {
+			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);
+		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,
+					sequence: sequence.name,
+					sinceLastMs: now - last
+				}
+			});
+			return {
+				name: sequence.name,
+				ran: false,
+				stepsRun: 0,
+				skippedReason: "throttled"
+			};
+		}
+		this.lastRunAt.set(key, now);
+		let stepsRun = 0;
+		for (const [index, action] of sequence.actions.entries()) try {
+			await this.step(action);
+			stepsRun += 1;
+		} catch (err) {
+			this.deps.logger.warn("rule action failed — stopping the sequence", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					ruleId: input.ruleId,
+					rule: input.ruleName,
+					sequence: sequence.name,
+					step: index,
+					action: action.kind === "cap" ? `${action.cap}.${action.method}` : "wait",
+					error: String(err)
+				}
+			});
+			return {
+				name: sequence.name,
+				ran: true,
+				stepsRun,
+				failedAt: index
+			};
+		}
+		this.deps.logger.info("rule actions ran", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				ruleId: input.ruleId,
+				rule: input.ruleName,
+				sequence: sequence.name,
+				steps: stepsRun
+			}
+		});
+		return {
+			name: sequence.name,
+			ran: true,
+			stepsRun
+		};
+	}
+	async step(action) {
+		if (action.kind === "wait") {
+			await this.sleep(action.seconds * 1e3);
+			return;
+		}
+		if (!this.deps.isDeviceScoped(action.cap)) throw new Error(`rule action refused: "${action.cap}" is not a device capability — only devices can be actuated`);
+		await this.deps.actuate({
+			deviceId: action.deviceId,
+			cap: action.cap,
+			method: action.method,
+			args: action.args ?? {}
+		});
+	}
+};
+//#endregion
 //#region src/notification-center/rule-store.ts
 var NC_RULES_COLLECTION = "notification-center:rules";
 var NC_RULES_COLUMNS = [
@@ -6612,6 +7035,53 @@ var NcRuleStore = class {
 		});
 	}
 };
+var NcDeviceStateCache = class {
+	deps;
+	states = /* @__PURE__ */ new Map();
+	lastOkAt = 0;
+	ids = [];
+	now;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	/**
+	* The device ids worth reading — recomputed from the rule set, so a cluster
+	* with no gated rule does no work at all.
+	*/
+	setWatched(ids) {
+		this.ids = [...new Set(ids)].sort((a, b) => a - b);
+	}
+	watched() {
+		return this.ids;
+	}
+	/** Hot-path read. No I/O, no await — this is called per event. */
+	get(deviceId) {
+		if (this.now() - this.lastOkAt > 3e5) return void 0;
+		return this.states.get(deviceId);
+	}
+	/**
+	* Re-read every watched state. Never throws: a gate that could fail the
+	* evaluation tick would take the notification pipeline with it.
+	*/
+	async refresh() {
+		if (this.ids.length === 0) {
+			this.states = /* @__PURE__ */ new Map();
+			return;
+		}
+		try {
+			const next = await this.deps.readStates(this.ids);
+			this.states = new Map(next);
+			this.lastOkAt = this.now();
+			for (const id of this.ids) if (!next.has(id)) this.deps.logger.info("device-state gate: no state for a watched device", { tags: { deviceId: id } });
+		} catch (err) {
+			this.deps.logger.warn("device-state refresh failed — keeping the previous states until they age out", { meta: {
+				watched: this.ids.length,
+				error: String(err)
+			} });
+		}
+	}
+};
 //#endregion
 //#region src/notification-center/snooze-digest.ts
 /** `14:03` in the node's local zone — a digest is read by a person, at home. */
@@ -7445,6 +7915,11 @@ var NotificationCenter = class NotificationCenter {
 	/** Snooze windows + what they hid. Mirrored into RAM; the dispatcher's gate
 	*  reads it with no I/O, the drain tick refreshes it. */
 	snoozes;
+	/** States the `deviceState` rule gate reads. Refreshed on the reload tick;
+	*  read with no I/O on the persist hook. */
+	deviceStates;
+	/** Runs a matched rule's action sequences. Null when no actuator is wired. */
+	actionRunner;
 	/** True when ≥1 enabled `device-event` rule declares an occupancy condition —
 	*  the watcher is idle (zero per-frame cost) otherwise. */
 	occupancyEnabled = false;
@@ -7477,6 +7952,17 @@ var NotificationCenter = class NotificationCenter {
 			store: deps.store,
 			logger: this.logger.child("occupancy")
 		});
+		this.actionRunner = deps.actuate !== void 0 && deps.isCapDeviceScoped !== void 0 ? new NcRuleActionRunner({
+			logger: this.logger.child("actions"),
+			actuate: deps.actuate,
+			isDeviceScoped: deps.isCapDeviceScoped,
+			...deps.now !== void 0 ? { now: deps.now } : {}
+		}) : null;
+		this.deviceStates = new NcDeviceStateCache({
+			logger: this.logger.child("device-state"),
+			readStates: deps.readDeviceStates ?? (async () => /* @__PURE__ */ new Map()),
+			...deps.now !== void 0 ? { now: deps.now } : {}
+		});
 		this.snoozes = new NcSnoozeStore({
 			store: deps.store,
 			logger: this.logger.child("snooze"),
@@ -7531,6 +8017,7 @@ var NotificationCenter = class NotificationCenter {
 		await this.snoozes.load();
 		this.refreshOccupancyWatch();
 		if (!opts.evaluation) return;
+		await this.deviceStates.refresh();
 		this.evaluationActive = true;
 		await this.outbox.load();
 		await this.seedCooldowns();
@@ -7802,7 +8289,7 @@ var NotificationCenter = class NotificationCenter {
 		let anyMatched = false;
 		const rejections = [];
 		for (const rule of candidates) {
-			const evaluation = evaluateRule(rule, subject);
+			const evaluation = evaluateRule(rule, subject, (id) => this.deviceStates.get(id));
 			if (!evaluation.matched) {
 				rejections.push(`${rule.name}:${evaluation.failedCondition ?? "unknown"}`);
 				this.logger.debug("rule did not match", {
@@ -7846,6 +8333,13 @@ var NotificationCenter = class NotificationCenter {
 					...subject.zones.length > 0 ? { zones: subject.zones } : {}
 				}
 			});
+			const sequences = rule.actions?.onTrigger;
+			if (sequences !== void 0 && sequences.length > 0 && this.actionRunner !== null) this.actionRunner.run({
+				ruleId: rule.id,
+				ruleName: rule.name,
+				deviceId: subject.deviceId,
+				sequences
+			});
 			const userTargets = await this.resolveUserTargets(rule, subject.deviceId);
 			if (await this.outbox.enqueue(this.buildEntries(rule, subject, kind, evaluation.matchedOn, userTargets)) > 0) this.lastFiredAt.set(key, now);
 			anyMatched = true;
@@ -8003,6 +8497,13 @@ var NotificationCenter = class NotificationCenter {
 		}
 		this.occupancyWatcher.setWatchedKeys(specs);
 		this.occupancyEnabled = specs.length > 0;
+		const gated = [];
+		for (const rule of this.rules.list()) {
+			if (!rule.enabled) continue;
+			const ds = rule.conditions.deviceState;
+			if (ds !== void 0) gated.push(ds.deviceId);
+		}
+		this.deviceStates.setWatched(gated);
 	}
 	/** Boot reseed of confirmed occupancy edge-state (durability, constraint 4) —
 	*  hydrate the watcher from the store, then prune orphaned durable rows to the
@@ -8019,6 +8520,7 @@ var NotificationCenter = class NotificationCenter {
 		await this.rules.load();
 		this.refreshOccupancyWatch();
 		if (!this.evaluationActive) return;
+		await this.deviceStates.refresh();
 		await this.occupancyStore.pruneExcept(this.activeOccupancyKeys());
 	}
 	/** The full-key set the watcher currently tracks (post prune) — the bound for
@@ -8243,10 +8745,16 @@ var NotificationCenter = class NotificationCenter {
 			const tracks = await this.deps.listRecentTracks(since, TEST_RULE_MAX_RESULTS);
 			for (const track of tracks) subjects.push(subjectFromTrack(track));
 		}
+		let lookup = (id) => this.deviceStates.get(id);
+		const gated = rule.conditions.deviceState;
+		if (gated !== void 0 && this.deps.readDeviceStates !== void 0) try {
+			const fresh = await this.deps.readDeviceStates([gated.deviceId]);
+			lookup = (id) => fresh.get(id) ?? this.deviceStates.get(id);
+		} catch {}
 		const results = [];
 		for (const subject of subjects.sort((a, b) => b.timestamp - a.timestamp)) {
 			if (results.length >= TEST_RULE_MAX_RESULTS) break;
-			const evaluation = evaluateRule(rule, subject);
+			const evaluation = evaluateRule(rule, subject, lookup);
 			results.push({
 				recordId: subject.recordId,
 				recordKind: subject.kind === "track-end" ? "track" : subject.kind === "audio-event" ? "object-event" : subject.kind === "occupancy-event" ? "device-event" : subject.kind,
@@ -21204,6 +21712,11 @@ async function resolveDefaultEventMedia(deps) {
 }
 //#endregion
 //#region src/pipeline-analytics/index.ts
+/** This addon's manifest id — the owner of the fixed Notification Center
+*  integration and of the alarm device under it. */
+var PIPELINE_ANALYTICS_ADDON_ID = "pipeline-analytics";
+/** Operator-visible name of the fixed integration. */
+var NC_INTEGRATION_NAME = "Notification Center";
 /**
 * Pipeline Analytics addon — subscribes to `PipelineInferenceResult` +
 * `PipelineAudioInferenceResult` on the bus, refines raw detections
@@ -21730,6 +22243,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const api = this.ctx.api;
 		if (!api) throw new Error("pipeline-analytics requires ctx.api (device-manager + settings-store)");
 		await this.declareCollections(api);
+		await this.ensureAlarmPanel(api);
 		const logger = this.ctx.logger;
 		const storage = await this.resolveMediaStorage(logger);
 		const stores = await this.buildStores(api, logger, storage);
@@ -21817,6 +22331,40 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	}
 	/** Declare typed collections up-front so the first insert doesn't race with
 	*  a CREATE TABLE. Idempotent. */
+	/**
+	* Bring the Notification Center's alarm panel into existence, once.
+	*
+	* Both steps are get-or-create, because this runs on every boot and an
+	* operator must never end up with a second panel after a restart. The
+	* integration is FIXED: it exists because this addon says so, not because
+	* anybody added it, and there is no add/delete flow for it.
+	*/
+	async ensureAlarmPanel(api) {
+		const devices = this.ctx.kernel.devices;
+		try {
+			const result = await ensureAlarmPanel({
+				logger: this.ctx.logger.child("alarm"),
+				addonId: PIPELINE_ANALYTICS_ADDON_ID,
+				integrationName: NC_INTEGRATION_NAME,
+				getIntegration: async (addonId) => api.integrations.getByAddonId.query({ addonId }),
+				createIntegration: async (input) => api.integrations.create.mutate(input),
+				findDeviceByStableId: async (stableId) => {
+					const found = (await api.deviceManager.listAll.query({ addonId: PIPELINE_ANALYTICS_ADDON_ID })).find((d) => d.stableId === stableId);
+					return found === void 0 ? null : { id: found.id };
+				},
+				createDevice: async ({ stableId, integrationId, name }) => {
+					return { id: (await devices.create(stableId, NC_ALARM_DEVICE_CLASS, {}, null, {
+						type: NC_ALARM_DEVICE_TYPE,
+						name,
+						integrationId
+					})).id };
+				}
+			});
+			if (result.created) this.ctx.logger.info("notification-center alarm panel ready", { tags: { deviceId: result.deviceId } });
+		} catch (err) {
+			this.ctx.logger.warn("alarm panel could not be ensured — rules still notify", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
 	async declareCollections(api) {
 		await TrackStore.declare(api.settingsStore);
 		await MediaStore.declare(api.settingsStore);
@@ -21841,7 +22389,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-DFKBSXUx.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-C5glqf4X.js"));
 			storage = new FilesystemStorageProvider(mediaRoot, { eventMedia: mediaRoot });
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -22198,6 +22746,32 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					addonId: device.addonId
 				};
 			},
+			actuate: async ({ deviceId, cap, method, args }) => {
+				const router = api[require_dist.kebabToCamel(cap)];
+				if (router === null || typeof router !== "object") throw new Error(`rule action: no router for capability "${cap}"`);
+				const proc = router[method];
+				const call = proc !== null && typeof proc === "object" ? proc : null;
+				const fn = call?.mutate ?? call?.query;
+				if (typeof fn !== "function") throw new Error(`rule action: "${cap}.${method}" is not a callable cap method`);
+				await fn({
+					deviceId,
+					...args
+				});
+			},
+			isCapDeviceScoped: require_dist.isDeviceScopedCap,
+			readDeviceStates: async (ids) => {
+				const out = /* @__PURE__ */ new Map();
+				for (const id of ids) try {
+					const state = require_dist.readDeviceStateFrom(await api.deviceManager.loadRuntimeState.query({ deviceId: id }));
+					if (state !== void 0) out.set(id, state);
+				} catch (err) {
+					this.ctx.logger.debug("device-state read failed", {
+						tags: { deviceId: id },
+						meta: { error: String(err) }
+					});
+				}
+				return out;
+			},
 			dispatcher: {
 				getZoneNames: async (deviceId) => {
 					return (await api.zones.listZones.query({ deviceId })).map((z) => ({