@k2b/cloud 0.27.0 → 0.29.0

package/src/services/notifications/email-frame.fixture.html

@@ -0,0 +1,51 @@
+
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body style="margin:0;padding:0;background:#f4f4f5;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;">
+  <table width="100%" cellpadding="0" cellspacing="0" style="padding:32px 16px;">
+    <tr><td align="center">
+      <table width="100%" style="max-width:520px;" cellpadding="0" cellspacing="0">
+
+        <!-- Header -->
+        <tr><td style="background:#ffffff;padding:20px 24px;border-radius:12px 12px 0 0;border:1px solid #e4e4e7;border-bottom:none;">
+          <table cellpadding="0" cellspacing="0"><tr>
+          <td style="padding-right:12px;vertical-align:middle;">
+              <img src="https://example.test/logo.svg" alt="Logo" width="28" height="28" style="display:block;">
+            </td>
+            <td style="vertical-align:middle;">
+              <span style="font-size:16px;font-weight:600;color:#18181b;">Test Cloud</span>
+            </td>
+          </tr></table>
+        </td></tr>
+
+        <!-- Content -->
+        <tr><td style="background:#ffffff;padding:28px 24px;border-left:1px solid #e4e4e7;border-right:1px solid #e4e4e7;">
+          <div style="font-size:14px;line-height:1.6;color:#27272a;">
+            {{body}}
+          </div>
+        </td></tr>
+
+        <!-- Footer -->
+        <tr><td style="background:#fafafa;padding:16px 24px;border-radius:0 0 12px 12px;border:1px solid #e4e4e7;border-top:none;">
+          <p style="margin:0 0 8px;font-size:11px;color:#71717a;text-align:center;">
+            <a href="https://example.test/impressum" style="color:#71717a;text-decoration:underline;">Imprint</a>
+            &nbsp;&middot;&nbsp;
+            <a href="https://example.test/legal/terms" style="color:#71717a;text-decoration:underline;">Terms</a>
+            &nbsp;&middot;&nbsp;
+            <a href="https://example.test/legal/privacy" style="color:#71717a;text-decoration:underline;">Privacy</a>
+          </p>
+          <p style="margin:0;font-size:11px;color:#a1a1aa;text-align:center;">
+            This message was sent automatically. Please do not reply to this email.
+          </p>
+        </td></tr>
+
+      </table>
+    </td></tr>
+  </table>
+</body>
+<!-- the answer is 42 ;D -->
+</html>

package/src/services/notifications/{email.ts → email-frame.ts}

@@ -1,47 +1,24 @@
 import sanitizeHtml from "sanitize-html";
-import { sanitizeEmailHtml } from "../../shared";
-import { resolveMailCredentials } from "../outgoing-mail/store";
-import { buildMailTransport } from "../outgoing-mail/transport";
+import { sanitizeEmailHtml } from "../../shared/email-html";
 import * as settings from "../settings";
 import { coreSettings } from "../settings/api";
 
-/** Sanitize plain text content (no HTML allowed). */
 const sanitizeContent = (content: string): string => sanitizeHtml(content, { allowedTags: [], allowedAttributes: {} });
 
