@camstack/system 1.2.444 → 1.2.446

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,6 @@
-import { $i as EventCategory, Fr as BaseAddon, Pr as errMsg, ct as alertsCapability, i as AlertSchema, yi as createEvent } from "../../dist-DERK-gP5.mjs";
+import { Ci as createEvent, Di as defineRecordKinds, Lr as errMsg, Rr as BaseAddon, ft as alertsCapability, i as AlertSchema, la as EventCategory } from "../../dist-CkZIrsAP.mjs";
+import { t as require_read_all_rows } from "../../read-all-rows-TaPqdWNF.mjs";
+import { t as resolvePhase6UseRecordsPathForHub } from "../../phase6-declare-gate-BDWZuB2n.mjs";
 //#region src/builtins/alerts/critical-push.ts
 /** Alert categories that are critical system findings. */
 var CRITICAL_CATEGORIES = new Set([
@@ -6,6 +8,9 @@ var CRITICAL_CATEGORIES = new Set([
 	"addon.runner-refused",
 	"system.runner-check"
 ]);
+function isCriticalPush(alert) {
+	return alert.severity === "critical" || CRITICAL_CATEGORIES.has(alert.category);
+}
 function isPushState(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const rec = value;
@@ -103,6 +108,59 @@ async function deliverDigest(input) {
 	return out;
 }
 //#endregion
+//#region src/builtins/alerts/emit-alert-policy.ts
+function episodeKeyFromMetadata(metadata) {
+	const key = metadata?.["episodeKey"];
+	return typeof key === "string" ? key : void 0;
+}
+/** Completed episodes start fresh — prior push must not suppress the next digest. */
+function shouldDropPriorPush(existingStatus) {
+	return existingStatus === "completed";
+}
+function alertWithRetainedPush(toStore, existingPush, existingStatus) {
+	if (existingPush === void 0 || shouldDropPriorPush(existingStatus)) return toStore;
+	return {
+		...toStore,
+		metadata: {
+			...toStore.metadata,
+			push: existingPush
+		}
+	};
+}
+/**
+* Re-emit of the same alert id: preserve read when the episode is unchanged
+* and still active. A completed episode starts again. Queue a critical push
+* only for active, unread critical findings.
+*/
+function mergeEmitAlert(input) {
+	const incomingKey = episodeKeyFromMetadata(input.incoming.metadata);
+	const existingKey = input.existing?.episodeKey;
+	if (input.existing?.read === true) {
+		const sameEpisode = incomingKey === void 0 || incomingKey === existingKey;
+		const priorCompleted = input.existing.status === "completed";
+		if (sameEpisode && !priorCompleted) return {
+			alert: {
+				...input.incoming,
+				read: true
+			},
+			queuePush: false
+		};
+	}
+	const queuePush = isCriticalPush(input.incoming) && input.incoming.status === "active" && input.incoming.read === false;
+	return {
+		alert: input.incoming,
+		queuePush
+	};
+}
+function criticalPushPayload(alert) {
+	const key = episodeKeyFromMetadata(alert.metadata) ?? alert.id;
+	const pushLine = alert.metadata?.["pushLine"];
+	return {
+		key,
+		line: typeof pushLine === "string" ? pushLine : alert.title
+	};
+}
+//#endregion
 //#region src/builtins/alerts/device-label.ts
 /**
 * Operator-facing device label for alert messages.
@@ -277,6 +335,210 @@ function runnerPushLine(record) {
 	return record.state === "refused" ? `${where}: refused to start. ${record.remedy ?? "See the Addons page."}` : `${where}: stopped after repeated crashes. Restart it from the Addons page.`;
 }
 //#endregion
+//#region src/builtins/alerts/record-kinds.ts
+var import_read_all_rows = require_read_all_rows();
+/**
+* Record kinds owned by alert-center (records plan phase 4).
+*/
+/** Legacy collection / adoptsFrom target (canonical KV before phase 4). */
+var ALERTS_COLLECTION = "alerts";
+var _alertCenterRecordKinds = defineRecordKinds({ alerts: {
+	schema: AlertSchema.omit({ id: true }),
+	class: "audit",
+	writeTrigger: "EventBus categories the alert center tracks, operator mark read/dismiss, and model-download progress merges",
+	device: "none",
+	at: "none",
+	indexes: [
+		{
+			name: "read",
+			fields: ["read"]
+		},
+		{
+			name: "created_at",
+			fields: ["createdAt"]
+		},
+		{
+			name: "updated_at",
+			fields: ["updatedAt"]
+		}
+	],
+	retention: {
+		owner: "alert-center",
+		reason: "maxAlerts cap and retentionDays enforced on write (enforceMaxAlerts / enforceRetention); read alerts preferred when trimming overflow"
+	},
+	adoptsFrom: ALERTS_COLLECTION
+} });
+var alertCenterRecordKinds = _alertCenterRecordKinds;
+/** Narrow kind for `records.kind()` — `IsolatedRecordKinds` string index is `| undefined`. */
+var alertsRecordKind = _alertCenterRecordKinds.alerts;
+//#endregion
+//#region src/builtins/alerts/alert-store.ts
+function toRecord(row) {
+	return {
+		id: row.id,
+		data: row.data
+	};
+}
+function toRecordFromLegacy(row) {
+	return {
+		id: row.id,
+		data: row.data
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyGetData(value) {
+	if (!isRecord(value)) return null;
+	if ("data" in value) {
+		const data = value.data;
+		return isRecord(data) ? data : null;
+	}
+	return value;
+}
+var AlertStore = class AlertStore {
+	kind;
+	legacyStore;
+	constructor(kind, legacyStore) {
+		this.kind = kind;
+		this.legacyStore = legacyStore;
+	}
+	static of(records) {
+		return new AlertStore(records.kind(alertsRecordKind), null);
+	}
+	static legacy(store) {
+		return new AlertStore(null, store);
+	}
+	async legacyRows() {
+		const store = this.legacyStore;
+		if (store === null) return [];
+		return (await store.query.query({
+			collection: ALERTS_COLLECTION,
+			filter: {}
+		})).map((row) => toRecordFromLegacy({
+			id: row.id,
+			data: row.data
+		}));
+	}
+	async list(filter) {
+		let out;
+		const kind = this.kind;
+		if (kind !== null) out = (await (0, import_read_all_rows.readAllRows)(kind, { order: "id" })).map(toRecord);
+		else out = [...await this.legacyRows()];
+		if (filter?.unreadOnly === true) out = out.filter((r) => r.data["read"] === false);
+		out.sort((a, b) => Number(b.data["updatedAt"] ?? 0) - Number(a.data["updatedAt"] ?? 0));
+		const limit = filter?.limit ?? 100;
+		return out.slice(0, limit);
+	}
+	async countUnread() {
+		return (await this.list({
+			unreadOnly: true,
+			limit: 1e4
+		})).length;
+	}
+	async countAll() {
+		const kind = this.kind;
+		if (kind !== null) return (await (0, import_read_all_rows.readAllRows)(kind)).length;
+		return (await this.legacyRows()).length;
+	}
+	async getData(id) {
+		const kind = this.kind;
+		if (kind !== null) {
+			const row = await kind.get(id);
+			if (row === null) return null;
+			return row.data;
+		}
+		const store = this.legacyStore;
+		if (store === null) return null;
+		return legacyGetData(await store.get.query({
+			collection: ALERTS_COLLECTION,
+			key: id
+		}));
+	}
+	async mergeUpdate(id, patch) {
+		const existing = await this.getData(id);
+		if (existing === null) return;
+		await this.putRaw(id, {
+			...existing,
+			...patch
+		});
+	}
+	async persist(alert) {
+		const { id, ...body } = alert;
+		const data = alertsRecordKind.schema.parse(body);
+		const kind = this.kind;
+		if (kind !== null) {
+			await kind.put({
+				id,
+				data
+			});
+			return;
+		}
+		await this.putRaw(id, {
+			...body,
+			id
+		});
+	}
+	async putRaw(id, data) {
+		const { id: _drop, ...body } = AlertSchema.parse({
+			id,
+			...data
+		});
+		const kind = this.kind;
+		if (kind !== null) {
+			await kind.put({
+				id,
+				data: body
+			});
+			return;
+		}
+		const store = this.legacyStore;
+		if (store === null) return;
+		await store.set.mutate({
+			collection: ALERTS_COLLECTION,
+			key: id,
+			value: {
+				id,
+				...body
+			}
+		});
+	}
+	async delete(id) {
+		const kind = this.kind;
+		if (kind !== null) {
+			await kind.delete(id);
+			return;
+		}
+		const store = this.legacyStore;
+		if (store === null) return;
+		await store.delete.mutate({
+			collection: ALERTS_COLLECTION,
+			key: id
+		});
+	}
+	async listAllByCreatedAtAsc() {
+		const kind = this.kind;
+		let out;
+		if (kind !== null) out = (await (0, import_read_all_rows.readAllRows)(kind)).map(toRecord);
+		else out = [...await this.legacyRows()];
+		out.sort((a, b) => Number(a.data["createdAt"] ?? 0) - Number(b.data["createdAt"] ?? 0));
+		return out;
+	}
+	async listRecent(limit) {
+		const kind = this.kind;
+		let out;
+		if (kind !== null) out = (await (0, import_read_all_rows.readAllRows)(kind, { order: "id" })).map(toRecord);
+		else out = [...await this.legacyRows()];
+		out.sort((a, b) => Number(b.data["updatedAt"] ?? 0) - Number(a.data["updatedAt"] ?? 0));
+		return out.slice(0, limit);
+	}
+	async findWhereDataField(field, value) {
+		const kind = this.kind;
+		if (kind !== null) return (await (0, import_read_all_rows.readAllRows)(kind)).filter((r) => r.data[field] === value).map(toRecord);
+		return (await this.legacyRows()).filter((r) => r.data[field] === value);
+	}
+};
+//#endregion
 //#region src/builtins/alerts/alerts.addon.ts
 var CATEGORY_MAPPINGS = {
 	"addon.crashed": {
@@ -449,13 +711,18 @@ var DEFAULT_CONFIG = {
 	maxAlerts: 500,
 	retentionDays: 30,
 	criticalPushEnabled: true,
-	criticalPushTargetIds: ""
+	criticalPushTargetIds: []
 };
+/** Accept the live `string[]` shape and the pre-multiselect CSV string. */
+function normalizeCriticalPushTargetIds(raw) {
+	if (Array.isArray(raw)) return raw.filter((id) => typeof id === "string" && id.trim().length > 0).map((id) => id.trim());
+	if (typeof raw === "string" && raw.trim().length > 0) return raw.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+	return [];
+}
 /** One burst of critical findings (a whole boot of refused runners) is ONE digest push. */
 var PUSH_COALESCE_MS = 2e3;
 /** Addons whose (re)start is a reason to retry pending critical pushes. */
 var PUSH_RECONCILE_ADDONS = new Set(["notifiers", "notification-center"]);
-var ALERTS_COLLECTION = "alerts";
 var EVENT_SOURCE = {
 	type: "addon",
 	id: "alert-center"
@@ -476,6 +743,7 @@ function toPrunable(record) {
 	};
 }
 var AlertCenterAddon = class extends BaseAddon {
+	alertStore = null;
 	unsubscribers = [];
 	/** How long a burst of critical findings is gathered into one digest push. */
 	pushCoalesceMs;
@@ -490,6 +758,11 @@ var AlertCenterAddon = class extends BaseAddon {
 	*/
 	rateLimitCounters = /* @__PURE__ */ new Map();
 	async onInitialize() {
+		const records = this.ctx.records;
+		const store = this.ctx.api?.settingsStore;
+		const useRecords = records !== void 0 && store !== void 0 && await resolvePhase6UseRecordsPathForHub(this.ctx, "alert-center", alertCenterRecordKinds, ["alerts"]);
+		this.alertStore = useRecords && records !== void 0 ? AlertStore.of(records) : store === void 0 ? null : AlertStore.legacy(store);
+		if (this.alertStore === null) throw new Error("alert-center needs ctx.records or settings-store on the hub");
 		const alertsProvider = {
 			emit: (alert) => this.emitAlert(alert),
 			update: (input) => this.updateAlert(input.alertId, input.patch),
@@ -509,6 +782,7 @@ var AlertCenterAddon = class extends BaseAddon {
 		this.unsubscribers = unsubs;
 		this.reconcilePendingPushes();
 		this.dismissLegacyStreamCards(void 0);
+		this.migrateCriticalPushTargetIds();
 		this.ctx.logger.info("Initialized", { meta: { trackedCategoriesCount: TRACKED_CATEGORIES.length } });
 		return [{
 			capability: alertsCapability,
@@ -556,43 +830,28 @@ var AlertCenterAddon = class extends BaseAddon {
 					type: "boolean",
 					key: "criticalPushEnabled",
 					label: "Push critical system alerts",
-					description: "A runner that failed or refused to start, or a node whose runners are degraded, is pushed straight to the notifier targets - even when notification-center is down.",
+					description: "A runner that failed or refused to start, or a node whose runners are degraded, is pushed straight to the notifier targets — even when Notification Center is down. This path does not use notification rules.",
 					default: true
 				}),
 				this.field({
-					type: "text",
+					type: "notification-target-multiselect",
 					key: "criticalPushTargetIds",
 					label: "Critical push targets",
-					description: "Comma-separated notifier target ids. Empty = every enabled shared (not personal) target.",
-					default: ""
+					description: "Notifier targets that receive critical system alerts. Empty = every enabled shared (not personal) target.",
+					default: []
 				})
 			]
 		}] });
 	}
 	async listAlerts(filter) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return [];
-		const whereClause = {};
-		if (filter?.unreadOnly) whereClause.read = false;
-		return (await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: {
-				where: Object.keys(whereClause).length > 0 ? whereClause : void 0,
-				orderBy: {
-					field: "updatedAt",
-					direction: "desc"
-				},
-				limit: filter?.limit ?? 100
-			}
-		})).map(parseAlert);
+		const store = this.alertStore;
+		if (store === null) return [];
+		return (await store.list(filter)).map(parseAlert);
 	}
 	async getUnreadCount() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return 0;
-		return backend.count.query({
-			collection: ALERTS_COLLECTION,
-			filter: { where: { read: false } }
-		});
+		const store = this.alertStore;
+		if (store === null) return 0;
+		return store.countUnread();
 	}
 	async markRead(alertId) {
 		await this.mergeUpdate(alertId, {
@@ -601,11 +860,11 @@ var AlertCenterAddon = class extends BaseAddon {
 		});
 	}
 	async markAllRead() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const unread = await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { where: { read: false } }
+		const store = this.alertStore;
+		if (store === null) return;
+		const unread = await store.list({
+			unreadOnly: true,
+			limit: 1e4
 		});
 		const now = Date.now();
 		for (const record of unread) await this.mergeUpdate(record.id, {
@@ -702,14 +961,14 @@ var AlertCenterAddon = class extends BaseAddon {
 		}
 	}
 	async readRunnerRecord(alertId) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return null;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: alertId
+		const store = this.alertStore;
+		if (store === null) return null;
+		const raw = await store.getData(alertId);
+		if (raw === null) return null;
+		const alert = AlertSchema.safeParse({
+			id: alertId,
+			...raw
 		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return null;
-		const alert = AlertSchema.safeParse(raw);
 		if (!alert.success || alert.data.status === "dismissed") return null;
 		return parseRunnerRecord(alert.data.metadata?.["runner"]);
 	}
@@ -837,20 +1096,20 @@ var AlertCenterAddon = class extends BaseAddon {
 		});
 	}
 	async readAlertRaw(alertId) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return null;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: alertId
-		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return null;
+		const store = this.alertStore;
+		if (store === null) return null;
+		const raw = await store.getData(alertId);
+		if (raw === null) return null;
 		const rec = Object.fromEntries(Object.entries(raw));
 		const meta = rec["metadata"];
 		const push = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta["push"] : void 0;
+		const metadata = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : void 0;
 		return {
 			...typeof rec["createdAt"] === "number" ? { createdAt: rec["createdAt"] } : {},
 			...typeof rec["read"] === "boolean" ? { read: rec["read"] } : {},
-			...isPushState(push) ? { push } : {}
+			...typeof rec["status"] === "string" ? { status: rec["status"] } : {},
+			...isPushState(push) ? { push } : {},
+			...episodeKeyFromMetadata(metadata) !== void 0 ? { episodeKey: episodeKeyFromMetadata(metadata) } : {}
 		};
 	}
 	/** Pushes run one at a time so a burst can never send the same state twice. */
@@ -861,9 +1120,19 @@ var AlertCenterAddon = class extends BaseAddon {
 	pushPolicy() {
 		return {
 			enabled: this.config.criticalPushEnabled,
-			targetIds: this.config.criticalPushTargetIds.split(",").map((id) => id.trim()).filter((id) => id.length > 0)
+			targetIds: normalizeCriticalPushTargetIds(this.config.criticalPushTargetIds)
 		};
 	}
+	/** Rewrite a legacy CSV `criticalPushTargetIds` string into `string[]`. */
+	async migrateCriticalPushTargetIds() {
+		const raw = this.config.criticalPushTargetIds;
+		if (typeof raw !== "string") return;
+		try {
+			await this.updateGlobalSettings({ criticalPushTargetIds: normalizeCriticalPushTargetIds(raw) });
+		} catch (err) {
+			this.ctx.logger.warn("criticalPushTargetIds CSV migration failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
 	pushPorts() {
 		const api = this.ctx.api;
 		return {
@@ -940,27 +1209,16 @@ var AlertCenterAddon = class extends BaseAddon {
 		return this.pushChain;
 	}
 	async storePushState(alertId, push) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: alertId
-		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return;
-		const existing = Object.fromEntries(Object.entries(raw));
-		const meta = existing["metadata"];
+		const store = this.alertStore;
+		if (store === null) return;
+		const raw = await store.getData(alertId);
+		if (raw === null) return;
+		const meta = raw["metadata"];
 		const metadata = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
-		await backend.set.mutate({
-			collection: ALERTS_COLLECTION,
-			key: alertId,
-			value: {
-				...existing,
-				metadata: {
-					...metadata,
-					push
-				}
-			}
-		});
+		await store.mergeUpdate(alertId, { metadata: {
+			...metadata,
+			push
+		} });
 	}
 	/**
 	* Retry every critical alert whose push is still pending - at boot and when
@@ -968,26 +1226,17 @@ var AlertCenterAddon = class extends BaseAddon {
 	* delivered is skipped by its key, so reconciling never sends twice.
 	*/
 	async reconcilePendingPushes() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
+		const store = this.alertStore;
+		if (store === null) return;
 		try {
-			const rows = await backend.query.query({
-				collection: ALERTS_COLLECTION,
-				filter: {
-					orderBy: {
-						field: "updatedAt",
-						direction: "desc"
-					},
-					limit: 500
-				}
-			});
+			const rows = await store.listRecent(500);
 			for (const row of rows) {
 				const parsed = AlertSchema.safeParse({
 					id: row.id,
 					...row.data
 				});
 				if (!parsed.success || parsed.data.status !== "active") continue;
-				if (!CRITICAL_CATEGORIES.has(parsed.data.category)) continue;
+				if (!isCriticalPush(parsed.data)) continue;
 				const push = parsed.data.metadata?.["push"];
 				if (!isPushState(push) || push.state !== "pending") continue;
 				this.pushQueue.set(parsed.data.id, {
@@ -1007,12 +1256,9 @@ var AlertCenterAddon = class extends BaseAddon {
 		const modelId = data.modelId ?? "unknown";
 		const progress = data.progress ?? 0;
 		const stableId = `model-download:${modelId}`;
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		if ((await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { where: { id: stableId } }
-		})).length > 0) {
+		const store = this.alertStore;
+		if (store === null) return;
+		if (await store.getData(stableId) !== null) {
 			const now = Date.now();
 			if (progress >= 100) {
 				await this.mergeUpdate(stableId, {
@@ -1336,8 +1582,29 @@ var AlertCenterAddon = class extends BaseAddon {
 		}
 	}
 	async emitAlert(alert) {
-		await this.persistAlert(alert);
-		this.emitAlertCreatedEvent(alert);
+		const existingRaw = await this.readAlertRaw(alert.id);
+		const { alert: toStore, queuePush } = mergeEmitAlert({
+			existing: existingRaw === null ? null : {
+				read: existingRaw.read,
+				episodeKey: existingRaw.episodeKey,
+				status: existingRaw.status
+			},
+			incoming: alert
+		});
+		const stored = alertWithRetainedPush(toStore, existingRaw?.push, existingRaw?.status);
+		const isNew = existingRaw === null;
+		await this.persistAlert(stored);
+		if (isNew) this.emitAlertCreatedEvent(stored);
+		else this.emitAlertUpdatedEvent(alert.id, stored);
+		if (queuePush) {
+			const { key, line } = criticalPushPayload(stored);
+			this.queuePush({
+				alertId: stored.id,
+				key,
+				title: stored.title,
+				line
+			});
+		}
 		await this.enforceMaxAlerts();
 		await this.enforceRetention();
 	}
@@ -1353,45 +1620,14 @@ var AlertCenterAddon = class extends BaseAddon {
 	* so we must read the existing record, merge the patch, and write back.
 	*/
 	async mergeUpdate(id, patch) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const raw = await backend.get.query({
-			collection: ALERTS_COLLECTION,
-			key: id
-		});
-		if (raw === null || raw === void 0 || typeof raw !== "object") return;
-		const existing = Object.fromEntries(Object.entries(raw));
-		await backend.set.mutate({
-			collection: ALERTS_COLLECTION,
-			key: id,
-			value: {
-				...existing,
-				...patch
-			}
-		});
+		const store = this.alertStore;
+		if (store === null) return;
+		await store.mergeUpdate(id, patch);
 	}
 	async persistAlert(alert) {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		const data = {
-			id: alert.id,
-			category: alert.category,
-			severity: alert.severity,
-			title: alert.title,
-			message: alert.message,
-			status: alert.status,
-			read: alert.read,
-			createdAt: alert.createdAt,
-			updatedAt: alert.updatedAt,
-			...alert.progress !== void 0 ? { progress: alert.progress } : {},
-			...alert.source ? { source: alert.source } : {},
-			...alert.metadata ? { metadata: alert.metadata } : {}
-		};
-		await backend.set.mutate({
-			collection: ALERTS_COLLECTION,
-			key: alert.id,
-			value: data
-		});
+		const store = this.alertStore;
+		if (store === null) return;
+		await store.persist(alert);
 	}
 	emitAlertCreatedEvent(alert) {
 		this.ctx.eventBus?.emit(createEvent("alert.created", EVENT_SOURCE, {
@@ -1411,36 +1647,18 @@ var AlertCenterAddon = class extends BaseAddon {
 		}));
 	}
 	async enforceMaxAlerts() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
-		if (await backend.count.query({ collection: ALERTS_COLLECTION }) <= this.config.maxAlerts) return;
-		const all = await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { orderBy: {
-				field: "createdAt",
-				direction: "asc"
-			} }
-		});
-		for (const id of selectOverflow(all.map(toPrunable), this.config.maxAlerts)) await backend.delete.mutate({
-			collection: ALERTS_COLLECTION,
-			key: id
-		});
+		const store = this.alertStore;
+		if (store === null) return;
+		if (await store.countAll() <= this.config.maxAlerts) return;
+		const all = await store.listAllByCreatedAtAsc();
+		for (const id of selectOverflow(all.map(toPrunable), this.config.maxAlerts)) await store.delete(id);
 	}
 	async enforceRetention() {
-		const backend = this.ctx.api.settingsStore;
-		if (!backend) return;
+		const store = this.alertStore;
+		if (store === null) return;
 		const cutoff = Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1e3;
-		const all = await backend.query.query({
-			collection: ALERTS_COLLECTION,
-			filter: { orderBy: {
-				field: "createdAt",
-				direction: "asc"
-			} }
-		});
-		for (const id of selectExpired(all.map(toPrunable), cutoff)) await backend.delete.mutate({
-			collection: ALERTS_COLLECTION,
-			key: id
-		});
+		const all = await store.listAllByCreatedAtAsc();
+		for (const id of selectExpired(all.map(toPrunable), cutoff)) await store.delete(id);
 	}
 };
 //#endregion

package/dist/builtins/alerts/critical-push.d.ts

@@ -59,6 +59,10 @@ export interface PushPolicy {
 }
 /** Alert categories that are critical system findings. */
 export declare const CRITICAL_CATEGORIES: ReadonlySet<string>;
+export declare function isCriticalPush(alert: {
+	readonly severity: string;
+	readonly category: string;
+}): boolean;
 export declare function isPushState(value: unknown): value is PushState;
 export declare function selectPushTargets(targets: readonly PushTarget[], policy: PushPolicy): readonly PushTarget[];
 /** One critical finding waiting for its push. */