@cosmicdrift/kumiko-samples 0.338.0

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

@@ -0,0 +1,52 @@
+export { hashUnsubscribeAddress } from "./address-opt-out.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 {
+  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";
+export {
+  type AddressUnsubscribeTokenPayload,
+  createUnsubscribeRoutes,
+  DELIVERY_UNSUBSCRIBE_ONE_CLICK_HEADER_VALUE,
+  signAddressUnsubscribeToken,
+  signUnsubscribeToken,
+  type UnsubscribeRouteOptions,
+  type UnsubscribeTokenPayload,
+} from "./unsubscribe.js";

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

@@ -0,0 +1,169 @@
+// delivery.render → delivery.send job handlers. Async (queued-mode) channels
+// are delivered here instead of inline in notify(): render runs the expensive
+// template step in its own worker and dispatches send on success, so a render
+// crash never blocks the SMTP send and each step retries independently. The
+// `queued` attempt event is written by the delivery-service at dispatch time;
+// these handlers append the terminal sent/failed event on the same stream.
+
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import type {
+  JobContext,
+  JobHandlerFn,
+  Registry,
+  TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
+import type { JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+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 type {
+  ChannelMessage,
+  DeliveryChannel,
+  DeliveryLogEntry,
+  RenderedMessage,
+} from "./types.js";
+
+const channelMessageSchema = z.object({
+  notificationType: z.string(),
+  title: z.string(),
+  body: z.string().optional(),
+  data: z.record(z.string(), z.unknown()).optional(),
+});
+
+const renderJobPayloadSchema = z.object({
+  channelName: z.string(),
+  address: z.string(),
+  tenantId: z.string(),
+  recipientId: z.string().nullable(),
+  notificationType: z.string(),
+  deliveryAttemptId: z.string(),
+  priority: z.enum(["critical", "normal", "low"]),
+  message: channelMessageSchema,
+});
+
+const sendJobPayloadSchema = renderJobPayloadSchema.extend({
+  rendered: z.object({ html: z.string(), subject: z.string() }).optional(),
+});
+
+type RenderJobPayload = z.infer<typeof renderJobPayloadSchema>;
+
+function requireTenantScopedDeps(
+  ctx: JobContext,
+  tenantId: TenantId,
+): { db: DbConnection; registry: Registry } {
+  const registry = ctx.registry;
+  if (!registry) throw new Error("delivery job: missing registry in job context");
+  // delivery is r.systemScope()'d, so JobContext.systemDb is guaranteed; unsafeRaw
+  // hands the underlying DbConnection to both — safe since they filter by tenantId themselves.
+  if (!ctx.systemDb) {
+    throw new InternalError({
+      message: "delivery job: ctx.systemDb missing on a system-scoped job",
+    });
+  }
+  ctx.systemDb.assertTenantMatch(tenantId);
+  const db = ctx.systemDb.unsafeRaw(
+    "delivery attempt append and channel context filter by this job's tenantId themselves",
+  ) as DbConnection; // @cast-boundary db-operator — DbRunner narrows to DbConnection, jobs never run inside a DbTx
+  return { db, registry };
+}
+
+function resolveChannel(registry: Registry, name: string): DeliveryChannel {
+  const channel = collectChannels(registry).find((c) => c.name === name);
+  if (!channel) throw new Error(`delivery job: unknown channel "${name}"`);
+  return channel;
+}
+
+function toMessage(p: RenderJobPayload): ChannelMessage {
+  return {
+    notificationType: p.message.notificationType,
+    title: p.message.title,
+    body: p.message.body,
+    data: p.message.data,
+  };
+}
+
+function entryFor(
+  p: RenderJobPayload,
+  status: DeliveryLogEntry["status"],
+  error: string | null,
+  address: string | null,
+): DeliveryLogEntry {
+  return {
+    tenantId: p.tenantId as TenantId, // @cast-boundary engine-payload — job payload string is the stream tenant
+    notificationType: p.notificationType,
+    channel: p.channelName,
+    recipientId: p.recipientId,
+    recipientAddress: address,
+    status,
+    error,
+    priority: p.priority,
+  };
+}
+
+function messageOf(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// 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);
+// the send step is never reached, so a stuck render can't half-send.
+export const deliveryRenderJob: JobHandlerFn = async (payload, ctx) => {
+  const p = renderJobPayloadSchema.parse(payload);
+  const tenantId = p.tenantId as TenantId; // @cast-boundary engine-payload — stream tenant
+  const { db, registry } = requireTenantScopedDeps(ctx, tenantId);
+  const channel = resolveChannel(registry, p.channelName);
+  const channelCtx = buildChannelContext(db, registry, undefined, tenantId);
+
+  try {
+    if (!channel.render) {
+      throw new Error(`delivery.render: channel "${p.channelName}" has no render step`);
+    }
+    const rendered: RenderedMessage = await channel.render(toMessage(p), channelCtx);
+    const jobRunner = ctx["jobRunner"] as 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;
+  }
+};
+
+// Deliver via the channel using the rendered payload (if any). On failure:
+// record the terminal failed event and rethrow so BullMQ retries the send with
+// the same already-rendered HTML — no re-render needed.
+export const deliverySendJob: JobHandlerFn = async (payload, ctx) => {
+  const p = sendJobPayloadSchema.parse(payload);
+  const tenantId = p.tenantId as TenantId; // @cast-boundary engine-payload — stream tenant
+  const { db, registry } = requireTenantScopedDeps(ctx, tenantId);
+  const channel = resolveChannel(registry, p.channelName);
+  const channelCtx = buildChannelContext(db, registry, undefined, tenantId);
+
+  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),
+    );
+  } catch (err) {
+    await appendAttemptEvent(
+      db,
+      registry,
+      p.deliveryAttemptId,
+      entryFor(p, "failed", `send: ${messageOf(err)}`, p.address),
+    );
+    throw err;
+  }
+};

