@cosmicdrift/kumiko-bundled-features 0.342.0 → 0.343.0

package/dist/delivery/constants.js

@@ -3,7 +3,7 @@ import { DELIVERY_FEATURE, DeliveryJobNames } from "./public-names.js";
 // Extension-point name for delivery-channel plugins (channel-email,
 // channel-in-app, channel-push, ...).
 export const DELIVERY_CHANNEL_EXTENSION = "deliveryChannel";
-export { DELIVERY_ATTEMPT_EVENT, DELIVERY_FEATURE, DELIVERY_LOG_SCREEN_ID, DELIVERY_RESUBSCRIBE_PATH, DELIVERY_STATUS_CELL_COMPONENT, DELIVERY_UNSUBSCRIBE_PATH, DeliveryErrors, DeliveryHandlers, DeliveryJobNames, DeliveryQueries, DeliveryStatus, } from "./public-names.js";
+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, DeliveryJobNames, DeliveryQueries, DeliveryStatus, } from "./public-names.js";
 // notify() priority → BullMQ job priority. Lower number = processed first; all
 // > 0 so prioritised delivery jobs never mix with BullMQ's "0 = unprioritised
 // FIFO" bucket. critical jobs jump ahead of normal/low in the worker queue.

package/dist/delivery/delivery-service.d.ts

@@ -1,10 +1,11 @@
 import type { SseBroker } from "@cosmicdrift/kumiko-framework/api";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import type { EscapeHatchAuditSink, NotifyJobDispatcher, Registry, TenantId } from "@cosmicdrift/kumiko-framework/engine";
-import type { Logger } from "@cosmicdrift/kumiko-framework/logging";
+import { type Logger } from "@cosmicdrift/kumiko-framework/logging";
 import type { SecretsContext } from "@cosmicdrift/kumiko-framework/secrets";
 import type { Redis } from "ioredis";
 import { type DeliveryChannel, type DeliveryService } from "./types.js";
