@cosmicdrift/kumiko-samples 0.342.0 → 0.343.0

package/packages/bundled-features/src/delivery/chat-webhook-sender.ts

@@ -1,22 +1,27 @@
+import type { ChatSendFailureCode } from "@cosmicdrift/kumiko-framework/engine";
 import { BlockedHostError, type EgressPolicy, egress } from "@cosmicdrift/kumiko-framework/http";
 import * as z from "zod";
 
 // Closed vocabulary: these codes (and nothing else) land in delivery_attempts.error.
 // Never err.message and never a provider response body — a fetch error can carry
 // the request URL, and the Telegram URL embeds the bot token.
-export type ChatSendFailureCode =
-  | `http_${number}`
-  | "timeout"
-  | "network_error"
-  | "redirect_blocked"
-  | "host_not_allowed"
-  | "missing_credentials"
-  | "invalid_address";
+export type { ChatSendFailureCode };
 
+// confirmed=false: the provider accepted the request but does not say whether the
+// message arrived (e.g. a 202 from a workflow endpoint).
 export type ChatSendResult =
-  | { readonly ok: true }
+  | { readonly ok: true; readonly confirmed: boolean }
   | { readonly ok: false; readonly code: ChatSendFailureCode };
 
+// What a classifier may look at on a 2xx answer. The body is never stored or logged.
+export type ChatWebhookResponse = {
+  readonly status: number;
+  // At most 64 bytes, UTF-8 decoded.
+  readBodyPrefix(): Promise<string>;
+};
+
+const MAX_BODY_PREFIX_BYTES = 64;
+
 export const DEFAULT_CHAT_TIMEOUT_MS = 10_000;
 
 // Tenant-chosen connection name (the route address for webhook channels). Also
@@ -41,6 +46,8 @@ export type ChatWebhookRequest = ChatWebhookTarget & {
   readonly body: unknown;
   // Test seam; production always uses the policy-bound egress().
   readonly send?: (url: string, init: RequestInit) => Promise<Response>;
+  // Called for 2xx answers only. Default: every 2xx is a confirmed send.
+  readonly classifyResponse?: (response: ChatWebhookResponse) => Promise<ChatSendResult>;
 };
 
 // https targets are provider endpoints on public hosts: egress "external" adds
@@ -129,15 +136,54 @@ export async function postChatWebhook(request: ChatWebhookRequest): Promise<Chat
     return { ok: false, code: classifyFailure(err) };
   }
 
-  // Free the connection; the body is never read or stored.
-  await response.body?.cancel().catch(() => undefined);
-
   const { status } = response;
-  if (status >= 300 && status < 400) return { ok: false, code: "redirect_blocked" };
-  if (status >= 200 && status < 300) return { ok: true };
+  if (status >= 300 && status < 400) {
+    await response.body?.cancel().catch(() => undefined);
+    return { ok: false, code: "redirect_blocked" };
+  }
+  if (status >= 200 && status < 300) return classifySuccess(request, response);
+  await response.body?.cancel().catch(() => undefined);
   return { ok: false, code: `http_${status}` };
 }
 