-/** Send an email with the standard HTML template. */
-export const sendEmail = async (
-  to: string,
-  subject: string,
-  opts: { content?: string; rawHtml?: string; messageId?: string },
-): Promise<void> => {
+// sanitize-html decodes entities before escaping &, < and > again. Decode only
+// those escapes once, so literal entity text is not recursively interpreted.
+const htmlText = (html: string): string =>
+  sanitizeContent(html.replace(/<br\b[^>]*>|<\/(?:p|div|h[1-6]|li|tr|td|th|ul|ol|table)>/gi, " "))
+    .replace(/&(amp|lt|gt);/g, (entity) => (entity === "&amp;" ? "&" : entity === "&lt;" ? "<" : ">"))
+    .replace(/\s+/g, " ")
+    .trim();
+
+export const prepareNotificationEmail = async (opts: { content?: string; rawHtml?: string }): Promise<{ html: string; text: string }> => {
   const rawAppUrl = await settings.get<string>("app.url");
   const appUrl = rawAppUrl.startsWith("http") ? rawAppUrl : `https://${rawAppUrl}`;
   const appName = await settings.get<string>("app.name");
-  const profile = await resolveMailCredentials();
-
-  let body = "";
-  if (opts.rawHtml) {
-    body = sanitizeEmailHtml(opts.rawHtml);
-  } else if (opts.content) {
-    body = `<p>${sanitizeContent(opts.content)}</p>`;
-  }
-  const text = opts.content ? sanitizeContent(opts.content) : undefined;
-
-  const html = await buildHtml(appUrl, appName, body);
-  const transporter = buildMailTransport(profile);
-
-  try {
-    await transporter.sendMail({
-      from: { address: profile.fromAddress, name: profile.fromName ?? appName },
-      to,
-      subject,
-      ...(opts.messageId ? { messageId: opts.messageId } : {}),
-      html,
-      ...(text ? { text } : {}),
-    });
-  } finally {
-    transporter.close();
-  }
+  const body = opts.rawHtml ? sanitizeEmailHtml(opts.rawHtml) : opts.content ? `<p>${sanitizeContent(opts.content)}</p>` : "";
+  return { html: await buildHtml(appUrl, appName, body), text: opts.content ? sanitizeContent(opts.content) : htmlText(body) };
 };
 
 /**

package/src/services/notifications/email-mail.ts

@@ -0,0 +1,101 @@
+import { domainToASCII } from "node:url";
+import type { ZodError } from "zod";
+import { type MailMessage, MailMessageSchema, type MailRecord } from "../../contracts/outgoing-mail";
+import { messageRecord, outgoingMailMessages } from "../outgoing-mail/messages";
+import { sendMail } from "../outgoing-mail/send";
+import { OutgoingMailError } from "../outgoing-mail/store";
+import { prepareNotificationEmail } from "./email-frame";
+
+export const notificationMailError = (error: unknown): Error & { code: string; retryable: boolean } => {
+  const code = error instanceof OutgoingMailError ? error.code : "mail_unavailable";
+  return Object.assign(new Error(error instanceof Error ? error.message : "Outgoing mail is unavailable."), {
+    code,
+    retryable: ["mail_unavailable", "backlog_full", "quota_exceeded", "attachment_storage_full"].includes(code),
+  });
+};
+
+export const normalizeNotificationMail = (to: string, subject: string) => {
+  const separator = to.lastIndexOf("@");
+  const domain = separator < 0 ? "" : to.slice(separator + 1);
+  // URL conversion can discard invalid address characters; leave those for validation.
+  const ascii = domain && !/[^\p{L}\p{N}\p{M}.-]/u.test(domain) ? domainToASCII(domain) : "";
+  return {
+    to: [ascii ? `${to.slice(0, separator + 1)}${ascii}` : to],
+    subject: subject
+      .replace(/[\r\n]+/g, " ")
+      .replace(/\0/g, "")
+      .trim()
+      .slice(0, 998),
+  };
+};
+
+export const notificationMailValidationError = (error: ZodError) =>
+  new OutgoingMailError(
+    "bad_input",
+    `Invalid notification email: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
+    400,
+  );
+
+const notificationMailMessage = async (
+  to: string,
+  subject: string,
+  body: { content?: string; rawHtml?: string },
+  key?: string,
+): Promise<MailMessage> => {
+  const parsed = MailMessageSchema.safeParse({
+    ...normalizeNotificationMail(to, subject),
+    ...(await prepareNotificationEmail(body)),
+    ...(key ? { key } : {}),
+  });
+  if (!parsed.success) throw notificationMailValidationError(parsed.error);
+  return parsed.data;
+};
+
+export const sendNotificationMail = async (
+  to: string,
+  subject: string,
+  body: { content?: string; rawHtml?: string },
+  key?: string,
+  signal?: AbortSignal,
+): Promise<MailRecord> => {
+  try {
+    return await sendMail("core", await notificationMailMessage(to, subject, body, key), signal, { trustedHtml: true });
+  } catch (error) {
+    throw notificationMailError(error);
+  }
+};
+
+export const notificationMailOutcome = async (record: MailRecord) => {
+  const row = await outgoingMailMessages.read(record.id, "core").catch(() => undefined);
+  const status = row?.status ?? record.status;
+  const errorCode = row?.error_code ?? (record.error ? "smtp_failed" : null);
+  const errorMessage = row?.error_message ?? row?.smtp_response ?? record.error ?? null;
+  if (status === "sent" || status === "bounced") return { status: "delivered" as const, outgoingMailId: record.id };
+  if (status === "failed" || status === "cancelled") {
+    throw Object.assign(new Error(errorMessage ?? `Outgoing mail ${status}.`), {
+      code: errorCode ?? "smtp_failed",
+      retryable: false,
+      outgoingMailId: record.id,
+    });
+  }
+  const next = row?.next_attempt_at ? new Date(row.next_attempt_at).getTime() - Date.now() : 60_000;
+  // Keep polling within the notification retry interval bounds.
+  const retryAfterMs = Number.isFinite(next) ? Math.min(5 * 60_000, Math.max(2_000, next)) : 60_000;
+  return { status: "pending" as const, outgoingMailId: record.id, retryAfterMs, errorMessage };
+};
+
+export const notificationMailOutcomeById = async (id: string) => {
+  const row = await outgoingMailMessages.read(id, "core").catch((error: unknown) => {
+    throw notificationMailError(error);
+  });
+  if (!row) {
+    // Retention may remove a settled mail before notification recovery. Its
+    // stored identity must never turn that recovery into another SMTP send.
+    throw Object.assign(new Error("Outgoing mail record is no longer available."), {
+      code: "smtp_failed",
+      retryable: false,
+      outgoingMailId: id,
+    });
+  }
+  return notificationMailOutcome(messageRecord(row));
+};

package/src/services/notifications/index.ts

@@ -4,7 +4,7 @@ import type { BoundNotificationDefinition, NotificationRecipientKind, Notificati
 import type { PaginationParams } from "../../contracts/shared";
 import { logger } from "../logging";
 import { escapeLikePattern } from "../postgres";
-import { sendEmail } from "./email";
+import { notificationMailOutcome, sendNotificationMail } from "./email-mail";
 import "./browser";
 import { notificationObservability } from "./observability";
 import { sendTypedNotification, type TypedNotificationSendResult } from "./platform";
@@ -107,6 +107,26 @@ type DbNotificationRow = {
   sent_by_name: string | null;
 };
 
+type LegacyMailRow = { id: string; type: NotificationType; recipient: string; subject: string; content: string; mail_generation: number };
+
+const deliverLegacyMail = async (row: LegacyMailRow, body: { content?: string; rawHtml?: string }) => {
+  const key = `notification-message:${row.id}${row.mail_generation ? `:${row.mail_generation}` : ""}`;
+  try {
+    const record = await sendNotificationMail(row.recipient, row.subject, body, key);
+    await sql`UPDATE notifications.messages SET outgoing_mail_id = ${record.id}::uuid, sent_at = NULL, error = NULL
+      WHERE id = ${row.id}::uuid AND mail_generation = ${row.mail_generation}`;
+    const outcome = await notificationMailOutcome(record);
+    if (outcome.status === "pending") return "pending" as const;
+    await sql`UPDATE notifications.messages SET sent_at = now(), error = NULL
+      WHERE id = ${row.id}::uuid AND mail_generation = ${row.mail_generation}`;
+    return "sent" as const;
+  } catch (error) {
+    await sql`UPDATE notifications.messages SET sent_at = NULL, error = ${error instanceof Error ? error.message : String(error)}
+      WHERE id = ${row.id}::uuid AND mail_generation = ${row.mail_generation}`;
+    throw error;
+  }
+};
+
 /**
  * Send a notification. Persists to DB, attempts delivery (if autoSend=true), updates sent_at/error.
  */
@@ -130,15 +150,11 @@ const sendLegacy = async (params: SendNotificationParams): Promise<SendNotificat
 
   // Attempt delivery
   try {
-    if (type === "email") {
-      await sendEmail(recipient, subject, { content, rawHtml });
-    }
-    await sql`UPDATE notifications.messages SET sent_at = now(), error = NULL WHERE id = ${id}`;
-    return { id, status: "sent" };
+    const status = await deliverLegacyMail({ id, type, recipient, subject, content: dbContent, mail_generation: 0 }, { content, rawHtml });
+    return { id, status };
   } catch (e) {
     const error = e instanceof Error ? e.message : String(e);
     log.error("Failed to send", { type, recipient, error });
-    await sql`UPDATE notifications.messages SET error = ${error} WHERE id = ${id}`;
     return { id, status: "error", error };
   }
 };
