@devmonks/notify 0.0.0-stage → 0.4.0

package/dist/drizzle/tables.js

@@ -0,0 +1,87 @@
+import { boolean, index, integer, jsonb, pgTable, primaryKey, text, timestamp, uniqueIndex, uuid, } from 'drizzle-orm/pg-core';
+import { isNotNull, isNull } from 'drizzle-orm';
+const ts = (name) => timestamp(name, { withTimezone: true, mode: 'date' });
+/** A user id column of the same SQL type as the app's `users.id` (`uuid` or `text`), so the foreign keys line up. */
+const userIdColumn = (usersId) => (name) => usersId.getSQLType() === 'uuid' ? uuid(name) : text(name);
+/**
+ * Drizzle tables for the notify module. Pass the app's users table so the foreign keys point at it;
+ * the user id columns take its id's type (`uuid` or `text`). Re-export the result from the app's schema so its drizzle-kit
+ * generates the migration:
+ *
+ *   export const { notifications, devices, notificationPrefs, notificationSettings, notificationDeliveries } =
+ *     notifyTables({ users });
+ */
+export function notifyTables({ users }) {
+    const userId = userIdColumn(users.id);
+    /** In-app inbox. One row per inApp delivery. */
+    const notifications = pgTable('notification', {
+        id: text('id').primaryKey(),
+        userId: userId('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+        type: text('type').notNull(),
+        title: text('title').notNull(),
+        body: text('body').notNull().default(''),
+        url: text('url'),
+        data: jsonb('data').notNull().default({}),
+        /** What it is about (an alert, a message), so "who got X" is a plain indexed lookup. */
+        sourceId: text('source_id'),
+        /** Who caused it, when a user did. Cleared when that user is deleted. */
+        actorId: userId('actor_id').references(() => users.id, { onDelete: 'set null' }),
+        readAt: ts('read_at'),
+        createdAt: ts('created_at').notNull().defaultNow(),
+    }, (t) => [
+        /** Keyset paging: newest first, id breaks ties. */
+        index('notification_user_created_idx').on(t.userId, t.createdAt.desc(), t.id.desc()),
+        index('notification_user_unread_idx').on(t.userId).where(isNull(t.readAt)),
+        /** One row per user for each thing it is about; also the "who got X" lookup. */
+        uniqueIndex('notification_source_uq').on(t.type, t.sourceId, t.userId).where(isNotNull(t.sourceId)),
+        index('notification_created_idx').on(t.createdAt),
+    ]);
+    /** One row per app install. `id` is generated by the app on first launch and stays stable; the push token may rotate. */
+    const devices = pgTable('notify_device', {
+        id: text('id').primaryKey(),
+        userId: userId('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+        /** 'ios' | 'android' */
+        platform: text('platform').notNull(),
+        token: text('token').notNull(),
+        appVersion: text('app_version').notNull().default(''),
+        createdAt: ts('created_at').notNull().defaultNow(),
+        /** Bumped on every registration. Devices are pruned by it only when the app enables pruneInactiveAfterDays. */
+        lastSeenAt: ts('last_seen_at').notNull().defaultNow(),
+        /** Consecutive permanent failures; the device is deleted at 3. A success resets it. */
+        failureCount: integer('failure_count').notNull().default(0),
+    }, (t) => [uniqueIndex('notify_device_token_uq').on(t.token), index('notify_device_user_idx').on(t.userId)]);
+    /** Per category and channel switch. A missing row means the app's default. */
+    const notificationPrefs = pgTable('notification_pref', {
+        userId: userId('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+        category: text('category').notNull(),
+        channel: text('channel').notNull(),
+        enabled: boolean('enabled').notNull(),
+    }, (t) => [primaryKey({ columns: [t.userId, t.category, t.channel] })]);
+    /** Quiet hours. A missing row means none. Times are local 'HH:MM'. */
+    const notificationSettings = pgTable('notification_settings', {
+        userId: userId('user_id').primaryKey().references(() => users.id, { onDelete: 'cascade' }),
+        quietFrom: text('quiet_from'),
+        quietTo: text('quiet_to'),
+        updatedAt: ts('updated_at').notNull().defaultNow(),
+    });
+    /** Audit and dedupe of every planned delivery. The unique idempotency key makes retries and double triggers harmless. */
+    const notificationDeliveries = pgTable('notification_delivery', {
+        id: text('id').primaryKey(),
+        idempotencyKey: text('idempotency_key').notNull(),
+        type: text('type').notNull(),
+        /** No FK: also used for address-only sends (sign-in codes before the account exists), as "email:<address>". */
+        userId: text('user_id').notNull(),
+        channel: text('channel').notNull(),
+        deviceId: text('device_id'),
+        /** pending | sent | failed | skipped */
+        status: text('status').notNull().default('pending'),
+        error: text('error'),
+        attempts: integer('attempts').notNull().default(0),
+        createdAt: ts('created_at').notNull().defaultNow(),
+    }, (t) => [
+        uniqueIndex('notification_delivery_key_uq').on(t.idempotencyKey),
+        index('notification_delivery_user_idx').on(t.userId, t.createdAt),
+        index('notification_delivery_created_idx').on(t.createdAt),
+    ]);
+    return { notifications, devices, notificationPrefs, notificationSettings, notificationDeliveries };
+}

package/dist/email/adapter.d.ts

@@ -0,0 +1,18 @@
+import type { Channel, Logger } from '../types.js';
+import type { EmailBrand } from './types.js';
+export interface EmailOptions {
+    brand?: EmailBrand;
+    /** Prefix for relative `content.url` values so the email button works, e.g. "https://example.com". */
+    linkBase?: string;
+}
+export interface ResendOptions extends EmailOptions {
+    apiKey: string;
+    /** e.g. `Acme <hello@example.com>` */
+    from: string;
+    /** Injected for tests; defaults to global fetch. */
+    fetch?: typeof fetch;
+}
+/** Email through the Resend HTTP API (fetch only, Workers-safe). 429 and 5xx are retryable. */
+export declare function resendEmail({ apiKey, from, fetch: f, brand, linkBase }: ResendOptions): Channel;
+/** Dev: prints the rendered plain-text email instead of sending. */
+export declare function logEmail(logger: Logger, opts?: EmailOptions): Channel;

package/dist/email/adapter.js

@@ -0,0 +1,51 @@
+import { errorMessage, retryableStatus, tryJson } from '../util.js';
+import { renderContentEmail } from './render.js';
+/** Email through the Resend HTTP API (fetch only, Workers-safe). 429 and 5xx are retryable. */
+export function resendEmail({ apiKey, from, fetch: f = fetch, brand, linkBase }) {
+    return {
+        name: 'email',
+        async send(to, content, ctx) {
+            let rendered;
+            try {
+                rendered = await renderContentEmail(content, brand, linkBase);
+            }
+            catch (e) {
+                return { ok: false, retryable: false, error: `render failed: ${errorMessage(e)}` };
+            }
+            let res;
+            try {
+                res = await f('https://api.resend.com/emails', {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                        ...(ctx?.idempotencyKey ? { 'Idempotency-Key': ctx.idempotencyKey } : {}),
+                    },
+                    body: JSON.stringify({ from, to: [to], subject: rendered.subject, html: rendered.html, text: rendered.text }),
+                });
+            }
+            catch (e) {
+                return { ok: false, retryable: true, error: `network: ${errorMessage(e)}` };
+            }
+            if (res.ok) {
+                const json = (await res.json().catch(() => ({})));
+                return json.id ? { ok: true, providerId: json.id } : { ok: true };
+            }
+            const raw = await res.text().catch(() => '');
+            const j = tryJson(raw);
+            const reason = [j?.name, j?.message].filter(Boolean).join(': ') || raw.slice(0, 300);
+            return { ok: false, retryable: retryableStatus(res.status), error: `resend ${res.status}: ${reason}` };
+        },
+    };
+}
+/** Dev: prints the rendered plain-text email instead of sending. */
+export function logEmail(logger, opts = {}) {
+    return {
+        name: 'email',
+        async send(to, content) {
+            const r = await renderContentEmail(content, opts.brand, opts.linkBase);
+            logger.info(`[email] to=${to} subject=${JSON.stringify(r.subject)}\n${r.text}`);
+            return { ok: true };
+        },
+    };
+}

package/dist/email/index.d.ts

@@ -0,0 +1,5 @@
+export { resendEmail, logEmail, type ResendOptions, type EmailOptions } from './adapter.js';
+export { BaseLayout, DEFAULT_BRAND, type BaseLayoutProps } from './layout.js';
+export { simpleEmail, type SimpleEmailProps } from './simple.js';
+export { renderEmail, renderContentEmail } from './render.js';
+export type { EmailBrand, EmailPalette, EmailTemplate } from './types.js';

package/dist/email/index.js

@@ -0,0 +1,4 @@
+export { resendEmail, logEmail } from './adapter.js';
+export { BaseLayout, DEFAULT_BRAND } from './layout.js';
+export { simpleEmail } from './simple.js';
+export { renderEmail, renderContentEmail } from './render.js';

package/dist/email/layout.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import type { EmailBrand, EmailPalette } from './types.js';
+export declare const DEFAULT_BRAND: EmailBrand;
+export declare const DEFAULT_PALETTE: EmailPalette;
+export declare const FONT = "-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, Helvetica, Arial, sans-serif";
+export declare const paletteOf: (brand: EmailBrand) => EmailPalette;
+export interface BaseLayoutProps {
+    brand?: EmailBrand;
+    /** Inbox preview line (shown next to the subject, hidden in the body). */
+    preview?: string;
+    children: ReactNode;
+}
+/** The one layout every email uses: logo or name, a card with the content, a footer. */
+export declare function BaseLayout({ brand, preview, children }: BaseLayoutProps): import("react").JSX.Element;

package/dist/email/layout.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Body, Container, Head, Html, Img, Link, Preview, Section, Text } from '@react-email/components';
+export const DEFAULT_BRAND = { name: 'Notifications', accent: '#221A2B' };
+export const DEFAULT_PALETTE = {
+    background: '#f6f4f9',
+    surface: '#ffffff',
+    line: '#ece6f2',
+    rule: 'transparent',
+    heading: '#221a2b',
+    text: '#4a4152',
+    muted: '#6f6578',
+    codeFill: '#f6f4f9',
+    codeBorder: '#ece6f2',
+};
+export const FONT = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
+export const paletteOf = (brand) => ({ ...DEFAULT_PALETTE, ...brand.palette });
+/** The one layout every email uses: logo or name, a card with the content, a footer. */
+export function BaseLayout({ brand = DEFAULT_BRAND, preview, children }) {
+    const c = paletteOf(brand);
+    const accent = brand.accent ?? DEFAULT_BRAND.accent;
+    const body = { backgroundColor: c.background, margin: 0, padding: '40px 16px', fontFamily: FONT };
+    const card = {
+        backgroundColor: c.surface,
+        border: `1px solid ${c.line}`,
+        borderRadius: '18px',
+        padding: '36px 32px 28px',
+        color: c.heading,
+    };
+    const footer = { color: c.muted, fontSize: '12px', lineHeight: '18px', margin: '4px 0 0', textAlign: 'center' };
+    const signoff = {
+        fontFamily: brand.headingFont ?? FONT,
+        fontStyle: 'italic',
+        fontSize: '18px',
+        lineHeight: '24px',
+        color: accent,
+        margin: '24px 0 0',
+    };
+    return (_jsxs(Html, { lang: "en", children: [_jsxs(Head, { children: [_jsx("meta", { name: "color-scheme", content: "light" }), _jsx("meta", { name: "supported-color-schemes", content: "light" }), brand.fontCssUrl ? _jsx("link", { rel: "stylesheet", href: brand.fontCssUrl }) : null] }), preview ? _jsx(Preview, { children: preview }) : null, _jsx(Body, { style: body, children: _jsxs(Container, { style: { maxWidth: '560px', margin: '0 auto' }, children: [_jsx(Section, { style: { textAlign: 'center', margin: '0 0 24px' }, children: brand.logoUrl ? (_jsx(Img, { src: brand.logoUrl, alt: brand.name, width: brand.logoWidth, height: brand.logoHeight ?? 32, style: { display: 'inline-block', border: 0, outline: 'none' } })) : (_jsx(Text, { style: { margin: 0, fontSize: '18px', fontWeight: 700, color: accent }, children: brand.name })) }), _jsxs(Section, { style: card, children: [children, brand.signoff ? _jsx(Text, { style: signoff, children: brand.signoff }) : null] }), _jsxs(Section, { style: { padding: '24px 0 0' }, children: [brand.footer ? _jsx(Text, { style: { ...footer, color: c.text, fontSize: '13px' }, children: brand.footer }) : null, brand.links?.length ? (_jsx(Text, { style: footer, children: brand.links.map((l, i) => (_jsxs("span", { children: [i > 0 ? '  ·  ' : '', _jsx(Link, { href: l.url, style: { color: c.muted, textDecoration: 'underline' }, children: l.label })] }, l.url))) })) : null, brand.supportEmail ? (_jsxs(Text, { style: footer, children: ["Need help? ", _jsx(Link, { href: `mailto:${brand.supportEmail}`, style: { color: accent }, children: brand.supportEmail })] })) : null] })] }) })] }));
+}

package/dist/email/render.d.ts

@@ -0,0 +1,17 @@
+import type { ReactElement } from 'react';
+import type { Content } from '../types.js';
+import type { EmailBrand } from './types.js';
+/** HTML and plain-text bodies of one email, rendered from the same React element. */
+export declare function renderEmail(element: ReactElement): Promise<{
+    html: string;
+    text: string;
+}>;
+/**
+ * Subject + html + text for a Content. No custom template: simpleEmail from title, body and url.
+ * [linkBase] prefixes a relative `content.url`; a url that is still relative gets no button.
+ */
+export declare function renderContentEmail(content: Content, brand?: EmailBrand, linkBase?: string): Promise<{
+    subject: string;
+    html: string;
+    text: string;
+}>;

package/dist/email/render.js

@@ -0,0 +1,38 @@
+import { render } from '@react-email/render';
+import { DEFAULT_BRAND } from './layout.js';
+import { simpleEmail } from './simple.js';
+/** Headings keep their case in the plain-text version (the library upper-cases them by default). */
+const HEADING_SELECTORS = ['h1', 'h2', 'h3'].map((selector) => ({ selector, options: { uppercase: false } }));
+/** HTML and plain-text bodies of one email, rendered from the same React element. */
+export async function renderEmail(element) {
+    const [html, text] = await Promise.all([
+        render(element),
+        render(element, { plainText: true, htmlToTextOptions: { selectors: HEADING_SELECTORS } }),
+    ]);
+    return { html, text };
+}
+const isAbsolute = (url) => /^https?:\/\//.test(url);
+/**
+ * Subject + html + text for a Content. No custom template: simpleEmail from title, body and url.
+ * [linkBase] prefixes a relative `content.url`; a url that is still relative gets no button.
+ */
+export async function renderContentEmail(content, brand = DEFAULT_BRAND, linkBase) {
+    const subject = content.email?.subject ?? content.title;
+    const template = content.email?.template;
+    let element;
+    if (template) {
+        element = template({ brand, ...content.email?.props });
+    }
+    else {
+        let url = content.url;
+        if (url && linkBase && !isAbsolute(url))
+            url = `${linkBase.replace(/\/+$/, '')}/${url.replace(/^\/+/, '')}`;
+        element = simpleEmail({
+            brand,
+            heading: content.title,
+            body: content.body,
+            ...(url && isAbsolute(url) ? { button: { label: `Open ${brand.name}`, url } } : {}),
+        });
+    }
+    return { subject, ...(await renderEmail(element)) };
+}

package/dist/email/simple.d.ts

@@ -0,0 +1,17 @@
+import type { EmailBrand } from './types.js';
+export interface SimpleEmailProps {
+    heading: string;
+    /** Plain text. Blank lines start a new paragraph. */
+    body: string;
+    /** A short code shown large (sign-in codes). */
+    code?: string;
+    button?: {
+        label: string;
+        url: string;
+    };
+    /** Inbox preview line. Defaults to the first line of the body. */
+    preview?: string;
+    brand?: EmailBrand;
+}
+/** Heading, paragraphs, optional code box, optional button: covers text-and-button emails without a custom template. */
+export declare function simpleEmail({ heading, body, code, button, preview, brand }: SimpleEmailProps): import("react").JSX.Element;

package/dist/email/simple.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Heading, Hr, Section, Text } from '@react-email/components';
+import { BaseLayout, DEFAULT_BRAND, FONT, paletteOf } from './layout.js';
+/** Heading, paragraphs, optional code box, optional button: covers text-and-button emails without a custom template. */
+export function simpleEmail({ heading, body, code, button, preview, brand = DEFAULT_BRAND }) {
+    const accent = brand.accent ?? DEFAULT_BRAND.accent;
+    const c = paletteOf(brand);
+    const paragraphs = body.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+    const h = {
+        fontFamily: brand.headingFont ?? FONT,
+        fontSize: brand.headingFont ? '32px' : '22px',
+        fontWeight: brand.headingFont ? 400 : 700,
+        lineHeight: brand.headingFont ? '38px' : '28px',
+        margin: '0 0 16px',
+        color: c.heading,
+    };
+    const p = { fontSize: '16px', lineHeight: '26px', margin: '0 0 16px', color: c.text };
+    const codeBox = {
+        fontFamily: '"SF Mono", Menlo, Consolas, "Courier New", monospace',
+        fontSize: '34px',
+        letterSpacing: '0.35em',
+        fontWeight: 700,
+        textAlign: 'center',
+        color: c.heading,
+        backgroundColor: c.codeFill,
+        border: `1px dashed ${c.codeBorder}`,
+        borderRadius: '14px',
+        padding: '18px 16px 18px calc(16px + 0.35em)',
+        margin: '8px 0 20px',
+    };
+    const btn = {
+        backgroundColor: accent,
+        color: '#ffffff',
+        borderRadius: '999px',
+        padding: '14px 28px',
+        fontSize: '15px',
+        fontWeight: 600,
+        textDecoration: 'none',
+        display: 'inline-block',
+    };
+    return (_jsxs(BaseLayout, { brand: brand, preview: preview ?? paragraphs[0] ?? heading, children: [_jsx(Heading, { as: "h1", style: h, children: heading }), c.rule !== 'transparent' ? _jsx(Hr, { style: { border: 'none', borderTop: `3px solid ${c.rule}`, width: '44px', margin: '-4px 0 20px 0' } }) : null, paragraphs.map((text, i) => (_jsx(Text, { style: p, children: text }, i))), code ? _jsx(Text, { style: codeBox, children: code }) : null, button ? (_jsx(Section, { style: { margin: '8px 0 0' }, children: _jsx(Button, { href: button.url, style: btn, children: button.label }) })) : null] }));
+}