+// The body is cancelled afterwards in every case, even when the classifier throws,
+// so the connection is freed and a large body is never read to the end.
+async function classifySuccess(
+  request: ChatWebhookRequest,
+  response: Response,
+): Promise<ChatSendResult> {
+  let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+  try {
+    if (!request.classifyResponse) return { ok: true, confirmed: true };
+    return await request.classifyResponse({
+      status: response.status,
+      async readBodyPrefix() {
+        reader ??= response.body?.getReader();
+        if (!reader) return "";
+        const chunks: Uint8Array[] = [];
+        let total = 0;
+        while (total < MAX_BODY_PREFIX_BYTES) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+          total += value.length;
+        }
+        const joined = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+          joined.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return new TextDecoder().decode(joined.subarray(0, MAX_BODY_PREFIX_BYTES));
+      },
+    });
+  } catch (err) {
+    return { ok: false, code: classifyFailure(err) };
+  } finally {
+    await (reader ? reader.cancel() : response.body?.cancel())?.catch(() => undefined);
+  }
+}
+
 export function truncateChars(text: string, maxChars: number): string {
   const chars = Array.from(text);
   return chars.length <= maxChars ? text : chars.slice(0, maxChars).join("");

package/packages/bundled-features/src/delivery/constants.ts

@@ -8,10 +8,14 @@ export const DELIVERY_CHANNEL_EXTENSION = "deliveryChannel" as const;
 
 export {
   DELIVERY_ATTEMPT_EVENT,
+  DELIVERY_CHANNEL_CELL_COMPONENT,
+  DELIVERY_ERROR_CELL_COMPONENT,
   DELIVERY_FEATURE,
   DELIVERY_LOG_SCREEN_ID,
   DELIVERY_RESUBSCRIBE_PATH,
   DELIVERY_STATUS_CELL_COMPONENT,
+  DELIVERY_TIME_CELL_COMPONENT,
+  DELIVERY_TYPE_CELL_COMPONENT,
   DELIVERY_UNSUBSCRIBE_PATH,
   DeliveryErrors,
   DeliveryHandlers,

package/packages/bundled-features/src/delivery/delivery-service.ts

@@ -2,6 +2,7 @@ import type { SseBroker } from "@cosmicdrift/kumiko-framework/api";
 import type { DbConnection, DbRow } from "@cosmicdrift/kumiko-framework/db";
 import { createSystemDbView, createTenantDb } from "@cosmicdrift/kumiko-framework/db";
 import type {
+  DeliveryErrorCode,
   EscapeHatchAuditSink,
   NotifyDelivery,
   NotifyJobDispatcher,
@@ -10,12 +11,13 @@ import type {
   TenantId,
 } from "@cosmicdrift/kumiko-framework/engine";
 import { createSystemUser } from "@cosmicdrift/kumiko-framework/engine";
-import type { Logger } from "@cosmicdrift/kumiko-framework/logging";
+import { createFallbackLogger, type Logger } from "@cosmicdrift/kumiko-framework/logging";
 import { createEscapeHatchReporter } from "@cosmicdrift/kumiko-framework/pipeline";
 import type { SecretsContext } from "@cosmicdrift/kumiko-framework/secrets";
 import { bridgeStub } from "@cosmicdrift/kumiko-framework/testing/handler-context";
 import { generateId } from "@cosmicdrift/kumiko-framework/utils";
 import type { Redis } from "ioredis";
+import { redactErrorText } from "../shared/index.js";
 import { hashUnsubscribeAddress } from "./address-opt-out.js";
 import { appendAttemptEvent, logAttempt } from "./attempt-log.js";
 import { buildChannelContext } from "./channel-context.js";
@@ -25,12 +27,18 @@ import { selectNotificationPreferences } from "./db/queries/preferences.js";
 import {
   type ChannelContext,
   type ChannelMessage,
+  type ChannelResult,
   type DeliveryChannel,
   type DeliveryLogEntry,
   type DeliveryService,
   isDeliveryChannelPlugin,
+  type RenderedMessage,
 } from "./types.js";
 
+export function redactedMessageOf(err: unknown): string {
+  return redactErrorText(err instanceof Error ? err.message : String(err));
+}
+
 export type RateLimitConfig = {
   readonly redis: Redis;
   readonly maxPerHour: number; // per channel per tenant
@@ -99,6 +107,7 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
     log,
   } = options;
   const idemRedis = idempotencyRedis ?? rateLimit?.redis;
+  const logError = createFallbackLogger("delivery", log);
 
   // Rate limit check: atomic INCR + TTL + over-limit rollback via server-side
   // Lua. Runs single-threaded in Redis, so two parallel clients can't both
@@ -232,6 +241,7 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
       recipientId: entry.recipientId,
       status: entry.status,
       error: entry.error,
+      ...(entry.confirmed === false && { confirmed: entry.confirmed }),
       deliveryAttemptId,
     });
   }
@@ -244,6 +254,36 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
     recordDelivery(run, entry, attemptId);
   }
 
