@cosmicdrift/kumiko-bundled-features 0.174.0 → 0.176.0

package/src/template-resolver/feature.ts

@@ -1,6 +1,9 @@
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { bySlugQuery } from "./handlers/by-slug.query";
+import { byTenantQuery } from "./handlers/by-tenant.query";
 import { findByIdQuery } from "./handlers/find-by-id.query";
 import { listQuery } from "./handlers/list.query";
+import { setWrite } from "./handlers/set.write";
 import { archiveWrite, publishWrite } from "./handlers/toggle-status.write";
 import { upsertSystemWrite } from "./handlers/upsert-system.write";
 import { upsertTenantWrite } from "./handlers/upsert-tenant.write";
@@ -31,13 +34,25 @@ export function createTemplateResolverFeature() {
       upsertTenant: r.writeHandler(upsertTenantWrite),
       publish: r.writeHandler(publishWrite),
       archive: r.writeHandler(archiveWrite),
+      set: r.writeHandler(setWrite),
     };
 
     const queries = {
       findById: r.queryHandler(findByIdQuery),
       list: r.queryHandler(listQuery),
+      bySlug: r.queryHandler(bySlugQuery),
+      byTenant: r.queryHandler(byTenantQuery),
     };
 
-    return { handlers, queries };
+    // Visual-tree actions for the text-block content tree. The handle is
+    // propagated through the setup export so other features can build
+    // compile-time-typed cross-feature edit targets.
+    const treeHandle = r.treeActions({
+      edit: { args: { slug: "" as string, locale: "" as string } },
+      list: {},
+      create: { args: { folder: "" as string } },
+    });
+
+    return { handlers, queries, treeHandle };
   });
 }

package/src/template-resolver/handlers/by-slug.query.ts