package/dist/email/types.d.ts

@@ -0,0 +1,46 @@
+import type { ReactElement } from 'react';
+/** A React Email template: props in, element out. The adapter also passes `brand` (see EmailBrand). */
+export type EmailTemplate<P = any> = (props: P) => ReactElement;
+/** Brand slot for emails (BaseLayout, simpleEmail). */
+export interface EmailBrand {
+    name: string;
+    /** CSS colour for buttons and accents. */
+    accent?: string;
+    /** Absolute URL of a logo image; the name is shown as text without it. */
+    logoUrl?: string;
+    /** Footer line, e.g. a tagline or address. */
+    footer?: string;
+    supportEmail?: string;
+    /** Logo size in CSS px (keep the image's aspect ratio; serve it at 2-3x). */
+    logoWidth?: number;
+    logoHeight?: number;
+    /** Colours; anything unset falls back to the neutral default. */
+    palette?: Partial<EmailPalette>;
+    /** Heading font stack (body text always uses the system stack). */
+    headingFont?: string;
+    /** Web font stylesheet for clients that load one (Apple Mail, iOS); others use the stack's fallbacks. */
+    fontCssUrl?: string;
+    /** Small links under the card, e.g. website, privacy. */
+    links?: {
+        label: string;
+        url: string;
+    }[];
+    /** Line under the content, e.g. "See you at 8 pm". */
+    signoff?: string;
+}
+export interface EmailPalette {
+    /** Outside the card. */
+    background: string;
+    /** The card. */
+    surface: string;
+    /** Card border. */
+    line: string;
+    /** Short rule under the heading; transparent = none. */
+    rule: string;
+    heading: string;
+    text: string;
+    muted: string;
+    /** Code box fill and border. */
+    codeFill: string;
+    codeBorder: string;
+}