package/packages/bundled-features/src/delivery/public-names.ts

@@ -0,0 +1,60 @@
+// @runtime client
+// String-only delivery QNs and screen ids — safe for client bundles.
+
+export const DELIVERY_FEATURE = "delivery" as const;
+
+export const DeliveryHandlers = {
+  setPreference: "delivery:write:set-preference",
+  unsubscribeAddress: "delivery:write:unsubscribe-address",
+  unsubscribeUser: "delivery:write:unsubscribe-user",
+  resubscribeAddress: "delivery:write:resubscribe-address",
+  resubscribeUser: "delivery:write:resubscribe-user",
+} as const;
+
+// Fixed so links mailed out today keep working — the unsubscribe route is
+// mounted at this exact path via `extraRoutes: [...createUnsubscribeRoutes(...)]`.
+export const DELIVERY_UNSUBSCRIBE_PATH = "/api/delivery/unsubscribe" as const;
+
+// Mounted alongside the unsubscribe route by the same
+// `createUnsubscribeRoutes(...)` call — same token, same verify() path, the
+// undo direction. Token is taken from the JSON/form body only, never the
+// query, so a mail-client link prefetcher can't accidentally resubscribe
+// someone.
+export const DELIVERY_RESUBSCRIBE_PATH = "/api/delivery/resubscribe" as const;
+
+export const DeliveryQueries = {
+  log: "delivery:query:log",
+  preferences: "delivery:query:preferences",
+} as const;
+
+export const DELIVERY_LOG_SCREEN_ID = "delivery-log" as const;
+
+// Client column-renderer registered for the delivery-log screen's status
+// column — see `screen.columns[].renderer.react.__component` in feature.ts
+// and `deliveryClient()`'s `columnRenderers` map.
+export const DELIVERY_STATUS_CELL_COMPONENT = "DeliveryStatusCell" as const;
+
+export const DeliveryErrors = {
+  noRecipient: "delivery_no_recipient",
+  channelFailed: "delivery_channel_failed",
+  // removeAddressOptOut refuses to delete the opt-out row at the last
+  // available id generation, so an address can always still unsubscribe
+  // (see MAX_ADDRESS_OPT_OUT_GENERATIONS in address-opt-out.ts).
+  resubscribeLimitReached: "resubscribe_limit_reached",
+} as const;
+
+export const DeliveryStatus = {
+  queued: "queued",
+  sent: "sent",
+  failed: "failed",
+  skipped: "skipped",
+} as const;
+
+export type DeliveryStatusValue = (typeof DeliveryStatus)[keyof typeof DeliveryStatus];
+
+export const DELIVERY_ATTEMPT_EVENT = "delivery:event:attempt" as const;
+
+export const DeliveryJobNames = {
+  render: "render",
+  send: "send",
+} as const;

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