+  // The stored/returned error is only the code; the redacted message goes to the log.
+  async function logInlineFailure(
+    run: NotifyRun,
+    args: {
+      readonly channel: DeliveryChannel;
+      readonly address: string;
+      readonly tenantId: TenantId;
+      readonly recipientId: string | null;
+      readonly notificationType: string;
+      readonly priority: NotifyPriority;
+    },
+    code: DeliveryErrorCode,
+    err: unknown,
+  ): Promise<void> {
+    logError.error(`${args.channel.name} ${code}: ${redactedMessageOf(err)}`, {
+      notificationType: args.notificationType,
+      channel: args.channel.name,
+    });
+    await logDelivery(run, {
+      tenantId: args.tenantId,
+      notificationType: args.notificationType,
+      channel: args.channel.name,
+      recipientId: args.recipientId,
+      recipientAddress: args.address,
+      status: "failed",
+      error: code,
+      priority: args.priority,
+    });
+  }
+
   // Deliver one resolved (channel, address) pair. Inline channels (inApp) and
   // the no-job-runner fallback render + send synchronously and log the terminal
   // status. Queued channels (email/push) record a `queued` attempt up front and
@@ -305,8 +345,24 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
       recordDelivery(run, queuedEntry, deliveryAttemptId);
     } else {
       // Inline (inApp) or no-job-runner fallback: render + send synchronously.
-      const rendered = channel.render ? await channel.render(message, channelCtx) : undefined;
-      const result = await channel.send(address, message, channelCtx, rendered);
+      let rendered: RenderedMessage | undefined;
+      if (channel.render) {
+        try {
+          rendered = await channel.render(message, channelCtx);
+        } catch (err) {
+          await logInlineFailure(run, args, "render_failed", err);
+          // skip: logInlineFailure recorded and logged the failure
+          return;
+        }
+      }
+      let result: ChannelResult;
+      try {
+        result = await channel.send(address, message, channelCtx, rendered);
+      } catch (err) {
+        await logInlineFailure(run, args, "send_failed", err);
+        // skip: logInlineFailure recorded and logged the failure
+        return;
+      }
       await logDelivery(run, {
         tenantId,
         notificationType,
@@ -316,6 +372,7 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
         status: result.status,
         error: result.error ?? null,
         priority,
+        ...(result.confirmed === false && { confirmed: result.confirmed }),
       });
     }
   }
@@ -517,6 +574,10 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
           priority,
         });
       } catch (err) {
+        logError.error(`${channel.name} channel_error: ${redactedMessageOf(err)}`, {
+          notificationType,
+          channel: channel.name,
+        });
         await logDelivery(run, {
           tenantId,
           notificationType,
@@ -524,7 +585,7 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
           recipientId: userId,
           recipientAddress: null,
           status: "failed",
-          error: err instanceof Error ? err.message : String(err),
+          error: "channel_error",
           priority,
         });
       }
@@ -599,6 +660,10 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
           priority,
         });
       } catch (err) {
+        logError.error(`${channel.name} channel_error: ${redactedMessageOf(err)}`, {
+          notificationType,
+          channel: channel.name,
+        });
         await logDelivery(run, {
           tenantId,
           notificationType,
@@ -606,7 +671,7 @@ export function createDeliveryService(options: DeliveryServiceOptions): Delivery
           recipientId,
           recipientAddress: address,
           status: "failed",
-          error: err instanceof Error ? err.message : String(err),
+          error: "channel_error",
           priority,
         });
       }

package/packages/bundled-features/src/delivery/events.ts

@@ -3,6 +3,11 @@
 // delivery-service.ts (validates payloads before the low-level append()
 // — out-of-dispatcher writes otherwise skip schema enforcement).
 
+import {
+  DELIVERY_FAILURE_CODES,
+  DELIVERY_SKIP_REASONS,
+  HTTP_ERROR_CODE_PATTERN,
+} from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { DeliveryStatus } from "./constants.js";
 
@@ -17,8 +22,17 @@ export const deliveryAttemptSchema = z.object({
     DeliveryStatus.failed,
     DeliveryStatus.skipped,
   ]),
-  error: z.string().nullable(),
+  // Closed code set; z.custom would not serialize to JSON-Schema. Events written
+  // before the code vocabulary may hold free text, they are not re-validated on replay.
+  error: z
+    .union([
+      z.enum([...DELIVERY_FAILURE_CODES, ...DELIVERY_SKIP_REASONS]),
+      z.string().regex(HTTP_ERROR_CODE_PATTERN),
+    ])
+    .nullable(),
   priority: z.enum(["critical", "normal", "low"]),