+export declare function redactedMessageOf(err: unknown): string;
 export type RateLimitConfig = {
     readonly redis: Redis;
     readonly maxPerHour: number;

package/dist/delivery/delivery-service.js

@@ -1,8 +1,10 @@
 import { createSystemDbView, createTenantDb } from "@cosmicdrift/kumiko-framework/db";
 import { createSystemUser } from "@cosmicdrift/kumiko-framework/engine";
+import { createFallbackLogger } from "@cosmicdrift/kumiko-framework/logging";
 import { createEscapeHatchReporter } from "@cosmicdrift/kumiko-framework/pipeline";
 import { bridgeStub } from "@cosmicdrift/kumiko-framework/testing/handler-context";
 import { generateId } from "@cosmicdrift/kumiko-framework/utils";
+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";
@@ -10,6 +12,9 @@ import { DELIVERY_CHANNEL_EXTENSION, DeliveryJobs, deliveryPriorityRank } from "
 import { isAddressOptedOut } from "./db/queries/address-opt-outs.js";
 import { selectNotificationPreferences } from "./db/queries/preferences.js";
 import { isDeliveryChannelPlugin, } from "./types.js";
+export function redactedMessageOf(err) {
+    return redactErrorText(err instanceof Error ? err.message : String(err));
+}
 // Build channel list from registry extension usages
 export function collectChannels(registry) {
     const usages = registry.getExtensionUsages(DELIVERY_CHANNEL_EXTENSION);
@@ -27,6 +32,7 @@ export function collectChannels(registry) {
 export function createDeliveryService(options) {
     const { db, registry, sseBroker, channels, tenantUserIdsQuery, rateLimit, isChannelKilled, idempotencyRedis, jobRunner, secrets, escapeHatchAuditSink, 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
     // observe `count <= max` and slip past. The prior non-atomic JS version
@@ -125,6 +131,7 @@ export function createDeliveryService(options) {
             recipientId: entry.recipientId,
             status: entry.status,
             error: entry.error,
+            ...(entry.confirmed === false && { confirmed: entry.confirmed }),
             deliveryAttemptId,
         });
     }
@@ -135,6 +142,23 @@ export function createDeliveryService(options) {
         const attemptId = await logAttempt(db, registry, entry);
         recordDelivery(run, entry, attemptId);
     }
+    // The stored/returned error is only the code; the redacted message goes to the log.
+    async function logInlineFailure(run, args, code, err) {
+        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
@@ -172,8 +196,26 @@ export function createDeliveryService(options) {
         }
         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;
+            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;
+            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,
@@ -183,6 +225,7 @@ export function createDeliveryService(options) {
                 status: result.status,
                 error: result.error ?? null,
                 priority,
+                ...(result.confirmed === false && { confirmed: result.confirmed }),
             });
         }
     }
@@ -340,6 +383,10 @@ export function createDeliveryService(options) {
                 });
             }
             catch (err) {
+                logError.error(`${channel.name} channel_error: ${redactedMessageOf(err)}`, {
+                    notificationType,
+                    channel: channel.name,
+                });
                 await logDelivery(run, {
                     tenantId,
                     notificationType,
@@ -347,7 +394,7 @@ export function createDeliveryService(options) {
                     recipientId: userId,
                     recipientAddress: null,
                     status: "failed",
-                    error: err instanceof Error ? err.message : String(err),
+                    error: "channel_error",
                     priority,
                 });
             }
@@ -409,6 +456,10 @@ export function createDeliveryService(options) {
                 });
             }
             catch (err) {
+                logError.error(`${channel.name} channel_error: ${redactedMessageOf(err)}`, {
+                    notificationType,
+                    channel: channel.name,
+                });
                 await logDelivery(run, {
                     tenantId,
                     notificationType,
@@ -416,7 +467,7 @@ export function createDeliveryService(options) {
                     recipientId,
                     recipientAddress: address,
                     status: "failed",
-                    error: err instanceof Error ? err.message : String(err),
+                    error: "channel_error",
                     priority,
                 });
             }

package/dist/delivery/events.d.ts

@@ -10,11 +10,29 @@ export declare const deliveryAttemptSchema: z.ZodObject<{
         sent: "sent";
         skipped: "skipped";
     }>;
-    error: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+        channel_disabled: "channel_disabled";
+        channel_error: "channel_error";
+        duplicate_idempotency_key: "duplicate_idempotency_key";
+        host_not_allowed: "host_not_allowed";
+        invalid_address: "invalid_address";
+        missing_credentials: "missing_credentials";
+        network_error: "network_error";
+        no_address: "no_address";
+        preference_disabled: "preference_disabled";
+        rate_limited: "rate_limited";
+        redirect_blocked: "redirect_blocked";
+        render_failed: "render_failed";
+        send_failed: "send_failed";
+        timeout: "timeout";
+        unexpected_response: "unexpected_response";
+        unsubscribed: "unsubscribed";
+    }>, z.ZodString]>>;
     priority: z.ZodEnum<{
         critical: "critical";
         low: "low";
         normal: "normal";
     }>;
+    confirmed: z.ZodOptional<z.ZodLiteral<false>>;
 }, z.core.$strip>;
 export type DeliveryAttemptPayload = z.infer<typeof deliveryAttemptSchema>;

package/dist/delivery/events.js

@@ -2,6 +2,7 @@
 // delivery-feature.ts (registers it via r.defineEvent) and
 // 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";
 export const deliveryAttemptSchema = z.object({
@@ -15,6 +16,15 @@ 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(),
 });

package/dist/delivery/feature.js

@@ -1,6 +1,6 @@
 import { upsertByPk } from "@cosmicdrift/kumiko-framework/bun-db";
 import { access, defineFeature, i18nKey, } from "@cosmicdrift/kumiko-framework/engine";
-import { DELIVERY_ATTEMPT_EVENT, DELIVERY_CHANNEL_EXTENSION, DELIVERY_LOG_SCREEN_ID, DELIVERY_STATUS_CELL_COMPONENT, DeliveryJobNames, DeliveryQueries, } from "./constants.js";
+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";
 import { deliveryAttemptSchema } from "./events.js";
 import { logQuery } from "./handlers/log.query.js";
 import { preferencesQuery } from "./handlers/preferences.query.js";