@@ -0,0 +1,155 @@
+import {
+  boolean,
+  buildBaseColumns,
+  defineUnmanagedTable,
+  type EntityTableMeta,
+  index,
+  instant,
+  table as pgTable,
+  sql,
+  text,
+  uniqueIndex,
+  uuid,
+} from "@cosmicdrift/kumiko-framework/db";
+import {
+  createBooleanField,
+  createEntity,
+  createTextField,
+} from "@cosmicdrift/kumiko-framework/engine";
+
+// Delivery-log is an append-only stream of per-attempt records. The stream
+// of truth lives in the events-Tabelle (one aggregate per attempt, event
+// type `delivery:event:attempt`). An INLINE projection materialises each
+// event into a row of deliveryAttemptsTable for the log-query handler —
+// same TX as the event-append, so callers can read their own writes
+// synchronously. No r.entity is registered for `deliveryAttempt`: the
+// boot-validator accepts events-only projection sources as long as every
+// apply-key is a registered domain-event (see registry.ts).
+//
+// PK = event aggregate-id (uuid). Keeps the projection row linked back to
+// its event stream 1:1 — same convention as jobRunsTable + tenantSecretsTable.
+// Event replays stay idempotent (primary-key conflict instead of duplicate rows).
+const DELIVERY_ATTEMPTS_TENANT_CREATED_INDEX = "store_delivery_attempts_tenant_id_created_at_idx";
+
+export const deliveryAttemptsTable = pgTable(
+  "store_delivery_attempts",
+  {
+    id: uuid("id").primaryKey(),
+    tenantId: uuid("tenant_id").notNull(),
+    notificationType: text("notification_type").notNull(),
+    channel: text("channel").notNull(),
+    // User-IDs as UUID-strings post-ES migration.
+    recipientId: text("recipient_id"),
+    recipientAddress: text("recipient_address"),
+    status: text("status").notNull().$type<"queued" | "sent" | "failed" | "skipped">(),
+    error: text("error"),
+    // 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<"critical" | "normal" | "low">(),
+    createdAt: instant("created_at").default(sql`now()`).notNull(),
+  },
+  (t) => [index(DELIVERY_ATTEMPTS_TENANT_CREATED_INDEX).on(t.tenantId, t.createdAt)],
+);
+
+// **Unmanaged table** — bewusst KEIN createEntity. Begründung:
+//   - id kommt aus dem Aggregate-Stream (kein gen_random_uuid()-DEFAULT)
+//   - kein version/inserted_by/modified_by/modified_at — keine in-place-
+//     Edits, keine Audit-Spalten nötig (idempotent-on-replay via PK-Konflikt)
+//   - created_at statt inserted_at — historischer Naming-Drift, kein Bug
+// App trägt Verantwortung für tenant-scoping in Queries + replay-idempotency.
+// pgTable bleibt source-of-truth für Query-API; Phase 4 leitet das pgTable
+// aus dieser Meta ab.
+export const deliveryAttemptsTableMeta: EntityTableMeta = defineUnmanagedTable({
+  tableName: "store_delivery_attempts",
+  indexes: [{ name: DELIVERY_ATTEMPTS_TENANT_CREATED_INDEX, columns: ["tenant_id", "created_at"] }],
+  columns: [
+    { name: "id", pgType: "uuid", notNull: true, primaryKey: true },
+    { name: "tenant_id", pgType: "uuid", notNull: true },
+    { name: "notification_type", pgType: "text", notNull: true },
+    { name: "channel", pgType: "text", notNull: true },
+    { name: "recipient_id", pgType: "text", notNull: false },
+    { name: "recipient_address", pgType: "text", notNull: false },
+    { name: "status", pgType: "text", notNull: true },
+    { name: "error", pgType: "text", notNull: false },
+    { name: "priority", pgType: "text", notNull: true, defaultSql: "'normal'" },
+    { name: "created_at", pgType: "timestamptz", notNull: true, defaultSql: "now()" },
+  ],
+});
+
+// User-scoped opt-in/opt-out for (notificationType, channel) pairs. Post-ES
+// refactor: each row is a notificationPreference aggregate with
+// `.created / .updated / .deleted` lifecycle events written via the
+// event-store executor. The unique index on (tenant, user, type, channel)
+// is the effective natural key; the uuid PK is the aggregate id.
+export const notificationPreferenceEntity = createEntity({
+  table: "read_notification_preferences",
+  fields: {
+    userId: createTextField({ required: true, personal: false, reason: "pseudonymous_fk" }),
+    notificationType: createTextField({
+      required: true,
+      personal: false,
+      reason: "technical_reference",
+    }), // qualified name or "*"
+    channel: createTextField({ required: true, personal: false, reason: "technical_reference" }), // "inApp", "email", "push", or "*"
+    enabled: createBooleanField({ default: true }),
+  },
+});
+
+export const notificationPreferencesTable = pgTable(
+  "read_notification_preferences",
+  {
+    ...buildBaseColumns(false, "uuid"),
+    userId: text("user_id").notNull(),
+    notificationType: text("notification_type").notNull(),
+    channel: text("channel").notNull(),
+    enabled: boolean("enabled").default(true).notNull(),
+  },
+  (table) => [
+    uniqueIndex("read_notification_preferences_unique").on(
+      table.tenantId,
+      table.userId,
+      table.notificationType,
+      table.channel,
+    ),
+  ],
+);
+
+// Opt-out for a recipient ADDRESS that has no user account (direct sends via
+// `ctx.notify(type, { route: { email } })`). addressHash is a keyed HMAC
+// (computeBlindIndex over the normalized address) — the plaintext address
+// never reaches this entity or the token that unsubscribes it.
+// A row's mere existence is the opt-out; there is no `enabled` toggle to flip.
+// Resubscribing (removeAddressOptOut) hard-deletes the row instead — the
+// entity has no softDelete, and a later re-opt-out for the same address
+// picks the next id generation (see addressOptOutAggregateId) since the
+// deleted stream can't be revived.
+export const notificationAddressOptOutEntity = createEntity({
+  table: "read_notification_address_opt_outs",
+  fields: {
+    addressHash: createTextField({ required: true, personal: false, reason: "keyed_hash" }),
+    notificationType: createTextField({
+      required: true,
+      personal: false,
+      reason: "technical_reference",
+    }),
+    channel: createTextField({ required: true, personal: false, reason: "technical_reference" }),
+  },
+});
+
+export const notificationAddressOptOutsTable = pgTable(
+  "read_notification_address_opt_outs",
+  {
+    ...buildBaseColumns(false, "uuid"),
+    addressHash: text("address_hash").notNull(),
+    notificationType: text("notification_type").notNull(),
+    channel: text("channel").notNull(),
+  },
+  (table) => [
+    uniqueIndex("read_notification_address_opt_outs_unique").on(
+      table.tenantId,
+      table.addressHash,
+      table.notificationType,
+      table.channel,
+    ),
+  ],
+);

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

