@cosmicdrift/kumiko-samples 0.383.0 → 0.384.0

package/packages/bundled-features/src/sessions/handlers/list.query.ts

@@ -8,6 +8,7 @@ import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
 import * as z from "zod";
 import { decryptStoredPii } from "../../shared/index.ts";
 import { userSessionTable } from "../schema/user-session.ts";
+import { parsedDeviceSchema, parseUserAgent } from "../web/user-agent.ts";
 
 // `sort` arrives raw from the client's query string. selectMany's orderBy
 // has no column-existence check — an unrecognised field just gets
@@ -47,6 +48,7 @@ export const createListQuery = (adminRoles: readonly string[] = access.admin) =>
           revokedAt: z.unknown(),
           ip: z.string().nullable(),
           userAgent: z.string().nullable(),
+          device: parsedDeviceSchema,
         }),
       ),
       nextCursor: z.string().nullable(),
@@ -79,17 +81,21 @@ export const createListQuery = (adminRoles: readonly string[] = access.admin) =>
         ...(query.payload.limit !== undefined && { limit: query.payload.limit }),
       });
       const decryptedRows = await Promise.all(
-        rows.map(async (r) => ({
-          id: r.id,
-          userId: r.userId,
-          createdAt: r.createdAt,
-          expiresAt: r.expiresAt,
-          revokedAt: r.revokedAt,
-          ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:list") : r.ip,
-          userAgent: r.userAgent
+        rows.map(async (r) => {
+          const userAgent = r.userAgent
             ? await decryptStoredPii(r.userAgent, "userAgent", "sessions:list")
-            : r.userAgent,
-        })),
+            : r.userAgent;
+          return {
+            id: r.id,
+            userId: r.userId,
+            createdAt: r.createdAt,
+            expiresAt: r.expiresAt,
+            revokedAt: r.revokedAt,
+            ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:list") : r.ip,
+            userAgent,
+            device: parseUserAgent(userAgent),
+          };
+        }),
       );
       return { rows: decryptedRows, nextCursor: null };
     },

package/packages/bundled-features/src/sessions/handlers/mine.query.ts

@@ -3,6 +3,7 @@ import { definePagedQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { decryptStoredPii } from "../../shared/index.ts";
 import { userSessionTable } from "../schema/user-session.ts";
+import { parsedDeviceSchema, parseUserAgent } from "../web/user-agent.ts";
 
 // "My live sessions" — the backing data for a devices/sessions UI. Returns
 // ONLY the current user's own, currently-live sessions, ordered by most-
@@ -29,6 +30,7 @@ export const mineQuery = definePagedQueryHandler({
         expiresAt: z.unknown(),
         ip: z.string().nullable(),
         userAgent: z.string().nullable(),
+        device: parsedDeviceSchema,
         current: z.boolean(),
       }),
     ),
@@ -51,16 +53,20 @@ export const mineQuery = definePagedQueryHandler({
     );
     const currentSid = query.user.sid;
     const decryptedRows = await Promise.all(
-      rows.map(async (r) => ({
-        id: r.id,
-        createdAt: r.createdAt,
-        expiresAt: r.expiresAt,
-        ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:mine") : r.ip,
-        userAgent: r.userAgent
+      rows.map(async (r) => {
+        const userAgent = r.userAgent
           ? await decryptStoredPii(r.userAgent, "userAgent", "sessions:mine")
-          : r.userAgent,
-        current: currentSid === r.id,
-      })),
+          : r.userAgent;
+        return {
+          id: r.id,
+          createdAt: r.createdAt,
+          expiresAt: r.expiresAt,
+          ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:mine") : r.ip,
+          userAgent,
+          device: parseUserAgent(userAgent),
+          current: currentSid === r.id,
+        };
+      }),
     );
     return { rows: decryptedRows, nextCursor: null };
   },

package/packages/bundled-features/src/sessions/screens.ts

@@ -12,6 +12,9 @@ import {
   SessionHandlers,
   SessionQueries,
 } from "./constants.ts";