@@ -482,23 +498,26 @@ export const getById = async (id: string): Promise<NotificationMessage | null> =
  * Resend a notification (retry delivery).
  */
 export const resend = async (id: string): Promise<{ ok: true } | { ok: false; code: "not_found" | "delivery_failed"; error: string }> => {
-  const notification = await getById(id);
-  if (!notification) {
-    return { ok: false, code: "not_found", error: "Notification not found" };
-  }
-
+  const notification = await sql.begin(async (tx): Promise<(LegacyMailRow & { current_mail_status: string | null }) | undefined> => {
+    const [row] = await tx<(LegacyMailRow & { outgoing_mail_id: string | null; current_mail_status: string | null })[]>`
+      SELECT m.*, mail.status AS current_mail_status FROM notifications.messages m
+      LEFT JOIN outgoing_mail.messages mail ON mail.id = m.outgoing_mail_id
+      WHERE m.id = ${id}::uuid FOR UPDATE OF m
+    `;
+    if (!row || row.current_mail_status === "queued" || row.current_mail_status === "sending" || !row.outgoing_mail_id) return row;
+    const [updated] = await tx<LegacyMailRow[]>`
+      UPDATE notifications.messages SET mail_generation = mail_generation + 1, outgoing_mail_id = NULL, sent_at = NULL, error = NULL
+      WHERE id = ${id}::uuid RETURNING *
+    `;
+    return updated ? { ...updated, current_mail_status: null } : undefined;
+  });
+  if (!notification) return { ok: false, code: "not_found", error: "Notification not found" };
+  if (["queued", "sending"].includes(notification.current_mail_status ?? "")) return { ok: true };
   try {
-    if (notification.type === "email") {
-      await sendEmail(notification.recipient, notification.subject, {
-        rawHtml: notification.content,
-      });
-    }
-    await sql`UPDATE notifications.messages SET sent_at = now(), error = NULL WHERE id = ${id}`;
+    await deliverLegacyMail(notification, { rawHtml: notification.content });
     return { ok: true };
   } catch (e) {
-    const error = e instanceof Error ? e.message : String(e);
-    await sql`UPDATE notifications.messages SET error = ${error} WHERE id = ${id}`;
-    return { ok: false, code: "delivery_failed", error };
+    return { ok: false, code: "delivery_failed", error: e instanceof Error ? e.message : String(e) };
   }
 };
 