@@ -0,0 +1,53 @@
+import type { SseBroker } from "@cosmicdrift/kumiko-framework/api";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import type {
+  EscapeHatchAuditSink,
+  Registry,
+  TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import type { Logger } from "@cosmicdrift/kumiko-framework/logging";
+import type { Redis } from "ioredis";
+import type { KillSwitchResolver, RateLimitConfig } from "./delivery-service.js";
+import { collectChannels, createDeliveryService } from "./delivery-service.js";
+import type { DeliveryService } from "./types.js";
+
+export type CreateDeliveryTestContextOptions = {
+  readonly tenantUserIdsQuery?: string;
+  readonly rateLimit?: RateLimitConfig;
+  readonly isChannelKilled?: KillSwitchResolver;
+  readonly escapeHatchAuditSink?: EscapeHatchAuditSink;
+  readonly log?: Logger;
+};
+
+/**
+ * Helper for setupTestStack: creates a DeliveryService + _notifyFactory for the test context.
+ * Abstracts the boilerplate that every Delivery-using test needs.
+ *
+ * Usage:
+ *   setupTestStack({
+ *     features: [...],
+ *     extraContext: (deps) => createDeliveryTestContext(deps, { tenantUserIdsQuery: TenantQueries.resolveUserIds }),
+ *   });
+ */
+export function createDeliveryTestContext(
+  deps: { registry: Registry; db: DbConnection; sseBroker: SseBroker; redis: Redis },
+  options: CreateDeliveryTestContextOptions = {},
+): Record<string, unknown> & { deliveryService: DeliveryService } {
+  const { registry, db, sseBroker } = deps;
+  const channels = collectChannels(registry);
+  const deliveryService = createDeliveryService({
+    db,
+    registry,
+    sseBroker,
+    channels,
+    ...options,
+  });
+
+  return {
+    deliveryService, // exposed so tests can inspect/call directly if needed
+    _notifyFactory:
+      (user: { id: number; tenantId: TenantId }, tenantId: TenantId) =>
+      (notificationType: string, notifyOptions: Record<string, unknown>) =>
+        deliveryService.notify(notificationType, notifyOptions as never, user as never, tenantId), // @cast-boundary engine-bridge
+  };
+}

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

@@ -0,0 +1,121 @@
+import type { SseBroker } from "@cosmicdrift/kumiko-framework/api";
+import type { TenantDb } from "@cosmicdrift/kumiko-framework/db";
+import type {
+  NotifyOptions,
+  NotifyPriority,
+  Registry,
+  SessionUser,
+  TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { DELIVERY_CHANNEL_EXTENSION } from "./constants.js";
+
+// --- Channel Interface ---
+
+export type ChannelContext = {
+  readonly db: TenantDb;
+  readonly registry: Registry;
+  readonly sseBroker: SseBroker | undefined;
+  readonly tenantId: TenantId;
+};
+
+export type ChannelMessage = {
+  readonly notificationType: string;
+  readonly title: string;
+  readonly body: string | undefined;
+  readonly data: Readonly<Record<string, unknown>> | undefined;
+};
+
+export type ChannelResult = {
+  readonly status: "sent" | "failed" | "skipped";
+  readonly error?: string;
+  readonly address?: string;
+};
+
+// Output of a channel's render step, passed into send(). Only channels that
+// declare render() (email) produce one; inline channels (inApp) and channels
+// without an expensive render step (push) receive `undefined`.
+export type RenderedMessage = {
+  readonly html: string;
+  readonly subject: string;
+};
+
+// `mode` decides how the delivery-service dispatches a channel:
+//   inline — sent synchronously inside notify() (inApp: DB insert + SSE).
+//   queued — sent asynchronously via the delivery.send job; channels with a
+//            render() additionally run through delivery.render first.
+export const DELIVERY_CHANNEL_MODES = ["inline", "queued"] as const;
+export type DeliveryChannelMode = (typeof DELIVERY_CHANNEL_MODES)[number];
+
+export type DeliveryChannel = {
+  readonly name: string;
+  readonly mode: DeliveryChannelMode;
+  resolve(userId: string, ctx: ChannelContext): Promise<string | null>;
+  render?(message: ChannelMessage, ctx: ChannelContext): Promise<RenderedMessage>;
+  send(
+    address: string,
+    message: ChannelMessage,
+    ctx: ChannelContext,
+    rendered?: RenderedMessage,
+  ): Promise<ChannelResult>;
+};
+
+// --- Notification Renderer ---
+
+export type RendererInput = {
+  readonly template: string;
+  readonly variables: Readonly<Record<string, unknown>>;
+};
+
+export type NotificationRenderer = {
+  readonly name: string;
+  render(input: RendererInput): Promise<string>;
+};
+
+// --- Delivery Log Entry ---
+
+export type DeliveryLogEntry = {
+  readonly tenantId: TenantId;
+  readonly notificationType: string;
+  readonly channel: string;
+  readonly recipientId: string | null;
+  readonly recipientAddress: string | null;
+  readonly status: "queued" | "sent" | "failed" | "skipped";
+  readonly error: string | null;
+  readonly priority: NotifyPriority;
+};
+
+// --- Delivery Service ---
+
+export type DeliveryService = {
+  notify(
+    notificationType: string,
+    options: NotifyOptions,
+    user: SessionUser,
+    tenantId: TenantId,
+  ): Promise<void>;
+};
+
+// r.useExtension options-shape: `name` is NOT part of the registration
+// payload — collectChannels derives it from the usage's entityName instead.
+export type DeliveryChannelPlugin = Omit<DeliveryChannel, "name">;
+
+export function isDeliveryChannelPlugin(o: unknown): o is DeliveryChannelPlugin {
+  return (
+    typeof o === "object" &&
+    o !== null &&
+    "mode" in o &&
+    DELIVERY_CHANNEL_MODES.some((mode) => mode === o.mode) &&
+    (!("render" in o) || o.render === undefined || typeof o.render === "function") &&
+    "resolve" in o &&
+    typeof o.resolve === "function" &&
+    "send" in o &&
+    typeof o.send === "function"
+  );
+}
+
+// r.useExtension options-shape, co-located since the framework never imports upward.
+declare module "@cosmicdrift/kumiko-framework/engine" {
+  interface KumikoExtensionOptionsMap {
+    [DELIVERY_CHANNEL_EXTENSION]: DeliveryChannelPlugin;
+  }
+}