@cosmicdrift/kumiko-bundled-features 0.124.0 → 0.125.0

package/src/compliance-profiles/web/compliance-profile-screen.tsx

@@ -0,0 +1,152 @@
+// @runtime client
+import { useDispatcher, usePrimitives, useTranslation } from "@cosmicdrift/kumiko-renderer";
+import { FormScreenShell } from "@cosmicdrift/kumiko-renderer-web";
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { ComplianceProfileHandlers, ComplianceProfileQueries } from "../constants";
+
+type ProfileSummary = {
+  readonly key: string;
+  readonly region: string;
+  readonly label: string;
+  readonly authorityContact: string;
+};
+
+type ListProfilesResponse = {
+  readonly profiles: readonly ProfileSummary[];
+};
+
+type CurrentProfileResponse = {
+  readonly key: string;
+  readonly label: string;
+  readonly region: string;
+  readonly warning?: string;
+};
+
+type State =
+  | { readonly kind: "loading" }
+  | { readonly kind: "error"; readonly message: string }
+  | {
+      readonly kind: "ready";
+      readonly profiles: readonly ProfileSummary[];
+      readonly current: CurrentProfileResponse | null;
+    };
+
+export function ComplianceProfileScreen(): ReactNode {
+  const t = useTranslation();
+  const { Banner, Button, Card, Field, Form, Heading, Input, Text } = usePrimitives();
+  const dispatcher = useDispatcher();
+  const [state, setState] = useState<State>({ kind: "loading" });
+  const [selected, setSelected] = useState("");
+  const [saving, setSaving] = useState(false);
+  const [actionError, setActionError] = useState<string | null>(null);
+
+  const load = useCallback(async (): Promise<void> => {
+    setState({ kind: "loading" });
+    const [profilesRes, currentRes] = await Promise.all([
+      dispatcher.query<ListProfilesResponse>(ComplianceProfileQueries.listProfiles, {}),
+      dispatcher.query<CurrentProfileResponse>(ComplianceProfileQueries.forTenant, {}),
+    ]);
+    if (!profilesRes.isSuccess) {
+      setState({ kind: "error", message: profilesRes.error.message });
+      return;
+    }
+    if (!currentRes.isSuccess) {
+      setState({ kind: "error", message: currentRes.error.message });
+      return;
+    }
+    setSelected(currentRes.data.key);
+    setState({ kind: "ready", profiles: profilesRes.data.profiles, current: currentRes.data });
+  }, [dispatcher]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const onSave = (): void => {
+    void (async (): Promise<void> => {
+      if (selected === "") return;
+      setActionError(null);
+      setSaving(true);
+      const res = await dispatcher.write(ComplianceProfileHandlers.setProfile, {
+        profileKey: selected,
+      });
+      setSaving(false);
+      if (!res.isSuccess) {
+        setActionError(res.error.message);
+        return;
+      }
+      await load();
+    })();
+  };
+
+  if (state.kind === "loading") {
+    return (
+      <FormScreenShell testId="compliance-profile-screen">
+        <Text variant="small">{t("compliance.profile.loading")}</Text>
+      </FormScreenShell>
+    );
+  }
+
+  if (state.kind === "error") {
+    return (
+      <FormScreenShell testId="compliance-profile-screen">
+        <Banner variant="error">{state.message}</Banner>
+      </FormScreenShell>
+    );
+  }
+
+  const profileOptions = state.profiles.map((profile) => ({
+    value: profile.key,
+    label: `${profile.label} (${profile.key})`,
+  }));
+
+  return (
+    <FormScreenShell testId="compliance-profile-screen" className="flex flex-col gap-6">
+      <Heading variant="page">{t("compliance.profile.title")}</Heading>
+
+      {state.current !== null && (
+        <Banner variant="info" testId="compliance-current-profile">
+          {t("compliance.profile.current")}: {state.current.label} ({state.current.key})
+        </Banner>
+      )}
+
+      <Form
+        onSubmit={onSave}
+        actions={
+          <Button
+            type="submit"
+            variant="primary"
+            disabled={saving || selected === ""}
+            loading={saving}
+            testId="compliance-profile-save"
+          >
+            {saving ? t("compliance.profile.saving") : t("compliance.profile.save")}
+          </Button>
+        }
+      >
+        <Field id="compliance-profile-select" label={t("compliance.profile.select")} required>
+          <Input
+            kind="select"
+            id="compliance-profile-select"
+            name="compliance-profile-select"
+            value={selected}
+            onChange={setSelected}
+            options={profileOptions}
+            required
+          />
+        </Field>
+        {actionError !== null && <Banner variant="error">{actionError}</Banner>}
+      </Form>
+
+      <Card slots={{ title: t("compliance.profile.catalog") }}>
+        <ul className="flex flex-col gap-2 text-sm">
+          {state.profiles.map((profile) => (
+            <li key={profile.key} data-profile-key={profile.key}>
+              <strong>{profile.label}</strong> — {profile.region} — {profile.authorityContact}
+            </li>
+          ))}
+        </ul>
+      </Card>
+    </FormScreenShell>
+  );
+}

package/src/compliance-profiles/web/i18n.ts

@@ -0,0 +1,25 @@
+// @runtime client
+import type { TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+
+export const defaultTranslations: TranslationsByLocale = {
+  de: {
+    "compliance.profile.title": "Compliance-Profil",
+    "compliance.profile.loading": "Lade Compliance-Profile…",
+    "compliance.profile.current": "Aktuell",
+    "compliance.profile.select": "Profil",
+    "compliance.profile.save": "Profil speichern",
+    "compliance.profile.saving": "Speichert…",
+    "compliance.profile.catalog": "Verfügbare Profile",
+    "compliance-profiles:nav.profilePicker": "Compliance",
+  },
+  en: {
+    "compliance.profile.title": "Compliance profile",
+    "compliance.profile.loading": "Loading compliance profiles…",
+    "compliance.profile.current": "Current",
+    "compliance.profile.select": "Profile",
+    "compliance.profile.save": "Save profile",
+    "compliance.profile.saving": "Saving…",
+    "compliance.profile.catalog": "Available profiles",
+    "compliance-profiles:nav.profilePicker": "Compliance",
+  },
+};

package/src/compliance-profiles/web/index.ts

@@ -0,0 +1,6 @@
+// @runtime client
+export {
+  type ComplianceProfilesClientOptions,
+  complianceProfilesClient,
+} from "./client-plugin";
+export { ComplianceProfileScreen } from "./compliance-profile-screen";

package/src/delivery/__tests__/delivery-screens.boot.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { access, validateBoot } from "@cosmicdrift/kumiko-framework/engine";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { DELIVERY_LOG_SCREEN_ID } from "../constants";
+import { createDeliveryFeature } from "../feature";
+
+describe("delivery screens + handler access alignment", () => {
+  const features = [createDeliveryFeature()];
+
+  test("boot-validates with delivery-log screen registered", () => {
+    expect(() => validateBoot(features)).not.toThrow();
+  });
+
+  test("delivery-log screen is custom, access.admin-gated", () => {
+    const delivery = createDeliveryFeature();
+    const screen = delivery.screens[DELIVERY_LOG_SCREEN_ID];
+    expect(screen?.type).toBe("custom");
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(access.admin);
+    }
+  });
+
+  test("delivery log handler shares access.admin", () => {
+    const delivery = createDeliveryFeature();
+    expect(rolesOf(delivery.queryHandlers["log"]?.access)).toEqual([...access.admin]);
+  });
+});

package/src/delivery/__tests__/delivery-security.integration.test.ts

@@ -0,0 +1,106 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { insertMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { access, createRegistry } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  createTestUser,
+  setupTestStack,
+  type TestStack,
+  testTenantId,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { DELIVERY_LOG_SCREEN_ID, DeliveryQueries } from "../constants";
+import { createDeliveryFeature } from "../feature";
+import { deliveryAttemptsTable, notificationPreferencesTable } from "../tables";
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [createDeliveryFeature()],
+  });
+  await unsafePushTables(stack.db, { deliveryAttemptsTable, notificationPreferencesTable });
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+describe("delivery access matrix", () => {
+  test("delivery log handler and screen share access.admin", () => {
+    const registry = createRegistry([createDeliveryFeature()]);
+    expect(rolesOf(registry.getQueryHandler(DeliveryQueries.log)?.access)).toEqual([
+      ...access.admin,
+    ]);
+    const delivery = createDeliveryFeature();
+    const screen = delivery.screens[DELIVERY_LOG_SCREEN_ID];
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(access.admin);
+    }
+  });
+});
+
+describe("delivery log HTTP access", () => {
+  test("TenantAdmin can query delivery log", async () => {
+    const user = createTestUser({ id: 11, roles: ["TenantAdmin"] });
+    const res = await stack.http.queryOk<{ rows: readonly unknown[] }>(
+      DeliveryQueries.log,
+      {},
+      user,
+    );
+    expect(Array.isArray(res.rows)).toBe(true);
+  });
+
+  test("historic Admin can query delivery log", async () => {
+    const user = createTestUser({ id: 12, roles: ["Admin"] });
+    const res = await stack.http.queryOk<{ rows: readonly unknown[] }>(
+      DeliveryQueries.log,
+      {},
+      user,
+    );
+    expect(Array.isArray(res.rows)).toBe(true);
+  });
+
+  test("regular User gets 403", async () => {
+    const user = createTestUser({ id: 13, roles: ["User"] });
+    expect((await stack.http.query(DeliveryQueries.log, {}, user)).status).toBe(403);
+  });
+});
+
+describe("delivery log tenant isolation", () => {
+  // delivery runs in system-scope, so the handler must filter by tenantId —
+  // otherwise a TenantAdmin reads every tenant's attempts (with decrypted PII).
+  test("TenantAdmin only sees their own tenant's delivery attempts", async () => {
+    const tenantA = testTenantId(1); // createTestUser default tenant
+    const tenantB = testTenantId(2);
+    await insertMany(stack.db, deliveryAttemptsTable, [
+      {
+        id: crypto.randomUUID(),
+        tenantId: tenantA,
+        notificationType: "welcome",
+        channel: "email",
+        recipientAddress: null,
+        status: "sent",
+      },
+      {
+        id: crypto.randomUUID(),
+        tenantId: tenantB,
+        notificationType: "welcome",
+        channel: "email",
+        recipientAddress: null,
+        status: "sent",
+      },
+    ]);
+
+    const adminA = createTestUser({ id: 21, roles: ["TenantAdmin"], tenantId: tenantA });
+    const res = await stack.http.queryOk<{ rows: readonly { tenantId: string }[] }>(
+      DeliveryQueries.log,
+      {},
+      adminA,
+    );
+
+    expect(res.rows.length).toBeGreaterThan(0);
+    expect(res.rows.every((r) => r.tenantId === tenantA)).toBe(true);
+    expect(res.rows.some((r) => r.tenantId === tenantB)).toBe(false);
+  });
+});

