@cosmicdrift/kumiko-bundled-features 1.0.0 → 2.0.0

package/src/jobs/web/i18n.ts

@@ -0,0 +1,12 @@
+// @runtime client
+import type { TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import { JOBS_I18N } from "../i18n";
+
+const LOCALES = ["de", "en"] as const;
+
+export const defaultTranslations: TranslationsByLocale = Object.fromEntries(
+  LOCALES.map((locale) => [
+    locale,
+    Object.fromEntries(Object.entries(JOBS_I18N).map(([key, value]) => [key, value[locale]])),
+  ]),
+);

package/src/jobs/web/index.ts

@@ -0,0 +1,4 @@
+// @runtime client
+export { type JobsClientOptions, jobsClient } from "./client-plugin";
+export { JobRunDetailScreen } from "./job-run-detail-screen";
+export { JobRunsScreen } from "./job-runs-screen";

package/src/jobs/web/job-run-detail-screen.tsx

@@ -0,0 +1,180 @@
+// @runtime client
+// Single job-run detail + logs. Route entityId = run uuid.
+
+import {
+  formatWhen,
+  useDispatcher,
+  useNav,
+  usePrimitives,
+  useTranslation,
+} from "@cosmicdrift/kumiko-renderer";
+import { FormScreenShell } from "@cosmicdrift/kumiko-renderer-web";
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { JOB_RUNS_SCREEN_ID, JobHandlers, JobQueries } from "../constants";
+
+type LogRow = {
+  readonly level: string;
+  readonly message: string;
+  readonly timestamp: string;
+};
+
+type JobRunDetail = {
+  readonly id: string;
+  readonly jobName: string;
+  readonly status: string;
+  readonly startedAt: string;
+  readonly finishedAt?: string | null;
+  readonly duration?: number | null;
+  readonly error?: string | null;
+  readonly logs: readonly LogRow[];
+};
+
+type State =
+  | { readonly kind: "loading" }
+  | { readonly kind: "missing" }
+  | { readonly kind: "error"; readonly message: string }
+  | { readonly kind: "ready"; readonly run: JobRunDetail };
+
+export function JobRunDetailScreen(): ReactNode {
+  const t = useTranslation();
+  const { Banner, Button, Card, Text } = usePrimitives();
+  const dispatcher = useDispatcher();
+  const nav = useNav();
+  const runId = nav.route?.entityId;
+  const [state, setState] = useState<State>({ kind: "loading" });
+  const [retrying, setRetrying] = useState(false);
+  const [actionError, setActionError] = useState<string | null>(null);
+
+  const load = useCallback(async (): Promise<void> => {
+    if (runId === undefined || runId === "") {
+      setState({ kind: "missing" });
+      return;
+    }
+    setState({ kind: "loading" });
+    const res = await dispatcher.query<JobRunDetail | null>(JobQueries.details, { runId });
+    if (!res.isSuccess) {
+      setState({ kind: "error", message: res.error.message });
+      return;
+    }
+    if (res.data === null) {
+      setState({ kind: "missing" });
+      return;
+    }
+    setState({ kind: "ready", run: res.data });
+  }, [dispatcher, runId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const onRetry = async (): Promise<void> => {
+    if (runId === undefined || runId === "") return;
+    setActionError(null);
+    setRetrying(true);
+    const res = await dispatcher.write(JobHandlers.retry, { runId });
+    setRetrying(false);
+    if (!res.isSuccess) {
+      setActionError(res.error.message);
+      return;
+    }
+    nav.navigate({ screenId: JOB_RUNS_SCREEN_ID });
+  };
+
+  if (state.kind === "loading") {
+    return (
+      <FormScreenShell testId="job-run-detail-screen">
+        <Text variant="small">{t("jobs.detail.loading")}</Text>
+      </FormScreenShell>
+    );
+  }
+
+  if (state.kind === "missing") {
+    return (
+      <FormScreenShell testId="job-run-detail-screen">
+        <Banner variant="error">{t("jobs.detail.missing")}</Banner>
+      </FormScreenShell>
+    );
+  }
+
+  if (state.kind === "error") {
+    return (
+      <FormScreenShell testId="job-run-detail-screen">
+        <Banner variant="error">{state.message}</Banner>
+      </FormScreenShell>
+    );
+  }
+
+  const { run } = state;
+
+  return (
+    <FormScreenShell testId="job-run-detail-screen" className="flex flex-col gap-6">
+      <Card slots={{ title: run.jobName }}>
+        <dl className="grid gap-3 text-sm">
+          <div>
+            <dt className="font-medium">{t("jobs.detail.field.status")}</dt>
+            <dd data-testid="job-run-status">{run.status}</dd>
+          </div>
+          <div>
+            <dt className="font-medium">{t("jobs.detail.field.started")}</dt>
+            <dd data-testid="job-run-started">{formatWhen(run.startedAt)}</dd>
+          </div>
+          {run.finishedAt !== undefined && run.finishedAt !== null && (
+            <div>
+              <dt className="font-medium">{t("jobs.detail.field.finished")}</dt>
+              <dd data-testid="job-run-finished">{formatWhen(run.finishedAt)}</dd>
+            </div>
+          )}
+          {run.duration !== undefined && run.duration !== null && (
+            <div>
+              <dt className="font-medium">{t("jobs.detail.field.duration")}</dt>
+              <dd data-testid="job-run-duration">{run.duration}</dd>
+            </div>
+          )}
+          <div>
+            <dt className="font-medium">{t("jobs.detail.field.id")}</dt>
+            <dd>
+              <Text variant="code">{run.id}</Text>
+            </dd>
+          </div>
+          {run.error !== undefined && run.error !== null && run.error !== "" && (
+            <div>
+              <dt className="font-medium">{t("jobs.detail.field.error")}</dt>
+              <dd>
+                <Banner variant="error">{run.error}</Banner>
+              </dd>
+            </div>
+          )}
+        </dl>
+      </Card>
+
+      {run.status === "failed" && (
+        <Button
+          type="button"
+          variant="primary"
+          disabled={retrying}
+          loading={retrying}
+          onClick={() => void onRetry()}
+          testId="job-run-retry"
+        >
+          {retrying ? t("jobs.detail.retrying") : t("jobs.detail.retry")}
+        </Button>
+      )}
+
+      {actionError !== null && <Banner variant="error">{actionError}</Banner>}
+
+      <Card slots={{ title: t("jobs.detail.logs") }}>
+        {run.logs.length === 0 ? (
+          <Text variant="small">{t("jobs.detail.logs.empty")}</Text>
+        ) : (
+          <ul className="flex flex-col gap-1 font-mono text-sm" data-testid="job-run-logs">
+            {run.logs.map((log) => (
+              <li key={`${log.timestamp}-${log.level}-${log.message}`}>
+                <span className="text-muted-foreground">[{log.level}]</span> {log.message}
+              </li>
+            ))}
+          </ul>
+        )}
+      </Card>
+    </FormScreenShell>
+  );
+}

package/src/jobs/web/job-runs-screen.tsx

@@ -0,0 +1,146 @@
+// @runtime client
+// SystemAdmin job-run list with link to detail screen.
+
+import {
+  type DataTableSort,
+  formatWhen,
+  sortByAccessor,
+  useDispatcher,
+  useNav,
+  usePrimitives,
+  useTranslation,
+} from "@cosmicdrift/kumiko-renderer";
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { JOB_RUN_DETAIL_SCREEN_ID, JobQueries } from "../constants";
+
+type JobRunRow = {
+  readonly id: string;
+  readonly jobName: string;
+  readonly status: string;
+  readonly startedAt: string;
+  readonly finishedAt?: string | null;
+  readonly duration?: number | null;
+  readonly error?: string | null;
+};
+
+type ListResponse = { readonly rows: readonly JobRunRow[] };
+
+type State =
+  | { readonly kind: "loading" }
+  | { readonly kind: "error"; readonly message: string }
+  | { readonly kind: "ready"; readonly rows: readonly JobRunRow[] };
+
+const STATUS_FILTER_OPTIONS = [
+  { value: "", labelKey: "jobs.runs.filter.all" },
+  { value: "completed", labelKey: "jobs.runs.filter.completed" },
+  { value: "failed", labelKey: "jobs.runs.filter.failed" },
+  { value: "running", labelKey: "jobs.runs.filter.running" },
+  { value: "queued", labelKey: "jobs.runs.filter.queued" },
+] as const;
+
+export function JobRunsScreen(): ReactNode {
+  const t = useTranslation();
+  const { Banner, DataTable, Field, Input, Text } = usePrimitives();
+  const dispatcher = useDispatcher();
+  const nav = useNav();
+  const [state, setState] = useState<State>({ kind: "loading" });
+  const [statusFilter, setStatusFilter] = useState("");
+  const [sort, setSort] = useState<DataTableSort | null>(null);
+
+  const filterOptions = STATUS_FILTER_OPTIONS.map((opt) => ({
+    value: opt.value,
+    label: t(opt.labelKey),
+  }));
+
+  const refresh = useCallback(async (): Promise<void> => {
+    setState({ kind: "loading" });
+    const res = await dispatcher.query<ListResponse>(JobQueries.list, {
+      limit: 50,
+      ...(statusFilter !== "" && {
+        status: statusFilter as "queued" | "running" | "completed" | "failed",
+      }),
+    });
+    if (!res.isSuccess) {
+      setState({ kind: "error", message: res.error.message });
+      return;
+    }
+    setState({ kind: "ready", rows: res.data.rows });
+  }, [dispatcher, statusFilter]);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  if (state.kind === "loading") {
+    return (
+      <div className="p-6" data-testid="job-runs-screen">
+        <Text variant="small">{t("jobs.runs.loading")}</Text>
+      </div>
+    );
+  }
+
+  if (state.kind === "error") {
+    return (
+      <div className="p-6" data-testid="job-runs-screen">
+        <Banner variant="error">{state.message}</Banner>
+      </div>
+    );
+  }
+
+  const openDetail = (id: string): void =>
+    nav.navigate({ screenId: JOB_RUN_DETAIL_SCREEN_ID, entityId: id });
+
+  return (
+    <DataTable
+      testId="job-runs-table"
+      columns={[
+        { field: "job", label: t("jobs.runs.col.job"), type: "string", sortable: true },
+        { field: "status", label: t("jobs.runs.col.status"), type: "string", sortable: true },
+        { field: "started", label: t("jobs.runs.col.started"), type: "string", sortable: true },
+        { field: "duration", label: t("jobs.runs.col.duration"), type: "string", sortable: false },
+      ]}
+      sort={sort}
+      onSortChange={setSort}
+      rows={sortByAccessor(state.rows, sort, SORT_ACCESSORS).map((row) => ({
+        id: row.id,
+        values: {
+          job: row.jobName,
+          status: row.status,
+          started: formatWhen(row.startedAt),
+          duration: row.duration ?? "—",
+        },
+      }))}
+      onRowClick={(row) => openDetail(row.id)}
+      toolbarStart={
+        <Field id="job-runs-status-filter" label={t("jobs.runs.filter.status")}>
+          <Input
+            kind="select"
+            id="job-runs-status-filter"
+            name="job-runs-status-filter"
+            value={statusFilter}
+            onChange={setStatusFilter}
+            options={filterOptions}
+          />
+        </Field>
+      }
+      rowActions={[
+        {
+          id: "open",
+          label: t("jobs.runs.open"),
+          style: "secondary",
+          onTrigger: (row) => openDetail(row.id),
+        },
+      ]}
+      rowActionMode="inline"
+      emptyState={<Text variant="small">{t("jobs.runs.empty")}</Text>}
+    />
+  );
+}
+
+// Client-sort over the loaded page (≤50 rows). startedAt is an ISO string, so
+// lexicographic compare is chronological — no Date parsing needed.
+const SORT_ACCESSORS: Record<string, (r: JobRunRow) => string | number> = {
+  job: (r) => r.jobName,
+  status: (r) => r.status,
+  started: (r) => r.startedAt,
+};

package/src/ledger/__tests__/ledger.integration.test.ts

@@ -371,8 +371,8 @@ describe("ledger integration — confirm-schedule-period (recurring)", () => {
     scheduleId: string,
     period: string,
     amount?: number,
-  ): Promise<{ id: string }> {
-    return stack.http.writeOk<{ id: string }>(
+  ): Promise<{ id: string; alreadyBooked: boolean }> {
+    return stack.http.writeOk<{ id: string; alreadyBooked: boolean }>(
       LedgerHandlers.confirmSchedulePeriod,
       amount === undefined ? { scheduleId, period } : { scheduleId, period, amount },
       admin,
@@ -384,7 +384,10 @@ describe("ledger integration — confirm-schedule-period (recurring)", () => {
     const rent = await createAccount("Mieterträge", "income");
     const scheduleId = await createSchedule(bank, rent);
 
-    await confirm(scheduleId, "2026-01");
+    const fresh = await confirm(scheduleId, "2026-01");
+    // 684/6: fresh bookings carry alreadyBooked: false, same shape as the
+    // idempotent-path response — no "does the field even exist" check needed.
+    expect(fresh.alreadyBooked).toBe(false);
 
     const rows = await listTransactions();
     expect(rows).toHaveLength(1);
@@ -405,6 +408,8 @@ describe("ledger integration — confirm-schedule-period (recurring)", () => {
     const second = await confirm(scheduleId, "2026-01");
 
     expect(second.id).toBe(first.id);
+    expect(first.alreadyBooked).toBe(false);
+    expect(second.alreadyBooked).toBe(true);
     expect(await listTransactions()).toHaveLength(1);
   });
 

package/src/ledger/handlers/confirm-schedule-period.write.ts

@@ -13,7 +13,7 @@ import {
   transactionExecutor,
   transactionTable,
 } from "../executor";
-import { isoMonth, scheduleReference } from "../recurring";
+import { findReversedIds, isoMonth, scheduleReference } from "../recurring";
 import { type ConfirmSchedulePeriodPayload, confirmSchedulePeriodPayloadSchema } from "../schemas";
 
 // confirm-schedule-period — turn ONE projected period of a schedule into a posted,
@@ -78,8 +78,13 @@ export function createConfirmSchedulePeriodHandler(
               reference: { in: candidateIds },
             })
           : [];
-      const reversedCandidateIds = new Set(stornos.map((r) => String(r["reference"])));
-      const active = candidates.find((r) => !reversedCandidateIds.has(String(r["id"])));
+      const reversedIds = findReversedIds(
+        [...candidates, ...stornos].map((r) => ({
+          id: String(r["id"]),
+          reference: r["reference"] === null ? null : String(r["reference"]),
+        })),
+      );
+      const active = candidates.find((r) => !reversedIds.has(String(r["id"])));
       if (active) {
         const ok: WriteResult<{ id: string; alreadyBooked: true }> = {
           isSuccess: true,
@@ -89,7 +94,7 @@ export function createConfirmSchedulePeriodHandler(
       }
 
       const amount = payload.amount ?? Number(schedule["amount"]);
-      return transactionExecutor.create(
+      const created = await transactionExecutor.create(
         {
           id: generateId(),
           date: payload.date ?? `${payload.period}-01`,
@@ -104,6 +109,14 @@ export function createConfirmSchedulePeriodHandler(
         event.user,
         ctx.db,
       );
+      // Same shape as the idempotent-path return above (684/6) — a caller
+      // shouldn't have to check "does alreadyBooked exist" to know which
+      // branch fired.
+      if (!created.isSuccess) return created;
+      return {
+        isSuccess: true,
+        data: { ...created.data, alreadyBooked: false as const },
+      };
     },
   };
 }

package/src/ledger/recurring.ts

@@ -53,6 +53,22 @@ export function scheduleReference(scheduleId: string, period: string): string {
   return `schedule:${scheduleId}:${period}`;
 }
 
+// A Storno mirror carries reference = the reversed tx's id, so any tx whose
+// reference names another tx in the set marks that other tx reversed. Shared
+// by mergeScheduleActuals (below) and confirm-schedule-period.write.ts's
+// idempotency check (684/4) — same detection, kept in one place so a fix
+// can't land in one call-site and drift from the other.
+export function findReversedIds(
+  rows: readonly { readonly id: string; readonly reference: string | null }[],
+): Set<string> {
+  const ids = new Set(rows.map((r) => r.id));
+  return new Set(
+    rows
+      .filter((r) => r.reference !== null && ids.has(r.reference))
+      .map((r) => r.reference as string),
+  );
+}
+
 // "YYYY-MM" ⇄ a month index (year*12 + monthOfYear), so window math is pure
 // integer arithmetic — no Date object (no-date-api guard) and no DST/timezone
 // drift. isoMonth tolerates a full ISO date ("2026-01-15" → "2026-01").
@@ -105,14 +121,7 @@ export function mergeScheduleActuals(
   transactions: readonly LedgerTxRow[],
   asOf: string,
 ): ScheduleMonth[] {
-  const txIds = new Set(transactions.map((t) => t.id));
-  // A Storno mirror carries reference = the reversed tx's id, so any tx whose
-  // reference names another tx marks that other tx reversed.
-  const reversedTxIds = new Set(
-    transactions
-      .filter((t) => t.reference != null && txIds.has(t.reference))
-      .map((t) => t.reference as string),
-  );
+  const reversedTxIds = findReversedIds(transactions);
   const asOfIndex = monthIndex(isoMonth(asOf));
 
   return projection.map((projected) => {

package/src/ledger/web/index.ts

@@ -1,6 +1,7 @@
 // @runtime client
-// Client-safe ledger surface: QN constants + the pure recurring helpers
-// (projection + Soll/Ist merge), nothing else. The full `../ledger` entry
+// Client-safe ledger surface: QN constants, the pure recurring helpers
+// (projection + Soll/Ist merge), and the Zod payload schemas (for client-side
+// pre-validation before dispatch) — nothing else. The full `../ledger` entry
 // re-exports the feature/handlers/executor, which pull bun-db/postgres — a
 // browser bundle that imports from there fails on Node builtins. A client screen
 // (e.g. a rent-cashflow view) imports the dispatch QNs + the pure forecast/merge

package/src/legal-pages/__tests__/legal-pages.integration.test.ts

@@ -238,6 +238,10 @@ describe("legal-pages :: SYSTEM_TENANT-routing (production-bug-regression)", ()
         // Resolver gibt IMMER einen anderen Tenant zurück — wenn legal-
         // pages den respektieren würde, wäre der DB-Lookup leer.
         tenantResolver: () => otherTenantId,
+        // Mirrors publicstatus's real subdomain resolver: the tenant is
+        // derived from the host, which the client cannot forge — trusted
+        // over any client-supplied tenant.
+        resolverTrust: "authoritative",
         tenantExists: async (id) => id === otherTenantId || id === SYSTEM_TENANT_ID,
       },
       extraContext: ({ db }) => ({
@@ -268,6 +272,57 @@ describe("legal-pages :: SYSTEM_TENANT-routing (production-bug-regression)", ()
   });
 });
 
+describe("legal-pages :: wrapLayout erhält route.slug (alt-lang-switch-regression)", () => {
+  test("custom wrapLayout bekommt den passenden slug pro Route, nicht immer imprint", async () => {
+    const seenSlugs: (string | undefined)[] = [];
+    const customStack = await setupTestStack({
+      features: [
+        createTextContentFeature(),
+        createLegalPagesFeature({
+          wrapLayout: (opts) => {
+            seenSlugs.push(opts.slug);
+            return `<html data-slug="${opts.slug ?? ""}">${opts.bodyHtml}</html>`;
+          },
+        }),
+      ],
+      anonymousAccess: { defaultTenantId: SYSTEM_TENANT_ID },
+      extraContext: ({ db }) => ({
+        textContent: createTextContentApi(db),
+      }),
+    });
+    try {
+      await unsafeCreateEntityTable(customStack.db, textBlockEntity);
+      await createEventsTable(customStack.db);
+      await seedTextBlock(customStack.db, {
+        tenantId: SYSTEM_TENANT_ID,
+        slug: "imprint",
+        lang: "de",
+        title: "Impressum",
+        body: "Body",
+      });
+      await seedTextBlock(customStack.db, {
+        tenantId: SYSTEM_TENANT_ID,
+        slug: "privacy",
+        lang: "de",
+        title: "Datenschutzerklärung",
+        body: "Body",
+      });
+
+      const imprintRes = await customStack.app.request("/legal/impressum");
+      expect(imprintRes.status).toBe(200);
+      expect(await imprintRes.text()).toContain('data-slug="imprint"');
+
+      const privacyRes = await customStack.app.request("/legal/datenschutz");
+      expect(privacyRes.status).toBe(200);
+      expect(await privacyRes.text()).toContain('data-slug="privacy"');
+
+      expect(seenSlugs).toEqual(["imprint", "privacy"]);
+    } finally {
+      await customStack.cleanup();
+    }
+  });
+});
+
 describe("legal-pages :: runLegalPagesBootCheck (direct unit-tests)", () => {
   // Direkter Test der Boot-Check-Logik mit constructed ctx-Objects —
   // keine JobRunner-Coupling, keine Test-Stacks. Das ist die echte

package/src/legal-pages/feature.ts

@@ -21,14 +21,10 @@ import { renderMarkdownToHtml, wrapInLayout } from "./markdown";
 // wie bei jedem API-Endpunkt.
 const TEXT_CONTENT_BY_SLUG_QN = "text-content:query:by-slug";
 
-// Wire-Body-Shape von /api/query — das, was bySlugQuery returnt.
-type ByslugQueryBody = {
-  data: { title: string; body: string | null; updatedAt: string } | null;
-};
+// Return-Shape von bySlugQuery (text-content/handlers/by-slug.query.ts).
+type TextBlockQueryResult = { title: string; body: string | null; updatedAt: string } | null;
 
-// Legal-Content ändert sich selten — ein 60s-Shared-Cache-Fenster spart den
-// Origin-Revalidate-Roundtrip (jeder 304 re-runt sonst die Content-Query),
-// ohne dass Edits spürbar stale wirken.
+// 60s-shared-cache saves the origin-revalidate roundtrip; legal-content edits are live within 60s.
 const PUBLIC_PAGE_CACHE = { kind: "revalidate", maxAgeSeconds: 60 } as const;
 
 // legal-pages — Opt-in-Wrapper um text-content für DACH-Compliance.
@@ -54,6 +50,7 @@ export type LegalPagesWrapLayout = (opts: {
   readonly title: string;
   readonly bodyHtml: string;
   readonly lang: string;
+  readonly slug?: (typeof LEGAL_ROUTES)[number]["slug"];
 }) => string;
 
 export type LegalPagesOptions = {
@@ -83,35 +80,30 @@ export function createLegalPagesFeature(opts: LegalPagesOptions = {}): FeatureDe
         method: "GET",
         path: route.path,
         anonymous: true,
-        handler: async (c, { app }) => {
-          const url = new URL(c.req.url);
+        handler: async (c, { systemQuery }) => {
           // Architektur: 1 App = X Tenants = 1 Impressum. Egal welche
           // Subdomain der Visitor besucht (apex, admin.*, tenant-x.*) —
-          // legal-pages serven IMMER die SYSTEM_TENANT-Texte. Deshalb
-          // explizit X-Tenant-Header setzen statt host weiterreichen
-          // (sonst würde ein host-basierter anonymousAccess-Resolver
-          // die tenant-Subdomain auf tenant-tenantId resolven und
-          // tenant-x's leere imprint-Tabelle abfragen → 404).
-          const queryRes = await app.fetch(
-            new Request(`${url.origin}/api/query`, {
-              method: "POST",
-              headers: {
-                "content-type": "application/json",
-                "X-Tenant": SYSTEM_TENANT_ID,
-              },
-              body: JSON.stringify({
-                type: TEXT_CONTENT_BY_SLUG_QN,
-                payload: { slug: route.slug, lang: route.lang },
-              }),
-            }),
-          );
-
-          if (!queryRes.ok) {
+          // legal-pages serven IMMER die SYSTEM_TENANT-Texte. systemQuery
+          // erzwingt SYSTEM_TENANT_ID in-process (kein X-Tenant-Header-
+          // Trick über app.fetch — der sähe für einen host-basierten
+          // anonymousAccess-Resolver wie ein Client-Override aus und würde
+          // von resolverTrust: "authoritative" zurecht abgelehnt).
+          let data: TextBlockQueryResult;
+          try {
+            // @cast-boundary engine-payload — dispatcher.query returnt
+            // unknown; Shape ist durch bySlugQuery's Handler-Return-Type
+            // (siehe text-content/handlers/by-slug.query.ts) vertraut.
+            data = (await systemQuery(
+              TEXT_CONTENT_BY_SLUG_QN,
+              { slug: route.slug, lang: route.lang },
+              SYSTEM_TENANT_ID,
+            )) as TextBlockQueryResult;
+          } catch (err) {
+            // biome-ignore lint/suspicious/noConsole: ops-visible fallback, no logger wired into HttpRouteHandlerDeps
+            console.error(`legal-pages: text-content query failed for slug="${route.slug}"`, err);
             return c.text("legal page unavailable", 503);
           }
 
-          const body: ByslugQueryBody = await queryRes.json();
-          const data = body.data;
           if (!data?.body) {
             return c.text(
               `${route.titleFallback} not configured. Tenant-Admin must set this text-block.`,
@@ -144,6 +136,7 @@ export function createLegalPagesFeature(opts: LegalPagesOptions = {}): FeatureDe
             title: data.title || route.titleFallback,
             bodyHtml: renderMarkdownToHtml(data.body),
             lang: route.lang,
+            slug: route.slug,
           });
 
           return cachedSecurePageResponse(c.req.raw, {

package/src/legal-pages/index.ts

@@ -8,6 +8,7 @@ export {
 export {
   createLegalPagesFeature,
   type LegalPagesBootCheckCtx,
+  type LegalPagesOptions,
   runLegalPagesBootCheck,
 } from "./feature";
 export { renderMarkdownToHtml, wrapInLayout } from "./markdown";

package/src/mail-foundation/__tests__/feature.test.ts

@@ -28,12 +28,11 @@ describe("mailFoundationFeature — shape", () => {
 });
 
 describe("mailFoundationFeature.exports — typed handles", () => {
-  test("exposes only the provider-selector config-key", () => {
-    const keys = mailFoundationFeature.exports.configKeys;
-    expect(keys.provider).toBeDefined();
-    // No host/port/from/authUser — those live in the provider-plugin.
-    expect((keys as Record<string, unknown>)["host"]).toBeUndefined();
-    expect((keys as Record<string, unknown>)["port"]).toBeUndefined();
+  test("exposes the provider-selector handle", () => {
+    expect(mailFoundationFeature.exports.providerConfigKey).toBeDefined();
+    expect(mailFoundationFeature.exports.providerConfigKey.name).toBe(
+      "mail-foundation:config:provider",
+    );
   });
 });