@voltro/plugin-notifications 0.86.0 → 0.88.0

package/dist/index.js

@@ -2,76 +2,76 @@ import { PushTokenRejected as e } from "./errors.js";
 import { consoleChannel as t, customChannel as n, emailChannel as r, pushChannel as i, resolveChannels as a, richPushOf as o, smsChannel as s, webhookChannel as c } from "./channels.js";
 import { dataStoreNotificationStore as l, memoryNotificationStore as u } from "./store.js";
 import { buildNotificationService as d, inAppChannel as f, inQuietHours as p, minuteOfDayInZone as m, quietHoursEnd as h } from "./service.js";
-import { BASE_NAME as g, archiveDescriptor as _, clearQuietHoursDescriptor as ee, inboxDescriptor as te, inboxFeed as ne, markAllReadDescriptor as re, markReadDescriptor as ie, markUnreadDescriptor as ae, notificationsRpcClientImports as v, preferencesDescriptor as oe, setPreferenceDescriptor as se, setQuietHoursDescriptor as ce, subscribeDescriptor as y, unarchiveDescriptor as le, unreadCountDescriptor as ue, unsubscribeDescriptor as de, webPushPublicKeyDescriptor as fe, webPushRpcClientImports as pe, webPushStatusDescriptor as me, webPushSubscribeDescriptor as he, webPushUnsubscribeDescriptor as ge } from "./rpc.js";
-import { clickTokenMatches as _e, decryptWebPushPayload as b, encryptWebPushPayload as x, generateVapidPrivateKey as S, sendWebPush as C, vapidAuthorization as w, vapidPublicKeyFor as T } from "./webPushProtocol.js";
-import { assertWebPushConfigured as ve, bindWebPushStore as ye, dataStorePushSubscriptionStore as E, endpointHashOf as D, memoryPushSubscriptionStore as O, pushSubscriptionsTable as k, resetWebPushStoreForTest as be, webPushCell as A, webPushChannel as j, webPushPublicKey as M } from "./webPush.js";
-import { defineNotification as N } from "./define.js";
-import { sendNotification as xe } from "./sendNotification.js";
-import { NOTIFICATION_SEND_EFFECT as Se, enqueueNotification as Ce, notificationOutboxHandler as we } from "./durable.js";
-import { APNS_HOSTS as Te, APNS_TOKEN_REJECTIONS as Ee, apnsBody as De, apnsProviderToken as Oe, apnsTransport as ke } from "./apnsPush.js";
-import { FCM_SCOPE as Ae, FCM_TOKEN_REJECTIONS as je, GOOGLE_TOKEN_URI as P, fcmAssertion as Me, fcmMessage as Ne, fcmSendEndpoint as Pe, fcmTransport as Fe, parseServiceAccount as Ie } from "./fcmPush.js";
-import { EXPO_PUSH_ENDPOINT as Le, expoPushTransport as Re, isExpoPushToken as ze } from "./expoPush.js";
-import { Context as Be, Effect as F, Layer as Ve } from "effect";
-import { boolean as He, id as I, integer as L, isNotNull as Ue, json as R, registerRetention as z, retentionTtlMsFromEnv as B, table as V, text as H, timestamp as U } from "@voltro/database";
-import { definePlugin as We, pluginInstanceName as Ge, publishReactivity as Ke } from "@voltro/protocol";
-//#region src/index.ts
-var W = V("_voltro_notification_inbox", {
-	id: I({ prefix: "notif" }),
-	subjectId: H(),
-	category: H(),
-	title: H(),
-	body: H(),
-	data: R(),
-	readAt: U().nullable(),
-	archivedAt: U().nullable(),
-	createdAt: U().default("now"),
-	tenantId: H().nullable()
-}).renamedFrom("notification_inbox").index("byInboxSubject", ["subjectId"]).index("byInboxSubjectCreatedAt", ["subjectId", "createdAt"]).index("byInboxSubjectUnread", ["subjectId"], { where: "\"readAt\" IS NULL" }), G = V("_voltro_notification_preferences", {
-	id: I({ prefix: "notifpref" }),
-	subjectId: H(),
-	category: H(),
-	channel: H(),
-	enabled: He().default(!0)
+import { BASE_NAME as g, archiveDescriptor as ee, clearQuietHoursDescriptor as te, inboxDescriptor as ne, inboxFeed as re, markAllReadDescriptor as ie, markReadDescriptor as ae, markUnreadDescriptor as oe, notificationsRpcClientImports as _, preferencesDescriptor as se, preferencesFeed as ce, setPreferenceDescriptor as le, setQuietHoursDescriptor as v, subscribeDescriptor as ue, unarchiveDescriptor as de, unreadCountDescriptor as fe, unsubscribeDescriptor as pe, webPushPublicKeyDescriptor as me, webPushRpcClientImports as he, webPushStatusDescriptor as ge, webPushSubscribeDescriptor as _e, webPushUnsubscribeDescriptor as ve } from "./rpc.js";
+import { clickTokenMatches as ye, decryptWebPushPayload as y, encryptWebPushPayload as b, generateVapidPrivateKey as x, sendWebPush as S, vapidAuthorization as C, vapidPublicKeyFor as w } from "./webPushProtocol.js";
+import { assertWebPushConfigured as be, bindWebPushStore as xe, dataStorePushSubscriptionStore as T, endpointHashOf as E, memoryPushSubscriptionStore as D, pushSubscriptionsTable as O, resetWebPushStoreForTest as k, webPushCell as A, webPushChannel as j, webPushPublicKey as M } from "./webPush.js";
+import { defineNotification as Se } from "./define.js";
+import { sendNotification as Ce } from "./sendNotification.js";
+import { NOTIFICATION_SEND_EFFECT as we, enqueueNotification as Te, notificationOutboxHandler as Ee } from "./durable.js";
+import { APNS_HOSTS as De, APNS_TOKEN_REJECTIONS as Oe, apnsBody as ke, apnsProviderToken as Ae, apnsTransport as je } from "./apnsPush.js";
+import { FCM_SCOPE as Me, FCM_TOKEN_REJECTIONS as N, GOOGLE_TOKEN_URI as Ne, fcmAssertion as Pe, fcmMessage as Fe, fcmSendEndpoint as Ie, fcmTransport as Le, parseServiceAccount as Re } from "./fcmPush.js";
+import { EXPO_PUSH_ENDPOINT as ze, expoPushTransport as Be, isExpoPushToken as Ve } from "./expoPush.js";
+import { Context as He, Effect as P, Layer as Ue } from "effect";
+import { boolean as We, id as F, integer as I, isNotNull as Ge, json as L, registerRetention as R, retentionTtlMsFromEnv as z, table as B, text as V, timestamp as H } from "@voltro/database";
+import { definePlugin as Ke, pluginInstanceName as qe, publishReactivity as U } from "@voltro/protocol";
+// src/index.ts
+var W = B("_voltro_notification_inbox", {
+	id: F({ prefix: "notif" }),
+	subjectId: V(),
+	category: V(),
+	title: V(),
+	body: V(),
+	data: L(),
+	readAt: H().nullable(),
+	archivedAt: H().nullable(),
+	createdAt: H().default("now"),
+	tenantId: V().nullable()
+}).renamedFrom("notification_inbox").index("byInboxSubject", ["subjectId"]).index("byInboxSubjectCreatedAt", ["subjectId", "createdAt"]).index("byInboxSubjectUnread", ["subjectId"], { where: "\"readAt\" IS NULL" }), G = B("_voltro_notification_preferences", {
+	id: F({ prefix: "notifpref" }),
+	subjectId: V(),
+	category: V(),
+	channel: V(),
+	enabled: We().default(!0)
 }).renamedFrom("notification_preferences").unique("byPreferencesSubjectCategoryChannel", [
 	"subjectId",
 	"category",
 	"channel"
-]), K = V("_voltro_notification_deliveries", {
-	id: I({ prefix: "notifdlv" }),
-	recipient: H(),
-	category: H(),
-	channel: H(),
-	status: H(),
-	error: H().nullable(),
-	at: U().default("now"),
-	endpoint: H().nullable(),
-	clickToken: H().nullable(),
-	clickedAt: U().nullable()
-}).renamedFrom("notification_deliveries").index("byDeliveriesAt", ["at"]).index("byDeliveriesClickToken", ["clickToken"]), q = V("_voltro_notification_topic_subscriptions", {
-	id: I({ prefix: "notiftsub" }),
-	topic: H(),
-	subjectId: H(),
-	tenantId: H().nullable()
-}).renamedFrom("notification_topic_subscriptions").unique("byTopicSubject", ["topic", "subjectId"]).index("byTopic", ["topic"]), J = V("_voltro_notification_quiet_hours", {
-	id: I({ prefix: "notifqh" }),
-	subjectId: H(),
-	startMinute: L(),
-	endMinute: L(),
-	tz: H().default("UTC"),
-	policy: H().default("hold")
-}).renamedFrom("notification_quiet_hours").unique("byQuietHoursSubject", ["subjectId"]), Y = V("_voltro_notification_held", {
-	id: I({ prefix: "notifheld" }),
-	kind: H(),
-	subjectId: H(),
-	send: R(),
-	flushAt: U()
-}).renamedFrom("notification_held").index("byHeldFlushAt", ["flushAt"]).index("byHeldSubjectKind", ["subjectId", "kind"]), X = class extends Be.Service()("@voltro/plugin-notifications/NotificationService") {}, Z = (e) => async (t) => {
+]), K = B("_voltro_notification_deliveries", {
+	id: F({ prefix: "notifdlv" }),
+	recipient: V(),
+	category: V(),
+	channel: V(),
+	status: V(),
+	error: V().nullable(),
+	at: H().default("now"),
+	endpoint: V().nullable(),
+	clickToken: V().nullable(),
+	clickedAt: H().nullable()
+}).renamedFrom("notification_deliveries").index("byDeliveriesAt", ["at"]).index("byDeliveriesClickToken", ["clickToken"]), q = B("_voltro_notification_topic_subscriptions", {
+	id: F({ prefix: "notiftsub" }),
+	topic: V(),
+	subjectId: V(),
+	tenantId: V().nullable()
+}).renamedFrom("notification_topic_subscriptions").unique("byTopicSubject", ["topic", "subjectId"]).index("byTopic", ["topic"]), J = B("_voltro_notification_quiet_hours", {
+	id: F({ prefix: "notifqh" }),
+	subjectId: V(),
+	startMinute: I(),
+	endMinute: I(),
+	tz: V().default("UTC"),
+	policy: V().default("hold")
+}).renamedFrom("notification_quiet_hours").unique("byQuietHoursSubject", ["subjectId"]), Y = B("_voltro_notification_held", {
+	id: F({ prefix: "notifheld" }),
+	kind: V(),
+	subjectId: V(),
+	send: L(),
+	flushAt: H()
+}).renamedFrom("notification_held").index("byHeldFlushAt", ["flushAt"]).index("byHeldSubjectKind", ["subjectId", "kind"]), X = class extends He.Service()("@voltro/plugin-notifications/NotificationService") {}, Z = (e) => async (t) => {
 	if (e !== void 0) try {
 		let n = await e(t);
 		if (typeof n == "string" && n !== "") return n;
 	} catch {}
 	return t.request.subject.id ?? "anonymous";
-}, Q = (e) => e.request.subject.tenantId ?? null, $ = g, qe = { collects: [
+}, Q = (e) => e.request.subject.tenantId ?? null, $ = g, Je = { collects: [
 	{
 		category: "device-id",
 		linked: !0,
@@ -90,33 +90,33 @@ var W = V("_voltro_notification_inbox", {
 		tracking: !1,
 		purposes: ["app-functionality"]
 	}
-] }, Je = (e = {}) => {
-	let n = Z(e.resolveSubjectId), r = Ge({
+] }, Ye = (e = {}) => {
+	let n = Z(e.resolveSubjectId), r = qe({
 		base: $,
 		alias: e.alias,
 		instance: e.name
 	});
-	z({
+	R({
 		source: "plugin",
 		table: "_voltro_notification_deliveries",
 		timeColumn: "at",
-		ttlMs: B(process.env.VOLTRO_NOTIFICATION_DELIVERIES_TTL_HOURS, 2160),
+		ttlMs: z(process.env.VOLTRO_NOTIFICATION_DELIVERIES_TTL_HOURS, 2160),
 		envVar: "VOLTRO_NOTIFICATION_DELIVERIES_TTL_HOURS"
-	}), z({
+	}), R({
 		source: "plugin",
 		table: "_voltro_notification_inbox",
 		timeColumn: "createdAt",
-		ttlMs: B(process.env.VOLTRO_NOTIFICATION_INBOX_READ_TTL_HOURS, 4320),
+		ttlMs: z(process.env.VOLTRO_NOTIFICATION_INBOX_READ_TTL_HOURS, 4320),
 		envVar: "VOLTRO_NOTIFICATION_INBOX_READ_TTL_HOURS",
-		where: Ue("readAt")
-	}), z({
+		where: Ge("readAt")
+	}), R({
 		source: "plugin",
 		table: "_voltro_notification_held",
 		timeColumn: "flushAt",
-		ttlMs: B(process.env.VOLTRO_NOTIFICATION_HELD_TTL_HOURS, 168),
+		ttlMs: z(process.env.VOLTRO_NOTIFICATION_HELD_TTL_HOURS, 168),
 		envVar: "VOLTRO_NOTIFICATION_HELD_TTL_HOURS"
 	});
-	let i = e.store === void 0, a = { current: e.store ?? u() }, o, s = (e) => e.then((e) => (Ke(o, ne), e)), c = {
+	let i = e.store === void 0, a = { current: e.store ?? u() }, o, s = (e) => e.then((e) => (U(o, re), e)), c = (e) => e.then((e) => (U(o, ce), e)), p = {
 		addInbox: (e) => s(a.current.addInbox(e)),
 		listInbox: (e, t) => a.current.listInbox(e, t),
 		markRead: (e, t) => s(a.current.markRead(e, t)),
@@ -125,7 +125,7 @@ var W = V("_voltro_notification_inbox", {
 		setArchived: (e, t, n) => s(a.current.setArchived(e, t, n)),
 		unreadCount: (e) => a.current.unreadCount(e),
 		getPreferences: (e) => a.current.getPreferences(e),
-		setPreference: (e) => a.current.setPreference(e),
+		setPreference: (e) => c(a.current.setPreference(e)),
 		recordDelivery: (e) => a.current.recordDelivery(e),
 		listDeliveries: (e) => a.current.listDeliveries(e),
 		markClicked: (e) => a.current.markClicked(e),
@@ -139,55 +139,56 @@ var W = V("_voltro_notification_inbox", {
 		pendingDigest: (e) => a.current.pendingDigest(e),
 		dueHeld: (e) => a.current.dueHeld(e),
 		clearHeld: (e) => a.current.clearHeld(e)
-	}, p = e.channels ?? [t()], m = p.some((e) => e.id === "inApp") ? p : [...p, f(c)], h = e.digestWindowMs ?? 0, g = m.some((e) => e.id === "webPush"), b = d({
-		channels: m,
-		store: c,
-		digestWindowMs: h
+	}, m = e.channels ?? [t()], h = m.some((e) => e.id === "inApp") ? m : [...m, f(p)], g = e.digestWindowMs ?? 0, y = h.some((e) => e.id === "webPush"), b = d({
+		channels: h,
+		store: p,
+		digestWindowMs: g,
+		...e.deliveryGuards === void 0 ? {} : { deliveryGuards: e.deliveryGuards }
 	}), x, S = [
 		{
-			...te,
+			...ne,
 			description: "The caller's in-app inbox items.",
-			execute: (e, t) => F.promise(async () => b.inbox(await n(t), e))
+			execute: (e, t) => P.promise(async () => b.inbox(await n(t), e))
 		},
 		{
-			...ue,
+			...fe,
 			description: "The caller's unread count.",
-			execute: (e, t) => F.promise(async () => ({ count: await b.unreadCount(await n(t)) }))
+			execute: (e, t) => P.promise(async () => ({ count: await b.unreadCount(await n(t)) }))
 		},
 		{
-			...ie,
+			...ae,
 			description: "Mark an inbox item read.",
-			execute: (e, t) => F.promise(async () => ({ ok: await b.markRead(e.id, await n(t)) }))
+			execute: (e, t) => P.promise(async () => ({ ok: await b.markRead(e.id, await n(t)) }))
 		},
 		{
-			...ae,
+			...oe,
 			description: "Mark an inbox item unread again.",
-			execute: (e, t) => F.promise(async () => ({ ok: await b.markUnread(e.id, await n(t)) }))
+			execute: (e, t) => P.promise(async () => ({ ok: await b.markUnread(e.id, await n(t)) }))
 		},
 		{
-			...re,
+			...ie,
 			description: "Mark every unread item in the caller's inbox read.",
-			execute: (e, t) => F.promise(async () => ({ count: await b.markAllRead(await n(t)) }))
+			execute: (e, t) => P.promise(async () => ({ count: await b.markAllRead(await n(t)) }))
 		},
 		{
-			..._,
+			...ee,
 			description: "Archive an inbox item — a different state from read; this is what empties the inbox.",
-			execute: (e, t) => F.promise(async () => ({ ok: await b.setArchived(e.id, await n(t), !0) }))
+			execute: (e, t) => P.promise(async () => ({ ok: await b.setArchived(e.id, await n(t), !0) }))
 		},
 		{
-			...le,
+			...de,
 			description: "Return an archived item to the inbox.",
-			execute: (e, t) => F.promise(async () => ({ ok: await b.setArchived(e.id, await n(t), !1) }))
+			execute: (e, t) => P.promise(async () => ({ ok: await b.setArchived(e.id, await n(t), !1) }))
 		},
 		{
-			...oe,
+			...se,
 			description: "The caller's channel preferences.",
-			execute: (e, t) => F.promise(async () => b.getPreferences(await n(t)))
+			execute: (e, t) => P.promise(async () => b.getPreferences(await n(t)))
 		},
 		{
-			...se,
+			...le,
 			description: "Toggle a channel on/off for a category.",
-			execute: (e, t) => F.promise(async () => {
+			execute: (e, t) => P.promise(async () => {
 				let { category: r, channel: i, enabled: a } = e;
 				return await b.setPreference({
 					subjectId: await n(t),
@@ -198,19 +199,19 @@ var W = V("_voltro_notification_inbox", {
 			})
 		},
 		{
-			...y,
+			...ue,
 			description: "Subscribe the caller to a broadcast topic.",
-			execute: (e, t) => F.promise(async () => (await b.subscribe(e.topic, await n(t), Q(t)), { ok: !0 }))
+			execute: (e, t) => P.promise(async () => (await b.subscribe(e.topic, await n(t), Q(t)), { ok: !0 }))
 		},
 		{
-			...de,
+			...pe,
 			description: "Unsubscribe the caller from a broadcast topic.",
-			execute: (e, t) => F.promise(async () => (await b.unsubscribe(e.topic, await n(t)), { ok: !0 }))
+			execute: (e, t) => P.promise(async () => (await b.unsubscribe(e.topic, await n(t)), { ok: !0 }))
 		},
 		{
-			...ce,
+			...v,
 			description: "Set the caller's quiet-hours (DND) window.",
-			execute: (e, t) => F.promise(async () => {
+			execute: (e, t) => P.promise(async () => {
 				let r = e;
 				return await b.setQuietHours({
 					subjectId: await n(t),
@@ -222,25 +223,25 @@ var W = V("_voltro_notification_inbox", {
 			})
 		},
 		{
-			...ee,
+			...te,
 			description: "Clear the caller's quiet-hours window.",
-			execute: (e, t) => F.promise(async () => (await b.clearQuietHours(await n(t)), { ok: !0 }))
+			execute: (e, t) => P.promise(async () => (await b.clearQuietHours(await n(t)), { ok: !0 }))
 		}
-	], C = g ? [
+	], C = y ? [
 		{
-			...fe,
+			...me,
 			description: "The VAPID application-server key a subscribing browser needs.",
-			execute: () => F.sync(() => ({ key: M(A().channelOptions?.privateKey) }))
+			execute: () => P.sync(() => ({ key: M(A().channelOptions?.privateKey) }))
 		},
 		{
-			...he,
+			..._e,
 			description: "Register the calling subject's browser push subscription (one row per endpoint).",
-			execute: (e, t) => F.promise(async () => {
+			execute: (e, t) => P.promise(async () => {
 				let r = e;
 				return await A().store.upsert({
 					subjectId: await n(t),
 					endpoint: r.endpoint,
-					endpointHash: D(r.endpoint),
+					endpointHash: E(r.endpoint),
 					p256dh: r.p256dh,
 					auth: r.auth,
 					ua: r.ua ?? null,
@@ -249,14 +250,14 @@ var W = V("_voltro_notification_inbox", {
 			})
 		},
 		{
-			...ge,
+			...ve,
 			description: "Remove one of the calling subject's own subscriptions.",
-			execute: (e, t) => F.promise(async () => ({ ok: await A().store.removeForSubject(D(e.endpoint), await n(t)) }))
+			execute: (e, t) => P.promise(async () => ({ ok: await A().store.removeForSubject(E(e.endpoint), await n(t)) }))
 		},
 		{
-			...me,
+			...ge,
 			description: "How many push endpoints the calling subject has registered.",
-			execute: (e, t) => F.promise(async () => ({ endpoints: await A().store.countForSubject(await n(t)) }))
+			execute: (e, t) => P.promise(async () => ({ endpoints: await A().store.countForSubject(await n(t)) }))
 		}
 	] : [], w = (e) => ({
 		kind: "json",
@@ -265,18 +266,18 @@ var W = V("_voltro_notification_inbox", {
 		kind: "json",
 		status: e,
 		data: { error: t }
-	}), E = (e, t) => new URLSearchParams(new URL(e, "http://x").search).get(t), O = [{
+	}), D = (e, t) => new URLSearchParams(new URL(e, "http://x").search).get(t), k = [{
 		method: "GET",
 		path: "/deliveries",
 		scope: "process",
 		description: "Recent delivery records (newest first) + per-channel + per-status counts.",
-		handler: () => F.promise(async () => {
-			let e = await c.listDeliveries({ limit: 200 }), t = {}, n = 0, r = 0;
+		handler: () => P.promise(async () => {
+			let e = await p.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++ : i.status === "failed" && r++;
 			let i = e.slice(0, 100).map(({ clickToken: e, ...t }) => t);
 			return w({
 				deliveries: i,
-				channels: m.map((e) => e.id),
+				channels: h.map((e) => e.id),
 				stats: {
 					sent: n,
 					failed: r,
@@ -290,15 +291,15 @@ var W = V("_voltro_notification_inbox", {
 		scope: "process",
 		description: "In-app inbox for a subject (?subjectId=…).",
 		handler: (e) => {
-			let t = E(e.url, "subjectId");
-			return t ? F.promise(async () => w({
-				items: await c.listInbox(t, { limit: 100 }),
-				unread: await c.unreadCount(t)
-			})) : F.succeed(T(400, "subjectId query param required"));
+			let t = D(e.url, "subjectId");
+			return t ? P.promise(async () => w({
+				items: await p.listInbox(t, { limit: 100 }),
+				unread: await p.unreadCount(t)
+			})) : P.succeed(T(400, "subjectId query param required"));
 		}
 	}];
-	return We({
-		privacy: qe,
+	return Ke({
+		privacy: Je,
 		name: r,
 		baseName: $,
 		description: "Unified notifications — email/slack/sms/push/in-app with preference routing, inbox + delivery log.",
@@ -310,9 +311,9 @@ var W = V("_voltro_notification_inbox", {
 			q,
 			J,
 			Y,
-			k
+			O
 		] } },
-		...g ? {
+		...y ? {
 			declaredEnv: [{
 				name: "VOLTRO_VAPID_PRIVATE_KEY",
 				required: !0,
@@ -328,12 +329,12 @@ var W = V("_voltro_notification_inbox", {
 					try {
 						t = JSON.parse(Buffer.from(e.rawBody).toString("utf8")).token;
 					} catch {}
-					if (typeof t != "string" || t === "" || !_e(t, t)) return {
+					if (typeof t != "string" || t === "" || !ye(t, t)) return {
 						status: 400,
 						body: JSON.stringify({ error: "token required" }),
 						contentType: "application/json"
 					};
-					let n = await c.markClicked(t);
+					let n = await p.markClicked(t);
 					return {
 						status: n ? 200 : 404,
 						body: JSON.stringify({ ok: n }),
@@ -343,27 +344,26 @@ var W = V("_voltro_notification_inbox", {
 				maxBodyBytes: 4096
 			}]
 		} : {},
-		services: Ve.succeed(X, b),
+		services: Ue.succeed(X, b),
 		routes: [...S, ...C],
-		rpcClientDescriptors: g ? [...v, ...pe] : v,
-		inspectEndpoints: O,
+		rpcClientDescriptors: y ? [..._, ...he] : _,
+		inspectEndpoints: k,
 		bindDataStore: (t) => {
-			o = t, i && (a.current = l(t)), ye(t);
+			o = t, i && (a.current = l(t)), xe(t);
 			let n = e.flushIntervalMs ?? 3e4;
 			x = setInterval(() => {
 				b.flushDue().catch(() => {});
 			}, n), typeof x.unref == "function" && x.unref();
 		},
-		onActivate: (e) => F.sync(() => {
-			g && ve(), e.logger.info("notifications active", {
-				channels: m.map((e) => e.id),
-				digestWindowMs: h
+		onActivate: (e) => P.sync(() => {
+			y && be(), e.logger.info("notifications active", {
+				channels: h.map((e) => e.id),
+				digestWindowMs: g
 			});
 		}),
-		onDeactivate: () => F.sync(() => {
+		onDeactivate: () => P.sync(() => {
 			x && clearInterval(x), x = void 0;
 		})
 	});
 };
-//#endregion
-export { Te as APNS_HOSTS, Ee as APNS_TOKEN_REJECTIONS, Le as EXPO_PUSH_ENDPOINT, Ae as FCM_SCOPE, je as FCM_TOKEN_REJECTIONS, P as GOOGLE_TOKEN_URI, Se as NOTIFICATION_SEND_EFFECT, X as NotificationService, e as PushTokenRejected, De as apnsBody, Oe as apnsProviderToken, ke as apnsTransport, d as buildNotificationService, t as consoleChannel, n as customChannel, l as dataStoreNotificationStore, E as dataStorePushSubscriptionStore, b as decryptWebPushPayload, N as defineNotification, K as deliveriesTable, r as emailChannel, x as encryptWebPushPayload, D as endpointHashOf, Ce as enqueueNotification, Re as expoPushTransport, Me as fcmAssertion, Ne as fcmMessage, Pe as fcmSendEndpoint, Fe as fcmTransport, S as generateVapidPrivateKey, Y as heldTable, f as inAppChannel, p as inQuietHours, W as inboxTable, ze as isExpoPushToken, Z as makeSubjectId, u as memoryNotificationStore, O as memoryPushSubscriptionStore, m as minuteOfDayInZone, we as notificationOutboxHandler, Je as notificationsPlugin, Ie as parseServiceAccount, G as preferencesTable, i as pushChannel, k as pushSubscriptionsTable, h as quietHoursEnd, J as quietHoursTable, be as resetWebPushStoreForTest, a as resolveChannels, o as richPushOf, xe as sendNotification, C as sendWebPush, s as smsChannel, q as topicSubscriptionsTable, w as vapidAuthorization, T as vapidPublicKeyFor, j as webPushChannel, M as webPushPublicKey, c as webhookChannel };
+export { De as APNS_HOSTS, Oe as APNS_TOKEN_REJECTIONS, ze as EXPO_PUSH_ENDPOINT, Me as FCM_SCOPE, N as FCM_TOKEN_REJECTIONS, Ne as GOOGLE_TOKEN_URI, we as NOTIFICATION_SEND_EFFECT, X as NotificationService, e as PushTokenRejected, ke as apnsBody, Ae as apnsProviderToken, je as apnsTransport, d as buildNotificationService, t as consoleChannel, n as customChannel, l as dataStoreNotificationStore, T as dataStorePushSubscriptionStore, y as decryptWebPushPayload, Se as defineNotification, K as deliveriesTable, r as emailChannel, b as encryptWebPushPayload, E as endpointHashOf, Te as enqueueNotification, Be as expoPushTransport, Pe as fcmAssertion, Fe as fcmMessage, Ie as fcmSendEndpoint, Le as fcmTransport, x as generateVapidPrivateKey, Y as heldTable, f as inAppChannel, p as inQuietHours, W as inboxTable, Ve as isExpoPushToken, Z as makeSubjectId, u as memoryNotificationStore, D as memoryPushSubscriptionStore, m as minuteOfDayInZone, Ee as notificationOutboxHandler, Ye as notificationsPlugin, Re as parseServiceAccount, G as preferencesTable, i as pushChannel, O as pushSubscriptionsTable, h as quietHoursEnd, J as quietHoursTable, k as resetWebPushStoreForTest, a as resolveChannels, o as richPushOf, Ce as sendNotification, S as sendWebPush, s as smsChannel, q as topicSubscriptionsTable, C as vapidAuthorization, w as vapidPublicKeyFor, j as webPushChannel, M as webPushPublicKey, c as webhookChannel };

package/dist/rpc.d.ts

@@ -22,6 +22,14 @@ export declare const archiveDescriptor: MutationProcedureDescriptor<"notificatio
  */
 export declare const BASE_NAME = "@voltro/plugin-notifications";
 
+/** One channel switch of the calling subject for one category. */
+export declare const ChannelPreferenceSchema: Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly category: Schema.String;
+    readonly channel: Schema.String;
+    readonly enabled: Schema.Boolean;
+}>;
+
 export declare const clearQuietHoursDescriptor: MutationProcedureDescriptor<"notifications.clearQuietHours", Schema.Struct<{}>, Schema.Struct<{
     readonly ok: Schema.Boolean;
 }>, Schema.Never>;
@@ -55,7 +63,15 @@ export declare const markUnreadDescriptor: MutationProcedureDescriptor<"notifica
  *  emitted into the generated client group. Kept in lockstep with the exports. */
 export declare const notificationsRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
 
-export declare const preferencesDescriptor: QueryProcedureDescriptor<"notifications.preferences", Schema.Struct<{}>, Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>, Schema.Never>;
+export declare const preferencesDescriptor: QueryProcedureDescriptor<"notifications.preferences", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly category: Schema.String;
+    readonly channel: Schema.String;
+    readonly enabled: Schema.Boolean;
+}>>, Schema.Never>;
+
+/** Every preference write publishes this channel, so `notifications.preferences` subscribers see the change live. */
+export declare const preferencesFeed: ReactivityChannel;
 
 export declare const setPreferenceDescriptor: MutationProcedureDescriptor<"notifications.setPreference", Schema.Struct<{
     readonly category: Schema.String;

package/dist/rpc.js

@@ -1,7 +1,12 @@
 import { Schema as e } from "effect";
 import { defineMutation as t, defineQuery as n, reactivityChannel as r } from "@voltro/protocol";
-//#region src/rpc.ts
-var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
+// src/rpc.ts
+var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = r("notifications-preferences"), s = e.Struct({
+	subjectId: e.String,
+	category: e.String,
+	channel: e.String,
+	enabled: e.Boolean
+}), c = n({
 	name: "notifications.inbox",
 	source: a,
 	input: e.Struct({
@@ -10,43 +15,44 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 	}),
 	output: e.Array(e.Record(e.String, e.Unknown)),
 	openAccess: "self-scoped read: returns only the calling subject's own inbox items"
-}), s = n({
+}), l = n({
 	name: "notifications.unreadCount",
 	source: a,
 	input: e.Struct({}),
 	output: e.Struct({ count: e.Number }),
 	openAccess: "self-scoped read: counts only the calling subject's own unread items"
-}), c = t({
+}), u = t({
 	name: "notifications.markRead",
 	input: e.Struct({ id: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: marks an item read only within the calling subject's own inbox"
-}), l = t({
+}), d = t({
 	name: "notifications.markUnread",
 	input: e.Struct({ id: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: marks an item unread only within the calling subject's own inbox"
-}), u = t({
+}), f = t({
 	name: "notifications.markAllRead",
 	input: e.Struct({}),
 	output: e.Struct({ count: e.Number }),
 	openAccess: "self-scoped write: clears unread state only in the calling subject's own inbox"
-}), d = t({
+}), p = t({
 	name: "notifications.archive",
 	input: e.Struct({ id: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: archives an item only within the calling subject's own inbox"
-}), f = t({
+}), m = t({
 	name: "notifications.unarchive",
 	input: e.Struct({ id: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: unarchives an item only within the calling subject's own inbox"
-}), p = n({
+}), h = n({
 	name: "notifications.preferences",
+	source: o,
 	input: e.Struct({}),
-	output: e.Array(e.Record(e.String, e.Unknown)),
+	output: e.Array(s),
 	openAccess: "self-scoped read: returns only the calling subject's own channel preferences"
-}), m = t({
+}), g = t({
 	name: "notifications.setPreference",
 	input: e.Struct({
 		category: e.String,
@@ -55,17 +61,17 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 	}),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: toggles a channel only on the calling subject's own preferences"
-}), h = t({
+}), _ = t({
 	name: "notifications.subscribe",
 	input: e.Struct({ topic: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-service: subscribes the calling subject itself to a topic (the subject is never caller-supplied)"
-}), g = t({
+}), v = t({
 	name: "notifications.unsubscribe",
 	input: e.Struct({ topic: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-service: unsubscribes the calling subject itself from a topic"
-}), _ = t({
+}), y = t({
 	name: "notifications.setQuietHours",
 	input: e.Struct({
 		startMinute: e.Number,
@@ -75,17 +81,17 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 	}),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: sets only the calling subject's own quiet-hours window"
-}), v = t({
+}), b = t({
 	name: "notifications.clearQuietHours",
 	input: e.Struct({}),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: clears only the calling subject's own quiet-hours window"
-}), y = n({
+}), x = n({
 	name: "notifications.webPushPublicKey",
 	input: e.Struct({}),
 	output: e.Struct({ key: e.String }),
 	openAccess: "public application-server key — the value every subscribing browser is handed by design"
-}), b = t({
+}), S = t({
 	name: "notifications.webPushSubscribe",
 	input: e.Struct({
 		endpoint: e.String,
@@ -95,17 +101,17 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 	}),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: registers the calling subject's own browser subscription (the subject is never caller-supplied)"
-}), x = t({
+}), C = t({
 	name: "notifications.webPushUnsubscribe",
 	input: e.Struct({ endpoint: e.String }),
 	output: e.Struct({ ok: e.Boolean }),
 	openAccess: "self-scoped write: removes only a subscription the calling subject owns"
-}), S = n({
+}), w = n({
 	name: "notifications.webPushStatus",
 	input: e.Struct({}),
 	output: e.Struct({ endpoints: e.Number }),
 	openAccess: "self-scoped read: counts only the calling subject's own subscriptions"
-}), C = [
+}), T = [
 	{
 		tag: "notifications.webPushPublicKey",
 		kind: "query",
@@ -138,7 +144,7 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 			name: "webPushStatusDescriptor"
 		}
 	}
-], w = [
+], E = [
 	{
 		tag: "notifications.inbox",
 		kind: "query",
@@ -244,5 +250,4 @@ var i = "@voltro/plugin-notifications", a = r("notifications-inbox"), o = n({
 		}
 	}
 ];
-//#endregion
-export { i as BASE_NAME, d as archiveDescriptor, v as clearQuietHoursDescriptor, o as inboxDescriptor, a as inboxFeed, u as markAllReadDescriptor, c as markReadDescriptor, l as markUnreadDescriptor, w as notificationsRpcClientImports, p as preferencesDescriptor, m as setPreferenceDescriptor, _ as setQuietHoursDescriptor, h as subscribeDescriptor, f as unarchiveDescriptor, s as unreadCountDescriptor, g as unsubscribeDescriptor, y as webPushPublicKeyDescriptor, C as webPushRpcClientImports, S as webPushStatusDescriptor, b as webPushSubscribeDescriptor, x as webPushUnsubscribeDescriptor };
+export { i as BASE_NAME, s as ChannelPreferenceSchema, p as archiveDescriptor, b as clearQuietHoursDescriptor, c as inboxDescriptor, a as inboxFeed, f as markAllReadDescriptor, u as markReadDescriptor, d as markUnreadDescriptor, E as notificationsRpcClientImports, h as preferencesDescriptor, o as preferencesFeed, g as setPreferenceDescriptor, y as setQuietHoursDescriptor, _ as subscribeDescriptor, m as unarchiveDescriptor, l as unreadCountDescriptor, v as unsubscribeDescriptor, x as webPushPublicKeyDescriptor, T as webPushRpcClientImports, w as webPushStatusDescriptor, S as webPushSubscribeDescriptor, C as webPushUnsubscribeDescriptor };