pi-roundtable-web 0.24.2 → 0.26.0

package/src/push/dispatch.ts

@@ -0,0 +1,156 @@
+import type { IdentityService, Logger, Tier } from "pi-roundtable";
+import type { NewOutboxRow, OutboxKind, PushOutbox } from "./outbox.ts";
+import type { PushPrefsStore } from "./prefs.ts";
+import { previewOf } from "./triggers.ts";
+
+export interface PushDispatchOptions {
+	outbox: Pick<PushOutbox, "enqueue">;
+	prefs: Pick<PushPrefsStore, "quietAt">;
+	identity: Pick<IdentityService, "tierOf" | "speakerFor">;
+	/** The tiers whose people receive push. */
+	tiers: readonly Tier[];
+	/** `full` queues a title (and a preview with `preview`); `none` queues the kind, tag and count only. */
+	content: "full" | "none";
+	preview: boolean;
+	/** Whether a page of the person is in view now. */
+	visible(principalId: string): boolean;
+	/** The operator's quiet window, which holds back a normal notice; absent = none. */
+	quiet?: (at: number) => boolean;
+	/** Starts the in-process sender at once; absent when a separate process drains the outbox. */
+	kick?: () => void;
+	/** Whether push is set up at all (a VAPID contact, or an external sender). */
+	enabled: boolean;
+	/** The transports the sender has, which a notice's `via` may name. */
+	transports: readonly string[];
+	logger: Logger;
+	/** The clock, in milliseconds; default `Date.now`. */
+	now?: () => number;
+}
+
+/** What a notice says when it is queued for a person. */
+export interface NoticePush {
+	tag: string;
+	title: string;
+	body?: string;
+	/** The path a tap opens. */
+	open: string;
+	urgency: "normal" | "high";
+	badge: number;
+	via?: readonly string[];
+}
+
+/** Why a push was not queued; the notice itself is in the bell all the same. */
+export type Withheld = "off" | "tier" | "visible" | "quiet" | "failed";
+
+/**
+ * Decides whether a notice becomes a push for a person and queues it. A person gets it only when
+ * push is set up, their tier may receive it, and (for a normal notice) no page of theirs is in
+ * view and it is not their quiet hours or the operator's; a `high` notice ignores the last two.
+ * Whatever the content setting, the row carries a title and preview only with `content: "full"`.
+ */
+export class PushDispatch {
+	readonly #options: PushDispatchOptions;
+
+	constructor(options: PushDispatchOptions) {
+		this.#options = options;
+	}
+
+	/** The transports the sender has; a notice's `via` must name only these. */
+	get transports(): readonly string[] {
+		return this.#options.transports;
+	}
+
+	async notice(
+		principalId: string,
+		notice: NoticePush,
+	): Promise<"queued" | Withheld> {
+		const { logger } = this.#options;
+		try {
+			if (!this.#options.enabled) return "off";
+			if (!(await this.#mayReceive(principalId))) return "tier";
+			if (notice.urgency === "normal") {
+				if (this.#options.visible(principalId)) return "visible";
+				const at = (this.#options.now ?? Date.now)();
+				if (this.#options.quiet?.(at)) return "quiet";
+				if (await this.#options.prefs.quietAt(principalId, at)) return "quiet";
+			}
+			await this.#queue(principalId, "notice", notice);
+			return "queued";
+		} catch (error) {
+			logger.warn({ err: error, tag: notice.tag }, "a notice was not queued");
+			return "failed";
+		}
+	}
+
+	/** Tells the person's devices a notice is gone: closes its notification and sets the count. */
+	async clear(
+		principalId: string,
+		tag: string,
+		open: string,
+		badge: number,
+	): Promise<void> {
+		try {
+			if (!this.#options.enabled) return;
+			await this.#queue(principalId, "clear", {
+				tag,
+				title: "",
+				open,
+				urgency: "normal",
+				badge,
+			});
+		} catch (error) {
+			this.#options.logger.warn(
+				{ err: error, tag },
+				"a notice was not cleared on the devices",
+			);
+		}
+	}
+
+	/** A test push to the person's own devices; it is not held back by quiet hours or an open page. */
+	async test(principalId: string, tag: string, open: string, badge: number) {
+		await this.#queue(principalId, "test", {
+			tag,
+			title: "Test notification",
+			body: "Notifications work on this device.",
+			open,
+			urgency: "normal",
+			badge,
+		});
+	}
+
+	async #mayReceive(principalId: string): Promise<boolean> {
+		const { identity, tiers } = this.#options;
+		const lasting = await identity.tierOf(principalId);
+		if (lasting) return tiers.includes(lasting);
+		try {
+			return tiers.includes((await identity.speakerFor(principalId)).tier);
+		} catch {
+			return false;
+		}
+	}
+
+	async #queue(
+		principalId: string,
+		kind: OutboxKind,
+		notice: NoticePush,
+	): Promise<void> {
+		const { content, preview, outbox, kick } = this.#options;
+		const row: NewOutboxRow = {
+			kind,
+			tag: notice.tag,
+			principalId,
+			open: notice.open,
+			urgency: notice.urgency,
+			badge: notice.badge,
+			...(content === "full" && kind !== "clear"
+				? {
+						title: notice.title,
+						...(preview && notice.body ? { body: previewOf(notice.body) } : {}),
+					}
+				: {}),
+			...(notice.via ? { via: notice.via } : {}),
+		};
+		await outbox.enqueue(row);
+		kick?.();
+	}
+}

package/src/push/drain.ts

@@ -0,0 +1,139 @@
+import type { Logger } from "pi-roundtable";
+import type { DeliveryResult, OutboxRow, PushOutbox } from "./outbox.ts";
+
+/** How a transport carries a push; a host adds its own beside `web-push`. */
+export interface PushTransport {
+	/** The name a notice's `via` uses, such as `web-push`. */
+	name: string;
+	send(
+		row: OutboxRow,
+		rendered: { title: string; body?: string },
+		signal: AbortSignal,
+	): Promise<DeliveryResult>;
+}
+
+export interface OutboxSenderOptions {
+	outbox: Pick<PushOutbox, "claim" | "finish" | "sweep">;
+	/** Tried in order for each row until one says `sent`. */
+	transports: readonly PushTransport[];
+	/** Words a row. With push.content `none` a row carries no text, so this is where it comes from. */
+	render(row: OutboxRow): { title: string; body?: string };
+	logger: Logger;
+	/** How often the outbox is looked at; default 1 s. */
+	intervalMs?: number;
+	/** How long one transport may take for one row; default 20 s. */
+	transportTimeoutMs?: number;
+	/** The most rows taken at once; default 20. */
+	batch?: number;
+}
+
+const SWEEP_EVERY_MS = 3_600_000;
+
+/**
+ * The loop that empties the push outbox: it takes queued rows, words each with `render`, offers it
+ * to the row's transports in order until one says `sent`, and records what each said. A transport
+ * that throws or runs out of time counts as `failed`; one row never stops the others.
+ */
+export class OutboxSender {
+	readonly #options: OutboxSenderOptions;
+	#timer: ReturnType<typeof setInterval> | undefined;
+	#sweeper: ReturnType<typeof setInterval> | undefined;
+	#running: Promise<number> | undefined;
+	#stopped = false;
+
+	constructor(options: OutboxSenderOptions) {
+		this.#options = options;
+	}
+
+	start(): void {
+		this.#stopped = false;
+		this.#timer = setInterval(() => {
+			this.drain().catch((error: unknown) =>
+				this.#options.logger.warn(
+					{ err: error },
+					"the push outbox was not read",
+				),
+			);
+		}, this.#options.intervalMs ?? 1000);
+		this.#sweeper = setInterval(() => {
+			this.#options.outbox
+				.sweep()
+				.catch((error: unknown) =>
+					this.#options.logger.warn(
+						{ err: error },
+						"old pushes were not deleted",
+					),
+				);
+		}, SWEEP_EVERY_MS);
+	}
+
+	async stop(): Promise<void> {
+		this.#stopped = true;
+		clearInterval(this.#timer);
+		clearInterval(this.#sweeper);
+		await this.#running?.catch(() => undefined);
+	}
+
+	/** Takes and sends what is queued now; returns how many rows it finished. Calls do not overlap. */
+	drain(): Promise<number> {
+		this.#running ??= this.#drain().finally(() => {
+			this.#running = undefined;
+		});
+		return this.#running;
+	}
+
+	async #drain(): Promise<number> {
+		let finished = 0;
+		for (;;) {
+			if (this.#stopped) return finished;
+			const rows = await this.#options.outbox.claim(this.#options.batch ?? 20);
+			if (rows.length === 0) return finished;
+			for (const row of rows) {
+				await this.#one(row);
+				finished += 1;
+			}
+		}
+	}
+
+	async #one(row: OutboxRow): Promise<void> {
+		const { transports, logger } = this.#options;
+		const chosen = row.via
+			? row.via.flatMap((name) => {
+					const found = transports.find((t) => t.name === name);
+					return found ? [found] : [];
+				})
+			: transports;
+		const deliveries: { transport: string; result: DeliveryResult }[] = [];
+		let rendered: { title: string; body?: string };
+		try {
+			// A row that clears a notice has no words.
+			rendered =
+				row.kind === "clear" ? { title: "" } : this.#options.render(row);
+		} catch (error) {
+			logger.warn({ err: error, kind: row.kind }, "a push was not worded");
+			await this.#options.outbox.finish(row.id, [
+				{ transport: "render", result: "failed" },
+			]);
+			return;
+		}
+		for (const transport of chosen) {
+			let result: DeliveryResult;
+			try {
+				result = await transport.send(
+					row,
+					rendered,
+					AbortSignal.timeout(this.#options.transportTimeoutMs ?? 20_000),
+				);
+			} catch (error) {
+				logger.warn(
+					{ err: error, transport: transport.name },
+					"a push transport failed",
+				);
+				result = "failed";
+			}
+			deliveries.push({ transport: transport.name, result });
+			if (result === "sent") break;
+		}
+		await this.#options.outbox.finish(row.id, deliveries);
+	}
+}

