@cosmicdrift/kumiko-bundled-features 0.220.0 → 0.221.0

package/src/tags/__tests__/tag-screens.boot.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { validateBoot } from "@cosmicdrift/kumiko-framework/engine";
+import { TAGS_EDIT_SCREEN_ID, TAGS_SCREEN_ID } from "../constants";
+import { createTagsFeature } from "../feature";
+
+// QN convention: entityList loads tags:query:tag:list; entityEdit loads
+// tags:query:tag:detail and saves via tags:write:tag:{create,update,delete}.
+// Legacy create-tag/update-tag/delete-tag stay registered for TagManager.
+
+describe("tags catalog screens (entityList + entityEdit)", () => {
+  const feature = createTagsFeature();
+
+  test("boot-validates with declarative tag-list + tag-edit", () => {
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("tag-list is entityList gated by default tag roles", () => {
+    const list = feature.screens[TAGS_SCREEN_ID];
+    expect(list?.type).toBe("entityList");
+    expect(list?.access).toEqual({ roles: ["TenantAdmin", "TenantMember"] });
+  });
+
+  test("tag-edit is entityEdit with matching access", () => {
+    const edit = feature.screens[TAGS_EDIT_SCREEN_ID];
+    expect(edit?.type).toBe("entityEdit");
+    expect(edit?.access).toEqual({ roles: ["TenantAdmin", "TenantMember"] });
+  });
+
+  test("convention handlers sit beside legacy create-tag/update-tag/delete-tag", () => {
+    expect(Object.keys(feature.writeHandlers)).toEqual(
+      expect.arrayContaining([
+        "create-tag",
+        "update-tag",
+        "delete-tag",
+        "tag:create",
+        "tag:update",
+        "tag:delete",
+      ]),
+    );
+    expect(Object.keys(feature.queryHandlers)).toEqual(
+      expect.arrayContaining(["tag:list", "tag:detail", "tag-assignment:list"]),
+    );
+  });
+
+  test("createTagsFeature({ roles }) threads access onto both screens", () => {
+    const custom = createTagsFeature({ roles: ["Admin"] });
+    expect(custom.screens[TAGS_SCREEN_ID]?.access).toEqual({ roles: ["Admin"] });
+    expect(custom.screens[TAGS_EDIT_SCREEN_ID]?.access).toEqual({ roles: ["Admin"] });
+    expect(custom.writeHandlers["tag:delete"]?.access).toEqual({ roles: ["Admin"] });
+  });
+});

package/src/tags/constants.ts

@@ -25,9 +25,10 @@ export const TAGS_FILTER_EXTENSION_NAME = "TagFilter";
 // after mounting tagsClient() (which registers it under clientFeatures.columnRenderers).
 export const TAGS_COLUMN_RENDERER_NAME = "TagsCell";
 
-// Screen-id of the standalone Tags management screen (custom screen rendering
-// TagManager). Qualified = "tags:screen:tag-list"; the app places it via r.nav.
+// Screen-ids for the declarative tag catalog (entityList + entityEdit).
+// Qualified list = "tags:screen:tag-list"; the app places it via r.nav.
 export const TAGS_SCREEN_ID = "tag-list";
+export const TAGS_EDIT_SCREEN_ID = "tag-edit";
 
 // Qualified handler names (QN format: scope:type:name). Clients reference the
 // object instead of magic strings (mirror custom-fields' Handlers/Queries).

package/src/tags/entity.ts

@@ -15,6 +15,8 @@ export const tagEntity = createEntity({
     name: createTextField({
       required: true,
       maxLength: 64,
+      sortable: true,
+      searchable: true,
       personal: false,
       reason: "catalog_label",
     }),

package/src/tags/feature.ts

@@ -14,15 +14,19 @@
 //
 // Handlers: create-tag, update-tag (rename/recolor/re-scope), delete-tag
 // (cascades over assignments), assign-tag, remove-tag, list tags, list assignments.
+// Convention aliases tag:{create,update,delete} + tag:detail back the
+// entityList/entityEdit catalog screens (legacy QNs stay for TagManager).
 // Deferred: optional host-projection decoration (`wireTagsFor`), search indexing.
 
 import {
   type AccessRule,
+  defineEntityDetailHandler,
   defineEntityListHandler,
+  defineEntityUpdateHandler,
   defineFeature,
   type FeatureRegistrar,
 } from "@cosmicdrift/kumiko-framework/engine";
-import { DEFAULT_TAG_ACCESS, TAGS_FEATURE_NAME, TAGS_SCREEN_ID } from "./constants";
+import { DEFAULT_TAG_ACCESS, TAGS_FEATURE_NAME } from "./constants";
 import { tagAssignmentEntity, tagEntity } from "./entity";
 import { createAssignTagHandler } from "./handlers/assign-tag.write";
 import { createCreateTagHandler } from "./handlers/create-tag.write";
@@ -30,6 +34,7 @@ import { createDeleteTagHandler } from "./handlers/delete-tag.write";
 import { createRemoveTagHandler } from "./handlers/remove-tag.write";
 import { createUpdateTagHandler } from "./handlers/update-tag.write";
 import { TAGS_FEATURE_I18N } from "./i18n";
+import { createTagEditScreen, createTagListScreen } from "./screens";
 
 // Opt-in tier-gating: when set, the feature declares itself r.toggleable so the
 // dispatcher gate + feature-toggles + tier-engine can switch the WHOLE feature
@@ -45,7 +50,7 @@ function registerTags(
   toggleable: TagsToggleable | undefined,
 ): void {
   r.describe(
-    "Generic, host-agnostic tagging for any entity. Owns two event-sourced entities — the per-tenant `tag` catalog (`read_tags`, with optional `color` and `scope`) and `tag-assignment` join rows keyed by (entityType, entityId) (`read_tag_assignments`) — so tagging adds NO column to the host entity and needs no relational pivot or JOIN. Provides write-handlers `create-tag`, `update-tag` (optimistic-locked rename/recolor/re-scope), `delete-tag` (cascades over assignments), `assign-tag` (idempotent), `remove-tag` (idempotent) and list queries for the catalog and the assignments. Read which tags an entity has, or which entities carry a tag, by listing `tag-assignment` filtered on `entityId` or `tagId` and composing in the read-layer. A tag with empty `scope` is global; a `scope` of an entityType restricts it to that type in the picker. Every path uses one access rule — adopt the host's model with createTagsFeature({ access: { openToAll: true } }) or pin roles with createTagsFeature({ roles }). Pass { toggleable: { default: false } } to make the whole feature tier-gatable via the tier-engine (no host hook).",
+    "Generic, host-agnostic tagging for any entity. Owns two event-sourced entities — the per-tenant `tag` catalog (`read_tags`, with optional `color` and `scope`) and `tag-assignment` join rows keyed by (entityType, entityId) (`read_tag_assignments`) — so tagging adds NO column to the host entity and needs no relational pivot or JOIN. Catalog screens are declarative (`entityList` + `entityEdit`) and use convention QNs `tag:{create,update,delete}`; TagManager/TagPicker keep `create-tag`/`update-tag`/`delete-tag`. Also: `assign-tag` (idempotent), `remove-tag` (idempotent) and list queries for the catalog and the assignments. Read which tags an entity has, or which entities carry a tag, by listing `tag-assignment` filtered on `entityId` or `tagId` and composing in the read-layer. A tag with empty `scope` is global; a `scope` of an entityType restricts it to that type in the picker. Every path uses one access rule — adopt the host's model with createTagsFeature({ access: { openToAll: true } }) or pin roles with createTagsFeature({ roles }). Pass { toggleable: { default: false } } to make the whole feature tier-gatable via the tier-engine (no host hook).",
   );
   r.uiHints({
     displayLabel: "Tags",
@@ -66,18 +71,22 @@ function registerTags(
   r.writeHandler(createAssignTagHandler(access));
   r.writeHandler(createRemoveTagHandler(access));
 
+  // Convention aliases for entityList/entityEdit — create stays flat-payload
+  // (payloadMode=values); update must accept the {id,version,changes} envelope
+  // entityEdit sends (legacy update-tag stays for TagManager). delete stays
+  // legacy so assignment cascade is preserved (convention delete would orphan).
+  r.writeHandler(createCreateTagHandler(access, "tag:create"));
+  r.writeHandler(defineEntityUpdateHandler("tag", tagEntity, { access }));
+  r.writeHandler(createDeleteTagHandler(access, "tag:delete"));
+
   r.queryHandler(defineEntityListHandler("tag", tagEntity, { access }));
   r.queryHandler(defineEntityListHandler("tag-assignment", tagAssignmentEntity, { access }));
+  r.queryHandler(defineEntityDetailHandler("tag", tagEntity, { access }));
 
-  // Standalone Tags management screen (custom React: TagManager). The app places
-  // it in nav via r.nav("tags:screen:tag-list"); tagsClient() maps the component.
-  // kumiko-lint-ignore app-feature-structure Phase-3 conversion tracked in #2312
-  r.screen({
-    id: TAGS_SCREEN_ID,
-    type: "custom",
-    renderer: { react: { __component: "TagsScreen" } },
-    access,
-  });
+  // Standalone catalog: entityList + entityEdit. App navs via
+  // r.nav("tags:screen:tag-list"). TagManager stays for picker/section only.
+  r.screen(createTagListScreen(access));
+  r.screen(createTagEditScreen(access));
   r.translations({ keys: TAGS_FEATURE_I18N });
 }
 

package/src/tags/handlers/create-tag.write.ts

@@ -7,9 +7,12 @@ import { type CreateTagPayload, createTagPayloadSchema } from "../schemas";
 // UUIDv7 id (no explicit id passed). Tag names are not unique by design: the
 // catalog is a free list and dedup is a UI concern (autocomplete from existing
 // tags). Editing is update-tag.write.ts; delete (with cascade) is delete-tag.write.ts.
-export function createCreateTagHandler(access: AccessRule = DEFAULT_TAG_ACCESS): WriteHandlerDef {
+export function createCreateTagHandler(
+  access: AccessRule = DEFAULT_TAG_ACCESS,
+  name = "create-tag",
+): WriteHandlerDef {
   return {
-    name: "create-tag",
+    name,
     schema: createTagPayloadSchema,
     access,
     handler: async (event, ctx) => {

package/src/tags/handlers/delete-tag.write.ts

@@ -16,9 +16,12 @@ const CASCADE_PAGE = 200;
 // hides isDeleted rows, so a keyset cursor over the shrinking result set would
 // silently skip rows. Re-reading the head always returns the remaining live
 // rows and terminates when none are left.
-export function createDeleteTagHandler(access: AccessRule = DEFAULT_TAG_ACCESS): WriteHandlerDef {
+export function createDeleteTagHandler(
+  access: AccessRule = DEFAULT_TAG_ACCESS,
+  name = "delete-tag",
+): WriteHandlerDef {
   return {
-    name: "delete-tag",
+    name,
     schema: deleteTagPayloadSchema,
     access,
     handler: async (event, ctx) => {

package/src/tags/handlers/update-tag.write.ts

@@ -8,9 +8,12 @@ import { type UpdateTagPayload, updateTagPayloadSchema } from "../schemas";
 // the fields present in the payload go into `changes`, and the executor merges
 // shallowly, so any omitted field is preserved (color/scope accept "" to clear).
 // A stale version returns version_conflict; the UI refetches and retries.
-export function createUpdateTagHandler(access: AccessRule = DEFAULT_TAG_ACCESS): WriteHandlerDef {
+export function createUpdateTagHandler(
+  access: AccessRule = DEFAULT_TAG_ACCESS,
+  name = "update-tag",
+): WriteHandlerDef {
   return {
-    name: "update-tag",
+    name,
     schema: updateTagPayloadSchema,
     access,
     handler: async (event, ctx) => {

package/src/tags/i18n.ts

@@ -2,4 +2,8 @@ type LocalizedString = { readonly en: string };
 
 export const TAGS_FEATURE_I18N: Readonly<Record<string, LocalizedString>> = {
   "screen:tag-list.title": { en: "Tags" },
+  "screen:tag-edit.title": { en: "Tag" },
+  "tags:entity:tag:field:name": { en: "Name" },
+  "tags:entity:tag:field:color": { en: "Color" },
+  "tags:entity:tag:field:scope": { en: "Scope" },
 };

package/src/tags/index.ts

@@ -3,6 +3,7 @@ export {
   DEFAULT_TAG_ACCESS,
   DEFAULT_TAG_ROLES,
   TAGS_COLUMN_RENDERER_NAME,
+  TAGS_EDIT_SCREEN_ID,
   TAGS_FEATURE_NAME,
   TAGS_FILTER_EXTENSION_NAME,
   TAGS_SCREEN_ID,
@@ -44,3 +45,4 @@ export {
   type UpdateTagPayload,
   updateTagPayloadSchema,
 } from "./schemas";
+export { createTagEditScreen, createTagListScreen } from "./screens";

package/src/tags/screens.ts

@@ -0,0 +1,66 @@
+import type {
+  AccessRule,
+  EntityEditScreenDefinition,
+  EntityListScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { DEFAULT_TAG_ACCESS, TAGS_EDIT_SCREEN_ID, TAGS_SCREEN_ID } from "./constants";
+
+// Declarative catalog screens (Phase-3 / #2312). Access matches create/update/
+// delete so createTagsFeature({ access|roles }) stays consistent. TagManager
+// remains for TagPicker/TagSection — only the standalone admin screen moved.
+
+export function createTagListScreen(
+  access: AccessRule = DEFAULT_TAG_ACCESS,
+): EntityListScreenDefinition {
+  return {
+    id: TAGS_SCREEN_ID,
+    type: "entityList",
+    entity: "tag",
+    columns: ["name", "color", "scope"],
+    defaultSort: { field: "name", dir: "asc" },
+    searchable: true,
+    rowActions: [
+      {
+        kind: "navigate",
+        id: "edit",
+        label: "kumiko.actions.edit",
+        screen: TAGS_EDIT_SCREEN_ID,
+        entityId: "id",
+      },
+      {
+        kind: "writeHandler",
+        id: "delete",
+        label: "kumiko.actions.delete",
+        // Convention QN — same cascade body as legacy tags:write:delete-tag.
+        handler: "tags:write:tag:delete",
+        payload: { pick: ["id"] },
+        confirm: "kumiko.actions.delete-confirm",
+        style: "danger",
+      },
+    ],
+    access,
+  };
+}
+
+export function createTagEditScreen(
+  access: AccessRule = DEFAULT_TAG_ACCESS,
+): EntityEditScreenDefinition {
+  return {
+    id: TAGS_EDIT_SCREEN_ID,
+    type: "entityEdit",
+    entity: "tag",
+    layout: {
+      sections: [
+        {
+          columns: 2,
+          fields: [
+            { field: "name", span: 2 },
+            { field: "color", span: 1 },
+            { field: "scope", span: 1 },
+          ],
+        },
+      ],
+    },
+    access,
+  };
+}

package/src/tags/web/client-plugin.tsx

@@ -5,12 +5,10 @@ import {
   TAGS_COLUMN_RENDERER_NAME,
   TAGS_FEATURE_NAME,
   TAGS_FILTER_EXTENSION_NAME,
-  TAGS_SCREEN_ID,
   TAGS_SECTION_EXTENSION_NAME,
 } from "../constants";
 import { defaultTranslations } from "./i18n";
 import { TagFilter } from "./tag-filter";
-import { TagManager } from "./tag-manager";
 import { TagSection } from "./tag-section";
 import { TagsCell } from "./tags-cell";
 
@@ -26,10 +24,7 @@ export function tagsClient(): ClientFeatureDefinition {
     columnRenderers: {
       [TAGS_COLUMN_RENDERER_NAME]: TagsCell,
     },
-    // Standalone Tags management screen (custom screen → TagManager).
-    components: {
-      [TAGS_SCREEN_ID]: TagManager,
-    },
+    // Catalog screen is declarative entityList — no custom TagsScreen mount.
     translations: defaultTranslations,
   };
 }

package/src/tags/web/index.ts

@@ -1,6 +1,7 @@
 // @runtime client
 export {
   TAGS_COLUMN_RENDERER_NAME,
+  TAGS_EDIT_SCREEN_ID,
   TAGS_FILTER_EXTENSION_NAME,
   TAGS_SCREEN_ID,
   TAGS_SECTION_EXTENSION_NAME,

package/src/template-resolver/__tests__/seed-legal-content.integration.test.ts

@@ -14,7 +14,12 @@ import {
 } from "@cosmicdrift/kumiko-framework/stack";
 import { TEXT_BLOCK_KIND } from "../constants";
 import { createTemplateResolverFeature } from "../feature";
-import { type LegalContentBlock, seedLegalContentFromJson } from "../seeding";
+import {
+  type LegalContentBlock,
+  type SeedSystemTemplateOptions,
+  seedLegalContentFromJson,
+  seedSystemTemplate,
+} from "../seeding";
 import { type TemplateResourceRow, templateResourceEntity, templateResourcesTable } from "../table";
 
 // Pins seedLegalContentFromJson: seeds into SYSTEM_TENANT_ID by default and
@@ -44,6 +49,15 @@ function read(slug: string, locale: string) {
   });
 }
 
+function readSystemTemplate(slug: string, locale: string, kind: SeedSystemTemplateOptions["kind"]) {
+  return fetchOne<TemplateResourceRow>(db, templateResourcesTable, {
+    tenantId: SYSTEM_TENANT_ID,
+    slug,
+    kind,
+    locale,
+  });
+}
+
 describe("seedLegalContentFromJson", () => {
   test("seeds all blocks into SYSTEM_TENANT_ID as SYSTEM_USER", async () => {
     const blocks: LegalContentBlock[] = [
@@ -82,6 +96,30 @@ describe("seedLegalContentFromJson", () => {
     expect(row.modifiedById).toBe(SYSTEM_USER_ID);
   });
 
+  test("re-seed of a healthy row (existing events) keeps id and appends, does not delete+recreate", async () => {
+    await seedLegalContentFromJson(db, [
+      { slug: "healthy-block", locale: "de", title: "Titel", content: "v1" },
+    ]);
+    const before = await read("healthy-block", "de");
+    expect(before).not.toBeNull();
+    const eventsBefore = await selectMany(db, eventsTable, { aggregateId: String(before!.id) });
+    expect(eventsBefore.map((e) => e.type)).toEqual(["template-resource.created"]);
+
+    await seedLegalContentFromJson(db, [
+      { slug: "healthy-block", locale: "de", title: "Titel", content: "v2" },
+    ]);
+
+    const after = await read("healthy-block", "de");
+    expect(after).not.toBeNull();
+    expect(after!.id).toBe(before!.id);
+    expect(after).toMatchObject({ content: "v2" });
+
+    const eventsAfter = await selectMany(db, eventsTable, { aggregateId: String(before!.id) });
+    expect(eventsAfter.filter((e) => e.type === "template-resource.created")).toHaveLength(1);
+    expect(eventsAfter.filter((e) => e.type === "template-resource.updated")).toHaveLength(1);
+    expect(eventsAfter).toHaveLength(2);
+  });
+
   test("orphan projection (row without events) is recreated on ifExists:update", async () => {
     await seedLegalContentFromJson(db, [
       { slug: "orphan-privacy", locale: "de", title: "DS", content: "old" },
@@ -108,6 +146,31 @@ describe("seedLegalContentFromJson", () => {
     expect(events.some((e) => e.type === "template-resource.created")).toBe(true);
   });
 
+  test("orphan projection (row without events) is recreated on ifExists:update — seedSystemTemplate path", async () => {
+    const opts: SeedSystemTemplateOptions = {
+      slug: "orphan-notification",
+      kind: "notification",
+      locale: "de",
+      content: "old",
+      contentFormat: "plain",
+      ifExists: "update",
+    };
+    await seedSystemTemplate(db, opts);
+    const before = await readSystemTemplate(opts.slug, opts.locale, opts.kind);
+    expect(before).not.toBeNull();
+
+    // Same desync as prod: projection left behind, event stream empty.
+    await deleteMany(db, eventsTable, { aggregateId: String(before!.id) });
+    expect(await readSystemTemplate(opts.slug, opts.locale, opts.kind)).not.toBeNull();
+
+    await seedSystemTemplate(db, { ...opts, content: "new from template" });
+    const after = await readSystemTemplate(opts.slug, opts.locale, opts.kind);
+    expect(after).toMatchObject({ content: "new from template" });
+    const events2 = await selectMany(db, eventsTable, { aggregateId: String(after!.id) });
+    expect(events2.length).toBeGreaterThan(0);
+    expect(events2.some((e) => e.type === "template-resource.created")).toBe(true);
+  });
+
   test("identical re-seed is a no-op (no update event, version/modifiedAt stable)", async () => {
     const blocks: LegalContentBlock[] = [
       { slug: "terms", locale: "de", title: "AGB", content: "stable" },

package/src/template-resolver/seeding.ts

@@ -15,6 +15,7 @@ import {
   type DbConnection,
   deleteMany,
   type EntityTableMeta,
+  type TenantDb,
 } from "@cosmicdrift/kumiko-framework/db";
 import {
   createSystemUser,
@@ -22,18 +23,19 @@ import {
   SYSTEM_TENANT_ID,
   type TenantId,
 } from "@cosmicdrift/kumiko-framework/engine";
-import { getStreamVersion } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  getStreamVersion,
+  getUnscopedStreamMaxVersionForSeed,
+} from "@cosmicdrift/kumiko-framework/event-store";
 import { runEventStoreSeed, type SeedIfExists } from "@cosmicdrift/kumiko-framework/seeding";
 import { type ContentFormat, TEXT_BLOCK_KIND, type UpsertKind } from "./constants";
 import { executor } from "./handlers/shared";
 import { type TemplateResourceRow, templateResourcesTable } from "./table";
 
-/** Projection row without events — update() would 409 (expectedVersion from
- *  projection, stream currentVersion=0). Drop the orphan and treat as create
- *  so boot seeds (legal ifExists:update) survive desync. Stream version is the
- *  optimistic-lock source of truth when events exist. */
+/** Drop projection orphans (no events anywhere) so boot seeds can recreate. */
 async function resolveExistingForEventStoreSeed(
   db: DbConnection,
+  tdb: TenantDb,
   existingRow: { readonly id: string | number; readonly version: number } | null,
   tenantId: TenantId,
 ): Promise<{ id: string; version: number } | null> {
@@ -41,7 +43,17 @@ async function resolveExistingForEventStoreSeed(
   const id = String(existingRow.id);
   const streamVersion = await getStreamVersion(db, id, tenantId);
   if (streamVersion === 0) {
-    await deleteMany(db, templateResourcesTable as EntityTableMeta, { id });
+    // Tenant-scoped 0 can still hide a live stream under another tenant —
+    // only delete when unscoped is also empty (true orphan).
+    const unscoped = await getUnscopedStreamMaxVersionForSeed(db, id);
+    if (unscoped !== 0) {
+      throw new Error(
+        `seed orphan check: projection ${id} has no events for tenant ${tenantId} but unscoped stream version is ${unscoped} — refusing delete/recreate to avoid wiping a live stream`,
+      );
+    }
+    // @cast-boundary orphan projection cleanup: empty stream, no executor verb;
+    // plain table ident trips guard-direct-entity-writes (infra EXCLUDE follow-up).
+    await deleteMany(tdb, templateResourcesTable as EntityTableMeta, { id, tenantId });
     return null;
   }
   return { id, version: streamVersion };
@@ -76,6 +88,7 @@ export async function seedSystemTemplate(
   });
   const existing = await resolveExistingForEventStoreSeed(
     db,
+    tdb,
     existingRow ? { id: existingRow.id, version: existingRow.version } : null,
     tenantId,
   );
@@ -105,6 +118,34 @@ export async function seedSystemTemplate(
     create: async () => {
       const result = await executor.create({ ...rowFields, tenantId }, by, tdb);
       if (!result.isSuccess) {
+        // Parallel boot pods can both delete the orphan and race on create —
+        // unique on (tenantId, slug, kind, locale) → resolve winner and update.
+        if (result.error?.code === "unique_violation") {
+          const again = await fetchOne<TemplateResourceRow>(db, templateResourcesTable, {
+            tenantId,
+            slug: opts.slug,
+            kind: opts.kind,
+            locale: opts.locale,
+          });
+          const resolved = await resolveExistingForEventStoreSeed(
+            db,
+            tdb,
+            again ? { id: again.id, version: again.version } : null,
+            tenantId,
+          );
+          if (resolved == null) {
+            throw new Error(`seedSystemTemplate create unique_violation but row missing`);
+          }
+          const upd = await executor.update(
+            { id: resolved.id, version: resolved.version, changes: rowFields },
+            by,
+            tdb,
+          );
+          if (!upd.isSuccess) {
+            throw new Error(`seedSystemTemplate race-update failed: ${JSON.stringify(upd)}`);
+          }
+          return { id: resolved.id };
+        }
         throw new Error(`seedSystemTemplate create failed: ${JSON.stringify(result)}`);
       }
       const data = result.data as Partial<TemplateResourceRow>;
@@ -159,6 +200,7 @@ export async function seedTextBlock(
   });
   const existing = await resolveExistingForEventStoreSeed(
     db,
+    tdb,
     existingRow ? { id: existingRow.id, version: existingRow.version } : null,
     opts.tenantId,
   );
@@ -184,6 +226,36 @@ export async function seedTextBlock(
     create: async () => {
       const result = await executor.create({ ...fields, tenantId: opts.tenantId }, by, tdb);
       if (!result.isSuccess) {
+        if (result.error?.code === "unique_violation") {
+          const again = await fetchOne<TemplateResourceRow>(db, templateResourcesTable, {
+            tenantId: opts.tenantId,
+            slug: opts.slug,
+            kind: TEXT_BLOCK_KIND,
+            locale: opts.locale,
+          });
+          const resolved = await resolveExistingForEventStoreSeed(
+            db,
+            tdb,
+            again ? { id: again.id, version: again.version } : null,
+            opts.tenantId,
+          );
+          if (resolved == null) {
+            throw new Error("seedTextBlock create unique_violation but row missing");
+          }
+          const upd = await executor.update(
+            {
+              id: resolved.id,
+              version: resolved.version,
+              changes: { title: fields.title, content: fields.content, folder: fields.folder },
+            },
+            by,
+            tdb,
+          );
+          if (!upd.isSuccess) {
+            throw new Error(`seedTextBlock race-update failed: ${JSON.stringify(upd)}`);
+          }
+          return { id: resolved.id };
+        }
         throw new Error(`seedTextBlock create failed: ${JSON.stringify(result)}`);
       }
       // @cast-boundary db-row — executor.create returns the inserted row from

package/src/template-resolver/web/__tests__/client-plugin.test.tsx

@@ -22,9 +22,9 @@ mock.module("@cosmicdrift/kumiko-bundled-features/auth-email-password/web", () =
   useShellUser: mock(),
 }));
 
-const actual_renderer = await import("@cosmicdrift/kumiko-renderer");
+const actualRenderer = await import("@cosmicdrift/kumiko-renderer");
 mock.module("@cosmicdrift/kumiko-renderer", () => ({
-  ...actual_renderer,
+  ...actualRenderer,
   useDispatcher: mock(() => ({ write: mock(), query: mock() })),
   useQuery: mock(() => ({
     data: {

package/src/template-resolver/web/client-plugin.tsx

@@ -32,6 +32,7 @@ import {
   PlainContentEditor,
   RichContentEditor,
 } from "@cosmicdrift/kumiko-renderer-web";
+import type { ContentEditorFormat } from "@cosmicdrift/kumiko-types/nav";
 import { type FormEvent, type ReactNode, useEffect, useId, useState } from "react";
 import {
   collectionHandlerName,
@@ -226,7 +227,7 @@ function findCollection(
 function findContentFormat(
   features: readonly FeatureSchema[],
   collectionId?: string,
-): string | undefined {
+): ContentEditorFormat | undefined {
   return findCollection(features, collectionId)?.contentFormat;
 }
 

package/src/tenant/__tests__/members-facet-i18n.test.ts

@@ -23,7 +23,30 @@ function membersFacetLabelKeys(): readonly string[] {
   );
 }
 
+// Column labels of the members screen itself — deliberately scoped to this
+// one screen, not a generic "walk every column of every screen" helper.
+function membersColumnLabelKeys(): readonly string[] {
+  const screen = createTenantFeature().screens[MEMBERS_SCREEN_ID];
+  if (screen?.type !== "projectionList") {
+    throw new Error("expected members screen to be projectionList");
+  }
+  return screen.columns.flatMap((col) =>
+    typeof col === "string" || col.label === undefined ? [] : [col.label],
+  );
+}
+
+// Nav-menu-entry label(s) that point at the members screen — same
+// single-screen scope as the facet/column helpers above.
+function membersNavLabelKeys(): readonly string[] {
+  const feature = createTenantFeature();
+  const membersScreenTarget = `${feature.name}:screen:${MEMBERS_SCREEN_ID}`;
+  return Object.values(feature.navs)
+    .filter((nav) => nav.screen === membersScreenTarget)
+    .map((nav) => nav.label);
+}
+
 const facetKeys = membersFacetLabelKeys();
+const membersScreenI18nKeys = [...facetKeys, ...membersColumnLabelKeys(), ...membersNavLabelKeys()];
 
 const localePacks: ReadonlyArray<readonly [string, Readonly<Record<string, string>>]> = [
   ["es", localeEsBundle],
@@ -31,12 +54,21 @@ const localePacks: ReadonlyArray<readonly [string, Readonly<Record<string, strin
 ];
 
 describe("members status filter labels are localized in every shipped locale (fw#2376)", () => {
-  test("the status facet ships the keys the locale packs have to cover", () => {
-    expect(facetKeys).toEqual([
-      "tenant.members.filter.status",
-      "tenant.members.filter.status.option.active",
-      "tenant.members.filter.status.option.pending",
-    ]);
+  // A hardcoded toEqual() array here would fail with a confusing "array
+  // mismatch" the moment a facet/column/nav-label key is added to the
+  // members screen — instead of the clear "key not translated" failure a
+  // missing en copy should produce. Reading the keys off the live screen
+  // definition and checking each one resolves catches the real failure
+  // mode (fw#2376) without hardcoding an ever-growing key list.
+  test("every facet/column/nav-label key of the members screen has English copy", () => {
+    expect(membersScreenI18nKeys.length).toBeGreaterThan(0);
+    const translations = createTenantFeature().translations ?? {};
+    for (const key of membersScreenI18nKeys) {
+      const label = translations[key]?.["en"];
+      expect(label).toBeString();
+      expect(label).not.toBe(key);
+      expect((label ?? "").trim()).not.toBe("");
+    }
   });
 
   test("every facet label has English copy in the tenant feature itself", () => {