@@ -535,7 +554,9 @@ export const update = async (
       subject = COALESCE(${data.subject ?? null}, subject),
       content = COALESCE(${data.content ?? null}, content),
       recipient = COALESCE(${data.recipient ?? null}, recipient),
-      error = CASE WHEN ${clearError} THEN NULL ELSE error END
+      error = CASE WHEN ${clearError} THEN NULL ELSE error END,
+      mail_generation = CASE WHEN ${clearError} THEN mail_generation + 1 ELSE mail_generation END,
+      outgoing_mail_id = CASE WHEN ${clearError} THEN NULL ELSE outgoing_mail_id END
     WHERE id = ${id}
   `;
 
@@ -548,7 +569,7 @@ export const update = async (
 export const getPendingSystemCount = async (): Promise<number> => {
   const rows = await sql`
     SELECT COUNT(*)::int as count FROM notifications.messages
-    WHERE sent_at IS NULL AND error IS NULL AND sent_by IS NULL
+    WHERE sent_at IS NULL AND error IS NULL AND sent_by IS NULL AND outgoing_mail_id IS NULL
   `;
   return rows[0]?.count ?? 0;
 };
@@ -563,10 +584,10 @@ export const sendAllPendingSystem = async (): Promise<{
   errors: { id: string; recipient: string; error: string }[];
 }> => {
   // Get all pending system notifications
-  const rows = await sql`
-    SELECT id, type, recipient, subject, content
+  const rows = await sql<LegacyMailRow[]>`
+    SELECT id, type, recipient, subject, content, mail_generation
     FROM notifications.messages
-    WHERE sent_at IS NULL AND error IS NULL AND sent_by IS NULL
+    WHERE sent_at IS NULL AND error IS NULL AND sent_by IS NULL AND outgoing_mail_id IS NULL
     ORDER BY created_at ASC
   `;
 
@@ -575,21 +596,13 @@ export const sendAllPendingSystem = async (): Promise<{
   const errors: { id: string; recipient: string; error: string }[] = [];
 
   for (const row of rows) {
-    const id = row.id as string;
-    const type = row.type as NotificationType;
-    const recipient = row.recipient as string;
-    const subject = row.subject as string;
-    const content = row.content as string;
+    const { id, recipient, content } = row;
 
     try {
-      if (type === "email") {
-        await sendEmail(recipient, subject, { rawHtml: content });
-      }
-      await sql`UPDATE notifications.messages SET sent_at = now(), error = NULL WHERE id = ${id}`;
+      if ((await deliverLegacyMail(row, { rawHtml: content })) === "pending") continue;
       sent++;
     } catch (e) {
       const error = e instanceof Error ? e.message : String(e);
-      await sql`UPDATE notifications.messages SET error = ${error} WHERE id = ${id}`;
       failed++;
       errors.push({ id, recipient, error });
     }

package/src/services/notifications/observability.ts

@@ -1,4 +1,5 @@
 import { type SQL, sql } from "bun";
+import type { MailStatus } from "../../contracts/outgoing-mail";
 import type { NotificationDeliveryStatus } from "../../contracts/user-notifications";
 import { escapeLikePattern, toPgTextArray } from "../postgres";
 
@@ -20,6 +21,8 @@ export type NotificationDeliveryObservabilityItem = {
   required: boolean;
   routePriority: number | null;
   status: NotificationDeliveryStatus;
+  outgoingMailId: string | null;
+  outgoingMailStatus: MailStatus | null;
   attemptCount: number;
   errorCode: string | null;
   errorMessage: string | null;
@@ -79,6 +82,8 @@ type DeliveryRow = {
   required: boolean;
   route_priority: number | null;
   status: NotificationDeliveryStatus;
+  outgoing_mail_id: string | null;
+  outgoing_mail_status: MailStatus | null;
   attempt_count: number;
   error_code: string | null;
   error_message: string | null;
@@ -168,11 +173,12 @@ const listDeliveries = async (input: {
         COALESCE(NULLIF(u.display_name, ''), NULLIF(u.uid, ''), e.recipient_email, e.recipient_key) AS recipient_label,
         COALESCE(NULLIF(u.mail, ''), NULLIF(u.uid, ''), e.recipient_email, e.recipient_key) AS recipient_reference,
         d.channel, d.destination_label, d.required, d.route_priority, d.status,
-        d.attempt_count, d.error_code, d.error_message, d.created_at, d.updated_at, d.delivered_at
+        d.outgoing_mail_id, mail.status AS outgoing_mail_status, d.attempt_count, d.error_code, d.error_message, d.created_at, d.updated_at, d.delivered_at
       FROM notifications.deliveries d
       JOIN notifications.events e ON e.id = d.event_id
       JOIN notifications.definitions n ON n.id = e.definition_id
       LEFT JOIN auth.users u ON u.id = e.recipient_user_id
+      LEFT JOIN outgoing_mail.messages mail ON mail.id = d.outgoing_mail_id
       WHERE ${where}
       ORDER BY d.created_at DESC, d.id DESC
       LIMIT ${perPage} OFFSET ${offset}
@@ -196,6 +202,8 @@ const listDeliveries = async (input: {
       required: row.required,
       routePriority: row.route_priority,
       status: row.status,
+      outgoingMailId: row.outgoing_mail_id,
+      outgoingMailStatus: row.outgoing_mail_status,
       attemptCount: row.attempt_count,
       errorCode: row.error_code,
       errorMessage: row.error_message,

package/src/services/notifications/platform.ts

@@ -1,5 +1,6 @@
 import { sql } from "bun";
 import type { output, ZodType } from "zod";
+import { isNotificationGroup, notificationGroupTag } from "../../contracts/notification-group";
 import type {
   BoundNotificationDefinition,
   EmailNotificationPresentation,
@@ -15,6 +16,7 @@ import { encryptSecret } from "../secrets";
 import { ensureNotificationDefinition } from "./catalog";
 import { getNotificationChannel, type NotificationDestination, type ResolvedNotificationRecipient } from "./channels";
 import { processNotificationDelivery } from "./dispatcher";
+import { normalizeNotificationPreview } from "./preview";
 import { enqueueNotificationDeliveries, enqueueNotificationDelivery } from "./runtime";
 
 export type TypedNotificationDeliveryStatus = "deferred" | "pending" | "sending" | "delivered" | "suppressed" | "failed";
@@ -69,14 +71,38 @@ const preparationFailure = (input: { channel: string; required: boolean; routePr
   errorMessage: "Notification delivery could not be prepared.",
 });
 
-const validatePresentation = (presentation: NotificationPresentation): NotificationPresentation => {
+const validatePresentation = (presentation: NotificationPresentation, appId: string): NotificationPresentation => {
   const title = presentation.title.trim();
   const body = presentation.body?.trim();
+  if (presentation.preview !== undefined && typeof presentation.preview !== "string") {
+    throw new Error("Notification preview must be a string");
+  }
+  const preview = presentation.preview === undefined ? undefined : normalizeNotificationPreview(presentation.preview);
   if (!title) throw new Error("Notification title is required");
   if (title.length > 200) throw new Error("Notification title must not exceed 200 characters");
   if (body && body.length > 4_000) throw new Error("Notification body must not exceed 4000 characters");
   const targetHref = presentation.targetHref ? validateNotificationTargetHref(presentation.targetHref) : undefined;
-  return { title, ...(body ? { body } : {}), ...(targetHref ? { targetHref } : {}) };
+  if (presentation.group !== undefined && !isNotificationGroup(presentation.group)) {
+    throw new Error(
+      "Notification group must contain 1 to 128 characters using only letters, digits, dots, underscores, colons, or hyphens",
+    );
+  }
+  if (presentation.group !== undefined && notificationGroupTag(appId, presentation.group) === null) {
+    throw new Error(
+      "Notification group requires an app ID that starts with a lowercase letter and contains only lowercase letters, digits, and hyphens",
+    );
+  }
+  if (presentation.badge !== undefined && (!Number.isSafeInteger(presentation.badge) || presentation.badge < 0)) {
+    throw new Error("Notification badge must be a non-negative safe integer");
+  }
+  return {
+    title,
+    ...(body ? { body } : {}),
+    ...(preview ? { preview } : {}),
+    ...(targetHref ? { targetHref } : {}),
+    ...(presentation.group !== undefined ? { group: presentation.group } : {}),
+    ...(presentation.badge !== undefined ? { badge: presentation.badge } : {}),
+  };
 };
 
 const resolveRecipient = async (
@@ -172,6 +198,8 @@ const prepareChannel = async (input: {
 
   try {
     const emailPresentation = input.channel === "email" ? await input.emailPresentation?.() : undefined;
+    const { preview: _preview, ...otherPresentation } = input.presentation;
+    const presentation = input.channel === "browser" ? input.presentation : otherPresentation;
     return await Promise.all(
       destinations.map(async (destination) => ({
         channel: input.channel,
@@ -179,7 +207,7 @@ const prepareChannel = async (input: {
         destinationKey: destination.key,
         destinationLabel: destination.label,
         payloadEncrypted: await encryptSecret(
-          driver.createPayload({ presentation: input.presentation, email: emailPresentation, destination, event: input.event }),
+          driver.createPayload({ presentation, email: emailPresentation, destination, event: input.event }),
         ),
         required: input.required,
         routePriority: input.routePriority,
@@ -241,7 +269,7 @@ export const sendTypedNotification = async <
 
   const data: output<S> = definition.data.parse(input.data);
   const renderContext = { locale: normalizeLocale(input.locale) };
-  const presentation = validatePresentation(await definition.render(data, renderContext));
+  const presentation = validatePresentation(await definition.render(data, renderContext), definition.appId);
   const resolved = await resolveRecipient(input.recipient);
   const candidateEventId = crypto.randomUUID();
   await ensureNotificationDefinition(definition);
@@ -407,7 +435,7 @@ export const sendTypedNotification = async <
   if (persisted.prepared) {
     for (const deliveryId of persisted.requiredIds) {
       const result = await processNotificationDelivery(deliveryId);
-      if (result.status === "retry") await enqueueNotificationDelivery(deliveryId, result.retryAfterMs);
+      if (result.status === "retry" || result.status === "pending") await enqueueNotificationDelivery(deliveryId, result.retryAfterMs);
       if (result.activatedIds?.length) await enqueueNotificationDeliveries(result.activatedIds);
     }
     await enqueueNotificationDeliveries(persisted.pendingIds);

package/src/services/notifications/preview.ts

@@ -0,0 +1,23 @@
+export const NOTIFICATION_PREVIEW_LIMIT = 200;
+const PREVIEW_INPUT_LIMIT = 1_000;
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export const normalizeNotificationPreview = (value: string): string | undefined => {
+  let prefix = value.slice(0, PREVIEW_INPUT_LIMIT);
+  const clipped = value.length > prefix.length;
+  if (clipped) {
+    // A boundary at or before the bound depends on at most one following code point (two UTF-16 units).
+    const last = segmenter.segment(value.slice(0, PREVIEW_INPUT_LIMIT + 2)).containing(PREVIEW_INPUT_LIMIT - 1);
+    if (last && last.index + last.segment.length > PREVIEW_INPUT_LIMIT) prefix = prefix.slice(0, last.index);
+  }
+  const text = prefix.replace(/[\s\p{Cc}]+/gu, " ").trim();
+  if (!text) return undefined;
+  if (!clipped && text.length <= NOTIFICATION_PREVIEW_LIMIT) return text;
+
+  let end = 0;
+  for (const { segment, index } of segmenter.segment(text)) {
+    if (index + segment.length > NOTIFICATION_PREVIEW_LIMIT - 1) break;
+    end = index + segment.length;
+  }
+  return `${text.slice(0, end).trimEnd()}…`;
+};