@voltro/plugin-notifications 0.1.0

package/dist/index.js

@@ -0,0 +1,689 @@
+import { clearQuietHoursDescriptor as e, inboxDescriptor as t, markReadDescriptor as n, notificationsRpcClientImports as r, preferencesDescriptor as i, setPreferenceDescriptor as a, setQuietHoursDescriptor as o, subscribeDescriptor as s, unreadCountDescriptor as c, unsubscribeDescriptor as l } from "./rpc.js";
+import { Context as u, Effect as d, Layer as f, Schema as p } from "effect";
+import { and as m, boolean as h, eq as g, generateId as _, id as v, integer as y, isNotNull as ee, isNull as b, json as x, lte as S, registerRetention as C, retentionTtlMsFromEnv as w, table as T, text as E, timestamp as D } from "@voltro/database";
+import { definePlugin as O } from "@voltro/protocol";
+import { randomUUID as k } from "node:crypto";
+//#region src/errors.ts
+var A = class extends p.TaggedError()("PushTokenRejected", {
+	token: p.String,
+	reason: p.String
+}) {}, j = () => ({
+	id: "console",
+	deliver: async (e) => {
+		process.stdout.write(`[notify:${e.category}] → ${e.to}: ${e.title} — ${e.body}\n`);
+	}
+}), M = (e) => ({
+	id: e.id ?? "slack",
+	deliver: async (t) => {
+		let n = e.format ? e.format(t) : { text: `*${t.title}*\n${t.body}` }, r = await fetch(e.url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				...e.headers ?? {}
+			},
+			body: JSON.stringify(n)
+		});
+		if (!r.ok) throw Error(`webhook ${e.id ?? "slack"} POST ${r.status}`);
+	}
+}), N = (e) => ({
+	id: "email",
+	deliver: (t) => e({
+		to: t.to,
+		subject: t.title,
+		html: `<p>${t.body}</p>`,
+		text: t.body
+	})
+}), P = (e) => ({
+	id: "sms",
+	deliver: (t) => e(t.to, `${t.title}: ${t.body}`)
+}), te = (e, t) => ({
+	id: e,
+	deliver: t
+}), F = (e) => ({
+	id: e.id ?? "push",
+	deliver: async (t) => {
+		let n = await e.tokensFor(t.to), r = t.data?.badge, i = typeof r == "number" ? r : void 0;
+		for (let r of n) {
+			let n = {
+				token: r,
+				title: t.title,
+				body: t.body,
+				...i === void 0 ? {} : { badge: i },
+				data: t.data ?? {}
+			};
+			try {
+				await e.transport(n);
+			} catch (e) {
+				throw e instanceof A ? e : new A({
+					token: r,
+					reason: e instanceof Error ? e.message : String(e)
+				});
+			}
+		}
+	}
+}), I = (e, t, n, r, i) => {
+	let a = n ? e.filter((e) => n.includes(e)) : [...e], o = new Set(r.filter((e) => e.subjectId === i && e.category === t && e.enabled === !1).map((e) => e.channel));
+	return a.filter((e) => !o.has(e));
+}, L = () => {
+	let e = [], t = /* @__PURE__ */ new Map(), n = [], r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = [], o = (e) => `${e.subjectId}|${e.category}|${e.channel}`, s = (e, t) => `${e}|${t}`;
+	return {
+		addInbox: async (t) => {
+			e.unshift({
+				...t,
+				readAt: null,
+				data: t.data ?? {},
+				tenantId: t.tenantId ?? null
+			});
+		},
+		listInbox: async (t, n) => {
+			let r = e.filter((e) => e.subjectId === t);
+			return n?.unreadOnly && (r = r.filter((e) => e.readAt === null)), n?.limit === void 0 ? r : r.slice(0, n.limit);
+		},
+		markRead: async (t, n) => {
+			let r = e.findIndex((e) => e.id === t && e.subjectId === n);
+			return r === -1 ? !1 : (e[r] = {
+				...e[r],
+				readAt: (/* @__PURE__ */ new Date(0)).toISOString()
+			}, !0);
+		},
+		unreadCount: async (t) => e.filter((e) => e.subjectId === t && e.readAt === null).length,
+		getPreferences: async (e) => [...t.values()].filter((t) => t.subjectId === e),
+		setPreference: async (e) => {
+			t.set(o(e), e);
+		},
+		recordDelivery: async (e) => {
+			n.unshift(e);
+		},
+		listDeliveries: async (e) => e?.limit === void 0 ? [...n] : n.slice(0, e.limit),
+		subscribeTopic: async (e) => {
+			r.set(s(e.topic, e.subjectId), e);
+		},
+		unsubscribeTopic: async (e, t) => {
+			r.delete(s(e, t));
+		},
+		listTopicSubscribers: async (e) => [...r.values()].filter((t) => t.topic === e),
+		getQuietHours: async (e) => i.get(e) ?? null,
+		setQuietHours: async (e) => {
+			i.set(e.subjectId, e);
+		},
+		clearQuietHours: async (e) => {
+			i.delete(e);
+		},
+		enqueueHeld: async (e) => {
+			a.push(e);
+		},
+		pendingDigest: async (e) => a.filter((t) => t.kind === "digest" && t.subjectId === e),
+		dueHeld: async (e) => a.filter((t) => t.flushAt <= e).sort((e, t) => e.flushAt < t.flushAt ? -1 : 1),
+		clearHeld: async (e) => {
+			let t = new Set(e);
+			for (let e = a.length - 1; e >= 0; e--) t.has(a[e].id) && a.splice(e, 1);
+		}
+	};
+}, R = (e) => e instanceof Date ? e.toISOString() : typeof e == "string" ? e : "", z = (e) => {
+	let t = async (t, n, r, i) => await e.query({
+		table: t,
+		predicate: n,
+		order: r,
+		take: i,
+		skip: void 0,
+		projection: void 0
+	}), n = (e) => ({
+		id: String(e.id),
+		subjectId: String(e.subjectId),
+		category: String(e.category),
+		title: String(e.title),
+		body: String(e.body),
+		data: e.data ?? {},
+		readAt: e.readAt == null ? null : R(e.readAt),
+		createdAt: R(e.createdAt),
+		tenantId: e.tenantId ?? null
+	}), r = (e) => ({
+		subjectId: String(e.subjectId),
+		category: String(e.category),
+		channel: String(e.channel),
+		enabled: !!e.enabled
+	}), i = (e) => {
+		let t = {
+			id: String(e.id),
+			to: String(e.recipient),
+			category: String(e.category),
+			channel: String(e.channel),
+			status: e.status,
+			at: R(e.at)
+		};
+		return e.error == null ? t : {
+			...t,
+			error: String(e.error)
+		};
+	}, a = (e) => ({
+		topic: String(e.topic),
+		subjectId: String(e.subjectId),
+		tenantId: e.tenantId ?? null
+	}), o = (e) => ({
+		subjectId: String(e.subjectId),
+		startMinute: Number(e.startMinute),
+		endMinute: Number(e.endMinute),
+		tz: String(e.tz ?? "UTC"),
+		policy: e.policy === "drop" ? "drop" : "hold"
+	}), s = (e) => ({
+		id: String(e.id),
+		kind: e.kind === "quiet" ? "quiet" : "digest",
+		subjectId: String(e.subjectId),
+		send: e.send ?? {},
+		flushAt: R(e.flushAt)
+	});
+	return {
+		addInbox: async (t) => {
+			await e.insert("notification_inbox", {
+				id: t.id,
+				subjectId: t.subjectId,
+				category: t.category,
+				title: t.title,
+				body: t.body,
+				data: t.data ?? {},
+				readAt: null,
+				createdAt: t.createdAt,
+				tenantId: t.tenantId ?? null
+			});
+		},
+		listInbox: async (e, r) => {
+			let i = r?.unreadOnly ? m(g("subjectId", e), b("readAt")) : g("subjectId", e);
+			return (await t("notification_inbox", i, [{
+				column: "createdAt",
+				direction: "desc"
+			}], r?.limit)).map(n);
+		},
+		markRead: async (n, r) => (await t("notification_inbox", m(g("id", n), g("subjectId", r)), [], 1))[0] ? (await e.update("notification_inbox", n, { readAt: (/* @__PURE__ */ new Date()).toISOString() }), !0) : !1,
+		unreadCount: async (e) => (await t("notification_inbox", m(g("subjectId", e), b("readAt")), [], void 0)).length,
+		getPreferences: async (e) => (await t("notification_preferences", g("subjectId", e), [], void 0)).map(r),
+		setPreference: async (t) => {
+			let n = _({
+				kind: "typeid",
+				prefix: "notifpref"
+			}, "notification_preferences");
+			await e.upsert("notification_preferences", {
+				id: n,
+				subjectId: t.subjectId,
+				category: t.category,
+				channel: t.channel,
+				enabled: t.enabled
+			}, {
+				conflictColumns: [
+					"subjectId",
+					"category",
+					"channel"
+				],
+				update: ["enabled"]
+			});
+		},
+		recordDelivery: async (t) => {
+			await e.insert("notification_deliveries", {
+				id: t.id,
+				recipient: t.to,
+				category: t.category,
+				channel: t.channel,
+				status: t.status,
+				error: t.error ?? null,
+				at: t.at
+			});
+		},
+		listDeliveries: async (e) => (await t("notification_deliveries", void 0, [{
+			column: "at",
+			direction: "desc"
+		}], e?.limit)).map(i),
+		subscribeTopic: async (t) => {
+			let n = _({
+				kind: "typeid",
+				prefix: "notiftsub"
+			}, "notification_topic_subscriptions");
+			await e.upsert("notification_topic_subscriptions", {
+				id: n,
+				topic: t.topic,
+				subjectId: t.subjectId,
+				tenantId: t.tenantId ?? null
+			}, {
+				conflictColumns: ["topic", "subjectId"],
+				update: ["tenantId"]
+			});
+		},
+		unsubscribeTopic: async (n, r) => {
+			let i = await t("notification_topic_subscriptions", m(g("topic", n), g("subjectId", r)), [], 1);
+			i[0] && await e.delete("notification_topic_subscriptions", String(i[0].id));
+		},
+		listTopicSubscribers: async (e) => (await t("notification_topic_subscriptions", g("topic", e), [], void 0)).map(a),
+		getQuietHours: async (e) => {
+			let n = await t("notification_quiet_hours", g("subjectId", e), [], 1);
+			return n[0] ? o(n[0]) : null;
+		},
+		setQuietHours: async (t) => {
+			let n = _({
+				kind: "typeid",
+				prefix: "notifqh"
+			}, "notification_quiet_hours");
+			await e.upsert("notification_quiet_hours", {
+				id: n,
+				subjectId: t.subjectId,
+				startMinute: t.startMinute,
+				endMinute: t.endMinute,
+				tz: t.tz ?? "UTC",
+				policy: t.policy ?? "hold"
+			}, {
+				conflictColumns: ["subjectId"],
+				update: [
+					"startMinute",
+					"endMinute",
+					"tz",
+					"policy"
+				]
+			});
+		},
+		clearQuietHours: async (n) => {
+			let r = await t("notification_quiet_hours", g("subjectId", n), [], 1);
+			r[0] && await e.delete("notification_quiet_hours", String(r[0].id));
+		},
+		enqueueHeld: async (t) => {
+			await e.insert("notification_held", {
+				id: t.id,
+				kind: t.kind,
+				subjectId: t.subjectId,
+				send: t.send,
+				flushAt: t.flushAt
+			});
+		},
+		pendingDigest: async (e) => (await t("notification_held", m(g("kind", "digest"), g("subjectId", e)), [{
+			column: "flushAt",
+			direction: "asc"
+		}], void 0)).map(s),
+		dueHeld: async (e) => (await t("notification_held", S("flushAt", e), [{
+			column: "flushAt",
+			direction: "asc"
+		}], void 0)).map(s),
+		clearHeld: async (t) => {
+			for (let n of t) await e.delete("notification_held", n);
+		}
+	};
+}, B = (e) => ({
+	id: "inApp",
+	deliver: async (t) => {
+		await e.addInbox({
+			id: k(),
+			subjectId: t.to,
+			category: t.category,
+			title: t.title,
+			body: t.body,
+			data: t.data ?? {},
+			tenantId: t.tenantId ?? null,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+}), V = (e, t) => {
+	try {
+		let n = new Intl.DateTimeFormat("en-US", {
+			timeZone: t,
+			hour: "2-digit",
+			minute: "2-digit",
+			hour12: !1
+		}).formatToParts(e), r = Number(n.find((e) => e.type === "hour")?.value ?? "0") % 24, i = Number(n.find((e) => e.type === "minute")?.value ?? "0");
+		return r * 60 + i;
+	} catch {
+		return e.getUTCHours() * 60 + e.getUTCMinutes();
+	}
+}, H = (e, t) => {
+	if (e.startMinute === e.endMinute) return !1;
+	let n = V(t, e.tz ?? "UTC");
+	return e.startMinute < e.endMinute ? n >= e.startMinute && n < e.endMinute : n >= e.startMinute || n < e.endMinute;
+}, U = (e, t) => {
+	let n = V(t, e.tz ?? "UTC"), r = e.endMinute - n;
+	return r <= 0 && (r += 1440), new Date(t.getTime() + r * 6e4);
+}, W = (e) => {
+	let t = new Map(e.channels.map((e) => [e.id, e])), n = e.channels.map((e) => e.id), r = e.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()), i = e.digestWindowMs ?? 0, a = async (i) => {
+		let a = await e.store.getPreferences(i.to), o = I(n, i.category, i.channels, a, i.to), s = n.filter((e) => !o.includes(e)), c = [], l = [], u = {
+			to: i.to,
+			category: i.category,
+			title: i.title,
+			body: i.body,
+			...i.data ? { data: i.data } : {},
+			tenantId: i.tenantId ?? null
+		};
+		for (let n of o) {
+			let a = t.get(n);
+			if (!a) continue;
+			let o = {
+				id: k(),
+				to: i.to,
+				category: i.category,
+				channel: n,
+				at: r()
+			};
+			try {
+				await a.deliver(u), c.push(n), await e.store.recordDelivery({
+					...o,
+					status: "sent"
+				});
+			} catch (t) {
+				let r = t instanceof Error ? t.message : String(t);
+				l.push({
+					channel: n,
+					error: r
+				}), await e.store.recordDelivery({
+					...o,
+					status: "failed",
+					error: r
+				});
+			}
+		}
+		return {
+			delivered: c,
+			failed: l,
+			skipped: s
+		};
+	}, o = async (t) => {
+		let n = await e.store.getQuietHours(t.to), o = new Date(r());
+		if (n && H(n, o)) return (n.policy ?? "hold") === "drop" ? {
+			delivered: [],
+			failed: [],
+			skipped: [],
+			held: "quiet-drop"
+		} : (await e.store.enqueueHeld({
+			id: k(),
+			kind: "quiet",
+			subjectId: t.to,
+			send: t,
+			flushAt: U(n, o).toISOString()
+		}), {
+			delivered: [],
+			failed: [],
+			skipped: [],
+			held: "quiet-held"
+		});
+		if (i > 0 && !t.channels) {
+			let n = (await e.store.pendingDigest(t.to))[0]?.flushAt ?? new Date(o.getTime() + i).toISOString();
+			return await e.store.enqueueHeld({
+				id: k(),
+				kind: "digest",
+				subjectId: t.to,
+				send: t,
+				flushAt: n
+			}), {
+				delivered: [],
+				failed: [],
+				skipped: [],
+				held: "digest"
+			};
+		}
+		return a(t);
+	};
+	return {
+		send: o,
+		inbox: (t, n) => e.store.listInbox(t, n),
+		unreadCount: (t) => e.store.unreadCount(t),
+		markRead: (t, n) => e.store.markRead(t, n),
+		getPreferences: (t) => e.store.getPreferences(t),
+		setPreference: (t) => e.store.setPreference(t),
+		subscribe: (t, n, r) => e.store.subscribeTopic({
+			topic: t,
+			subjectId: n,
+			tenantId: r ?? null
+		}),
+		unsubscribe: (t, n) => e.store.unsubscribeTopic(t, n),
+		broadcast: async (t, n) => {
+			let r = await e.store.listTopicSubscribers(t), i = [];
+			for (let e of r) i.push(await o({
+				...n,
+				to: e.subjectId,
+				tenantId: n.tenantId ?? e.tenantId ?? null
+			}));
+			return {
+				recipients: r.length,
+				results: i
+			};
+		},
+		setQuietHours: (t) => e.store.setQuietHours(t),
+		clearQuietHours: (t) => e.store.clearQuietHours(t),
+		getQuietHours: (t) => e.store.getQuietHours(t),
+		flushDue: async (t = new Date(r())) => {
+			let n = await e.store.dueHeld(t.toISOString());
+			if (n.length === 0) return 0;
+			for (let e of n.filter((e) => e.kind === "quiet")) await a(e.send);
+			let i = /* @__PURE__ */ new Map();
+			for (let e of n.filter((e) => e.kind === "digest")) {
+				let t = i.get(e.subjectId) ?? [];
+				t.push(e), i.set(e.subjectId, t);
+			}
+			for (let [e, t] of i) await a(G(e, t));
+			return await e.store.clearHeld(n.map((e) => e.id)), n.length;
+		}
+	};
+}, G = (e, t) => {
+	if (t.length === 1) return t[0].send;
+	let n = t.map((e) => ({
+		category: e.send.category,
+		title: e.send.title,
+		body: e.send.body
+	}));
+	return {
+		to: e,
+		category: "digest",
+		title: `${t.length} new notifications`,
+		body: n.map((e) => `• ${e.title}`).join("\n"),
+		data: { items: n },
+		tenantId: t[0].send.tenantId ?? null
+	};
+}, K = T("notification_inbox", {
+	id: v({ prefix: "notif" }),
+	subjectId: E(),
+	category: E(),
+	title: E(),
+	body: E(),
+	data: x(),
+	readAt: D().nullable(),
+	createdAt: D().default("now"),
+	tenantId: E().nullable()
+}).index("bySubject", ["subjectId"]), q = T("notification_preferences", {
+	id: v({ prefix: "notifpref" }),
+	subjectId: E(),
+	category: E(),
+	channel: E(),
+	enabled: h().default(!0)
+}).unique("bySubjectCategoryChannel", [
+	"subjectId",
+	"category",
+	"channel"
+]), J = T("notification_deliveries", {
+	id: v({ prefix: "notifdlv" }),
+	recipient: E(),
+	category: E(),
+	channel: E(),
+	status: E(),
+	error: E().nullable(),
+	at: D().default("now")
+}).index("byAt", ["at"]), Y = T("notification_topic_subscriptions", {
+	id: v({ prefix: "notiftsub" }),
+	topic: E(),
+	subjectId: E(),
+	tenantId: E().nullable()
+}).unique("byTopicSubject", ["topic", "subjectId"]).index("byTopic", ["topic"]), X = T("notification_quiet_hours", {
+	id: v({ prefix: "notifqh" }),
+	subjectId: E(),
+	startMinute: y(),
+	endMinute: y(),
+	tz: E().default("UTC"),
+	policy: E().default("hold")
+}).unique("bySubject", ["subjectId"]), Z = T("notification_held", {
+	id: v({ prefix: "notifheld" }),
+	kind: E(),
+	subjectId: E(),
+	send: x(),
+	flushAt: D()
+}).index("byFlushAt", ["flushAt"]).index("bySubjectKind", ["subjectId", "kind"]), Q = class extends u.Tag("@voltro/plugin-notifications/NotificationService")() {}, $ = (e) => e.request.subject.id ?? "anonymous", ne = (e) => e.request.subject.tenantId ?? null, re = (u = {}) => {
+	let p = u.name ? `@voltro/plugin-notifications#${u.name}` : "@voltro/plugin-notifications";
+	C({
+		table: "notification_deliveries",
+		timeColumn: "at",
+		ttlMs: w(process.env.VOLTRO_NOTIFICATION_DELIVERIES_TTL_HOURS, 2160)
+	}), C({
+		table: "notification_inbox",
+		timeColumn: "createdAt",
+		ttlMs: w(process.env.VOLTRO_NOTIFICATION_INBOX_READ_TTL_HOURS, 4320),
+		where: ee("readAt")
+	}), C({
+		table: "notification_held",
+		timeColumn: "flushAt",
+		ttlMs: w(process.env.VOLTRO_NOTIFICATION_HELD_TTL_HOURS, 168)
+	});
+	let m = u.store === void 0, h = { current: u.store ?? L() }, g = {
+		addInbox: (e) => h.current.addInbox(e),
+		listInbox: (e, t) => h.current.listInbox(e, t),
+		markRead: (e, t) => h.current.markRead(e, t),
+		unreadCount: (e) => h.current.unreadCount(e),
+		getPreferences: (e) => h.current.getPreferences(e),
+		setPreference: (e) => h.current.setPreference(e),
+		recordDelivery: (e) => h.current.recordDelivery(e),
+		listDeliveries: (e) => h.current.listDeliveries(e),
+		subscribeTopic: (e) => h.current.subscribeTopic(e),
+		unsubscribeTopic: (e, t) => h.current.unsubscribeTopic(e, t),
+		listTopicSubscribers: (e) => h.current.listTopicSubscribers(e),
+		getQuietHours: (e) => h.current.getQuietHours(e),
+		setQuietHours: (e) => h.current.setQuietHours(e),
+		clearQuietHours: (e) => h.current.clearQuietHours(e),
+		enqueueHeld: (e) => h.current.enqueueHeld(e),
+		pendingDigest: (e) => h.current.pendingDigest(e),
+		dueHeld: (e) => h.current.dueHeld(e),
+		clearHeld: (e) => h.current.clearHeld(e)
+	}, _ = u.channels ?? [j()], v = _.some((e) => e.id === "inApp") ? _ : [..._, B(g)], y = u.digestWindowMs ?? 0, b = W({
+		channels: v,
+		store: g,
+		digestWindowMs: y
+	}), x, S = [
+		{
+			...t,
+			description: "The caller's in-app inbox items.",
+			execute: (e, t) => d.promise(() => b.inbox($(t), e))
+		},
+		{
+			...c,
+			description: "The caller's unread count.",
+			execute: (e, t) => d.promise(async () => ({ count: await b.unreadCount($(t)) }))
+		},
+		{
+			...n,
+			description: "Mark an inbox item read.",
+			execute: (e, t) => d.promise(async () => ({ ok: await b.markRead(e.id, $(t)) }))
+		},
+		{
+			...i,
+			description: "The caller's channel preferences.",
+			execute: (e, t) => d.promise(() => b.getPreferences($(t)))
+		},
+		{
+			...a,
+			description: "Toggle a channel on/off for a category.",
+			execute: (e, t) => d.promise(async () => {
+				let { category: n, channel: r, enabled: i } = e;
+				return await b.setPreference({
+					subjectId: $(t),
+					category: n,
+					channel: r,
+					enabled: i
+				}), { ok: !0 };
+			})
+		},
+		{
+			...s,
+			description: "Subscribe the caller to a broadcast topic.",
+			execute: (e, t) => d.promise(async () => (await b.subscribe(e.topic, $(t), ne(t)), { ok: !0 }))
+		},
+		{
+			...l,
+			description: "Unsubscribe the caller from a broadcast topic.",
+			execute: (e, t) => d.promise(async () => (await b.unsubscribe(e.topic, $(t)), { ok: !0 }))
+		},
+		{
+			...o,
+			description: "Set the caller's quiet-hours (DND) window.",
+			execute: (e, t) => d.promise(async () => {
+				let n = e;
+				return await b.setQuietHours({
+					subjectId: $(t),
+					startMinute: n.startMinute,
+					endMinute: n.endMinute,
+					...n.tz ? { tz: n.tz } : {},
+					...n.policy ? { policy: n.policy } : {}
+				}), { ok: !0 };
+			})
+		},
+		{
+			...e,
+			description: "Clear the caller's quiet-hours window.",
+			execute: (e, t) => d.promise(async () => (await b.clearQuietHours($(t)), { ok: !0 }))
+		}
+	], T = (e) => ({
+		kind: "json",
+		data: e
+	}), E = (e, t) => ({
+		kind: "json",
+		status: e,
+		data: { error: t }
+	}), D = (e, t) => new URLSearchParams(new URL(e, "http://x").search).get(t);
+	return O({
+		name: p,
+		description: "Unified notifications — email/slack/sms/push/in-app with preference routing, inbox + delivery log.",
+		permissions: ["inspect:read", "store:write"],
+		extendSchema: { tables: [
+			K,
+			q,
+			J,
+			Y,
+			X,
+			Z
+		] },
+		services: f.succeed(Q, b),
+		routes: S,
+		rpcClientDescriptors: r,
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/deliveries",
+			description: "Recent delivery records (newest first) + per-channel + per-status counts.",
+			handler: () => d.promise(async () => {
+				let e = await g.listDeliveries({ limit: 200 }), t = {}, n = 0, r = 0;
+				for (let i of e) t[i.channel] = (t[i.channel] ?? 0) + 1, i.status === "sent" ? n++ : r++;
+				return T({
+					deliveries: e.slice(0, 100),
+					channels: v.map((e) => e.id),
+					stats: {
+						sent: n,
+						failed: r,
+						byChannel: t
+					}
+				});
+			})
+		}, {
+			method: "GET",
+			path: "/inbox",
+			description: "In-app inbox for a subject (?subjectId=…).",
+			handler: (e) => {
+				let t = D(e.url, "subjectId");
+				return t ? d.promise(async () => T({
+					items: await g.listInbox(t, { limit: 100 }),
+					unread: await g.unreadCount(t)
+				})) : d.succeed(E(400, "subjectId query param required"));
+			}
+		}],
+		bindDataStore: (e) => {
+			m && (h.current = z(e));
+			let t = u.flushIntervalMs ?? 3e4;
+			x = setInterval(() => {
+				b.flushDue().catch(() => {});
+			}, t), typeof x.unref == "function" && x.unref();
+		},
+		onActivate: (e) => d.sync(() => e.logger.info("notifications active", {
+			channels: v.map((e) => e.id),
+			digestWindowMs: y
+		})),
+		onDeactivate: () => d.sync(() => {
+			x && clearInterval(x), x = void 0;
+		})
+	});
+};
+//#endregion
+export { Q as NotificationService, A as PushTokenRejected, W as buildNotificationService, j as consoleChannel, te as customChannel, z as dataStoreNotificationStore, N as emailChannel, B as inAppChannel, H as inQuietHours, L as memoryNotificationStore, V as minuteOfDayInZone, re as notificationsPlugin, F as pushChannel, U as quietHoursEnd, I as resolveChannels, P as smsChannel, M as webhookChannel };