+  // Provider accepted the request but does not confirm delivery (e.g. Teams 202).
+  confirmed: z.literal(false).optional(),
 });
 
 export type DeliveryAttemptPayload = z.infer<typeof deliveryAttemptSchema>;

package/packages/bundled-features/src/delivery/feature.ts

@@ -8,9 +8,13 @@ import {
 import type * as z from "zod";
 import {
   DELIVERY_ATTEMPT_EVENT,
+  DELIVERY_CHANNEL_CELL_COMPONENT,
   DELIVERY_CHANNEL_EXTENSION,
+  DELIVERY_ERROR_CELL_COMPONENT,
   DELIVERY_LOG_SCREEN_ID,
   DELIVERY_STATUS_CELL_COMPONENT,
+  DELIVERY_TIME_CELL_COMPONENT,
+  DELIVERY_TYPE_CELL_COMPONENT,
   DeliveryJobNames,
   DeliveryQueries,
 } from "./constants.js";
@@ -118,8 +122,14 @@ export function createDeliveryFeature(options?: DeliveryFeatureOptions): Feature
               status: p.status,
               error: p.error,
               priority: p.priority,
+              confirmed: p.confirmed ?? null,
+            },
+            {
+              status: p.status,
+              error: p.error,
+              recipientAddress: p.recipientAddress,
+              confirmed: p.confirmed ?? null,
             },
-            { status: p.status, error: p.error, recipientAddress: p.recipientAddress },
           );
         },
       },
@@ -168,20 +178,38 @@ export function createDeliveryFeature(options?: DeliveryFeatureOptions): Feature
       type: "projectionList",
       query: DeliveryQueries.log,
       columns: [
+        {
+          field: "createdAt",
+          label: i18nKey("delivery.log.col.createdAt"),
+          renderer: { react: { __component: DELIVERY_TIME_CELL_COMPONENT } },
+        },
         {
           field: "tenantId",
           label: i18nKey("delivery.log.col.tenantId"),
           refEntity: "tenant:tenant",
           refLabelField: "name",
         },
-        { field: "type", label: i18nKey("delivery.log.col.type") },
-        { field: "channel", label: i18nKey("delivery.log.col.channel") },
-        { field: "recipient", label: i18nKey("delivery.log.col.recipient") },
+        {
+          field: "type",
+          label: i18nKey("delivery.log.col.type"),
+          renderer: { react: { __component: DELIVERY_TYPE_CELL_COMPONENT } },
+        },
+        {
+          field: "channel",
+          label: i18nKey("delivery.log.col.channel"),
+          renderer: { react: { __component: DELIVERY_CHANNEL_CELL_COMPONENT } },
+        },
+        { field: "recipientLabel", label: i18nKey("delivery.log.col.recipient") },
         {
           field: "status",
           label: i18nKey("delivery.log.col.status"),
           renderer: { react: { __component: DELIVERY_STATUS_CELL_COMPONENT } },
         },
+        {
+          field: "error",
+          label: i18nKey("delivery.log.col.error"),
+          renderer: { react: { __component: DELIVERY_ERROR_CELL_COMPONENT } },
+        },
       ],
       // Cursor-based paging: deliveryAttemptsTable's id is an event-stream
       // aggregate id (not a sequential PK), so the "pages" default (offset +

package/packages/bundled-features/src/delivery/handlers/log.query.ts

@@ -1,15 +1,25 @@
 import { selectMany, type WhereObject } from "@cosmicdrift/kumiko-framework/bun-db";
-import { decodeKeysetCursor, encodeKeysetCursor } from "@cosmicdrift/kumiko-framework/db";
+import {
+  decodeKeysetCursor,
+  encodeKeysetCursor,
+  type TenantDb,
+} from "@cosmicdrift/kumiko-framework/db";
 import {
   access,
+  type DeliveryErrorCode,
   definePagedQueryHandler,
+  isDeliveryErrorCode,
+  isUuid,
   MAX_LIST_LIMIT,
   type NotifyPriority,
+  type Registry,
+  SYSTEM_USER_ID,
 } from "@cosmicdrift/kumiko-framework/engine";
 import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
 import { Temporal } from "temporal-polyfill";
 import * as z from "zod";
 import { decryptStoredPii } from "../../shared/index.js";