+import { SESSION_DEVICE_CELL_COMPONENT } from "./web/constants.ts";
+
+const DEVICE_RENDERER = { react: { __component: SESSION_DEVICE_CELL_COMPONENT } } as const;
 
 export const createSessionListScreen = (
   adminRoles: readonly string[] = access.admin,
@@ -35,6 +38,11 @@ export const createSessionListScreen = (
       refEntity: "user:user",
       refLabelField: "displayName",
     },
+    {
+      field: "device",
+      label: i18nKey("sessions.list.col.device"),
+      renderer: DEVICE_RENDERER,
+    },
     {
       field: "createdAt",
       label: i18nKey("sessions.list.col.createdAt"),
@@ -43,6 +51,7 @@ export const createSessionListScreen = (
     {
       field: "expiresAt",
       label: i18nKey("sessions.list.col.expiresAt"),
+      hideOnNarrow: true,
       renderer: { format: "timestamp" },
     },
     {
@@ -85,6 +94,7 @@ export const createSessionDetailScreen = (
           { field: "createdAt", renderer: { format: "timestamp" } },
           { field: "expiresAt", renderer: { format: "timestamp" } },
           { field: "revokedAt", renderer: { format: "timestamp" } },
+          { field: "device", renderer: DEVICE_RENDERER },
           "ip",
           "userAgent",
         ],
@@ -97,6 +107,7 @@ export const createSessionDetailScreen = (
     createdAt: i18nKey("sessions.detail.field.createdAt"),
     expiresAt: i18nKey("sessions.detail.field.expiresAt"),
     revokedAt: i18nKey("sessions.detail.field.revokedAt"),
+    device: i18nKey("sessions.list.col.device"),
     ip: i18nKey("sessions.detail.field.ip"),
     userAgent: i18nKey("sessions.detail.field.userAgent"),
   },
@@ -109,6 +120,17 @@ export const sessionMineScreen: ProjectionListScreenDefinition = {
   type: "projectionList",
   query: SessionQueries.mine,
   columns: [
+    { field: "device", label: i18nKey("sessions.mine.col.userAgent"), renderer: DEVICE_RENDERER },
+    { field: "ip", label: i18nKey("sessions.mine.col.ip") },
+    {
+      field: "current",
+      label: i18nKey("sessions.mine.col.current"),
+      renderer: {
+        format: "boolean",
+        trueLabel: i18nKey("sessions.mine.current.yes"),
+        falseLabel: i18nKey("sessions.mine.current.no"),
+      },
+    },
     {
       field: "createdAt",
       label: i18nKey("sessions.list.col.createdAt"),
@@ -117,15 +139,8 @@ export const sessionMineScreen: ProjectionListScreenDefinition = {
     {
       field: "expiresAt",
       label: i18nKey("sessions.list.col.expiresAt"),
-      renderer: { format: "timestamp" },
-    },
-    { field: "ip", label: i18nKey("sessions.mine.col.ip") },
-    { field: "userAgent", label: i18nKey("sessions.mine.col.userAgent") },
-    {
-      field: "current",
-      label: i18nKey("sessions.mine.col.current"),
       hideOnNarrow: true,
-      renderer: { format: "boolean" },
+      renderer: { format: "timestamp" },
     },
   ],
   rowActions: [

package/packages/bundled-features/src/sessions/web/client-plugin.tsx

@@ -0,0 +1,17 @@
+import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer/web";
+import { SESSION_DEVICE_CELL_COMPONENT, SESSIONS_FEATURE } from "./constants.ts";
+import { defaultTranslations } from "./default-translations.ts";
+import { SessionDeviceCell } from "./session-device-cell.tsx";
+
+export type SessionsClientOptions = {
+  readonly translations?: TranslationsByLocale;
+};
+
+export function sessionsClient(options?: SessionsClientOptions): ClientFeatureDefinition {
+  return {
+    name: SESSIONS_FEATURE,
+    translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
+    columnRenderers: { [SESSION_DEVICE_CELL_COMPONENT]: SessionDeviceCell },
+  };
+}

package/packages/bundled-features/src/sessions/web/constants.ts

@@ -0,0 +1,3 @@
+export const SESSIONS_FEATURE = "sessions" as const;
+/** Column-renderer name shared by screens.ts and `sessionsClient()`. */
+export const SESSION_DEVICE_CELL_COMPONENT = "session-device-cell" as const;

package/packages/bundled-features/src/sessions/web/default-translations.ts

@@ -0,0 +1,8 @@
+import {
+  type TranslationsByLocale,
+  translationsByLocaleFromKeys,
+} from "@cosmicdrift/kumiko-renderer";
+import { SESSIONS_I18N } from "./i18n.ts";
+
+export const defaultTranslations: TranslationsByLocale =
+  translationsByLocaleFromKeys(SESSIONS_I18N);

package/packages/bundled-features/src/sessions/web/i18n.ts

@@ -22,7 +22,11 @@ export const SESSIONS_I18N: Readonly<Record<string, LocalizedString>> = {
   "screen:my-sessions.title": { en: "Your sessions" },
   "sessions.mine.col.ip": { en: "IP address" },
   "sessions.mine.col.userAgent": { en: "Device" },
-  "sessions.mine.col.current": { en: "This device" },
+  "sessions.mine.col.current": { en: "Session" },
+  "sessions.mine.current.yes": { en: "This session" },
+  "sessions.mine.current.no": { en: "-" },
+  "sessions.list.col.device": { en: "Device" },
+  "sessions.device.unknown": { en: "Unknown device" },
   "sessions.mine.revoke": { en: "Sign out" },
   "sessions.mine.revoke.confirm": { en: "Sign this device out?" },
   "sessions.mine.revokeAllOthers": { en: "Sign out all other devices" },

package/packages/bundled-features/src/sessions/web/index.ts

@@ -0,0 +1 @@
+export { type SessionsClientOptions, sessionsClient } from "./client-plugin.tsx";

package/packages/bundled-features/src/sessions/web/session-device-cell.tsx

@@ -0,0 +1,19 @@
+// Column renderer for the parsed `device` of a session row, registered via `sessionsClient()`.
+
+import { type ColumnRendererProps, useTranslation } from "@cosmicdrift/kumiko-renderer";
+import type { ReactNode } from "react";
+import { parsedDeviceSchema } from "./user-agent.ts";
+
+export function SessionDeviceCell({ value }: ColumnRendererProps): ReactNode {
+  const t = useTranslation();
+  const parsed = parsedDeviceSchema.safeParse(value);
+  const device = parsed.success ? parsed.data : null;
+  if (device === null) return t("sessions.device.unknown");
+  const browser =
+    device.browser === null
+      ? null
+      : device.browserMajor === null
+        ? device.browser
+        : `${device.browser} ${device.browserMajor}`;
+  return [browser, device.os].filter((part) => part !== null).join(" · ");
+}

package/packages/bundled-features/src/sessions/web/user-agent.ts

@@ -0,0 +1,74 @@
+import * as z from "zod";
+
+export const USER_AGENT_BROWSERS = [
+  "Edge",
+  "Opera",
+  "Samsung Internet",
+  "Firefox",
+  "Chrome",
+  "Safari",
+] as const;
+export const USER_AGENT_OPERATING_SYSTEMS = [
+  "Windows",
+  "iOS",
+  "Android",
+  "macOS",
+  "ChromeOS",
+  "Linux",
+] as const;
+
+export type UserAgentBrowser = (typeof USER_AGENT_BROWSERS)[number];
+export type UserAgentOperatingSystem = (typeof USER_AGENT_OPERATING_SYSTEMS)[number];
+
+export const parsedDeviceSchema = z
+  .object({
+    browser: z.enum(USER_AGENT_BROWSERS).nullable(),
+    browserMajor: z.number().int().nullable(),
+    os: z.enum(USER_AGENT_OPERATING_SYSTEMS).nullable(),
+  })
+  .nullable();
+
+export type ParsedDevice = z.infer<typeof parsedDeviceSchema>;
+
+// Order matters: Chromium forks and iOS Chrome/Firefox also carry the engine tokens of the browsers they derive from.
+const BROWSER_PATTERNS: readonly {
+  readonly browser: UserAgentBrowser;
+  readonly pattern: RegExp;
+}[] = [
+  { browser: "Edge", pattern: /\bEdg(?:e|A|iOS)?\/(\d+)/ },
+  { browser: "Opera", pattern: /\bOPR\/(\d+)/ },
+  { browser: "Samsung Internet", pattern: /\bSamsungBrowser\/(\d+)/ },
+  { browser: "Firefox", pattern: /\b(?:Firefox|FxiOS)\/(\d+)/ },
+  { browser: "Chrome", pattern: /\b(?:Chrome|CriOS)\/(\d+)/ },
+  { browser: "Safari", pattern: /\bVersion\/(\d+)[\s\S]*\bSafari\// },
+];
+
+// iPhone/iPad UAs say "like Mac OS X" and Android UAs say "Linux", so the more specific systems come first.
+const OPERATING_SYSTEM_PATTERNS: readonly {
+  readonly os: UserAgentOperatingSystem;
+  readonly pattern: RegExp;
+}[] = [
+  { os: "Windows", pattern: /\bWindows\b/ },
+  { os: "iOS", pattern: /\b(?:iPhone|iPad|iPod)\b/ },
+  { os: "Android", pattern: /\bAndroid\b/ },
+  { os: "macOS", pattern: /\bMacintosh\b/ },
+  { os: "ChromeOS", pattern: /\bCrOS\b/ },
+  { os: "Linux", pattern: /\bLinux\b/ },
+];
+
+export function parseUserAgent(userAgent: string | null): ParsedDevice {
+  if (userAgent === null || userAgent === "") return null;
+  let browser: UserAgentBrowser | null = null;
+  let browserMajor: number | null = null;
+  for (const candidate of BROWSER_PATTERNS) {
+    const match = candidate.pattern.exec(userAgent);
+    if (match) {
+      browser = candidate.browser;
+      browserMajor = match[1] === undefined ? null : Number(match[1]);
+      break;
+    }
+  }
+  const os =
+    OPERATING_SYSTEM_PATTERNS.find((candidate) => candidate.pattern.test(userAgent))?.os ?? null;
+  return browser === null && os === null ? null : { browser, browserMajor, os };
+}

package/packages/bundled-features/src/template-resolver/changes.json

@@ -1,4 +1,10 @@
 [
+  {
+    "version": "0.384.0",
+    "type": "improvement",
+    "title": "Template overview reports tenant overrides per template",
+    "detail": "template-resolver has a SystemAdmin query tenant-override-counts, and the overview rows for system templates carry overriddenBy { active, total } for SystemAdmins. The designer's overview reads it instead of issuing one tenant-overrides query per row. Reading it uses a declared unsafeRaw escape hatch because it counts across tenants."
+  },
   {
     "version": "0.379.0",
     "type": "improvement",

package/packages/bundled-features/src/template-resolver/feature.ts

@@ -31,6 +31,7 @@ import { makeResourceUploadWrite } from "./handlers/resource-upload.write.ts";
 import { makeSendTestWrite } from "./handlers/send-test.write.ts";
 import { sendTestStatusQuery } from "./handlers/send-test-status.query.ts";
 import { makeSetWrite } from "./handlers/set.write.ts";
+import { tenantOverrideCountsQuery } from "./handlers/tenant-override-counts.query.ts";
 import { tenantOverridesQuery } from "./handlers/tenant-overrides.query.ts";
 import {
   makeArchiveSystemWrite,
@@ -184,6 +185,7 @@ export function createTemplateResolverFeature(opts: TemplateResolverOptions = {}
       overview: r.queryHandler(makeOverviewQuery(policy)),
       layoutSource: r.queryHandler(layoutSourceQuery),
       tenantOverrides: r.queryHandler(tenantOverridesQuery),
+      tenantOverrideCounts: r.queryHandler(tenantOverrideCountsQuery),
       diffToSystem: r.queryHandler(diffToSystemQuery),
       validate: r.queryHandler(validateQuery),
       preview: r.queryHandler(previewQuery),

package/packages/bundled-features/src/template-resolver/handlers/overview.query.ts

@@ -12,6 +12,7 @@ import {
   activeVersionOf,
   draftViewerTenantId,
   isHiddenSystemDraft,
+  isSystemAdmin,
   parseTemplateDraft,
   servedVersionOf,
 } from "../template-draft.ts";
@@ -23,7 +24,9 @@ import {
   FALLBACK_LOCALE,
   type TemplateStatus,
 } from "../web/constants.ts";
+import { TemplateResolverQueries } from "../web/qualified-names.ts";
 import { storedRecord } from "./template-gates.ts";
+import { tenantOverrideCountsResultSchema } from "./tenant-override-counts.query.ts";
 
 const OVERVIEW_KINDS = ["mail", "document-pdf", "mail-layout", "pdf-layout"] as const;
 type OverviewKind = (typeof OVERVIEW_KINDS)[number];
@@ -65,6 +68,8 @@ export type OverviewRow = {
   readonly modifiedAt: string;
   readonly usedBy: readonly OverviewUsage[];
   readonly usedByCount: number;
+  /** SystemAdmin only, system-origin rows: tenants overriding this template; total is null without the tenant feature. */
+  readonly overriddenBy?: { readonly active: number; readonly total: number | null };
 };
 
 export type OverviewResponse = {
@@ -308,6 +313,26 @@ function withUsage(
   return { ...draft, usedBy, usedByCount: usedBy.length };
 }
 
+function withOverriddenBy(
+  rows: readonly OverviewRow[],
+  overrides: z.infer<typeof tenantOverrideCountsResultSchema>,
+): OverviewRow[] {
+  const activeByKey = new Map(
+    overrides.counts.map((entry) => [`${entry.kind}|${entry.slug}`, entry.activeOverrides]),
+  );
+  return rows.map((row) =>
+    row.origin === "system"
+      ? {
+          ...row,
+          overriddenBy: {
+            active: activeByKey.get(`${row.kind}|${row.slug}`) ?? 0,
+            total: overrides.totalTenants,
+          },
+        }
+      : row,
+  );
+}
+
 function filterRows(
   rows: readonly OverviewRow[],
   search: string | undefined,
@@ -373,9 +398,17 @@ export function makeOverviewQuery(policy: TemplateEditPolicy) {
         deliveryPolicy,
       );
       const effectiveLayouts = effectiveMailLayoutSlugs(visibleRows, deliveryPolicy);
-      const overviewRows = drafts.map((draft) =>
+      const rowsWithUsage = drafts.map((draft) =>
         withUsage(draft, layoutSlugByDocument, ctx.registry, effectiveLayouts),
       );
+      const overviewRows = isSystemAdmin(query.user)
+        ? withOverriddenBy(
+            rowsWithUsage,
+            tenantOverrideCountsResultSchema.parse(
+              await ctx.query(TemplateResolverQueries.tenantOverrideCounts, {}),
+            ),
+          )
+        : rowsWithUsage;
       const filtered = filterRows(
         overviewRows,
         payload.search,

package/packages/bundled-features/src/template-resolver/handlers/tenant-override-counts.query.ts

@@ -0,0 +1,53 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/db";
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { type TemplateResourceRow, templateResourcesTable } from "../table.ts";
+import {
+  loadEnabledTenantIds,
+  pickBestRowPerTenant,
+  TENANT_OVERRIDES_REASON,
+} from "./tenant-override-selection.ts";
+
+export const tenantOverrideCountsResultSchema = z.object({
+  totalTenants: z.number().nullable(),
+  counts: z.array(z.object({ slug: z.string(), kind: z.string(), activeOverrides: z.number() })),
+});
+
+export const tenantOverrideCountsQuery = defineQueryHandler({
+  name: "tenant-override-counts",
+  schema: z.object({}),
+  access: { roles: ["SystemAdmin"] },
+  description:
+    "Counts, per template slug and kind, the enabled tenants that override it with an active version, next to the number of enabled tenants; one query for the whole template overview instead of one tenant-overrides call per row.",
+  escapeHatch: { grants: ["unsafeRaw"], reason: TENANT_OVERRIDES_REASON },
+  handler: async (_query, ctx) => {
+    const found = await selectMany<TemplateResourceRow>(
+      ctx.db.unsafeRaw(),
+      templateResourcesTable,
+      {
+        scope: "tenant",
+      },
+    );
+    const enabledTenantIds = await loadEnabledTenantIds(ctx);
+
+    const rowsBySlugAndKind = new Map<
+      string,
+      { slug: string; kind: string; rows: TemplateResourceRow[] }
+    >();
+    for (const row of found) {
+      const key = `${row.kind}|${row.slug}`;
+      const group = rowsBySlugAndKind.get(key) ?? { slug: row.slug, kind: row.kind, rows: [] };
+      group.rows.push(row);
+      rowsBySlugAndKind.set(key, group);
+    }
+    const counts = [...rowsBySlugAndKind.values()].map(({ slug, kind, rows }) => ({
+      slug,
+      kind,
+      activeOverrides: [...pickBestRowPerTenant(rows, enabledTenantIds).values()].filter(
+        (row) => row.status === "active",
+      ).length,
+    }));
+
+    return { totalTenants: enabledTenantIds === null ? null : enabledTenantIds.size, counts };
+  },
+});

package/packages/bundled-features/src/template-resolver/handlers/tenant-override-selection.ts

@@ -0,0 +1,51 @@
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { TenantQueries } from "../../tenant/index.ts";
+import type { TemplateResourceRow } from "../table.ts";
+
+export const TENANT_OVERRIDES_REASON =
+  "SystemAdmin template overview lists which tenants override one system template; it reads tenant-scope template rows of every tenant (and the system row for the optional per-tenant diff), which the tenant-scoped db cannot reach";
+
+const tenantIdsSchema = z.array(z.string());
+
+type TenantIdQueryContext = {
+  readonly registry: { getQueryHandler(name: string): unknown };
+  readonly query: (name: string, payload: Record<string, never>) => Promise<unknown>;
+};
+
+/** Null when the tenant feature is not installed: every tenant row then counts. */
+export async function loadEnabledTenantIds(
+  ctx: TenantIdQueryContext,
+): Promise<ReadonlySet<string> | null> {
+  if (ctx.registry.getQueryHandler(TenantQueries.activeTenantIds) === undefined) return null;
+  return new Set(tenantIdsSchema.parse(await ctx.query(TenantQueries.activeTenantIds, {})));
+}
+
+// One row per tenant: its active override wins over a draft, then the newest version.
+function isBetterRow(candidate: TemplateResourceRow, current: TemplateResourceRow): boolean {
+  if ((candidate.status === "active") !== (current.status === "active")) {
+    return candidate.status === "active";
+  }
+  return candidate.version > current.version;
+}
+
+function isCountedTenantRow(
+  row: TemplateResourceRow,
+  enabledTenantIds: ReadonlySet<string> | null,
+): boolean {
+  if (row.tenantId === SYSTEM_TENANT_ID || row.status === "archived") return false;
+  return enabledTenantIds === null || enabledTenantIds.has(row.tenantId);
+}
+
+export function pickBestRowPerTenant(
+  found: readonly TemplateResourceRow[],
+  enabledTenantIds: ReadonlySet<string> | null,
+): Map<string, TemplateResourceRow> {
+  const bestByTenant = new Map<string, TemplateResourceRow>();
+  for (const row of found) {
+    if (!isCountedTenantRow(row, enabledTenantIds)) continue;
+    const current = bestByTenant.get(row.tenantId);
+    if (current === undefined || isBetterRow(row, current)) bestByTenant.set(row.tenantId, row);
+  }
+  return bestByTenant;
+}

package/packages/bundled-features/src/template-resolver/handlers/tenant-overrides.query.ts

@@ -6,11 +6,12 @@ import { type TemplateResourceRow, templateResourcesTable } from "../table.ts";
 import { servedVersionOf } from "../template-draft.ts";
 import { buildOverrideDiff } from "./override-diff.ts";
 import { kindSchema, localeSchema, templateSlugSchema } from "./shared.ts";
+import {
+  loadEnabledTenantIds,
+  pickBestRowPerTenant,
+  TENANT_OVERRIDES_REASON,
+} from "./tenant-override-selection.ts";
 
-const TENANT_OVERRIDES_REASON =
-  "SystemAdmin template overview lists which tenants override one system template; it reads tenant-scope template rows of every tenant (and the system row for the optional per-tenant diff), which the tenant-scoped db cannot reach";
-
-const tenantIdsSchema = z.array(z.string());
 const directorySchema = z.object({
   rows: z.array(z.object({ id: z.string(), label: z.string() })),
 });
@@ -21,39 +22,10 @@ function labelsOf(raw: unknown): ReadonlyMap<string, string> {
   return new Map(directorySchema.parse(raw).rows.map((row) => [row.id, row.label]));
 }
 
-// One row per tenant: its active override wins over a draft, then the newest version.
-function isBetterRow(candidate: TemplateResourceRow, current: TemplateResourceRow): boolean {
-  if ((candidate.status === "active") !== (current.status === "active")) {
-    return candidate.status === "active";
-  }
-  return candidate.version > current.version;
-}
-
 function statusOf(row: TemplateResourceRow): OverrideStatus {
   return row.status === "active" ? "active" : "draft";
 }
 
-function isCountedTenantRow(
-  row: TemplateResourceRow,
-  enabledTenantIds: ReadonlySet<string> | null,
-): boolean {
-  if (row.tenantId === SYSTEM_TENANT_ID || row.status === "archived") return false;
-  return enabledTenantIds === null || enabledTenantIds.has(row.tenantId);
-}
-
-function pickBestRowPerTenant(
-  found: readonly TemplateResourceRow[],
-  enabledTenantIds: ReadonlySet<string> | null,
-): Map<string, TemplateResourceRow> {
-  const bestByTenant = new Map<string, TemplateResourceRow>();
-  for (const row of found) {
-    if (!isCountedTenantRow(row, enabledTenantIds)) continue;
-    const current = bestByTenant.get(row.tenantId);
-    if (current === undefined || isBetterRow(row, current)) bestByTenant.set(row.tenantId, row);
-  }
-  return bestByTenant;
-}
-
 function toOverrideRow(
   row: TemplateResourceRow,
   tenantLabels: ReadonlyMap<string, string>,
@@ -95,11 +67,8 @@ export const tenantOverridesQuery = defineQueryHandler({
       ...(locale === undefined ? {} : { locale }),
     });
 
-    const hasTenantFeature =
-      ctx.registry.getQueryHandler(TenantQueries.activeTenantIds) !== undefined;
-    const enabledTenantIds = hasTenantFeature
-      ? new Set(tenantIdsSchema.parse(await ctx.query(TenantQueries.activeTenantIds, {})))
-      : null;
+    const enabledTenantIds = await loadEnabledTenantIds(ctx);
+    const hasTenantFeature = enabledTenantIds !== null;
 
     const bestByTenant = pickBestRowPerTenant(found, enabledTenantIds);
     const best = [...bestByTenant.values()];

package/packages/bundled-features/src/template-resolver/web/qualified-names.ts

@@ -29,6 +29,7 @@ export const TemplateResolverQueries = {
   overview: "template-resolver:query:overview",
   layoutSource: "template-resolver:query:layout-source",
   tenantOverrides: "template-resolver:query:tenant-overrides",
+  tenantOverrideCounts: "template-resolver:query:tenant-override-counts",
   diffToSystem: "template-resolver:query:diff-to-system",
   validate: "template-resolver:query:validate",
   preview: "template-resolver:query:preview",

package/packages/bundled-features/src/user-data-rights/changes.json

@@ -1,4 +1,22 @@
 [
+  {
+    "version": "0.384.0",
+    "type": "fix",
+    "title": "privacy center boot test fixture declares a field stance",
+    "detail": "Test-only change. Two changes merged back to back on main: one added the privacy center deletion test with plain text fixture fields, the other made a personal-data stance mandatory on entity text fields. The fixture fields now state allowPlaintext, so the framework type check passes again."
+  },
+  {
+    "version": "0.384.0",
+    "type": "fix",
+    "title": "Privacy center keeps the deletion section and speaks to the user",
+    "detail": "The deletion section only held a conditional field and the request-deletion and cancel-deletion actions, so the renderer dropped it as empty. It now stays whenever it has a visible action. The subtitle is written for the person on the page and names Art. 20, 18 and (when deletion is configured) 17."
+  },
+  {
+    "version": "0.384.0",
+    "type": "improvement",
+    "title": "Privacy center subtitle no longer mentions deletion when it is hidden",
+    "detail": "With privacyCenterShowDeletion false the screen description uses the new key userDataRights.privacyCenter.subtitleWithoutDeletion (English, German, French, Spanish and Italian provided) instead of the text that names Art. 17."
+  },
   {
     "version": "0.379.0",
     "type": "improvement",