package/src/push/mutes.ts

@@ -38,6 +38,23 @@ export class PushMutes {
 		return new Set(rows.map((row) => row.room));
 	}
 
+	/** Mutes or unmutes every room in the list as one step; a room already so is left as it is. */
+	async setMany(
+		rooms: readonly string[],
+		muted: boolean,
+		by: string,
+	): Promise<void> {
+		if (rooms.length === 0) return;
+		await this.#sql.begin(async (tx) => {
+			if (muted)
+				await tx`
+					INSERT INTO web_push_muted_rooms ${tx(rooms.map((room) => ({ room, muted_by: by })))}
+					ON CONFLICT (room) DO NOTHING`;
+			else
+				await tx`DELETE FROM web_push_muted_rooms WHERE room IN ${tx(rooms)}`;
+		});
+	}
+
 	/** Mutes or unmutes a room; doing either twice leaves it as it is. */
 	async set(room: string, muted: boolean, by: string): Promise<void> {
 		if (muted)

package/src/push/outbox.ts

@@ -0,0 +1,218 @@
+import type { SQL } from "bun";
+import type { Migration } from "pi-roundtable";
+
+/**
+ * What a push is about; a sender renders its words from it. A `clear` row has no words: it tells
+ * the devices a notice is gone (close its notification, set the count), and a transport that has
+ * no such thing skips it.
+ */
+export type OutboxKind = "card" | "reply" | "notice" | "test" | "clear";
+
+/**
+ * One push to one person, queued for a sender. It carries what a sender needs to word and address
+ * the push, and no host-room content: `title` and `body` are present only with `push.content`
+ * `full`.
+ */
+export interface OutboxRow {
+	id: number;
+	kind: OutboxKind;
+	/** Pushes with one tag replace each other on a device; a notice's tag is its dedupe key. */
+	tag: string;
+	principalId: string;
+	/** Where a tap goes: a path under the app's origin. */
+	open: string;
+	urgency: "normal" | "high";
+	/** The count the app icon shows after this push: the person's notices not handled. */
+	badge: number;
+	title?: string;
+	body?: string;
+	/** The transports that may carry the row, in order; absent = all the sender has, in order. */
+	via?: readonly string[];
+	createdAt: Date;
+}
+
+export type NewOutboxRow = Omit<OutboxRow, "id" | "createdAt">;
+
+/** What a transport said of one delivery. */
+export type DeliveryResult = "sent" | "gone" | "failed" | "skipped";
+
+interface Row {
+	id: string | number;
+	kind: OutboxKind;
+	tag: string;
+	principal_id: string;
+	open: string;
+	urgency: "normal" | "high";
+	badge: number;
+	title: string | null;
+	body: string | null;
+	via: string[] | null;
+	created_at: Date;
+}
+
+const rowOf = (row: Row): OutboxRow => ({
+	id: Number(row.id),
+	kind: row.kind,
+	tag: row.tag,
+	principalId: row.principal_id,
+	open: row.open,
+	urgency: row.urgency,
+	badge: row.badge,
+	...(row.title === null ? {} : { title: row.title }),
+	...(row.body === null ? {} : { body: row.body }),
+	...(row.via === null ? {} : { via: row.via }),
+	createdAt: row.created_at,
+});
+
+/** A claimed row that no sender finished is claimed again after this long. */
+const CLAIM_LEASE_SECONDS = 60;
+/** Finished rows, deliveries and receipts are kept this long, in days. */
+export const OUTBOX_KEEP_DAYS = 30;
+/** A device that returned a receipt this recently counts as working. */
+export const RECEIPT_WINDOW_DAYS = 30;
+
+/** A receipt the service worker posted: the notification arrived, or was opened. */
+export type ReceiptEvent = "received" | "opened";
+
+/**
+ * The queue between the app and the process that signs and sends pushes (`web_push_outbox`), what
+ * the sender did with each row (`web_push_deliveries`), and the receipts the service worker posts
+ * back (`web_push_receipts`). The app and an external sender both use it: the sender needs only to
+ * read and update the outbox and insert deliveries.
+ */
+export class PushOutbox {
+	readonly #sql: SQL;
+
+	constructor(sql: SQL) {
+		this.#sql = sql;
+	}
+
+	static readonly migration: Migration = {
+		name: "web-push-outbox",
+		up: async (sql) => {
+			await sql`
+				CREATE TABLE IF NOT EXISTS web_push_outbox (
+					id bigserial PRIMARY KEY,
+					kind text NOT NULL,
+					tag text NOT NULL,
+					principal_id text NOT NULL,
+					open text NOT NULL,
+					urgency text NOT NULL,
+					badge integer NOT NULL DEFAULT 0,
+					title text,
+					body text,
+					via text[],
+					created_at timestamptz NOT NULL DEFAULT now(),
+					claimed_at timestamptz,
+					done_at timestamptz
+				)`;
+			await sql`CREATE INDEX IF NOT EXISTS web_push_outbox_open ON web_push_outbox (id) WHERE done_at IS NULL`;
+			await sql`CREATE INDEX IF NOT EXISTS web_push_outbox_done ON web_push_outbox (done_at)`;
+			await sql`
+				CREATE TABLE IF NOT EXISTS web_push_deliveries (
+					outbox_id bigint NOT NULL,
+					transport text NOT NULL,
+					endpoint_hash text,
+					result text NOT NULL,
+					at timestamptz NOT NULL DEFAULT now()
+				)`;
+			await sql`CREATE INDEX IF NOT EXISTS web_push_deliveries_outbox ON web_push_deliveries (outbox_id)`;
+			await sql`
+				CREATE TABLE IF NOT EXISTS web_push_receipts (
+					principal_id text NOT NULL,
+					tag text NOT NULL,
+					event text NOT NULL,
+					at timestamptz NOT NULL DEFAULT now()
+				)`;
+			await sql`CREATE INDEX IF NOT EXISTS web_push_receipts_principal ON web_push_receipts (principal_id, at DESC)`;
+		},
+	};
+
+	/** Queues a push; returns its id. */
+	async enqueue(row: NewOutboxRow): Promise<number> {
+		const [made]: { id: string | number }[] = await this.#sql`
+			INSERT INTO web_push_outbox (kind, tag, principal_id, open, urgency, badge, title, body, via)
+			VALUES (${row.kind}, ${row.tag}, ${row.principalId}, ${row.open}, ${row.urgency},
+				${row.badge}, ${row.title ?? null}, ${row.body ?? null},
+				${row.via ? this.#sql.array([...row.via], "TEXT") : null})
+			RETURNING id`;
+		if (!made) throw new Error("the push outbox did not return an id");
+		return Number(made.id);
+	}
+
+	/** Takes up to `limit` rows no sender holds, oldest first; a row held longer than the lease is taken again. */
+	async claim(limit: number): Promise<OutboxRow[]> {
+		const rows: Row[] = await this.#sql`
+			UPDATE web_push_outbox SET claimed_at = now()
+			WHERE id IN (
+				SELECT id FROM web_push_outbox
+				WHERE done_at IS NULL
+					AND (claimed_at IS NULL OR claimed_at < now() - make_interval(secs => ${CLAIM_LEASE_SECONDS}))
+				ORDER BY id LIMIT ${limit}
+				FOR UPDATE SKIP LOCKED)
+			RETURNING *`;
+		return rows.map(rowOf).sort((a, b) => a.id - b.id);
+	}
+
+	/** Records what the transports said of a row and finishes it. */
+	async finish(
+		id: number,
+		deliveries: readonly { transport: string; result: DeliveryResult }[],
+	): Promise<void> {
+		await this.#sql.begin(async (tx) => {
+			for (const delivery of deliveries)
+				await tx`
+					INSERT INTO web_push_deliveries (outbox_id, transport, result)
+					VALUES (${id}, ${delivery.transport}, ${delivery.result})`;
+			await tx`UPDATE web_push_outbox SET done_at = now() WHERE id = ${id}`;
+		});
+	}
+
+	/** Whether the person has a queued push of this kind and tag, which makes a receipt for it theirs. */
+	async has(
+		principalId: string,
+		kind: OutboxKind,
+		tag: string,
+	): Promise<boolean> {
+		const [found]: { n: number }[] = await this.#sql`
+			SELECT count(*)::int AS n FROM web_push_outbox
+			WHERE principal_id = ${principalId} AND kind = ${kind} AND tag = ${tag}`;
+		return (found?.n ?? 0) > 0;
+	}
+
+	async receipt(
+		principalId: string,
+		tag: string,
+		event: ReceiptEvent,
+	): Promise<void> {
+		await this.#sql`
+			INSERT INTO web_push_receipts (principal_id, tag, event)
+			VALUES (${principalId}, ${tag}, ${event})`;
+	}
+
+	/** When a device of the person last posted a receipt, within the window; undefined for none. */
+	async lastReceiptAt(
+		principalId: string,
+		withinDays = RECEIPT_WINDOW_DAYS,
+	): Promise<Date | undefined> {
+		const [found]: { at: Date | null }[] = await this.#sql`
+			SELECT max(at) AS at FROM web_push_receipts
+			WHERE principal_id = ${principalId}
+				AND at > now() - make_interval(days => ${withinDays})`;
+		return found?.at ?? undefined;
+	}
+
+	/** Deletes finished rows, their deliveries and old receipts; returns how many rows went. */
+	async sweep(): Promise<number> {
+		const gone: { id: string | number }[] = await this.#sql`
+			DELETE FROM web_push_outbox
+			WHERE done_at < now() - make_interval(days => ${OUTBOX_KEEP_DAYS}) RETURNING id`;
+		await this.#sql`
+			DELETE FROM web_push_deliveries d WHERE NOT EXISTS (
+				SELECT 1 FROM web_push_outbox o WHERE o.id = d.outbox_id)`;
+		await this.#sql`
+			DELETE FROM web_push_receipts
+			WHERE at < now() - make_interval(days => ${OUTBOX_KEEP_DAYS})`;
+		return gone.length;
+	}
+}

package/src/push/prefs.ts

@@ -0,0 +1,118 @@
+import type { SQL } from "bun";
+import type { Migration } from "pi-roundtable";
+import { minutesOfDay, QuietClock, type QuietWindow } from "./quiet-hours.ts";
+
+/** A person's own quiet hours: no push for a normal notice in the window, on their time zone's clock. */
+export interface PushPrefs {
+	/** `HH:MM`, where the window begins. */
+	quietStart: string;
+	/** `HH:MM`, where it ends; before `start` when it crosses midnight. */
+	quietEnd: string;
+	/** The IANA zone the times are read in. */
+	timeZone: string;
+}
+
+interface Row {
+	quiet_start: string;
+	quiet_end: string;
+	time_zone: string;
+}
+
+/** Why a preference was refused, in words the page shows. */
+export class PrefsRefused extends Error {}
+
+/** Checks the three fields; throws `PrefsRefused` for a time that is not `HH:MM`, equal times or an unknown zone. */
+export function checkPrefs(value: unknown): PushPrefs {
+	const given = value as Partial<PushPrefs> | null;
+	if (
+		typeof given !== "object" ||
+		given === null ||
+		typeof given.quietStart !== "string" ||
+		typeof given.quietEnd !== "string" ||
+		typeof given.timeZone !== "string"
+	)
+		throw new PrefsRefused(
+			"Quiet hours need quietStart, quietEnd and timeZone.",
+		);
+	if (
+		minutesOfDay(given.quietStart) === undefined ||
+		minutesOfDay(given.quietEnd) === undefined
+	)
+		throw new PrefsRefused("Quiet hours are times like 22:00 and 07:30.");
+	if (given.quietStart === given.quietEnd)
+		throw new PrefsRefused("The two times of the quiet hours must differ.");
+	try {
+		new QuietClock(
+			{ start: given.quietStart, end: given.quietEnd },
+			given.timeZone,
+		);
+	} catch {
+		throw new PrefsRefused("That time zone is not known.");
+	}
+	return {
+		quietStart: given.quietStart,
+		quietEnd: given.quietEnd,
+		timeZone: given.timeZone,
+	};
+}
+
+/** The people's quiet hours, in `web_push_prefs`. */
+export class PushPrefsStore {
+	readonly #sql: SQL;
+
+	constructor(sql: SQL) {
+		this.#sql = sql;
+	}
+
+	static readonly migration: Migration = {
+		name: "web-push-prefs",
+		up: async (sql) => {
+			await sql`
+				CREATE TABLE IF NOT EXISTS web_push_prefs (
+					principal_id text PRIMARY KEY,
+					quiet_start text NOT NULL,
+					quiet_end text NOT NULL,
+					time_zone text NOT NULL
+				)`;
+		},
+	};
+
+	async get(principalId: string): Promise<PushPrefs | undefined> {
+		const [row]: Row[] = await this.#sql`
+			SELECT quiet_start, quiet_end, time_zone FROM web_push_prefs
+			WHERE principal_id = ${principalId}`;
+		return row
+			? {
+					quietStart: row.quiet_start,
+					quietEnd: row.quiet_end,
+					timeZone: row.time_zone,
+				}
+			: undefined;
+	}
+
+	/** Stores the person's quiet hours, or removes them with `undefined`. */
+	async set(principalId: string, prefs: PushPrefs | undefined): Promise<void> {
+		if (!prefs) {
+			await this
+				.#sql`DELETE FROM web_push_prefs WHERE principal_id = ${principalId}`;
+			return;
+		}
+		await this.#sql`
+			INSERT INTO web_push_prefs (principal_id, quiet_start, quiet_end, time_zone)
+			VALUES (${principalId}, ${prefs.quietStart}, ${prefs.quietEnd}, ${prefs.timeZone})
+			ON CONFLICT (principal_id) DO UPDATE SET
+				quiet_start = EXCLUDED.quiet_start, quiet_end = EXCLUDED.quiet_end,
+				time_zone = EXCLUDED.time_zone`;
+	}
+
+	/** Whether the moment is inside the person's quiet hours; false when they set none. */
+	async quietAt(principalId: string, at: number): Promise<boolean> {
+		const prefs = await this.get(principalId);
+		if (!prefs) return false;
+		const window: QuietWindow = {
+			start: prefs.quietStart,
+			end: prefs.quietEnd,
+		};
+		return new QuietClock(window, prefs.timeZone).quietAt(at);
+	}
+}

package/src/push/sender.ts

@@ -18,7 +18,11 @@ export interface PushPayload {
 	url?: string;
 	/** Notifications with one tag replace each other on the device. */
 	tag: string;
-	kind: "card" | "cap" | "reply" | "notice";
+	kind: "card" | "cap" | "reply" | "notice" | "test" | "clear";
+	/** The count the app icon shows after this push; absent = leave it. */
+	badge?: number;
+	/** `high` asks the device to keep the notification until it is dealt with. */
+	urgency?: "normal" | "high";
 }
 
 /** The part of a stored subscription the sender needs. */
@@ -83,7 +87,8 @@ export class PushSender {
 					"content-encoding": "aes128gcm",
 					"content-type": "application/octet-stream",
 					ttl: String(TTL_SECONDS),
-					urgency: payload.kind === "reply" ? "normal" : "high",
+					urgency:
+						payload.urgency ?? (payload.kind === "reply" ? "normal" : "high"),
 				},
 				body,
 				// A push service never redirects; a redirect would walk past the allowlist.