better-supabase 0.7.1 → 0.9.0

package/dist/blocks/notifications/index.js

@@ -1,14 +1,77 @@
-import { c as mapDbError, n as dbError } from "../../errors-B11Duf73.js";
-import { t as temporal } from "../../temporal-required-BVvW7SYJ.js";
-import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../../result-DzUbqgdW.js";
-import { n as validate } from "../../standard-BK0cqJ7y.js";
-import { i as emitBlockEvent } from "../../block-events-CrT8r7Fe.js";
-import { n as rpcTransport, r as sqlTransport, t as rawError } from "../../block-transport-BLr-ZgLc.js";
-import { c as errorText, d as isRecord, g as pageOf, h as optionalText, i as blockCall, m as optionalInstant, n as applyTemporal } from "../../block-helpers-DWHxHsEQ.js";
-import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BmjMyXTa.js";
-//#region src/blocks/notifications/notifications.ts
-const nullableText = (value) => optionalText(value) ?? null;
-const nullableInstant = (value) => optionalInstant(value) ?? null;
+import { t as DbException } from "../../db-exception-CnWcYPxL.js";
+import { n as dbError } from "../../errors-8i6tSICm.js";
+import { t as temporal } from "../../temporal-required-DqRzr7i0.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { n as validate } from "../../standard-B5fe2gnW.js";
+import { a as methodNotAllowed, o as problemResponse } from "../../problem-pIiL3WbE.js";
+import { a as stripTypePrefix } from "../../cloud-event-CTh9Sr5w.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { r as blockEmitter } from "../../block-events-DD9Q_NUz.js";
+import { s as verifyWebhook } from "../../signatures-B41ApWXA.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { C as optionalText, E as readBodyCapped, L as toBlockError, c as chunksOf, f as errorText, i as batchResultsOf, n as applyTemporal, o as blockCall, s as budget, v as nullableInstant, w as pageOf, y as nullableText } from "../../block-helpers-CfG_MvDR.js";
+import { t as subjectReaders } from "../../subject-readers-DiePmaYP.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as blockFields, s as rowFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as MAX_BATCH } from "../../batch-limit-DKVQDz4o.js";
+import { t as allowedSubscribers } from "../../subscribers-Cq--DL1E.js";
+import { t as mailHeaders } from "../../delivery-B1mKaOen.js";
+import { n as unreadCount, t as createNotificationsController } from "../../client-BpS8a6Fm.js";
+import { t as notificationsSqlOptions } from "../../options-Dmg1Da9P.js";
+//#region src/blocks/notifications/email.ts
+function defaultCompose(message) {
+	const text = message.text;
+	if (text === void 0) throw new TypeError("The email channel needs createNotifications({ render }) or a compose option");
+	return {
+		subject: text.title,
+		text: text.body ?? text.title
+	};
+}
+/**
+* A `NotificationChannel` named `email` that sends through `transport`,
+* with the delivery id as the idempotency key. A recipient without an
+* address is skipped.
+*/
+function emailChannel(options) {
+	const { transport } = options;
+	const version = transport.apiVersion;
+	const channel = transport.channel;
+	if (version !== 1 || channel !== "email") throw new TypeError(`emailChannel needs an email DeliveryTransport with apiVersion 1, got channel "${String(channel)}"`);
+	const compose = options.compose ?? defaultCompose;
+	return {
+		apiVersion: 1,
+		name: "email",
+		async send(message) {
+			if (message.email === null || message.email === "") return {
+				status: "skipped",
+				provider: transport.provider
+			};
+			const mail = await compose(message);
+			const category = mail.category ?? "notification";
+			const unsubscribe = category === "notification" ? await options.unsubscribe?.(message) : void 0;
+			const replyTo = mail.replyTo ?? options.replyTo;
+			const receipt = await transport.send({
+				from: options.from,
+				to: message.email,
+				subject: mail.subject,
+				...mail.text === void 0 ? {} : { text: mail.text },
+				...mail.html === void 0 ? {} : { html: mail.html },
+				...replyTo === void 0 ? {} : { replyTo },
+				category,
+				headers: mailHeaders(category, unsubscribe)
+			}, { idempotencyKey: message.deliveryId });
+			return {
+				provider: transport.provider,
+				...receipt?.providerMessageId === void 0 ? {} : { providerMessageId: receipt.providerMessageId },
+				...mail.templateKey === void 0 ? {} : { templateKey: mail.templateKey }
+			};
+		}
+	};
+}
+//#endregion
+//#region src/blocks/notifications/rows.ts
 function toItem(row) {
 	const type = nullableText(row["subject_type"]);
 	const id = nullableText(row["subject_id"]);
@@ -30,7 +93,8 @@ function toItem(row) {
 		priority: nullableText(row["priority"]),
 		createdAt: nullableInstant(row["created_at"]) ?? temporal().Now.instant(),
 		readAt: nullableInstant(row["read_at"]),
-		resolvedAt: nullableInstant(row["resolved_at"])
+		resolvedAt: nullableInstant(row["resolved_at"]),
+		fields: rowFields(row["fields"])
 	};
 }
 function cursorOf(before) {
@@ -68,21 +132,112 @@ const LEVELS = [
 	"all",
 	"ignore"
 ];
+//#endregion
+//#region src/blocks/notifications/notifications.ts
+const SUPPRESSION_REASONS = [
+	"bounce",
+	"complaint",
+	"manual"
+];
+const DELIVERY_EVENT_KINDS = [
+	"delivered",
+	"opened",
+	"clicked",
+	"bounced",
+	"complained",
+	"delayed"
+];
+const DELIVERY_STATUSES = [
+	"pending",
+	"sent",
+	"failed",
+	"skipped"
+];
+const kindOf = (value) => DELIVERY_EVENT_KINDS.find((kind) => kind === value) ?? null;
+const recordedOf = (value) => {
+	if (!isRecord(value)) return null;
+	const kind = kindOf(value["kind"]);
+	if (kind === null) return null;
+	return {
+		deliveryId: String(value["delivery_id"]),
+		notificationId: String(value["notification_id"]),
+		tenant: nullableText(value["tenant"]),
+		type: String(value["type"]),
+		channel: String(value["channel"]),
+		userId: nullableText(value["user_id"]),
+		subject: {
+			type: String(value["subject_type"]),
+			id: String(value["subject_id"])
+		},
+		kind,
+		providerStatus: kindOf(value["provider_status"]),
+		recorded: value["recorded"] === true
+	};
+};
+const subjectDeliveryOf = (row) => ({
+	id: String(row["id"]),
+	notificationId: String(row["notification_id"]),
+	type: String(row["type"]),
+	channel: String(row["channel"]),
+	userId: String(row["user_id"]),
+	status: DELIVERY_STATUSES.find((status) => status === row["status"]) ?? "pending",
+	provider: nullableText(row["provider"]),
+	providerMessageId: nullableText(row["provider_message_id"]),
+	providerStatus: kindOf(row["provider_status"]),
+	providerStatusAt: nullableInstant(row["provider_status_at"]),
+	templateKey: nullableText(row["template_key"]),
+	error: nullableText(row["error"]),
+	attempts: typeof row["attempts"] === "number" ? row["attempts"] : null,
+	createdAt: nullableInstant(row["created_at"]),
+	deliveredAt: nullableInstant(row["delivered_at"]),
+	events: (Array.isArray(row["events"]) ? row["events"] : []).filter(isRecord).flatMap((event) => {
+		const kind = kindOf(event["kind"]);
+		return kind === null ? [] : [{
+			kind,
+			occurredAt: nullableInstant(event["occurred_at"]),
+			detail: isRecord(event["detail"]) ? event["detail"] : {}
+		}];
+	})
+});
+/** The data of `notification.delivered` and `notification.failed` for one delivery. */
+const deliveryData = (message, channel) => {
+	const notification = message.notification;
+	return {
+		notificationId: notification.eventId,
+		organizationId: notification.tenant,
+		type: notification.type,
+		channel,
+		deliveryId: message.deliveryId,
+		subjectType: notification.subject?.type ?? "notification",
+		subjectId: notification.subject?.id ?? notification.eventId
+	};
+};
+function deliveryChannels(options) {
+	const channels = options.channels ?? [];
+	if (options.email === void 0) return channels;
+	if (channels.some((channel) => channel.name === "email")) throw new TypeError("createNotifications: `email` adds the \"email\" channel; remove the channel named \"email\" from `channels`");
+	return [...channels, emailChannel(options.email)];
+}
+/** The event a delivery's audience check sees: the notification, as its recipients read it. */
+const subscriberEventOf = (notification) => ({
+	type: notification.type,
+	tenant: notification.tenant,
+	actorId: notification.actorId,
+	payload: notification.data,
+	subject: notification.subject ? `${notification.subject.type}/${notification.subject.id}` : null
+});
 function createNotifications(options) {
 	applyTemporal(options);
+	const fields = blockFields(options.fields, "notification fields");
 	const { transport } = options;
 	const schema = options.schema ?? "better_supabase";
 	const mappers = options.mappers ?? [];
 	const run = blockCall(transport, schema, mappers);
-	const call = async (fn, args) => transport.call(schema, fn, args);
+	/** A call for the delivery loop, which handles a failure by throwing. */
+	const call = async (fn, args) => run(fn, args, (value) => value).orThrow();
+	const emitEvent = blockEmitter(options);
 	function emit(type, data, tenant) {
-		if (!options.events) return;
-		emitBlockEvent(options.events, type, data, {
-			subject: `notifications/${data.notificationId}`,
-			...tenant ? { tenant } : {},
-			...options.actorId ? { actorId: options.actorId } : {},
-			...options.context ? { context: options.context } : {}
-		});
+		emitEvent(type, data, `notifications/${data.notificationId}`, tenant);
 	}
 	const render = (item, locale, hydrated) => {
 		if (!options.render) return item;
@@ -123,7 +278,12 @@ function createNotifications(options) {
 		for (const item of items) {
 			const schemaOf = Object.hasOwn(options.types, item.type) ? options.types[item.type] : void 0;
 			if (schemaOf === void 0) {
-				out.push(item);
+				const extra = await fields.read(item.fields);
+				if (!extra.ok) return extra;
+				out.push({
+					...item,
+					fields: extra.data
+				});
 				continue;
 			}
 			const data = await validate(schemaOf, item.data, `${item.type} data of notification ${item.id}`);
@@ -131,9 +291,12 @@ function createNotifications(options) {
 				...data.error,
 				hint: "NOTIFICATION_DATA_INVALID"
 			});
+			const extra = await fields.read(item.fields);
+			if (!extra.ok) return extra;
 			out.push({
 				...item,
-				data: data.data
+				data: data.data,
+				fields: extra.data
 			});
 		}
 		return ok(out);
@@ -149,7 +312,10 @@ function createNotifications(options) {
 			const context = locale === void 0 ? {} : { locale };
 			const [hydrated, actors] = await Promise.all([options.hydrate ? options.hydrate(items, context) : void 0, listOptions.include?.includes("actor") ? actorsOf(items) : void 0]);
 			const out = items.map((item) => {
-				const text = render(item, locale, hydrated);
+				const text = {
+					...render(item, locale, hydrated),
+					fields: item.fields
+				};
 				return actors ? {
 					...text,
 					actor: item.actorId ? actors.get(item.actorId) ?? null : null
@@ -157,23 +323,85 @@ function createNotifications(options) {
 			});
 			return ok(out);
 		} catch (cause) {
-			const raw = rawError(cause);
-			return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
+			return err(toBlockError(cause, mappers));
 		}
 	};
-	async function deliverOne(channel, row, maxAttempts) {
+	const channelList = deliveryChannels(options);
+	const audience = options.audience ?? options.server?.authorization?.delivery?.audience ?? (options.server?.authorization === void 0 ? void 0 : subjectReaders(transport, { schema }));
+	const claimedOf = (channel, row) => {
 		const notification = isRecord(row["notification"]) ? toItem(row["notification"]) : void 0;
 		if (!notification) throw new TypeError("claim returned no notification");
-		const attempts = Number(row["attempts"] ?? 1);
-		const message = {
-			deliveryId: String(row["delivery_id"]),
-			channel: channel.name,
-			attempts,
-			userId: String(row["user_id"]),
-			email: nullableText(row["email"]),
-			notification,
-			...options.render ? { text: options.render(notification, {}) } : {}
+		return {
+			message: {
+				deliveryId: String(row["delivery_id"]),
+				channel: channel.name,
+				attempts: Number(row["attempts"] ?? 1),
+				userId: String(row["user_id"]),
+				email: nullableText(row["email"]),
+				notification,
+				...options.render ? { text: options.render(notification, {}) } : {}
+			},
+			suppressed: nullableText(row["suppressed"])
 		};
+	};
+	const fail = async (channel, message, error, maxAttempts) => {
+		await call("complete_notification_delivery", {
+			delivery: message.deliveryId,
+			status: "pending",
+			error,
+			max_attempts: maxAttempts
+		});
+		emit("notification.failed", {
+			...deliveryData(message, channel.name),
+			error
+		}, message.notification.tenant);
+		return "failed";
+	};
+	const skip = async (message, error) => {
+		await call("complete_notification_delivery", {
+			delivery: message.deliveryId,
+			status: "skipped",
+			error
+		});
+		return "skipped";
+	};
+	/**
+	* Sends a claimed batch: suppressed addresses are skipped first, then
+	* each notification's remaining recipients go through `audience` once.
+	*/
+	async function deliverBatch(channel, rows, maxAttempts) {
+		const claimed = rows.map((row) => claimedOf(channel, row));
+		const outcomes = [];
+		const byEvent = /* @__PURE__ */ new Map();
+		for (const { message, suppressed } of claimed) {
+			if (suppressed !== null) {
+				outcomes.push(await skip(message, `suppressed: ${suppressed}`));
+				continue;
+			}
+			const group = byEvent.get(message.notification.eventId) ?? [];
+			group.push(message);
+			byEvent.set(message.notification.eventId, group);
+		}
+		for (const messages of byEvent.values()) {
+			const notification = messages[0].notification;
+			const subscribers = messages.map((message) => ({
+				principal: message.userId,
+				kind: "user",
+				message
+			}));
+			const checked = await allowedSubscribers(audience, subscriberEventOf(notification), subscribers);
+			if (!checked.ok) {
+				const error = `audience check failed: ${errorText(checked.cause)}`;
+				for (const message of messages) outcomes.push(await fail(channel, message, error, maxAttempts));
+				continue;
+			}
+			const allowed = new Set(checked.allowed.map((subscriber) => subscriber.message));
+			for (const message of messages) outcomes.push(allowed.has(message) ? await deliverOne(channel, message, maxAttempts) : await skip(message, "audience"));
+		}
+		return outcomes;
+	}
+	async function deliverOne(channel, message, maxAttempts) {
+		const notification = message.notification;
 		try {
 			const result = await channel.send(message);
 			const status = result?.status ?? "sent";
@@ -181,86 +409,113 @@ function createNotifications(options) {
 				delivery: message.deliveryId,
 				status,
 				provider: result?.provider ?? null,
-				provider_message_id: result?.providerMessageId ?? null
+				provider_message_id: result?.providerMessageId ?? null,
+				...result?.templateKey === void 0 ? {} : { template_key: result.templateKey }
 			});
-			if (status === "sent") emit("notification.delivered", {
-				notificationId: notification.eventId,
-				type: notification.type,
-				channel: channel.name
-			}, notification.tenant);
+			if (status === "sent") emit("notification.delivered", deliveryData(message, channel.name), notification.tenant);
 			return status;
 		} catch (cause) {
-			const error = errorText(cause);
-			await call("complete_notification_delivery", {
-				delivery: message.deliveryId,
-				status: "pending",
-				error,
-				max_attempts: maxAttempts
-			});
-			emit("notification.failed", {
-				notificationId: notification.eventId,
-				type: notification.type,
-				channel: channel.name,
-				error
-			}, notification.tenant);
-			return "failed";
+			return fail(channel, message, errorText(cause), maxAttempts);
 		}
 	}
+	/** `send_notification`'s argument for one send, after the type's schema and the fields. */
+	const prepare = async (type, input) => {
+		const schemaOf = Object.hasOwn(options.types, type) ? options.types[type] : void 0;
+		if (schemaOf === void 0) return err(dbError("validation", `Unknown notification type "${type}"`, {
+			issues: [{
+				path: ["type"],
+				message: `Unknown type "${type}"`
+			}],
+			hint: "NOTIFICATION_TYPE_UNKNOWN"
+		}));
+		const data = await validate(schemaOf, input.data, `${type} data`);
+		if (!data.ok) return err(data.error);
+		const extra = input.fields === void 0 ? ok(void 0) : await fields.write({ ...input.fields });
+		if (!extra.ok) return extra;
+		if (input.permission !== void 0 && (input.tenant === void 0 || input.tenant === "")) {
+			const message = "A permission audience needs a tenant";
+			return err(dbError("validation", message, {
+				issues: [{
+					path: ["tenant"],
+					message
+				}],
+				hint: "NOTIFICATION_PERMISSION_NEEDS_TENANT"
+			}));
+		}
+		return ok({
+			type,
+			data: data.data,
+			recipients: input.recipients ?? [],
+			tenant: input.tenant,
+			permission: input.permission,
+			subject_type: input.subject?.type,
+			subject_id: input.subject?.id,
+			subject_label: input.subject?.label,
+			summary: input.summary,
+			action_path: input.actionPath,
+			priority: input.priority,
+			key: input.key,
+			channels: input.channels,
+			include_actor: input.includeActor,
+			activity: input.activity,
+			resolved: input.resolved,
+			actor: input.actorId,
+			watchers: input.watchers,
+			exclude: input.exclude,
+			fields: extra.data
+		});
+	};
+	const sentOf = (value) => isRecord(value) && value["id"] !== null && value["id"] !== void 0 ? {
+		id: String(value["id"]),
+		recipients: (Array.isArray(value["recipients"]) ? value["recipients"] : []).map(String)
+	} : null;
+	/** Announces a sent notification and runs `onSent`. */
+	const settle = async (sent, type, tenant) => {
+		if (sent === null) return ok(null);
+		const { id, recipients } = sent;
+		emit("notification.created", {
+			notificationId: id,
+			type,
+			recipientIds: recipients
+		}, tenant ?? null);
+		if (options.onSent) try {
+			await options.onSent({
+				id,
+				type,
+				tenant: tenant ?? null,
+				recipients
+			});
+		} catch (cause) {
+			return err(toDbError(cause));
+		}
+		return ok(sent);
+	};
 	const hooked = withBlockHooks({
 		send(type, input) {
 			return AsyncResult.from(async () => {
-				const schemaOf = Object.hasOwn(options.types, type) ? options.types[type] : void 0;
-				if (schemaOf === void 0) return err(dbError("validation", `Unknown notification type "${type}"`, {
-					issues: [{
-						path: ["type"],
-						message: `Unknown type "${type}"`
-					}],
-					hint: "NOTIFICATION_TYPE_UNKNOWN"
-				}));
-				const data = await validate(schemaOf, input.data, `${type} data`);
-				if (!data.ok) return err(data.error);
-				const notification = {
-					type,
-					data: data.data,
-					recipients: input.recipients ?? [],
-					tenant: input.tenant,
-					subject_type: input.subject?.type,
-					subject_id: input.subject?.id,
-					subject_label: input.subject?.label,
-					summary: input.summary,
-					action_path: input.actionPath,
-					priority: input.priority,
-					key: input.key,
-					channels: input.channels,
-					include_actor: input.includeActor,
-					activity: input.activity,
-					resolved: input.resolved,
-					actor: input.actorId,
-					watchers: input.watchers,
-					exclude: input.exclude
-				};
-				const sent = await run("send_notification", { notification }, (value) => isRecord(value) && value["id"] !== null && value["id"] !== void 0 ? {
-					id: String(value["id"]),
-					recipients: (Array.isArray(value["recipients"]) ? value["recipients"] : []).map(String)
-				} : null);
-				if (!sent.ok || sent.data === null) return sent;
-				const { id, recipients } = sent.data;
-				emit("notification.created", {
-					notificationId: id,
-					type,
-					recipientIds: recipients
-				}, input.tenant ?? null);
-				if (options.onSent) try {
-					await options.onSent({
-						id,
-						type,
-						tenant: input.tenant ?? null,
-						recipients
-					});
-				} catch (cause) {
-					return err(toDbError(cause));
+				const notification = await prepare(type, input);
+				if (!notification.ok) return notification;
+				const sent = await run("send_notification", { notification: notification.data }, sentOf);
+				return sent.ok ? settle(sent.data, type, input.tenant) : sent;
+			});
+		},
+		sendMany(items) {
+			return AsyncResult.from(async () => {
+				const prepared = await Promise.all(items.map((item) => prepare(item.type, item)));
+				const valid = prepared.flatMap((result, index) => result.ok ? [{
+					index,
+					notification: result.data
+				}] : []);
+				const sent = valid.length === 0 ? ok([]) : await run("send_notifications", { events: valid.map((entry) => entry.notification) }, (value) => batchResultsOf(value, valid.length, "notification", sentOf, mappers));
+				if (!sent.ok) return sent;
+				const results = prepared.map((result) => result.ok ? err(dbError("unexpected", "The notification was not sent")) : result);
+				for (const [position, { index }] of valid.entries()) {
+					const result = sent.data[position];
+					const item = items[index];
+					if (result === void 0 || item === void 0) continue;
+					results[index] = result.ok ? await settle(result.data, item.type, item.tenant) : result;
 				}
-				return sent;
+				return ok(results);
 			});
 		},
 		get(id, getOptions = {}) {
@@ -365,8 +620,8 @@ function createNotifications(options) {
 		},
 		async deliver(deliverOptions = {}) {
 			const wanted = deliverOptions.channels;
-			const channels = (options.channels ?? []).filter((channel) => !wanted || wanted.includes(channel.name));
-			const deadline = deliverOptions.budgetMs === void 0 ? Number.POSITIVE_INFINITY : Date.now() + deliverOptions.budgetMs;
+			const channels = channelList.filter((channel) => !wanted || wanted.includes(channel.name));
+			const spent = budget(deliverOptions.budgetMs);
 			const batch = deliverOptions.batch ?? 50;
 			const counts = {
 				sent: 0,
@@ -374,7 +629,7 @@ function createNotifications(options) {
 				failed: 0
 			};
 			await Promise.all(channels.map(async (channel) => {
-				while (Date.now() < deadline) {
+				while (!spent.expired()) {
 					const claimed = await call("claim_notification_deliveries", {
 						channel: channel.name,
 						max_items: batch,
@@ -382,7 +637,8 @@ function createNotifications(options) {
 						max_attempts: deliverOptions.maxAttempts ?? 5
 					});
 					const rows = (Array.isArray(claimed) ? claimed : []).filter(isRecord);
-					for (const row of rows) counts[await deliverOne(channel, row, deliverOptions.maxAttempts ?? 5)] += 1;
+					const outcomes = await deliverBatch(channel, rows, deliverOptions.maxAttempts ?? 5);
+					for (const outcome of outcomes) counts[outcome] += 1;
 					if (rows.length < batch) break;
 				}
 			}));
@@ -394,25 +650,100 @@ function createNotifications(options) {
 				batch: batch ?? null
 			}, Number);
 		},
+		suppress(input) {
+			return run("suppress_notification_address", {
+				address: input.address,
+				reason: input.reason,
+				channel: input.channel ?? "email",
+				provider: input.provider ?? null,
+				provider_event_id: input.providerEventId ?? null,
+				detail: input.detail ?? {}
+			}, (value) => value === true);
+		},
+		unsuppress(address, channel = "email") {
+			return run("unsuppress_notification_address", {
+				address,
+				channel
+			}, (value) => value === true);
+		},
+		suppressions(suppressionOptions = {}) {
+			return run("list_notification_suppressions", { max_items: suppressionOptions.limit ?? 50 }, (value) => (Array.isArray(value) ? value : []).filter(isRecord).flatMap((row) => {
+				const reason = SUPPRESSION_REASONS.find((entry) => entry === row["reason"]);
+				return reason === void 0 ? [] : [{
+					channel: String(row["channel"]),
+					address: String(row["address"]),
+					userId: nullableText(row["user_id"]),
+					reason,
+					provider: nullableText(row["provider"]),
+					createdAt: nullableInstant(row["created_at"])
+				}];
+			}));
+		},
+		recordDeliveryEvent(input) {
+			return run("record_delivery_event", {
+				provider: input.provider,
+				provider_message_id: input.providerMessageId,
+				kind: input.kind,
+				provider_event_id: input.providerEventId ?? null,
+				occurred_at: input.occurredAt?.toString() ?? null,
+				detail: input.detail ?? {},
+				suppress: input.suppress ?? null
+			}, recordedOf).map((recorded) => {
+				if (recorded?.recorded === true) emit(`notification.${recorded.kind}`, {
+					notificationId: recorded.notificationId,
+					organizationId: recorded.tenant,
+					type: recorded.type,
+					channel: recorded.channel,
+					deliveryId: recorded.deliveryId,
+					provider: input.provider,
+					providerEventId: input.providerEventId ?? null,
+					subjectType: recorded.subject.type,
+					subjectId: recorded.subject.id
+				}, recorded.tenant);
+				return recorded;
+			});
+		},
+		subjectDeliveries(deliveryOptions) {
+			return run("list_subject_deliveries", {
+				subject_type: deliveryOptions.subject.type,
+				subject_id: deliveryOptions.subject.id,
+				tenant: deliveryOptions.tenant ?? null,
+				max_items: deliveryOptions.limit ?? 50
+			}, (value) => (Array.isArray(value) ? value : []).filter(isRecord).map(subjectDeliveryOf));
+		},
 		sink(sinkOptions) {
-			const prefix = sinkOptions.typePrefix ?? "dev.better-supabase.";
+			const sendEach = async (chunk) => {
+				const results = [];
+				for (const item of chunk) results.push(await hooked.send(item.type, item));
+				return results;
+			};
 			return { async send(events) {
+				const items = [];
 				for (const event of events) {
-					const type = event.type.startsWith(prefix) ? event.type.slice(prefix.length) : event.type;
+					const type = stripTypePrefix(event.type, sinkOptions.typePrefix);
 					const mapped = await sinkOptions.map({
 						...event,
 						type
 					});
 					if (mapped === null) continue;
-					const { type: notificationType, ...rest } = mapped;
-					const input = rest;
 					const tenant = typeof event["partitionkey"] === "string" ? event["partitionkey"] : void 0;
-					await hooked.send(notificationType, {
-						...input,
-						key: input.key ?? event.id,
-						...input.tenant === void 0 && tenant !== void 0 ? { tenant } : {}
-					}).orThrow();
+					items.push({
+						...mapped,
+						key: mapped.key ?? event.id,
+						...mapped.tenant === void 0 && tenant !== void 0 ? { tenant } : {}
+					});
 				}
+				let failure;
+				const perEvent = options.hooks?.send !== void 0;
+				for (const chunk of chunksOf(items, MAX_BATCH)) {
+					const results = perEvent ? ok(await sendEach(chunk)) : await hooked.sendMany(chunk);
+					if (!results.ok) {
+						failure ??= new DbException(results.error);
+						continue;
+					}
+					for (const result of results.data) if (!result.ok) failure ??= new DbException(result.error);
+				}
+				if (failure !== void 0) throw failure;
 			} };
 		}
 	}, options.hooks, {
@@ -422,4 +753,297 @@ function createNotifications(options) {
 	return hooked;
 }
 //#endregion
-export { createNotifications, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };
+//#region src/blocks/notifications/transports/resend.ts
+/** A failed Resend call. `status` is the HTTP status, 0 when the request never got an answer. */
+var ResendError = class extends Error {
+	status;
+	/** Resend's error name, such as `validation_error`. */
+	code;
+	constructor(status, message, code) {
+		super(message);
+		this.name = "ResendError";
+		this.status = status;
+		this.code = code;
+	}
+};
+/**
+* A `DeliveryTransport` over Resend's `POST /emails`. The delivery
+* id goes in the `Idempotency-Key` header, so a retried delivery sends one
+* email; the message category becomes a `category` tag.
+*/
+function resendTransport(options) {
+	if (options.apiKey === "") throw new TypeError("resendTransport needs an apiKey");
+	const endpoint = `${(options.baseUrl ?? "https://api.resend.com").replace(/\/+$/, "")}/emails`;
+	const send = options.fetch ?? fetch;
+	return {
+		apiVersion: 1,
+		channel: "email",
+		provider: "resend",
+		async send(message, { idempotencyKey }) {
+			const response = await send(endpoint, {
+				method: "POST",
+				redirect: "error",
+				headers: {
+					authorization: `Bearer ${options.apiKey}`,
+					"content-type": "application/json",
+					"idempotency-key": idempotencyKey
+				},
+				body: JSON.stringify({
+					from: message.from,
+					to: [message.to],
+					subject: message.subject,
+					...message.text === void 0 ? {} : { text: message.text },
+					...message.html === void 0 ? {} : { html: message.html },
+					...message.replyTo === void 0 ? {} : { reply_to: message.replyTo },
+					headers: message.headers,
+					tags: [{
+						name: "category",
+						value: message.category
+					}]
+				})
+			}).catch((cause) => {
+				throw new ResendError(0, `Resend did not answer: ${cause instanceof Error ? cause.message : String(cause)}`);
+			});
+			const body = await response.json().catch(() => void 0);
+			if (!response.ok) {
+				const text = isRecord(body) && typeof body["message"] === "string" ? body["message"] : response.statusText;
+				throw new ResendError(response.status, `Resend answered ${String(response.status)}: ${text}`, isRecord(body) && typeof body["name"] === "string" ? body["name"] : void 0);
+			}
+			return isRecord(body) && typeof body["id"] === "string" ? { providerMessageId: body["id"] } : {};
+		}
+	};
+}
+//#endregion
+//#region src/blocks/notifications/transports/resend-webhook.ts
+const RESEND_KINDS = {
+	"email.delivered": "delivered",
+	"email.opened": "opened",
+	"email.clicked": "clicked",
+	"email.bounced": "bounced",
+	"email.complained": "complained",
+	"email.delivery_delayed": "delayed"
+};
+const instantOf = (value) => {
+	if (typeof value !== "string") return;
+	const { Instant } = temporal();
+	try {
+		return Instant.from(value);
+	} catch {
+		return;
+	}
+};
+/**
+* The delivery event a Resend event reports, matched to the delivery by
+* `data.email_id`: `email.delivered`, `opened`, `clicked`, `bounced`,
+* `complained` and `delivery_delayed`. A `Transient` bounce doesn't
+* suppress the address. `undefined` for any other event.
+*/
+function resendDeliveryEvent(event, eventId) {
+	if (!isRecord(event) || !isRecord(event["data"])) return;
+	const type = event["type"];
+	const kind = typeof type === "string" && Object.hasOwn(RESEND_KINDS, type) ? RESEND_KINDS[type] : void 0;
+	const data = event["data"];
+	const emailId = data["email_id"];
+	if (kind === void 0 || typeof emailId !== "string" || emailId === "") return;
+	const bounce = isRecord(data["bounce"]) ? data["bounce"] : void 0;
+	const click = isRecord(data["click"]) ? data["click"] : void 0;
+	const detail = {};
+	for (const key of [
+		"type",
+		"subType",
+		"message"
+	]) if (typeof bounce?.[key] === "string") detail[key === "type" ? "bounceType" : key] = bounce[key];
+	if (typeof click?.["link"] === "string") detail["link"] = click["link"];
+	const occurredAt = instantOf(event["created_at"]);
+	return {
+		provider: "resend",
+		providerMessageId: emailId,
+		kind,
+		...eventId === void 0 ? {} : { providerEventId: eventId },
+		...occurredAt === void 0 ? {} : { occurredAt },
+		detail,
+		...kind === "bounced" && bounce?.["type"] === "Transient" ? { suppress: false } : {}
+	};
+}
+/**
+* The suppressions a Resend event asks for: one per recipient of an
+* `email.bounced` (unless Resend reports the bounce as `Transient`) or an
+* `email.complained` event, and none for any other event. `eventId` is the
+* webhook message id, stored with each suppression.
+*/
+function resendSuppressions(event, eventId) {
+	if (!isRecord(event) || !isRecord(event["data"])) return [];
+	const data = event["data"];
+	const bounce = isRecord(data["bounce"]) ? data["bounce"] : void 0;
+	let reason;
+	switch (event["type"]) {
+		case "email.bounced":
+			if (bounce?.["type"] === "Transient") return [];
+			reason = "bounce";
+			break;
+		case "email.complained":
+			reason = "complaint";
+			break;
+		default: return [];
+	}
+	const to = Array.isArray(data["to"]) ? data["to"] : [data["to"]];
+	const detail = {};
+	if (typeof data["email_id"] === "string") detail["emailId"] = data["email_id"];
+	for (const key of [
+		"type",
+		"subType",
+		"message"
+	]) if (typeof bounce?.[key] === "string") detail[key === "type" ? "bounceType" : key] = bounce[key];
+	return to.filter((address) => typeof address === "string" && address.includes("@")).map((address) => ({
+		address,
+		reason,
+		channel: "email",
+		provider: "resend",
+		...eventId === void 0 ? {} : { providerEventId: eventId },
+		detail
+	}));
+}
+/**
+* A `Request` handler for Resend's webhooks. It verifies the Svix (Standard
+* Webhooks) signature, records each delivery status on its delivery
+* (`recordDeliveryEvent`), writes a suppression for each bounced or
+* complaining address, and answers 204. A failed write answers 500 so
+* Resend retries; other events are acknowledged and ignored.
+*/
+function resendWebhook(options) {
+	const limit = options.maxBodyBytes ?? 262144;
+	const format = options.problem;
+	return async (request) => {
+		if (request.method !== "POST") return methodNotAllowed(["POST"]);
+		const body = await readBodyCapped(request, limit);
+		if (body === void 0) return problemResponse({
+			...dbError("invalid_input", "The body is too large", { code: "WEBHOOK_TOO_LARGE" }),
+			status: 413
+		}, { format });
+		const verified = await verifyWebhook({
+			headers: request.headers,
+			body
+		}, options.secret, options);
+		if (!verified.ok) return problemResponse(verified.error, { format });
+		const delivery = resendDeliveryEvent(verified.data.payload, verified.data.id);
+		if (delivery !== void 0 && options.notifications.recordDeliveryEvent) {
+			const recorded = await options.notifications.recordDeliveryEvent(delivery);
+			if (!recorded.ok) return problemResponse(recorded.error, { format });
+		}
+		for (const input of resendSuppressions(verified.data.payload, verified.data.id)) {
+			const written = await options.notifications.suppress(input);
+			if (!written.ok) return problemResponse(written.error, { format });
+		}
+		return new Response(null, { status: 204 });
+	};
+}
+//#endregion
+//#region src/blocks/notifications/watcher-sink.ts
+function subjectData(event) {
+	const data = isRecord(event.data) ? event.data : void 0;
+	if (data === void 0) return;
+	const subjectType = optionalText(data["subjectType"]);
+	const subjectId = optionalText(data["subjectId"]);
+	const organizationId = optionalText(data["organizationId"]) ?? optionalText(event["partitionkey"]);
+	if (subjectType === void 0 || subjectId === void 0 || organizationId === void 0) return;
+	return {
+		...data,
+		organizationId,
+		subjectType,
+		subjectId
+	};
+}
+/**
+* An outbox sink that notifies the watchers of the subject an event is
+* about: `outbox.relay('watchers', watcherSink(notifications, { types }))`.
+* It reads `SubjectEventData` (tenant, subject type and id) from any block's
+* event, leaves out the actor (`actorId` or `authorId`), and keys each
+* notification by the event id, so a replayed event sends nothing new.
+* Build `notifications` with a service transport.
+*/
+function watcherSink(notifications, options) {
+	return notifications.sink({
+		...options.typePrefix === void 0 ? {} : { typePrefix: options.typePrefix },
+		map(event) {
+			const entry = options.types[event.type];
+			if (entry === void 0) return null;
+			const data = subjectData(event);
+			if (data === void 0) return null;
+			const rule = typeof entry === "string" ? { type: entry } : entry;
+			const actorId = optionalText(data["actorId"]) ?? optionalText(data["authorId"]);
+			const summary = rule.summary?.(data);
+			return {
+				type: rule.type,
+				tenant: data.organizationId,
+				subject: {
+					type: data.subjectType,
+					id: data.subjectId
+				},
+				recipients: rule.recipients?.(data) ?? [],
+				activity: rule.activity ?? "all",
+				key: `watch:${event.id}`,
+				data: rule.data === void 0 ? data : rule.data(event, data),
+				...actorId === void 0 ? {} : { actorId },
+				...summary === void 0 ? {} : { summary }
+			};
+		}
+	});
+}
+/**
+* `watcherSink` as an outbox handler:
+* `outbox.consume('watchers', watcherHandler(notifications, { types }))`.
+* CloudEvents leave the actor out, so a sink can only skip the author a
+* payload names. The outbox row carries the actor of every event, so with
+* this handler whoever tags, moves or shares a subject is not notified of it.
+*/
+function watcherHandler(notifications, options) {
+	const sink = watcherSink(notifications, options);
+	return async (events) => {
+		await sink.send(events.map(rowEvent));
+	};
+}
+function rowEvent(row) {
+	const data = row.actorId !== null && isRecord(row.payload) && !("actorId" in row.payload) ? {
+		...row.payload,
+		actorId: row.actorId
+	} : row.payload;
+	return {
+		specversion: "1.0",
+		id: row.id,
+		source: "/better-supabase/outbox",
+		type: row.type,
+		time: row.createdAt.toString(),
+		data,
+		...row.subject === null ? {} : { subject: row.subject },
+		...row.tenant === null ? {} : { partitionkey: row.tenant }
+	};
+}
+//#endregion
+//#region src/blocks/notifications/events.ts
+/** The `notifications` block's event types, for its manifest and `onBlockEvent`. */
+const notificationsEvents = defineEvents({
+	"notification.created": event(),
+	"notification.delivered": event(),
+	"notification.failed": event(),
+	"notification.opened": event(),
+	"notification.clicked": event(),
+	"notification.bounced": event(),
+	"notification.complained": event(),
+	"notification.delayed": event()
+});
+//#endregion
+//#region src/blocks/notifications/manifest.ts
+/** The `notifications` block's manifest (ADR 0029). */
+const notificationsBlock = defineBlock({
+	name: "notifications",
+	sql: ["notifications"],
+	options: { notifications: notificationsSqlOptions },
+	events: notificationsEvents,
+	provides: { notifier: (client) => client },
+	create: createNotifications,
+	client: "notifications",
+	category: "messaging",
+	recipes: ["notification-bell", "notification-list"]
+});
+//#endregion
+export { ResendError, createNotifications, createNotificationsController, dbTransport, emailChannel, extendBlock, mailHeaders, notificationsBlock, notificationsEvents, resendDeliveryEvent, resendSuppressions, resendTransport, resendWebhook, rpcTransport, sqlTransport, unreadCount, watcherHandler, watcherSink, withBlockHooks, wrapTransport };