@@ -0,0 +1,54 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import {
+  crossTenantOverrideDenied,
+  defineQueryHandler,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { z } from "zod";
+import { TEXT_BLOCK_KIND } from "../constants";
+import { type TemplateResourceRow, templateResourcesTable } from "../table";
+
+// Public read of a single text-block by (tenantId, slug, locale). Anonymous
+// must be listed explicitly — `openToAll` alone is auth-only (regression
+// guard). The kind is pinned to `text-block`: mail templates and AI prompts
+// live in the same table and must not be readable without a session.
+//
+// Tenant scope defaults to query.user.tenantId (an anonymous context resolves
+// to SYSTEM_TENANT_ID or the host-resolved tenant, depending on app setup).
+// Optional `tenantIdOverride` (SystemAdmin-only) allows a cross-tenant read —
+// symmetric to set.write.
+export const bySlugQuery = defineQueryHandler({
+  name: "by-slug",
+  schema: z.object({
+    slug: z.string().min(1).max(80),
+    locale: z.string().min(2).max(8),
+    /** Optional cross-tenant read — SystemAdmin only. See set.write.ts. */
+    tenantIdOverride: z.string().min(1).optional(),
+  }),
+  access: { roles: ["anonymous", "User", "TenantAdmin", "SystemAdmin"] },
+  handler: async (query, ctx) => {
+    const override = query.payload.tenantIdOverride;
+    const overrideDenied = crossTenantOverrideDenied(
+      query.user,
+      override,
+      "templateResolver.errors.tenantOverrideRequiresSystemAdmin",
+    );
+    if (overrideDenied) throw overrideDenied;
+    const tenantId = override ?? query.user.tenantId;
+    const row = await fetchOne<TemplateResourceRow>(ctx.db, templateResourcesTable, {
+      tenantId,
+      slug: query.payload.slug,
+      kind: TEXT_BLOCK_KIND,
+      locale: query.payload.locale,
+    });
+
+    if (!row) return null;
+    return {
+      slug: row.slug,
+      locale: row.locale,
+      title: row.title,
+      content: row.content,
+      folder: row.folder,
+      updatedAt: row.updatedAt,
+    };
+  },
+});

package/src/template-resolver/handlers/by-tenant.query.ts

@@ -0,0 +1,57 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { castTenantRows } from "@cosmicdrift/kumiko-framework/db";
+import {
+  crossTenantOverrideDenied,
+  defineQueryHandler,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { z } from "zod";
+import { TEXT_BLOCK_KIND } from "../constants";
+import { type TemplateResourceRow, templateResourcesTable } from "../table";
+
+// All text-blocks of one tenant — feeds the content tree sidebar. Anonymous
+// is listed explicitly so no-JWT visitors get the sidebar on public pages;
+// `kind` is pinned to text-block for the same reason as in by-slug.
+//
+// Unlike by-slug this returns summaries for every slug. The body travels along
+// because the tree marks empty blocks as stubs; full render content for a
+// single block still comes from by-slug.
+export type TextBlockSummary = {
+  readonly slug: string;
+  readonly locale: string;
+  readonly title: string | null;
+  readonly content: string | null;
+  readonly folder: string | null;
+  readonly updatedAt: Date;
+};
+
+export const byTenantQuery = defineQueryHandler({
+  name: "by-tenant",
+  schema: z.object({
+    /** Optional cross-tenant read — SystemAdmin only. Symmetric to by-slug. */
+    tenantIdOverride: z.string().min(1).optional(),
+  }),
+  access: { roles: ["anonymous", "User", "TenantAdmin", "SystemAdmin"] },
+  handler: async (query, ctx) => {
+    const override = query.payload.tenantIdOverride;
+    const overrideDenied = crossTenantOverrideDenied(
+      query.user,
+      override,
+      "templateResolver.errors.tenantOverrideRequiresSystemAdmin",
+    );
+    if (overrideDenied) throw overrideDenied;
+    const tenantId = override ?? query.user.tenantId;
+    const rows = castTenantRows<TemplateResourceRow>(
+      await selectMany(ctx.db, templateResourcesTable, { tenantId, kind: TEXT_BLOCK_KIND }),
+    );
+    return {
+      blocks: rows.map((row) => ({
+        slug: row.slug,
+        locale: row.locale,
+        title: row.title,
+        content: row.content,
+        folder: row.folder,
+        updatedAt: row.updatedAt,
+      })),
+    };
+  },
+});

package/src/template-resolver/handlers/set.write.ts

@@ -0,0 +1,110 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import {
+  crossTenantOverrideDenied,
+  defineWriteHandler,
+  SYSTEM_TENANT_ID,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import { z } from "zod";
+import { TEXT_BLOCK_KIND } from "../constants";
+import { type TemplateResourceRow, templateResourcesTable } from "../table";
+import { contentFormatSchema, executor, folderSchema, localeSchema, slugSchema } from "./shared";
+
+// Upsert of a single text-block, one operation per (tenantId, slug, locale).
+// This is the authoring path for kind=text-block: unlike upsertTenant it takes
+// a title and a folder, has no draft stage (text blocks are live when saved)
+// and it may write onto SYSTEM_TENANT_ID, which is where legal and marketing
+// copy lives. Cross-tenant writes are SystemAdmin-only.
+export const setWrite = defineWriteHandler({
+  name: "set",
+  schema: z.object({
+    slug: slugSchema,
+    locale: localeSchema,
+    title: z.string().min(1).max(200),
+    content: z.string().max(200_000).nullable(),
+    contentFormat: contentFormatSchema.default("markdown"),
+    /** Folder path for the content tree. Optional + null = root node. */
+    folder: folderSchema.nullable().optional(),
+    /** Optional cross-tenant write — SystemAdmin only. Typical use: the
+     *  editor lets a SystemAdmin write onto SYSTEM_TENANT_ID, otherwise the
+     *  text lands on their own platform tenant and the legal routes miss it. */
+    tenantIdOverride: z.string().min(1).optional(),
+  }),
+  // SystemAdmin is a global role, TenantAdmin is per tenant-membership — both
+  // paths are needed explicitly, otherwise nobody can set SYSTEM_TENANT texts.
+  access: { roles: ["TenantAdmin", "SystemAdmin"] },
+  handler: async (event, ctx) => {
+    const db = ctx.db;
+    const override = event.payload.tenantIdOverride;
+    const overrideDenied = crossTenantOverrideDenied(
+      event.user,
+      override,
+      "templateResolver.errors.tenantOverrideRequiresSystemAdmin",
+    );
+    if (overrideDenied) return writeFailure(overrideDenied);
+    // @cast-boundary engine-payload — override is a zod-validated string, the
+    // user's own tenantId is already TenantId-branded.
+    const tenantId = (override ?? event.user.tenantId) as TenantId;
+    // With an override the executor user has to move to the target tenant too,
+    // otherwise the event-store stream lookup runs against event.user.tenantId
+    // and reports a version conflict although the projection row exists.
+    const executorUser = override !== undefined ? { ...event.user, tenantId } : event.user;
+
+    const existing = await fetchOne<TemplateResourceRow>(db, templateResourcesTable, {
+      tenantId,
+      slug: event.payload.slug,
+      kind: TEXT_BLOCK_KIND,
+      locale: event.payload.locale,
+    });
+
+    const fields = {
+      slug: event.payload.slug,
+      kind: TEXT_BLOCK_KIND,
+      locale: event.payload.locale,
+      title: event.payload.title,
+      content: event.payload.content,
+      contentFormat: event.payload.contentFormat,
+      folder: event.payload.folder ?? null,
+      variableSchema: "{}",
+      linkedResources: "{}",
+      scope: tenantId === SYSTEM_TENANT_ID ? ("system" as const) : ("tenant" as const),
+      parentTemplateId: null,
+      // Text blocks have no draft stage — saving publishes, so resolveTemplate
+      // (which only returns active rows) finds them.
+      status: "active" as const,
+    };
+
+    if (existing) {
+      const result = await executor.update(
+        {
+          id: existing.id,
+          version: existing.version,
+          // Only the editable columns — slug/kind/locale are the unique key,
+          // and rewriting scope/status/variableSchema here would reset whatever
+          // the template upserts put on the row.
+          changes: {
+            title: fields.title,
+            content: fields.content,
+            contentFormat: fields.contentFormat,
+            folder: fields.folder,
+          },
+        },
+        executorUser,
+        db,
+      );
+      if (!result.isSuccess) return result;
+      return {
+        isSuccess: true as const,
+        data: { slug: event.payload.slug, locale: event.payload.locale, isNew: false },
+      };
+    }
+
+    const result = await executor.create({ ...fields, tenantId }, executorUser, db);
+    if (!result.isSuccess) return result;
+    return {
+      isSuccess: true as const,
+      data: { slug: event.payload.slug, locale: event.payload.locale, isNew: true },
+    };
+  },
+});

package/src/template-resolver/handlers/shared.ts

@@ -1,6 +1,6 @@
 import { createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
 import { z } from "zod";
-import { CONTENT_FORMATS, RENDER_KINDS, TEMPLATE_STATUSES } from "../constants";
+import { CONTENT_FORMATS, TEMPLATE_STATUSES, UPSERT_KINDS } from "../constants";
 import { templateResourceEntity, templateResourcesTable } from "../table";
 
 // Single executor pro Bundle — Pattern aus text-content. Wird von allen
@@ -23,7 +23,16 @@ export const localeSchema = z
   .max(8)
   .regex(/^[a-z]{2}(-[a-z]{2})?$/i, "locale must be ISO 639-1 (e.g. de, en, en-us)");
 
-export const kindSchema = z.enum(RENDER_KINDS);
+export const kindSchema = z.enum(UPSERT_KINDS);
+
+// Folder path for the content tree: kebab segments joined by `/`.
+export const folderSchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[a-z0-9][a-z0-9-]*(\/[a-z0-9][a-z0-9-]*)*$/, "folder must be kebab-case path");
+
+export const titleSchema = z.string().min(1).max(200);
 export const contentFormatSchema = z.enum(CONTENT_FORMATS);
 export const statusSchema = z.enum(TEMPLATE_STATUSES);
 
@@ -38,4 +47,6 @@ export const upsertPayloadSchema = z.object({
   variableSchema: z.record(z.string(), z.unknown()).default({}),
   linkedResources: z.record(z.string(), z.string()).default({}),
   parentTemplateId: z.string().min(1).optional(),
+  title: titleSchema.nullable().optional(),
+  folder: folderSchema.nullable().optional(),
 });

package/src/template-resolver/handlers/upsert-system.write.ts

@@ -41,6 +41,8 @@ export const upsertSystemWrite = defineWriteHandler({
       contentFormat: event.payload.contentFormat,
       variableSchema: JSON.stringify(event.payload.variableSchema),
       linkedResources: JSON.stringify(event.payload.linkedResources),
+      title: event.payload.title ?? null,
+      folder: event.payload.folder ?? null,
       scope: "system" as const,
       parentTemplateId: event.payload.parentTemplateId ?? null,
       // System-Defaults sind sofort active (kein draft-Stage für seeds).

package/src/template-resolver/handlers/upsert-tenant.write.ts

@@ -65,6 +65,8 @@ export const upsertTenantWrite = defineWriteHandler({
       contentFormat: event.payload.contentFormat,
       variableSchema: JSON.stringify(event.payload.variableSchema),
       linkedResources: JSON.stringify(event.payload.linkedResources),
+      title: event.payload.title ?? null,
+      folder: event.payload.folder ?? null,
       scope: "tenant" as const,
       parentTemplateId: event.payload.parentTemplateId ?? null,
       status: event.payload.status,

package/src/template-resolver/index.ts

@@ -10,13 +10,20 @@ export {
   CONTENT_FORMATS,
   type ContentFormat,
   FALLBACK_LOCALE,
+  NON_RENDER_KINDS,
+  type NonRenderKind,
   RENDER_KINDS,
   type RenderKind,
   SYSTEM_TENANT_ID,
+  TEMPLATE_KINDS,
   TEMPLATE_SCOPES,
   TEMPLATE_STATUSES,
+  TEXT_BLOCK_KIND,
+  type TemplateKind,
   type TemplateScope,
   type TemplateStatus,
+  UPSERT_KINDS,
+  type UpsertKind,
 } from "./constants";
 export { createTemplateResolverFeature } from "./feature";
 export {

package/src/template-resolver/qualified-names.ts

@@ -7,11 +7,14 @@ export const TemplateResolverHandlers = {
   upsertTenant: "template-resolver:write:upsert-tenant",
   publish: "template-resolver:write:publish",
   archive: "template-resolver:write:archive",
+  set: "template-resolver:write:set",
 } as const;
 
 export const TemplateResolverQueries = {
   findById: "template-resolver:query:find-by-id",
   list: "template-resolver:query:list",
+  bySlug: "template-resolver:query:by-slug",
+  byTenant: "template-resolver:query:by-tenant",
 } as const;
 
 export const TemplateResolverErrors = {

package/src/template-resolver/seeding.ts

@@ -18,13 +18,13 @@ import {
   type TenantId,
 } from "@cosmicdrift/kumiko-framework/engine";
 import { runEventStoreSeed, type SeedIfExists } from "@cosmicdrift/kumiko-framework/seeding";
-import type { ContentFormat, RenderKind } from "./constants";
+import { type ContentFormat, TEXT_BLOCK_KIND, type UpsertKind } from "./constants";
 import { executor } from "./handlers/shared";
 import { type TemplateResourceRow, templateResourcesTable } from "./table";
 
 export type SeedSystemTemplateOptions = {
   readonly slug: string;
-  readonly kind: RenderKind;
+  readonly kind: UpsertKind;
   readonly locale: string;
   readonly content: string;
   readonly contentFormat: ContentFormat;
@@ -62,6 +62,8 @@ export async function seedSystemTemplate(
     contentFormat: opts.contentFormat,
     variableSchema,
     linkedResources,
+    title: null,
+    folder: null,
     scope: "system" as const,
     parentTemplateId,
     status: "active" as const,
@@ -94,3 +96,125 @@ export async function seedSystemTemplate(
     },
   });
 }
+
+export type SeedTextBlockOptions = {
+  readonly tenantId: TenantId;
+  readonly slug: string;
+  readonly locale: string;
+  readonly title: string;
+  readonly content?: string | null;
+  /** Folder path for the content tree; optional + null = root node. The seed
+   *  path skips slug/folder validation (system-trusted), but app builders
+   *  should stay kebab-only so set.write can overwrite the row later. */
+  readonly folder?: string | null;
+  readonly contentFormat?: ContentFormat;
+  readonly by?: SessionUser;
+  readonly ifExists?: SeedIfExists;
+};
+
+// Boot/test seed for kind=text-block. Same projection path as set.write,
+// without the access check. Default ifExists="skip".
+export async function seedTextBlock(
+  db: DbConnection,
+  opts: SeedTextBlockOptions,
+): Promise<{ id: string }> {
+  const by = opts.by ?? createSystemUser(opts.tenantId);
+  const tdb = createTenantDb(db, opts.tenantId, "system");
+
+  const existingRow = await fetchOne<TemplateResourceRow>(db, templateResourcesTable, {
+    tenantId: opts.tenantId,
+    slug: opts.slug,
+    kind: TEXT_BLOCK_KIND,
+    locale: opts.locale,
+  });
+  const existing = existingRow
+    ? { id: String(existingRow.id), version: existingRow.version }
+    : null;
+
+  const fields = {
+    slug: opts.slug,
+    kind: TEXT_BLOCK_KIND,
+    locale: opts.locale,
+    title: opts.title,
+    content: opts.content ?? null,
+    contentFormat: opts.contentFormat ?? ("markdown" as const),
+    folder: opts.folder ?? null,
+    variableSchema: "{}",
+    linkedResources: "{}",
+    scope: opts.tenantId === SYSTEM_TENANT_ID ? ("system" as const) : ("tenant" as const),
+    parentTemplateId: null,
+    status: "active" as const,
+  };
+
+  return runEventStoreSeed({
+    existing,
+    ifExists: opts.ifExists,
+    create: async () => {
+      const result = await executor.create({ ...fields, tenantId: opts.tenantId }, by, tdb);
+      if (!result.isSuccess) {
+        throw new Error(`seedTextBlock create failed: ${JSON.stringify(result)}`);
+      }
+      // @cast-boundary db-row — executor.create returns the inserted row from
+      // INSERT/RETURNING; id is guaranteed by the PK in the returning clause.
+      const data = result.data as Partial<TemplateResourceRow>;
+      if (data.id === undefined) {
+        throw new Error("seedTextBlock: executor.create did not return an id");
+      }
+      return { id: String(data.id) };
+    },
+    update: async (row) => {
+      // Skip no-op updates so a legal re-seed on every pod boot does not bump
+      // version/updatedAt (ETag, "last changed", event-store growth).
+      if (
+        existingRow?.title === fields.title &&
+        existingRow?.content === fields.content &&
+        existingRow?.folder === fields.folder
+      ) {
+        return { id: String(row.id) };
+      }
+      const result = await executor.update(
+        {
+          id: row.id,
+          version: row.version,
+          changes: { title: fields.title, content: fields.content, folder: fields.folder },
+        },
+        by,
+        tdb,
+      );
+      if (!result.isSuccess) {
+        throw new Error(`seedTextBlock update failed: ${JSON.stringify(result)}`);
+      }
+      return { id: String(row.id) };
+    },
+  });
+}
+
+export type LegalContentBlock = {
+  readonly slug: string;
+  readonly locale: string;
+  readonly title: string;
+  readonly content: string;
+};
+
+// Boot seed for legal/marketing copy from a JSON template. `ifExists: "update"`
+// is load-bearing: the template is authoritative — otherwise legally required
+// additions never reach rows that were seeded once.
+export async function seedLegalContentFromJson(
+  db: DbConnection,
+  blocks: readonly LegalContentBlock[],
+  opts: { readonly tenantId?: TenantId; readonly by?: SessionUser } = {},
+): Promise<void> {
+  const tenantId = opts.tenantId ?? (SYSTEM_TENANT_ID as TenantId);
+  const by = opts.by ?? createSystemUser(tenantId);
+  for (const block of blocks) {
+    await seedTextBlock(db, {
+      tenantId,
+      slug: block.slug,
+      locale: block.locale,
+      title: block.title,
+      content: block.content,
+      ifExists: "update",
+      by,
+    });
+  }
+}

package/src/template-resolver/table.ts

@@ -5,7 +5,7 @@ import {
   createSelectField,
   createTextField,
 } from "@cosmicdrift/kumiko-framework/engine";
-import { CONTENT_FORMATS, RENDER_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES } from "./constants";
+import { CONTENT_FORMATS, TEMPLATE_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES } from "./constants";
 
 // TemplateResource — strukturierte Template-Definition mit Tenant-
 // Override-Hierarchie, Locale-Fallback und Resource-Linking via
@@ -19,8 +19,15 @@ export const templateResourceEntity = createEntity({
   table: "read_template_resources",
   fields: {
     slug: createTextField({ required: true }),
-    kind: createSelectField({ required: true, options: [...RENDER_KINDS] }),
+    kind: createSelectField({ required: true, options: [...TEMPLATE_KINDS] }),
     locale: createTextField({ required: true }),
+    // Human-facing heading for kind="text-block" (legal pages, marketing
+    // copy). Nullable because render templates carry their subject inside
+    // the body; a NOT NULL here would break every existing mail row.
+    title: createTextField({}),
+    // Folder path for the content tree, `/`-separated ("page/marketing").
+    // null = root node.
+    folder: createTextField({}),
     // Template-body is authored by TenantAdmin/Operator (email-templates etc.),
     // business data — kein end-user UGC.
     content: createLongTextField({ allowPlaintext: "is-business-data" }),
@@ -52,6 +59,8 @@ export type TemplateResourceRow = {
   readonly slug: string;
   readonly kind: string;
   readonly locale: string;
+  readonly title: string | null;
+  readonly folder: string | null;
   readonly content: string | null;
   readonly contentFormat: string;
   readonly variableSchema: string | null;

package/src/{text-content → template-resolver}/web/__tests__/client-plugin.test.tsx

@@ -1,30 +1,30 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
 import type { TreeNode } from "@cosmicdrift/kumiko-framework/engine";
-import { textContentClient } from "../client-plugin";
+import { textBlocksClient } from "../client-plugin";
 
-// Deckt die drei neuen Migrations-Pfade (advisor-Gap): navId-Attach + SSE-
-// Entities, no-leak ohne navId (conditional-spread), und der Unwrap (Provider
-// emittiert die Folder/Leaves direkt, NICHT unter dem "Content"-Wrapper).
-// Der Provider fetcht → fetch wird gemockt.
+// Covers the three new migration paths (advisor gap): navId attach + SSE
+// entities, no-leak without navId (conditional spread), and the unwrap (the
+// provider emits the folder/leaves directly, NOT under the "Content" wrapper).
+// The provider fetches → fetch is mocked.
 
-describe("textContentClient — shape", () => {
+describe("textBlocksClient — shape", () => {
   test("ohne navId: kein navProvider/navEntities (no-leak), aber Resolver bleibt", () => {
-    const def = textContentClient();
-    expect(def.name).toBe("text-content");
+    const def = textBlocksClient();
+    expect(def.name).toBe("template-resolver");
     expect(def.navProviders).toBeUndefined();
     expect(def.navEntities).toBeUndefined();
-    expect(def.resolvers?.["text-content:edit"]).toBeDefined();
+    expect(def.resolvers?.["template-resolver:edit"]).toBeDefined();
   });
 
   test("mit navId: Provider + SSE-Entities unter exakt dieser QN", () => {
     const navId = "publicstatus:nav:content";
-    const def = textContentClient({ navId });
+    const def = textBlocksClient({ navId });
     expect(Object.keys(def.navProviders ?? {})).toEqual([navId]);
-    expect(def.navEntities?.[navId]).toEqual(["text-block"]);
+    expect(def.navEntities?.[navId]).toEqual(["template-resource"]);
   });
 });
 
-describe("textContentClient — Provider unwrappt den Content-Container", () => {
+describe("textBlocksClient — Provider unwrappt den Content-Container", () => {
   const origFetch = globalThis.fetch;
   afterEach(() => {
     globalThis.fetch = origFetch;
@@ -32,11 +32,18 @@ describe("textContentClient — Provider unwrappt den Content-Container", () =>
 
   test("emittiert Folder/Leaves direkt, kein 'Content'-Wrapper-Knoten", async () => {
     const blocks = [
-      { slug: "imprint", lang: "de", title: "Imprint", body: "x", folder: null, updatedAt: "" },
-      { slug: "hero", lang: "de", title: "Hero", body: null, folder: "page", updatedAt: "" },
+      {
+        slug: "imprint",
+        locale: "de",
+        title: "Imprint",
+        content: "x",
+        folder: null,
+        updatedAt: "",
+      },
+      { slug: "hero", locale: "de", title: "Hero", content: null, folder: "page", updatedAt: "" },
     ];
-    // Test-Mock-Grenze: bun-Mock deckt nicht die volle fetch-Signatur
-    // (preconnect etc.) — Double-Cast bewusst, nur dieser Test ruft fetch.
+    // Test-mock boundary: bun's mock doesn't cover the full fetch signature
+    // (preconnect etc.) — double-cast is deliberate, only this test calls fetch.
     globalThis.fetch = mock(
       async () =>
         new Response(JSON.stringify({ data: { blocks } }), {
@@ -46,19 +53,19 @@ describe("textContentClient — Provider unwrappt den Content-Container", () =>
     ) as unknown as typeof fetch;
 
     const navId = "x:nav:content";
-    const provider = textContentClient({ navId }).navProviders?.[navId];
+    const provider = textBlocksClient({ navId }).navProviders?.[navId];
     if (provider === undefined) throw new Error("provider missing");
 
     let emitted: readonly TreeNode[] | undefined;
     provider()((nodes) => {
       emitted = nodes;
     });
-    // fetch().then(...) ist async → eine Makrotask abwarten bis emit lief.
+    // fetch().then(...) is async → wait one macrotask until emit has run.
     await new Promise((r) => setTimeout(r, 0));
 
     expect(emitted).toBeDefined();
     const labels = (emitted ?? []).map((n) => n.label).sort();
-    // Kein "Content"-Wrapper — root-leaf "Imprint" + folder "page" direkt.
+    // No "Content" wrapper — root-leaf "Imprint" + folder "page" directly.
     expect(labels).not.toContain("Content");
     expect(labels).toEqual(["Imprint", "page"]);
   });