package/src/delivery/constants.ts

@@ -1,8 +1,18 @@
 import type { NotifyPriority } from "@cosmicdrift/kumiko-framework/engine";
 import { QnTypes, qn } from "@cosmicdrift/kumiko-framework/engine";
-
-// Feature name
-export const DELIVERY_FEATURE = "delivery" as const;
+import { DELIVERY_FEATURE, DeliveryJobNames } from "./public-names";
+
+export {
+  DELIVERY_ATTEMPT_EVENT,
+  DELIVERY_FEATURE,
+  DELIVERY_LOG_SCREEN_ID,
+  DeliveryErrors,
+  DeliveryHandlers,
+  DeliveryJobNames,
+  DeliveryQueries,
+  DeliveryStatus,
+  type DeliveryStatusValue,
+} from "./public-names";
 
 // notify() priority → BullMQ job priority. Lower number = processed first; all
 // > 0 so prioritised delivery jobs never mix with BullMQ's "0 = unprioritised
@@ -13,54 +23,6 @@ export const deliveryPriorityRank: Record<NotifyPriority, number> = {
   low: 3,
 };
 
-// Qualified write handler names (QN format: scope:type:name)
-export const DeliveryHandlers = {
-  setPreference: "delivery:write:set-preference",
-} as const;
-
-// Qualified query handler names (QN format: scope:type:name)
-export const DeliveryQueries = {
-  log: "delivery:query:log",
-  preferences: "delivery:query:preferences",
-} as const;
-
-// Error codes
-export const DeliveryErrors = {
-  noRecipient: "delivery_no_recipient",
-  channelFailed: "delivery_channel_failed",
-} as const;
-
-// Delivery status values. `queued` is the initial state of an async attempt
-// (email/push) between dispatch and the worker running — it transitions to
-// sent/failed once the delivery.send job finishes. Synchronous attempts
-// (inApp, skips) never observe `queued`.
-export const DeliveryStatus = {
-  queued: "queued",
-  sent: "sent",
-  failed: "failed",
-  skipped: "skipped",
-} as const;
-
-export type DeliveryStatusValue = (typeof DeliveryStatus)[keyof typeof DeliveryStatus];
-
-// Qualified domain-event name. Emitted by the delivery-service on every
-// attempt (sent / failed / skipped). A multi-stream-projection materialises
-// each event into a row in deliveryAttemptsTable for the log-query handler.
-export const DELIVERY_ATTEMPT_EVENT = "delivery:event:attempt" as const;
-
-// Background jobs that carry async (queued-mode) channels. render decouples the
-// expensive template step from the send so each retries independently; render
-// dispatches send on success. Channels without a render() (push) skip straight
-// to send.
-//
-// Short names are what r.job() registers; the registry qualifies them to
-// `scope:job:name`. Dispatch (notify + render→send chaining) must use the
-// QUALIFIED name, so DeliveryJobs holds the qualified form via qn().
-export const DeliveryJobNames = {
-  render: "render",
-  send: "send",
-} as const;
-
 export const DeliveryJobs = {
   render: qn(DELIVERY_FEATURE, QnTypes.job, DeliveryJobNames.render),
   send: qn(DELIVERY_FEATURE, QnTypes.job, DeliveryJobNames.send),

package/src/delivery/feature.ts

@@ -1,7 +1,11 @@
 import { upsertByPk } from "@cosmicdrift/kumiko-framework/bun-db";
-import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  access,
+  defineFeature,
+  type FeatureDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
 import type { z } from "zod";
-import { DELIVERY_ATTEMPT_EVENT, DeliveryJobNames } from "./constants";
+import { DELIVERY_ATTEMPT_EVENT, DELIVERY_LOG_SCREEN_ID, DeliveryJobNames } from "./constants";
 import { deliveryAttemptSchema } from "./events";
 import { logQuery } from "./handlers/log.query";
 import { preferencesQuery } from "./handlers/preferences.query";
@@ -117,6 +121,19 @@ export function createDeliveryFeature(): FeatureDefinition {
       preferences: r.queryHandler(preferencesQuery),
     };
 
+    r.screen({
+      id: DELIVERY_LOG_SCREEN_ID,
+      type: "custom",
+      renderer: { react: { __component: "DeliveryLogScreen" } },
+      access: { roles: access.admin },
+    });
+    r.nav({
+      id: "delivery-log",
+      label: "delivery:nav.deliveryLog",
+      screen: "delivery:screen:delivery-log",
+      order: 40,
+    });
+
     return { handlers, queries };
   });
 }