@@ -81,7 +81,13 @@ export function createDeliveryFeature(options) {
                         status: p.status,
                         error: p.error,
                         priority: p.priority,
-                    }, { status: p.status, error: p.error, recipientAddress: p.recipientAddress });
+                        confirmed: p.confirmed ?? null,
+                    }, {
+                        status: p.status,
+                        error: p.error,
+                        recipientAddress: p.recipientAddress,
+                        confirmed: p.confirmed ?? null,
+                    });
                 },
             },
         });
@@ -116,20 +122,38 @@ export function createDeliveryFeature(options) {
             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/dist/delivery/handlers/log.query.d.ts

@@ -1,4 +1,4 @@
-import { type NotifyPriority } from "@cosmicdrift/kumiko-framework/engine";
+import { type DeliveryErrorCode, type NotifyPriority } from "@cosmicdrift/kumiko-framework/engine";
 import { Temporal } from "temporal-polyfill";
 import * as z from "zod";
 import type { DeliveryStatusValue } from "../constants.js";
@@ -17,8 +17,10 @@ export declare const logQuery: import("@cosmicdrift/kumiko-framework/engine").Pa
     type: string;
     channel: string;
     recipient: string | null;
+    recipientLabel: string | null;
     status: DeliveryStatusValue;
-    error: string | null;
+    error: DeliveryErrorCode | null;
     priority: NotifyPriority;
+    confirmed: boolean | null;
     createdAt: Temporal.Instant;
 }, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/delivery/handlers/log.query.js

@@ -1,17 +1,24 @@
 import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