+import { resolveUserDisplayNames, USER_FEATURE } from "../../user/index.js";
 import type { DeliveryStatusValue } from "../constants.js";
 import { deliveryAttemptsTable } from "../tables.js";
 
@@ -21,17 +31,25 @@ type DeliveryLogRow = {
   recipientId: string | null;
   recipientAddress: string | null;
   status: DeliveryStatusValue;
+  // Legacy rows may hold free text; the handler masks those on the way out.
   error: string | null;
   priority: NotifyPriority;
+  confirmed: boolean | null;
   createdAt: Temporal.Instant;
 };
 
+function toClientError(stored: string | null): DeliveryErrorCode | null {
+  if (stored === null) return null;
+  return isDeliveryErrorCode(stored) ? stored : "channel_error";
+}
+
 // Sort whitelist keyed by the DISPLAY field the client actually sends: the
 // declarative projectionList renderer marks every listed column uniformly
 // sortable and a header click sends `sort=<screen.columns[].field>`, not the
 // DB column name (see projection-list-shim.ts synthesizeProjectionEntity).
-// "recipient" is deliberately absent — it's PII decrypted per-row in
-// application code, so there is no column to ORDER BY in SQL for it.
+// "recipient" is deliberately absent — it's PII (name or decrypted address)
+// resolved in application code, so there is no column to ORDER BY in SQL for it.
+// A click on such a header sends an unlisted sort value and falls back to createdAt.
 const DELIVERY_LOG_SORT_COLUMNS = {
   createdAt: "createdAt",
   tenantId: "tenantId",
@@ -67,6 +85,48 @@ function decodeSortCursor(column: DeliveryLogSortColumn, cursor: string): Decode
   return { sortValue, lastId: decoded.sortValue === undefined ? undefined : decoded.id };
 }
 