package/src/delivery/handlers/log.query.ts

@@ -1,5 +1,5 @@
 import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
-import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { access, defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { z } from "zod";
 import { decryptStoredPii } from "../../shared";
 import { deliveryAttemptsTable } from "../tables";
@@ -9,12 +9,20 @@ export const logQuery = defineQueryHandler({
   schema: z.object({
     limit: z.number().min(1).max(100).default(50),
   }),
-  access: { roles: ["Admin", "SystemAdmin"] },
+  access: { roles: access.admin },
   handler: async (query, ctx) => {
-    const rows = await selectMany(ctx.db, deliveryAttemptsTable, undefined, {
-      orderBy: { col: "createdAt", direction: "desc" },
-      limit: query.payload.limit,
-    });
+    // delivery runs in system-scope (feature.ts r.systemScope()), so ctx.db is
+    // NOT auto-tenant-filtered — filter explicitly or a tenant admin reads every
+    // tenant's attempts (with decrypted recipient PII below).
+    const rows = await selectMany(
+      ctx.db,
+      deliveryAttemptsTable,
+      { tenantId: query.user.tenantId },
+      {
+        orderBy: { col: "createdAt", direction: "desc" },
+        limit: query.payload.limit,
+      },
+    );
     // recipientAddress is stored encrypted under the recipient's DEK (#799)
     // — decrypt for the admin log view; forgotten subjects show [[erased]].
     return {

package/src/delivery/index.ts

@@ -1,6 +1,7 @@
 export type { DeliveryStatusValue } from "./constants";
 export {
   DELIVERY_FEATURE,
+  DELIVERY_LOG_SCREEN_ID,
   DeliveryErrors,
   DeliveryHandlers,
   DeliveryJobs,

package/src/delivery/public-names.ts

@@ -0,0 +1,36 @@
+// @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",
+} 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;
+
+export const DeliveryErrors = {
+  noRecipient: "delivery_no_recipient",
+  channelFailed: "delivery_channel_failed",
+} 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/src/delivery/web/client-plugin.tsx

@@ -0,0 +1,20 @@
+// @runtime client
+import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
+import { DELIVERY_FEATURE, DELIVERY_LOG_SCREEN_ID } from "../public-names";
+import { DeliveryLogScreen } from "./delivery-log-screen";
+import { defaultTranslations } from "./i18n";
+
+export type DeliveryClientOptions = {
+  readonly translations?: TranslationsByLocale;
+};
+
+export function deliveryClient(options?: DeliveryClientOptions): ClientFeatureDefinition {
+  return {
+    name: DELIVERY_FEATURE,
+    translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
+    components: {
+      [DELIVERY_LOG_SCREEN_ID]: DeliveryLogScreen,
+    },
+  };
+}

package/src/delivery/web/delivery-log-screen.tsx

@@ -0,0 +1,103 @@
+// @runtime client
+import { useDispatcher, usePrimitives, useTranslation } from "@cosmicdrift/kumiko-renderer";
+import { FormScreenShell } from "@cosmicdrift/kumiko-renderer-web";
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { DeliveryQueries } from "../public-names";
+
+type DeliveryRow = {
+  readonly id: string;
+  readonly notificationType: string;
+  readonly channel: string;
+  readonly recipientAddress: string | null;
+  readonly status: string;
+  readonly error: string | null;
+};
+
+type DeliveryLogResponse = {
+  readonly rows: readonly DeliveryRow[];
+};
+
+type State =
+  | { readonly kind: "loading" }
+  | { readonly kind: "error"; readonly message: string }
+  | { readonly kind: "ready"; readonly rows: readonly DeliveryRow[] };
+
+export function DeliveryLogScreen(): ReactNode {
+  const t = useTranslation();
+  const { Banner, Card, DataTable, Heading, Text } = usePrimitives();
+  const dispatcher = useDispatcher();
+  const [state, setState] = useState<State>({ kind: "loading" });
+
+  const load = useCallback(async (): Promise<void> => {
+    setState({ kind: "loading" });
+    const res = await dispatcher.query<DeliveryLogResponse>(DeliveryQueries.log, { limit: 50 });
+    if (!res.isSuccess) {
+      setState({ kind: "error", message: res.error.message });
+      return;
+    }
+    setState({ kind: "ready", rows: res.data.rows });
+  }, [dispatcher]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  if (state.kind === "loading") {
+    return (
+      <FormScreenShell testId="delivery-log-screen">
+        <Text variant="small">{t("delivery.log.loading")}</Text>
+      </FormScreenShell>
+    );
+  }
+
+  if (state.kind === "error") {
+    return (
+      <FormScreenShell testId="delivery-log-screen">
+        <Banner variant="error">{state.message}</Banner>
+      </FormScreenShell>
+    );
+  }
+
+  return (
+    <FormScreenShell testId="delivery-log-screen" className="flex max-w-5xl flex-col gap-6">
+      <Heading variant="page">{t("delivery.log.title")}</Heading>
+
+      <Card options={{ padded: false }}>
+        <DataTable
+          testId="delivery-log-table"
+          columns={[
+            { field: "type", label: t("delivery.log.col.type"), type: "string", sortable: false },
+            {
+              field: "channel",
+              label: t("delivery.log.col.channel"),
+              type: "string",
+              sortable: false,
+            },
+            {
+              field: "recipient",
+              label: t("delivery.log.col.recipient"),
+              type: "string",
+              sortable: false,
+            },
+            {
+              field: "status",
+              label: t("delivery.log.col.status"),
+              type: "string",
+              sortable: false,
+            },
+          ]}
+          rows={state.rows.map((row) => ({
+            id: row.id,
+            values: {
+              type: row.notificationType,
+              channel: row.channel,
+              recipient: row.recipientAddress ?? "—",
+              status: row.error ? `${row.status} (${row.error})` : row.status,
+            },
+          }))}
+          emptyState={<Text variant="small">{t("delivery.log.empty")}</Text>}
+        />
+      </Card>
+    </FormScreenShell>
+  );
+}

package/src/delivery/web/i18n.ts

@@ -0,0 +1,25 @@
+// @runtime client
+import type { TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+
+export const defaultTranslations: TranslationsByLocale = {
+  de: {
+    "delivery.log.title": "Delivery-Log",
+    "delivery.log.loading": "Lade Zustellversuche…",
+    "delivery.log.empty": "Keine Zustellversuche.",
+    "delivery.log.col.type": "Typ",
+    "delivery.log.col.channel": "Kanal",
+    "delivery.log.col.recipient": "Empfänger",
+    "delivery.log.col.status": "Status",
+    "delivery:nav.deliveryLog": "Zustellungen",
+  },
+  en: {
+    "delivery.log.title": "Delivery log",
+    "delivery.log.loading": "Loading delivery attempts…",
+    "delivery.log.empty": "No delivery attempts.",
+    "delivery.log.col.type": "Type",
+    "delivery.log.col.channel": "Channel",
+    "delivery.log.col.recipient": "Recipient",
+    "delivery.log.col.status": "Status",
+    "delivery:nav.deliveryLog": "Delivery",
+  },
+};

package/src/delivery/web/index.ts

@@ -0,0 +1,3 @@
+// @runtime client
+export { type DeliveryClientOptions, deliveryClient } from "./client-plugin";
+export { DeliveryLogScreen } from "./delivery-log-screen";