-import { decodeKeysetCursor, encodeKeysetCursor } from "@cosmicdrift/kumiko-framework/db";
-import { access, definePagedQueryHandler, MAX_LIST_LIMIT, } from "@cosmicdrift/kumiko-framework/engine";
+import { decodeKeysetCursor, encodeKeysetCursor, } from "@cosmicdrift/kumiko-framework/db";
+import { access, definePagedQueryHandler, isDeliveryErrorCode, isUuid, MAX_LIST_LIMIT, 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 { deliveryAttemptsTable } from "../tables.js";
+function toClientError(stored) {
+    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",
@@ -38,6 +45,39 @@ function decodeSortCursor(column, cursor) {
     const sortValue = column === "createdAt" ? Temporal.Instant.from(raw) : raw;
     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, registry, rows) {
+    const recipientIds = [
+        ...new Set(rows
+            .map((row) => row.recipientId)
+            .filter((id) => 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, displayNames) {
+    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({
@@ -102,21 +142,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/dist/delivery/i18n.js

@@ -1,9 +1,45 @@
+import { DELIVERY_FAILURE_CODES, DELIVERY_SKIP_REASONS, } from "@cosmicdrift/kumiko-framework/engine";
+import { DeliveryStatus } from "./public-names.js";
+// 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",
+};
+const STATUS_LABELS = {
+    queued: "Queued",
+    sent: "Sent",
+    failed: "Failed",
+    skipped: "Skipped",
+};
+function labelKeys(prefix, codes, labels) {
+    return Object.fromEntries(codes.map((code) => [`${prefix}.${code}`, { en: labels[code] ?? code }]));
+}
 export const DELIVERY_I18N = {
     "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/dist/delivery/index.d.ts

@@ -1,10 +1,11 @@
 export { hashUnsubscribeAddress } from "./address-opt-out.js";
 export { type ChatWebhookChannelOptions, chatMessageText, createChatWebhookChannel, resolveChatWebhookTarget, toChannelResult, } from "./chat-webhook-channel.js";
-export { type ChatSendFailureCode, type ChatSendResult, type ChatWebhookRequest, type ChatWebhookTarget, chatConnectionNameSchema, chatWebhookUrlSchema, checkChatWebhookTarget, DEFAULT_CHAT_TIMEOUT_MS, postChatWebhook, truncateChars, } from "./chat-webhook-sender.js";
+export { type ChatSendFailureCode, type ChatSendResult, type ChatWebhookRequest, type ChatWebhookResponse, type ChatWebhookTarget, chatConnectionNameSchema, chatWebhookUrlSchema, checkChatWebhookTarget, DEFAULT_CHAT_TIMEOUT_MS, postChatWebhook, truncateChars, } from "./chat-webhook-sender.js";
 export type { DeliveryStatusValue } from "./constants.js";
 export { DELIVERY_CHANNEL_EXTENSION, DELIVERY_FEATURE, DELIVERY_LOG_SCREEN_ID, DELIVERY_UNSUBSCRIBE_PATH, DeliveryErrors, DeliveryHandlers, DeliveryJobs, DeliveryQueries, DeliveryStatus, } from "./constants.js";
 export { collectChannels, createDeliveryService, type DeliveryServiceOptions, type KillSwitchResolver, type RateLimitConfig, } from "./delivery-service.js";
 export { createDeliveryFeature, type DeliveryFeatureOptions } from "./feature.js";
+export { createDeliveryNotifyFactory } from "./notify-factory.js";
 export { deliveryAttemptsTable, notificationAddressOptOutEntity, notificationAddressOptOutsTable, notificationPreferenceEntity, notificationPreferencesTable, } from "./tables.js";
 export { type CreateDeliveryTestContextOptions, createDeliveryTestContext } from "./testing.js";
 export { type ChannelContext, type ChannelMessage, type ChannelResult, type DeliveryChannel, type DeliveryChannelMode, type DeliveryChannelPlugin, type DeliveryLogEntry, type DeliveryService, isDeliveryChannelPlugin, type NotificationRenderer, type RenderedMessage, type RendererInput, } from "./types.js";

package/dist/delivery/index.js

@@ -4,6 +4,7 @@ export { chatConnectionNameSchema, chatWebhookUrlSchema, checkChatWebhookTarget,
 export { DELIVERY_CHANNEL_EXTENSION, DELIVERY_FEATURE, DELIVERY_LOG_SCREEN_ID, DELIVERY_UNSUBSCRIBE_PATH, DeliveryErrors, DeliveryHandlers, DeliveryJobs, DeliveryQueries, DeliveryStatus, } from "./constants.js";
 export { collectChannels, createDeliveryService, } from "./delivery-service.js";
 export { createDeliveryFeature } from "./feature.js";
+export { createDeliveryNotifyFactory } from "./notify-factory.js";
 export { deliveryAttemptsTable, notificationAddressOptOutEntity, notificationAddressOptOutsTable, notificationPreferenceEntity, notificationPreferencesTable, } from "./tables.js";
 export { createDeliveryTestContext } from "./testing.js";
 export { isDeliveryChannelPlugin, } from "./types.js";

package/dist/delivery/jobs.js

@@ -9,7 +9,7 @@ import * as z from "zod";
 import { appendAttemptEvent } from "./attempt-log.js";
 import { buildChannelContext } from "./channel-context.js";
 import { DeliveryJobs, deliveryPriorityRank } from "./constants.js";
-import { collectChannels } from "./delivery-service.js";
+import { collectChannels, redactedMessageOf } from "./delivery-service.js";
 const channelMessageSchema = z.object({
     notificationType: z.string(),
     title: z.string(),
@@ -60,7 +60,7 @@ function toMessage(p) {
         locale: p.message.locale,
     };
 }
-function entryFor(p, status, error, address) {
+function entryFor(p, status, error, address, confirmed) {
     return {
         tenantId: p.tenantId, // @cast-boundary engine-payload — job payload string is the stream tenant
         notificationType: p.notificationType,
@@ -70,10 +70,20 @@ function entryFor(p, status, error, address) {
         status,
         error,
         priority: p.priority,
+        ...(confirmed === false && { confirmed }),
     };
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
+// The job runner stores err.message in the run row, and BullMQ keeps failedReason and
+// the stack trace in Redis in plain text, so the rethrown error carries only the code.
+// The redacted message goes to the log.
+async function failAttempt(ctx, db, registry, p, code, err) {
+    const message = redactedMessageOf(err);
+    ctx.log.error(`delivery.${p.channelName} ${code}: ${message}`, {
+        notificationType: p.notificationType,
+        channel: p.channelName,
+    });
+    await appendAttemptEvent(db, registry, p.deliveryAttemptId, entryFor(p, "failed", code, p.address));
+    throw new Error(code);
 }
 // Render the message and hand off to delivery.send. On failure: record the
 // terminal failed event and rethrow so BullMQ retries this step (re-render);
@@ -84,17 +94,22 @@ export const deliveryRenderJob = async (payload, ctx) => {
     const { db, registry } = requireTenantScopedDeps(ctx, tenantId);
     const channel = resolveChannel(registry, p.channelName);
     const channelCtx = buildChannelContext(db, registry, undefined, tenantId, ctx.secrets);
+    let rendered;
     try {
         if (!channel.render) {
             throw new Error(`delivery.render: channel "${p.channelName}" has no render step`);
         }
-        const rendered = await channel.render(toMessage(p), channelCtx);
+        rendered = await channel.render(toMessage(p), channelCtx);
+    }
+    catch (err) {
+        return failAttempt(ctx, db, registry, p, "render_failed", err);
+    }
+    try {
         const jobRunner = ctx["jobRunner"]; // @cast-boundary dynamic-key — dispatch lives on the concrete runner
         await jobRunner.dispatch(DeliveryJobs.send, { ...p, rendered }, { priority: deliveryPriorityRank[p.priority] });
     }
     catch (err) {
-        await appendAttemptEvent(db, registry, p.deliveryAttemptId, entryFor(p, "failed", `render: ${messageOf(err)}`, p.address));
-        throw err;
+        return failAttempt(ctx, db, registry, p, "channel_error", err);
     }
 };
 // Deliver via the channel using the rendered payload (if any). On failure:
@@ -108,10 +123,9 @@ export const deliverySendJob = async (payload, ctx) => {
     const channelCtx = buildChannelContext(db, registry, undefined, tenantId, ctx.secrets);
     try {
         const result = await channel.send(p.address, toMessage(p), channelCtx, p.rendered);
-        await appendAttemptEvent(db, registry, p.deliveryAttemptId, entryFor(p, result.status, result.error ?? null, result.address ?? p.address));
+        await appendAttemptEvent(db, registry, p.deliveryAttemptId, entryFor(p, result.status, result.error ?? null, result.address ?? p.address, result.confirmed));
     }
     catch (err) {
-        await appendAttemptEvent(db, registry, p.deliveryAttemptId, entryFor(p, "failed", `send: ${messageOf(err)}`, p.address));
-        throw err;
+        return failAttempt(ctx, db, registry, p, "send_failed", err);
     }
 };

package/dist/delivery/notify-factory.d.ts

@@ -0,0 +1,5 @@
+import type { NotifyFactory } from "@cosmicdrift/kumiko-framework/engine";
+import type { DeliveryService } from "./types.js";
+export declare function createDeliveryNotifyFactory(deliveryService: Pick<DeliveryService, "notify">, options?: {
+    readonly deliverQueuedInline?: boolean;
+}): NotifyFactory;

package/dist/delivery/notify-factory.js

@@ -0,0 +1,6 @@
+// The same binding runProdApp wires into the app context: the calling context's
+// job dispatcher is handed to notify() per call, so queued channels go through
+// the delivery jobs. deliverQueuedInline drops the dispatcher and sends inline.
+export function createDeliveryNotifyFactory(deliveryService, options = {}) {
+    return (user, tenantId, jobDispatcher) => (notificationType, notifyOptions) => deliveryService.notify(notificationType, notifyOptions, user, tenantId, options.deliverQueuedInline === true ? undefined : jobDispatcher);
+}

package/dist/delivery/public-names.d.ts

@@ -14,6 +14,10 @@ export declare const DeliveryQueries: {
 };
 export declare const DELIVERY_LOG_SCREEN_ID: "delivery-log";
 export declare const DELIVERY_STATUS_CELL_COMPONENT: "DeliveryStatusCell";
+export declare const DELIVERY_TYPE_CELL_COMPONENT: "DeliveryTypeCell";
+export declare const DELIVERY_CHANNEL_CELL_COMPONENT: "DeliveryChannelCell";
+export declare const DELIVERY_TIME_CELL_COMPONENT: "DeliveryTimeCell";
+export declare const DELIVERY_ERROR_CELL_COMPONENT: "DeliveryErrorCell";
 export declare const DeliveryErrors: {
     readonly noRecipient: "delivery_no_recipient";
     readonly channelFailed: "delivery_channel_failed";

package/dist/delivery/public-names.js

@@ -26,6 +26,10 @@ export const DELIVERY_LOG_SCREEN_ID = "delivery-log";
 // column — see `screen.columns[].renderer.react.__component` in feature.ts
 // and `deliveryClient()`'s `columnRenderers` map.
 export const DELIVERY_STATUS_CELL_COMPONENT = "DeliveryStatusCell";
+export const DELIVERY_TYPE_CELL_COMPONENT = "DeliveryTypeCell";
+export const DELIVERY_CHANNEL_CELL_COMPONENT = "DeliveryChannelCell";
+export const DELIVERY_TIME_CELL_COMPONENT = "DeliveryTimeCell";
+export const DELIVERY_ERROR_CELL_COMPONENT = "DeliveryErrorCell";
 export const DeliveryErrors = {
     noRecipient: "delivery_no_recipient",
     channelFailed: "delivery_channel_failed",

package/dist/delivery/tables.js

@@ -23,6 +23,8 @@ export const deliveryAttemptsTable = pgTable("store_delivery_attempts", {
     recipientAddress: text("recipient_address"),
     status: text("status").notNull().$type(),
     error: text("error"),
+    // false = provider accepted but did not confirm; null = confirmed or not applicable.
+    confirmed: boolean("confirmed"),
     // Default covers rows that predate the column; new rows always carry the
     // notify() priority from the event payload.
     priority: text("priority").notNull().default("normal").$type(),
@@ -48,6 +50,7 @@ export const deliveryAttemptsTableMeta = defineUnmanagedTable({
         { name: "recipient_address", pgType: "text", notNull: false },
         { name: "status", pgType: "text", notNull: true },
         { name: "error", pgType: "text", notNull: false },
+        { name: "confirmed", pgType: "boolean", notNull: false },
         { name: "priority", pgType: "text", notNull: true, defaultSql: "'normal'" },
         { name: "created_at", pgType: "timestamptz", notNull: true, defaultSql: "now()" },
     ],

package/dist/delivery/testing.d.ts

@@ -3,6 +3,7 @@ import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import type { EscapeHatchAuditSink, Registry } from "@cosmicdrift/kumiko-framework/engine";
 import type { JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
 import type { Logger } from "@cosmicdrift/kumiko-framework/logging";
+import type { SecretsContext } from "@cosmicdrift/kumiko-framework/secrets";
 import type { Redis } from "ioredis";
 import type { KillSwitchResolver, RateLimitConfig } from "./delivery-service.js";
 import type { DeliveryService } from "./types.js";
@@ -13,6 +14,7 @@ export type CreateDeliveryTestContextOptions = {
     readonly escapeHatchAuditSink?: EscapeHatchAuditSink;
     readonly log?: Logger;
     readonly jobRunner?: JobRunner;
+    readonly secrets?: SecretsContext;
 };
 /**
  * Helper for setupTestStack: creates a DeliveryService + _notifyFactory for the test context.

package/dist/delivery/testing.js

@@ -1,4 +1,5 @@
 import { collectChannels, createDeliveryService } from "./delivery-service.js";
+import { createDeliveryNotifyFactory } from "./notify-factory.js";
 /**
  * Helper for setupTestStack: creates a DeliveryService + _notifyFactory for the test context.
  * Abstracts the boilerplate that every Delivery-using test needs.
@@ -21,6 +22,6 @@ export function createDeliveryTestContext(deps, options = {}) {
     });
     return {
         deliveryService, // exposed so tests can inspect/call directly if needed
-        _notifyFactory: (user, tenantId) => (notificationType, notifyOptions) => deliveryService.notify(notificationType, notifyOptions, user, tenantId), // @cast-boundary engine-bridge
+        _notifyFactory: createDeliveryNotifyFactory(deliveryService),
     };
 }