+// One batched name lookup for the whole page. Only when the user feature is
+// mounted: delivery does not require it, and a direct-address send has no user.
+async function loadDisplayNames(
+  db: TenantDb,
+  registry: Registry,
+  rows: readonly DeliveryLogRow[],
+): Promise<ReadonlyMap<string, string>> {
+  const recipientIds = [
+    ...new Set(
+      rows
+        .map((row) => row.recipientId)
+        .filter((id): id is string => id !== null && id !== SYSTEM_USER_ID && isUuid(id)),
+    ),
+  ];
+  if (recipientIds.length === 0 || registry.getFeature(USER_FEATURE) === undefined)
+    return new Map();
+  return resolveUserDisplayNames(db, recipientIds);
+}
+
+// recipientLabel: display name, else the decrypted address, else the id.
+async function toClientRow(row: DeliveryLogRow, displayNames: ReadonlyMap<string, string>) {
+  const address =
+    row.recipientAddress !== null
+      ? await decryptStoredPii(row.recipientAddress, "recipientAddress", "delivery-log")
+      : null;
+  const name = row.recipientId !== null ? displayNames.get(row.recipientId) : undefined;
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    recipientId: row.recipientId,
+    type: row.notificationType,
+    channel: row.channel,
+    recipient: address,
+    recipientLabel: name ?? address ?? row.recipientId,
+    status: row.status,
+    error: toClientError(row.error),
+    priority: row.priority,
+    confirmed: row.confirmed,
+    createdAt: row.createdAt,
+  };
+}
+
 export const logQuery = definePagedQueryHandler({
   name: "log",
   schema: z.object({
@@ -153,24 +213,9 @@ export const logQuery = definePagedQueryHandler({
     // here, not in the client: a projectionList screen has no entity to
     // derive a field-mapping from, so the row shape the query returns is the
     // shape the declarative columns read directly.
+    const displayNames = await loadDisplayNames(db, ctx.registry, rows);
     return {
-      rows: await Promise.all(
-        rows.map(async (row) => ({
-          id: row.id,
-          tenantId: row.tenantId,
-          recipientId: row.recipientId,
-          type: row.notificationType,
-          channel: row.channel,
-          recipient:
-            row.recipientAddress !== null
-              ? await decryptStoredPii(row.recipientAddress, "recipientAddress", "delivery-log")
-              : row.recipientAddress,
-          status: row.status,
-          error: row.error,
-          priority: row.priority,
-          createdAt: row.createdAt,
-        })),
-      ),
+      rows: await Promise.all(rows.map((row) => toClientRow(row, displayNames))),
       nextCursor,
     };
   },

package/packages/bundled-features/src/delivery/i18n.ts

@@ -1,11 +1,66 @@
+import {
+  DELIVERY_FAILURE_CODES,
+  DELIVERY_SKIP_REASONS,
+  type DeliveryFailureCode,
+  type DeliverySkipReason,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { DeliveryStatus, type DeliveryStatusValue } from "./public-names.js";
+
 type LocalizedString = { readonly en: string };
 
+// Typed over the code vocabularies, so a new code without a label fails to compile.
+const ERROR_LABELS = {
+  timeout: "Timed out",
+  network_error: "Network error",
+  redirect_blocked: "Redirect blocked",
+  host_not_allowed: "Host not allowed",
+  missing_credentials: "Missing credentials",
+  invalid_address: "Invalid address",
+  unexpected_response: "Unexpected provider response",
+  render_failed: "Rendering failed",
+  send_failed: "Sending failed",
+  channel_error: "Channel error",
+  channel_disabled: "Channel disabled",
+  preference_disabled: "Disabled in preferences",
+  rate_limited: "Rate limited",
+  no_address: "No address",
+  unsubscribed: "Unsubscribed",
+  duplicate_idempotency_key: "Duplicate request",
+} as const satisfies Record<DeliveryFailureCode | DeliverySkipReason, string>;
+
+const STATUS_LABELS = {
+  queued: "Queued",
+  sent: "Sent",
+  failed: "Failed",
+  skipped: "Skipped",
+} as const satisfies Record<DeliveryStatusValue, string>;
+
+function labelKeys(
+  prefix: string,
+  codes: readonly string[],
+  labels: Readonly<Record<string, string>>,
+): Record<string, LocalizedString> {
+  return Object.fromEntries(
+    codes.map((code) => [`${prefix}.${code}`, { en: labels[code] ?? code }]),
+  );
+}
+
 export const DELIVERY_I18N: Readonly<Record<string, LocalizedString>> = {
   "screen:delivery-log.title": { en: "Delivery log" },
   "delivery:nav.deliveryLog": { en: "Delivery" },
+  "delivery.log.col.createdAt": { en: "Time" },
   "delivery.log.col.tenantId": { en: "Tenant" },
   "delivery.log.col.type": { en: "Type" },
   "delivery.log.col.channel": { en: "Channel" },
   "delivery.log.col.recipient": { en: "Recipient" },
   "delivery.log.col.status": { en: "Status" },
+  "delivery.log.col.error": { en: "Error" },
+  ...labelKeys("delivery.status", Object.values(DeliveryStatus), STATUS_LABELS),
+  ...labelKeys(
+    "delivery.error",
+    [...DELIVERY_FAILURE_CODES, ...DELIVERY_SKIP_REASONS],
+    ERROR_LABELS,
+  ),
+  "delivery.status.sentUnconfirmed": { en: "Sent (unconfirmed)" },
+  "delivery.error.http": { en: "HTTP {status}" },
 };

package/packages/bundled-features/src/delivery/index.ts

@@ -10,6 +10,7 @@ export {
   type ChatSendFailureCode,
   type ChatSendResult,
   type ChatWebhookRequest,
+  type ChatWebhookResponse,
   type ChatWebhookTarget,
   chatConnectionNameSchema,
   chatWebhookUrlSchema,
@@ -38,6 +39,7 @@ export {
   type RateLimitConfig,
 } from "./delivery-service.js";
 export { createDeliveryFeature, type DeliveryFeatureOptions } from "./feature.js";
+export { createDeliveryNotifyFactory } from "./notify-factory.js";
 export {
   deliveryAttemptsTable,
   notificationAddressOptOutEntity,