package/dist/email/types.js

@@ -0,0 +1 @@
+export {};

package/dist/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashParts(parts: (string | undefined)[]): string;

package/dist/hash.js

@@ -0,0 +1,17 @@
+/** Small synchronous 3x53-bit string hash (cyrb53), hex. Not cryptographic: used for stable dedupe keys. */
+function cyrb53(str, seed) {
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0; i < str.length; i++) {
+        const ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+export function hashParts(parts) {
+    const s = parts.map((p) => p ?? '').join('\u001f');
+    return [cyrb53(s, 1), cyrb53(s, 2), cyrb53(s, 3)].map((n) => n.toString(16).padStart(14, '0')).join('');
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export { createNotifier, defineNotification, type Notifier, type NotifierConfig } from './notifier.js';
+export { inQuietHours } from './quiet-hours.js';
+export { fcmPush, logPush, type FcmOptions } from './adapters/push.js';
+export { inApp, logSms } from './adapters/sms-inapp.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export { createNotifier, defineNotification } from './notifier.js';
+export { inQuietHours } from './quiet-hours.js';
+export { fcmPush, logPush } from './adapters/push.js';
+export { inApp, logSms } from './adapters/sms-inapp.js';

package/dist/notifier.d.ts

@@ -0,0 +1,14 @@
+import type { Channel, Delivery, NotificationType, PlanOptions, Recipient, SendResult } from './types.js';
+export interface NotifierConfig {
+    channels: Channel[];
+    types: NotificationType[];
+}
+export interface Notifier {
+    /** Pure: decides who gets what on which channel. Sends nothing. */
+    plan<D>(type: string | NotificationType<D>, recipient: Recipient, data: D, opts?: PlanOptions): Delivery[];
+    /** Sends ONE delivery through its channel adapter. Never throws. */
+    send(delivery: Delivery): Promise<SendResult>;
+}
+/** Identity: gives `render` its data type. */
+export declare function defineNotification<D>(type: NotificationType<D>): NotificationType<D>;
+export declare function createNotifier(config: NotifierConfig): Notifier;

package/dist/notifier.js

@@ -0,0 +1,77 @@
+import { hashParts } from './hash.js';
+import { inQuietHours } from './quiet-hours.js';
+import { errorMessage } from './util.js';
+/** Channels muted during quiet hours. In-app and email are not interruptive. */
+const QUIET_MUTED = new Set(['push', 'sms']);
+/** Identity: gives `render` its data type. */
+export function defineNotification(type) {
+    return type;
+}
+function addressesFor(channel, r) {
+    switch (channel) {
+        case 'email':
+            return r.email ? [{ to: r.email }] : [];
+        case 'sms':
+            return r.phone ? [{ to: r.phone }] : [];
+        case 'push': {
+            const seen = new Set();
+            return r.devices.filter((d) => d.token && !seen.has(d.token) && seen.add(d.token)).map((d) => ({ to: d.token, deviceId: d.id }));
+        }
+        case 'inApp':
+            return r.inAppEnabled === false ? [] : [{ to: r.id }];
+        default:
+            return [{ to: r.id }];
+    }
+}
+export function createNotifier(config) {
+    const channels = Object.fromEntries(config.channels.map((c) => [c.name, c]));
+    const types = Object.fromEntries(config.types.map((t) => [t.type, t]));
+    return {
+        plan(type, recipient, data, opts = {}) {
+            const def = typeof type === 'string' ? (Object.hasOwn(types, type) ? types[type] : undefined) : type;
+            if (!def)
+                throw new Error(`Unknown notification type: ${String(type)}`);
+            const now = opts.now ?? new Date();
+            const quiet = !def.transactional && inQuietHours(now, recipient.timeZone, recipient.quietHours);
+            const categoryPrefs = Object.hasOwn(recipient.prefs, def.category) ? (recipient.prefs[def.category] ?? {}) : {};
+            let content;
+            const out = [];
+            for (const channel of def.channels) {
+                if (!channels[channel])
+                    continue;
+                if (!def.transactional && categoryPrefs[channel] === false)
+                    continue;
+                if (quiet && QUIET_MUTED.has(channel))
+                    continue;
+                const addresses = addressesFor(channel, recipient);
+                if (addresses.length === 0)
+                    continue;
+                content ??= def.render(data, { locale: recipient.locale });
+                for (const { to, deviceId } of addresses) {
+                    out.push({
+                        id: crypto.randomUUID(),
+                        type: def.type,
+                        channel,
+                        to,
+                        content,
+                        recipientId: recipient.id,
+                        ...(deviceId ? { deviceId } : {}),
+                        idempotencyKey: hashParts([def.type, recipient.id, channel, to, opts.dedupeKey]),
+                    });
+                }
+            }
+            return out;
+        },
+        async send(delivery) {
+            const channel = channels[delivery.channel];
+            if (!channel)
+                return { ok: false, retryable: false, error: `No adapter for channel "${delivery.channel}"` };
+            try {
+                return await channel.send(delivery.to, delivery.content, { type: delivery.type, idempotencyKey: delivery.idempotencyKey });
+            }
+            catch (e) {
+                return { ok: false, retryable: true, error: errorMessage(e) };
+            }
+        },
+    };
+}

package/dist/quiet-hours.d.ts

@@ -0,0 +1,5 @@
+/** True when the recipient's local time is inside [from, to). Crosses midnight when from > to; from == to is "never". */
+export declare function inQuietHours(now: Date, tz: string, q: {
+    from: string;
+    to: string;
+} | undefined): boolean;

package/dist/quiet-hours.js

@@ -0,0 +1,45 @@
+const cache = new Map();
+function fmt(tz) {
+    let f = cache.get(tz);
+    if (!f) {
+        try {
+            f = new Intl.DateTimeFormat('en-GB', { timeZone: tz, hourCycle: 'h23', hour: '2-digit', minute: '2-digit' });
+        }
+        catch {
+            f = fmt('UTC');
+        }
+        cache.set(tz, f);
+    }
+    return f;
+}
+/** Minutes since local midnight for [now] in [tz] (bad zones fall back to UTC). */
+function localMinutes(now, tz) {
+    let h = 0;
+    let m = 0;
+    for (const p of fmt(tz).formatToParts(now)) {
+        if (p.type === 'hour')
+            h = Number(p.value) % 24;
+        if (p.type === 'minute')
+            m = Number(p.value);
+    }
+    return h * 60 + m;
+}
+function parseHHMM(s) {
+    const m = /^(\d{1,2}):(\d{2})$/.exec(s);
+    if (!m)
+        return null;
+    const h = Number(m[1]);
+    const min = Number(m[2]);
+    return h < 24 && min < 60 ? h * 60 + min : null;
+}
+/** True when the recipient's local time is inside [from, to). Crosses midnight when from > to; from == to is "never". */
+export function inQuietHours(now, tz, q) {
+    if (!q)
+        return false;
+    const from = parseHHMM(q.from);
+    const to = parseHHMM(q.to);
+    if (from === null || to === null || from === to)
+        return false;
+    const t = localMinutes(now, tz);
+    return from < to ? t >= from && t < to : t >= from || t < to;
+}