@cosmicdrift/kumiko-samples 0.338.0

package/samples/apps/use-all-bundled/src/app/notes-feature.ts

@@ -0,0 +1,174 @@
+// @runtime dev
+//
+// Dev-/screenshot-only host entity for the tags, custom-fields, and folders
+// features. A plain `note` knows NOTHING about those bundles (no extra columns
+// for tags/folders) — yet its edit screen hosts the drop-in extension sections,
+// proving the "extend any object" promise on real, bootable screens.
+//
+// Deliberately NOT in src/run-config.ts APP_FEATURES: that set is bundled-only
+// (schema/generate.ts FEATURE_IMPORT_REGISTRY + check-coverage gate it). Like
+// appScreensFeature, this app-owned feature is mounted only in the dev server
+// (src/app/dev-app-options.ts), where runDevApp dev-pushes its table into the ephemeral
+// DB. Nothing here ships to prod / the schema pipeline.
+
+import {
+  customFieldsField,
+  wireCustomFieldsFor,
+} from "@cosmicdrift/kumiko-bundled-features/custom-fields";
+import { CUSTOM_FIELDS_FORM_EXTENSION_NAME } from "@cosmicdrift/kumiko-bundled-features/custom-fields/web";
+import { FOLDER_SECTION_EXTENSION_NAME } from "@cosmicdrift/kumiko-bundled-features/folders";
+import {
+  TAGS_COLUMN_RENDERER_NAME,
+  TAGS_FILTER_EXTENSION_NAME,
+  TAGS_SECTION_EXTENSION_NAME,
+} from "@cosmicdrift/kumiko-bundled-features/tags";
+import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEntity,
+  createTextField,
+  defineFeature,
+  type EntityEditScreenDefinition,
+  type EntityListScreenDefinition,
+  type FeatureDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+
+const ADMIN_ACCESS = { roles: ["TenantAdmin", "SystemAdmin"] } as const;
+
+export const noteEntity = createEntity({
+  description:
+    "A demo note holding just a title plus per-tenant custom-field values, used as the host object that the tags, folders and custom-fields extensions attach to.",
+  table: "read_demo_notes",
+  fields: {
+    title: createTextField({
+      personal: false,
+      reason: "is_business_data",
+      required: true,
+      maxLength: 200,
+      sortable: true,
+    }),
+    customFields: customFieldsField(),
+  },
+});
+
+export const noteTable = buildEntityTable("note", noteEntity);
+
+const noteListScreen: EntityListScreenDefinition = {
+  id: "note-list",
+  type: "entityList",
+  entity: "note",
+  columns: [
+    "title",
+    {
+      field: "tags",
+      label: "Tags",
+      renderer: { react: { __component: TAGS_COLUMN_RENDERER_NAME } },
+    },
+  ],
+  searchable: true,
+  defaultSort: { field: "title", dir: "asc" },
+  slots: { header: { react: { __component: TAGS_FILTER_EXTENSION_NAME } } },
+  rowActions: [
+    {
+      kind: "navigate",
+      id: "edit",
+      label: "notes-demo:actions.edit",
+      screen: "note-edit",
+      entityId: "id",
+    },
+    {
+      kind: "writeHandler",
+      id: "delete",
+      label: "notes-demo:actions.delete",
+      handler: "notes-demo:write:note:delete",
+      payload: { pick: ["id"] },
+      confirm: "notes-demo:confirms.note-delete",
+      style: "danger",
+    },
+  ],
+  access: ADMIN_ACCESS,
+};
+
+const noteEditScreen: EntityEditScreenDefinition = {
+  id: "note-edit",
+  type: "entityEdit",
+  entity: "note",
+  layout: {
+    sections: [
+      { title: "notes-demo:section.note", fields: [{ field: "title", span: 1 }] },
+      {
+        kind: "extension",
+        title: "notes-demo:section.customFields",
+        component: { react: { __component: CUSTOM_FIELDS_FORM_EXTENSION_NAME } },
+        contributesToFormSubmit: true,
+      },
+      {
+        kind: "extension",
+        title: "notes-demo:section.folder",
+        component: { react: { __component: FOLDER_SECTION_EXTENSION_NAME } },
+      },
+      {
+        kind: "extension",
+        title: "notes-demo:section.tags",
+        component: { react: { __component: TAGS_SECTION_EXTENSION_NAME } },
+      },
+    ],
+  },
+  access: ADMIN_ACCESS,
+};
+
+export const notesFeature: FeatureDefinition = defineFeature("notes-demo", (r) => {
+  r.describe(
+    "Dev-only host entity demonstrating tags, custom-fields, and folders on a real entityEdit screen.",
+  );
+  r.requires("tags");
+  r.requires("custom-fields");
+  r.requires("folders");
+
+  wireCustomFieldsFor(r, "note", noteTable);
+
+  r.crud("note", noteEntity, {
+    write: { access: ADMIN_ACCESS },
+    read: { access: ADMIN_ACCESS },
+    descriptions: {
+      create:
+        "Creates one demo note from its title plus the values entered in the custom-fields form section; used when the note edit screen saves a note that has not been stored yet.",
+      update:
+        "Applies a changed title or changed custom-field values to one existing note, addressed by id plus the version the client last read; used when the note edit screen saves.",
+      delete:
+        "Removes one note row for good, addressed by id; used by the confirmed danger row action on the note list, and there is no restore because the entity is not soft-deleted.",
+      list: "Returns one page of notes, searchable and sorted by title; used by the note list screen that renders each row's tags column and the tag filter above it.",
+      detail:
+        "Returns one note by id; used when the note edit screen loads the row that hosts the custom-fields, folder and tags extension sections.",
+    },
+  });
+
+  r.nav({
+    id: "note-list",
+    label: "notes-demo:nav.noteList",
+    icon: "list",
+    screen: "notes-demo:screen:note-list",
+    order: 50,
+    workspaces: ["admin-shell:workspace:tenant-admin"],
+  });
+  r.translations({
+    keys: {
+      "notes-demo:nav.noteList": { en: "Notes", de: "Notizen" },
+      "screen:note-list.title": { en: "Notes", de: "Notizen" },
+      "screen:note-edit.title": { en: "Note", de: "Notiz" },
+      "notes-demo:entity:note:field:title": { en: "Title", de: "Titel" },
+      "notes-demo:section.note": { en: "Note", de: "Notiz" },
+      "notes-demo:section.customFields": { en: "Custom fields", de: "Zusatzfelder" },
+      "notes-demo:section.folder": { en: "Folder", de: "Ordner" },
+      "notes-demo:section.tags": { en: "Tags", de: "Tags" },
+      "notes-demo:actions.edit": { en: "Edit", de: "Bearbeiten" },
+      "notes-demo:actions.delete": { en: "Delete", de: "Löschen" },
+      "notes-demo:confirms.note-delete": {
+        en: "Delete this note?",
+        de: "Diese Notiz löschen?",
+      },
+    },
+  });
+  r.screen(noteListScreen);
+  r.screen(noteEditScreen);
+  return {};
+});

package/samples/apps/use-all-bundled/src/app/screens-feature.ts

@@ -0,0 +1,39 @@
+// App-side screen placement. Bundled features self-register their screens
+// (tenant-list, user-list, tier-admin, privacy-center, page-list, and — since
+// fw#2312 — user-profile's `profile` screen too). This app only points a nav
+// entry at it, which also makes it createKumikoApp's landing fallback
+// (#1258): an open screen not reachable via nav is no longer an eligible
+// fallback candidate.
+
+import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+
+export const appScreensFeature: FeatureDefinition = defineFeature("app-screens", (r) => {
+  r.describe("App-side nav placement for the user-profile self-service page.");
+  r.requires("user-profile");
+  r.nav({
+    id: "profile",
+    label: "screen:profile.title",
+    icon: "user",
+    screen: "user-profile:screen:profile",
+    order: 10,
+  });
+  // Provider node for template-resolver's text-block tree. The app owns
+  // label/icon/access, the feature supplies the children plus the editor
+  // (textBlocksClient in client.tsx).
+  r.nav({
+    id: "content",
+    label: "nav:content.title",
+    icon: "file",
+    provider: true,
+    order: 40,
+    access: { roles: ["SystemAdmin"] },
+    workspaces: ["admin-shell:workspace:platform"],
+  });
+  r.translations({
+    keys: {
+      "screen:profile.title": { de: "Profil", en: "Profile" },
+      "nav:content.title": { de: "Inhalte", en: "Content" },
+    },
+  });
+  return {};
+});

package/samples/apps/use-all-bundled/src/app/seed.ts

@@ -0,0 +1,429 @@
+// @runtime dev
+// Seed-Daten für die Feature-Reference-Screenshots: damit die entity-Listen
+// nicht leer rendern und die öffentlichen Legal-Routes Inhalt haben. Läuft
+// nach dem Admin (runDevApp seeds-Hook), idempotent über die seed-Helper.
+// Dev-only (importiert die dev-only notes-feature) — wird nur von server.ts
+// (runDevApp) als Screenshot-Seed genutzt, nie im Prod-Boot.
+
+import { seedPage } from "@cosmicdrift/kumiko-bundled-features/managed-pages/seeding";
+import { NotesHistoryHandlers } from "@cosmicdrift/kumiko-bundled-features/notes-history";
+import {
+  apiTokenEntity,
+  apiTokenTable,
+} from "@cosmicdrift/kumiko-bundled-features/personal-access-tokens";
+import {
+  tagAssignmentAggregateId,
+  tagAssignmentEntity,
+  tagEntity,
+} from "@cosmicdrift/kumiko-bundled-features/tags";
+import { seedTextBlock } from "@cosmicdrift/kumiko-bundled-features/template-resolver/seeding";
+import { seedTenantMembership } from "@cosmicdrift/kumiko-bundled-features/tenant/seeding";
+import {
+  tierAssignmentAggregateId,
+  tierAssignmentEntity,
+} from "@cosmicdrift/kumiko-bundled-features/tier-engine";
+import { userTable } from "@cosmicdrift/kumiko-bundled-features/user";
+import type { SeedFn } from "@cosmicdrift/kumiko-dev-server";
+import { fetchOne, insertOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { createTenantDb, type DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEntityExecutor,
+  type SessionUser,
+  SYSTEM_TENANT_ID,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { TestUsers, unsafeCreateEntityTable } from "@cosmicdrift/kumiko-framework/stack";
+import { generateId } from "@cosmicdrift/kumiko-framework/utils";
+import { Temporal } from "temporal-polyfill";
+import { ADMIN_EMAIL, BETA_TENANT_ID, DEMO_NOTE_ID, DEV_TENANT_ID } from "./auth-constants";
+import { noteEntity } from "./notes-feature";
+
+// Event-store executors mirror the real handlers (createEntityExecutor pairs the
+// projection table + executor), so seeded rows are proper event streams, not
+// projection-wiped direct writes. entityName must match the handlers' QNs.
+const { executor: tagExecutor } = createEntityExecutor("tag", tagEntity);
+const { executor: tagAssignmentExecutor } = createEntityExecutor(
+  "tag-assignment",
+  tagAssignmentEntity,
+);
+const { executor: noteExecutor } = createEntityExecutor("note", noteEntity);
+const { executor: tierAssignmentExecutor } = createEntityExecutor(
+  "tier-assignment",
+  tierAssignmentEntity,
+);
+
+// Resolves the real dev-admin user (runDevApp's auth.admin, seeded via
+// seedAdmin() before options.seeds run) so seeded writes carry a created_by
+// the audit-log actor lookup can resolve — TestUsers.systemAdmin has no user
+// row / tenant-membership and renders as a blank actor column.
+async function resolveAdminUserId(db: DbConnection): Promise<string> {
+  const admin = await fetchOne<{ id: string }>(db, userTable, { email: ADMIN_EMAIL });
+  if (!admin) {
+    throw new Error(
+      `seed.ts: no user with email ${ADMIN_EMAIL} — expected runDevApp's auth.admin to be seeded before options.seeds run`,
+    );
+  }
+  return admin.id;
+}
+
+// One tier-assignment per platform tenant — cap-overview's tenant-cap-list
+// tier column/facet and its per-tier cap limits (cap-overview-caps.ts) are
+// both silent without this: no assignment renders as "" (tier column blank,
+// DEFAULT_LIMIT for every cap), the tier-engine write-handler pattern this
+// mirrors (set-tenant-tier.write.ts) upserts by the same deterministic
+// aggregate-id.
+async function seedTierAssignment(
+  db: DbConnection,
+  tenantId: TenantId,
+  tier: string,
+  adminUserId: string,
+): Promise<void> {
+  const by: SessionUser = { ...TestUsers.systemAdmin, tenantId, id: adminUserId };
+  const tdb = createTenantDb(db, tenantId, "system");
+  const result = await tierAssignmentExecutor.create(
+    { id: tierAssignmentAggregateId(tenantId), tier, source: "manual", tenantId },
+    by,
+    tdb,
+  );
+  if (!result.isSuccess) {
+    throw new Error(`seedTierAssignment: tenant ${tenantId} tier ${tier} failed`);
+  }
+}
+
+// tags + notes + assignments for the tags feature-reference screenshots:
+//   - tag-list management screen: colored catalog + non-zero usage counts
+//   - note-list: rows to filter via the TagFilter header slot
+//   - note-edit: a note carrying chips in its TagSection
+// ponytail: no idempotency guard — the screenshot server boots a fresh ephemeral
+// DB (KUMIKO_DEV_DB_NAME="") and runs this once; add a fetchOne-by-name guard if
+// a persistent dev DB ever reuses the process.
+async function seedTagsAndNotes(
+  db: DbConnection,
+  tenantId: TenantId,
+  adminUserId: string,
+): Promise<void> {
+  const by: SessionUser = { ...TestUsers.systemAdmin, tenantId, id: adminUserId };
+  const tdb = createTenantDb(db, tenantId, "system");
+
+  const created = async (
+    label: string,
+    result: { isSuccess: boolean; data?: unknown },
+  ): Promise<string> => {
+    if (!result.isSuccess) throw new Error(`seedTagsAndNotes: ${label} failed`);
+    const id = (result.data as { id?: string }).id;
+    if (id === undefined) throw new Error(`seedTagsAndNotes: ${label} returned no id`);
+    return id;
+  };
+
+  // scope "" = global (offered on every entity); a value restricts the tag to
+  // that entityType in the picker. "billing" never matches a note → proves scope.
+  const tags: ReadonlyArray<{ name: string; color: string; scope: string }> = [
+    { name: "urgent", color: "#ef4444", scope: "" },
+    { name: "backend", color: "#3b82f6", scope: "" },
+    { name: "idea", color: "#22c55e", scope: "note" },
+    { name: "billing", color: "#a855f7", scope: "invoice" },
+  ];
+  const tagId: Record<string, string> = {};
+  for (const t of tags) {
+    tagId[t.name] = await created(
+      `tag ${t.name}`,
+      await tagExecutor.create({ name: t.name, color: t.color, scope: t.scope }, by, tdb),
+    );
+  }
+
+  // Note 0 gets a fixed id so the tags-section screenshot can deep-link to it.
+  const notes: ReadonlyArray<{ id?: string; title: string }> = [
+    { id: DEMO_NOTE_ID, title: "Refactor auth flow" },
+    { title: "Q3 budget review" },
+    { title: "Landing page copy" },
+  ];
+  const noteIds: string[] = [];
+  for (const n of notes) {
+    const data =
+      n.id !== undefined
+        ? { id: n.id, title: n.title, customFields: {} }
+        : { title: n.title, customFields: {} };
+    noteIds.push(await created(`note ${n.title}`, await noteExecutor.create(data, by, tdb)));
+  }
+
+  const assignments: ReadonlyArray<{ tag: string; note: number }> = [
+    { tag: "urgent", note: 0 },
+    { tag: "idea", note: 0 },
+    { tag: "backend", note: 1 },
+  ];
+  for (const a of assignments) {
+    const entityId = noteIds[a.note];
+    if (entityId === undefined) continue;
+    const id = tagAssignmentAggregateId(tenantId, tagId[a.tag] ?? "", "note", entityId);
+    await created(
+      `assign ${a.tag}`,
+      await tagAssignmentExecutor.create(
+        { id, tagId: tagId[a.tag] ?? "", entityType: "note", entityId },
+        by,
+        tdb,
+      ),
+    );
+  }
+}
+
+async function seedCustomFieldsAndFolders(
+  stack: Parameters<SeedFn>[0],
+  tenantId: TenantId,
+  adminUserId: string,
+): Promise<void> {
+  // Roles come from the tenant-membership row (server.ts auth.admin);
+  // sessionChecker re-derives them per write.
+  const by: SessionUser = {
+    ...TestUsers.systemAdmin,
+    tenantId,
+    id: adminUserId,
+  };
+
+  await stack.http.writeOk(
+    "custom-fields:write:define-tenant-field",
+    {
+      entityName: "note",
+      fieldKey: "priority",
+      serializedField: { type: "text" },
+      required: false,
+      searchable: false,
+      displayOrder: 0,
+    },
+    by,
+  );
+  await stack.http.writeOk(
+    "custom-fields:write:set-custom-field",
+    {
+      entityName: "note",
+      entityId: DEMO_NOTE_ID,
+      fieldKey: "priority",
+      value: "High",
+    },
+    by,
+  );
+  // Generic entity-create strips the unknown `id` field (not an entity column)
+  // and generates its own aggregate id → take the returned id for set-folder.
+  const folder = await stack.http.writeOk<{ id: string }>(
+    "folders:write:folder:create",
+    { name: "Inbox" },
+    by,
+  );
+  await stack.http.writeOk(
+    "folders:write:set-folder",
+    { entityType: "note", entityId: DEMO_NOTE_ID, folderId: folder.id },
+    by,
+  );
+  await stack.eventDispatcher?.runOnce();
+}
+
+// personal-access-tokens — the store_api_tokens store is a direct-write table
+// that the ephemeral screenshot DB doesn't auto-create (storeTable). Create
+// it and seed two demo tokens for the logged-in admin so the "your tokens" list
+// renders populated. Screenshot-only: hashes/prefixes are fake, never resolved.
+async function seedApiTokens(db: DbConnection, tenantId: TenantId): Promise<void> {
+  await unsafeCreateEntityTable(db, apiTokenEntity);
+  const admin = await fetchOne<{ id: string }>(db, userTable, { email: ADMIN_EMAIL });
+  if (!admin) return;
+  const now = Temporal.Now.instant();
+  const demo: ReadonlyArray<{ name: string; scopes: string[]; expiresInDays?: number }> = [
+    { name: "CI deploy", scopes: ["pages:write", "tags:read"], expiresInDays: 90 },
+    { name: "Ledger sync", scopes: ["ledger:read"] },
+  ];
+  for (const t of demo) {
+    await insertOne(db, apiTokenTable, {
+      id: generateId(),
+      userId: admin.id,
+      tenantId,
+      name: t.name,
+      tokenHash: `demo_${generateId()}`,
+      prefix: `kpat_${generateId().slice(0, 6)}`,
+      scopes: JSON.stringify(t.scopes),
+      createdAt: now,
+      expiresAt: t.expiresInDays ? now.add({ hours: 24 * t.expiresInDays }) : null,
+      revokedAt: null,
+    });
+  }
+}
+
+const PRIVACY_BODY = [
+  "## 1. Controller",
+  "",
+  "Acme Inc., 123 Example Street, 90001 Sample City.",
+  "",
+  "## 2. Data we collect",
+  "",
+  "This app sets **no tracking cookies** and uses no third-party analytics.",
+  "",
+  "## 3. Your rights (GDPR Art. 15–22)",
+  "",
+  "Access, rectification, erasure, restriction, portability, objection.",
+].join("\n");
+
+export const seedScreenshotData: SeedFn = async (stack) => {
+  const devTenant = DEV_TENANT_ID as TenantId;
+  const betaTenant = BETA_TENANT_ID as TenantId;
+
+  // managed-pages — zwei Seiten im Dev-Tenant für den page-list Screen.
+  await seedPage(stack.db, {
+    tenantId: devTenant,
+    slug: "about",
+    lang: "en",
+    title: "About Acme",
+    body: "# About Acme\n\nWe build calm software.",
+    published: true,
+  });
+  await seedPage(stack.db, {
+    tenantId: devTenant,
+    slug: "pricing",
+    lang: "en",
+    title: "Pricing",
+    body: "# Pricing\n\nSimple, per-seat pricing.",
+    published: false,
+  });
+
+  // legal-pages — Public-Route /legal/privacy liest den text-block aus dem
+  // SYSTEM_TENANT (anonymousAccess.defaultTenantId).
+  await seedTextBlock(stack.db, {
+    tenantId: SYSTEM_TENANT_ID,
+    slug: "privacy",
+    locale: "en",
+    title: "Privacy Policy",
+    content: PRIVACY_BODY,
+    folder: "legal",
+  });
+
+  // template-resolver text-blocks — a folder tree for the content screen:
+  // legal/ from the block above, plus marketing copy and one empty stub.
+  for (const block of [
+    {
+      slug: "imprint",
+      title: "Imprint",
+      folder: "legal",
+      content: "## Provider\n\n**Acme GmbH**\n\nLeipzig, Germany",
+    },
+    {
+      slug: "hero",
+      title: "Landing hero",
+      folder: "page/marketing",
+      content: "# Calm software\n\nEverything your team needs, nothing it doesn't.",
+    },
+    {
+      slug: "pricing-intro",
+      title: "Pricing intro",
+      folder: "page/marketing",
+      content: "Simple, per-seat pricing. No surprises at renewal.",
+    },
+    { slug: "faq-billing", title: "FAQ — Billing", folder: "page", content: null },
+  ]) {
+    await seedTextBlock(stack.db, { tenantId: SYSTEM_TENANT_ID, locale: "en", ...block });
+  }
+
+  // Real dev-admin identity (not TestUsers.systemAdmin — see resolveAdminUserId)
+  // so the audit-log actor column resolves for these seeded writes. One lookup
+  // for the whole tenant, not per record.
+  const devAdminId = await resolveAdminUserId(stack.db);
+
+  // tags + notes + assignments in the dev tenant for the tags screenshots.
+  await seedTagsAndNotes(stack.db, devTenant, devAdminId);
+
+  // Distinct tiers per tenant — cap-overview's tenant-cap-list tier column
+  // and facet filter (samples/e2e/cap-overview.spec.ts) need two different
+  // values to actually filter on. "free"'s tighter limits (cap-overview-
+  // caps.ts) also make the cards below cross the warn/danger thresholds
+  // with a realistic seed count instead of needing hundreds of rows.
+  await seedTierAssignment(stack.db, devTenant, "free", devAdminId);
+  await seedTierAssignment(stack.db, betaTenant, "pro", devAdminId);
+
+  // Push the dev tenant's "notes" cap past its free-tier limit (10) so the
+  // my-caps/platform-tenant-caps cards screenshot shows the danger tone
+  // (>=100%) alongside "tags"'s 4/5 = 80% warn tone from seedTagsAndNotes
+  // above — otherwise both caps sit at 0%/40% default, and the tone
+  // handling added for cap-cards-panel.tsx is never actually exercised.
+  const notesHistoryAuthor: SessionUser = {
+    ...TestUsers.systemAdmin,
+    tenantId: devTenant,
+    id: devAdminId,
+  };
+  for (let i = 0; i < 12; i++) {
+    await stack.http.writeOk(
+      NotesHistoryHandlers.addNote,
+      { entityType: "note", entityId: DEMO_NOTE_ID, body: `Historical note entry ${i + 1}` },
+      notesHistoryAuthor,
+    );
+  }
+
+  // "seats" cap (cap-overview-caps.ts) counts tenant-membership rows. The
+  // admin's own membership (server.ts) already puts both tenants at 1, but
+  // that leaves the cap's default (neutral) tone unseeded on purpose — add
+  // enough extra members to land clearly under the 80% warn threshold
+  // (dev: 2/5 = 40%, beta: 3/20 = 15%), so all three CapUsageTone states
+  // (default/warn/danger) are visible in one dashboard alongside notes'
+  // 120% danger and tags' 80% warn. Synthetic ids: cap usage only counts
+  // rows, it never resolves the member's user record (mfa-login.spec.ts
+  // now seeds its own tenant/user via seedTenant(), no fixed account here).
+  await seedTenantMembership(stack.db, {
+    userId: generateId(),
+    tenantId: devTenant,
+    roles: ["User"],
+  });
+  for (let i = 0; i < 2; i++) {
+    await seedTenantMembership(stack.db, {
+      userId: generateId(),
+      tenantId: betaTenant,
+      roles: ["User"],
+    });
+  }
+
+  // custom-fields + folders extension sections on note-edit.
+  await seedCustomFieldsAndFolders(stack, devTenant, devAdminId);
+
+  // personal-access-tokens list for the admin (active tenant = dev).
+  await seedApiTokens(stack.db, devTenant);
+
+  // invite-create dispatches — the delivery-log screen renders notification
+  // attempts, and only the real handler (not a projection write) produces
+  // them; #2292.
+  const inviter: SessionUser = { ...TestUsers.systemAdmin, tenantId: devTenant, id: devAdminId };
+  for (const invitee of [
+    { email: "amara.solis@example.com", role: "User" },
+    { email: "devon.park@example.com", role: "User" },
+    { email: "priya.nandan@example.com", role: "User" },
+  ]) {
+    await stack.http.writeOk("auth-email-password:write:invite-create", invitee, inviter);
+  }
+
+  // reply-snippets — entries for the rich collection. Written through the
+  // collection's own set-handler, the same path the editor uses, so the rows
+  // carry whatever the handler derives instead of a hand-built projection.
+  // SYSTEM_TENANT, not the dev tenant: the screenshot admin reads the system
+  // tenant — the same reason the text-block tree above seeds there.
+  const snippetAuthor: SessionUser = {
+    ...TestUsers.systemAdmin,
+    tenantId: SYSTEM_TENANT_ID,
+    roles: ["TenantAdmin"],
+  };
+  for (const snippet of [
+    {
+      slug: "order-confirmed",
+      title: "Order confirmed",
+      content:
+        "<p>Hi {{customerName}},</p><p>your order <strong>{{orderId}}</strong> is on its way. " +
+        "We'll send a tracking link as soon as it ships.</p><p>— {{agentName}}</p>",
+    },
+    {
+      slug: "refund-approved",
+      title: "Refund approved",
+      content:
+        "<p>Hi {{customerName}},</p><p>we've approved the refund for {{orderId}}. " +
+        "It should appear on your statement within five working days.</p><p>— {{agentName}}</p>",
+    },
+  ]) {
+    // "html", not "rich": on a record contentFormat is the storage format,
+    // while on the collection it names the editor. The rich editor stores HTML.
+    await stack.http.writeOk(
+      "template-resolver:write:reply-snippets-set",
+      { ...snippet, locale: "en", contentFormat: "html" },
+      snippetAuthor,
+    );
+  }
+};

package/samples/apps/use-all-bundled/src/app/server.ts

@@ -0,0 +1,5 @@
+// @runtime dev
+import { runDevApp } from "@cosmicdrift/kumiko-dev-server";
+import { devAppOptions } from "./dev-app-options";
+
+await runDevApp(devAppOptions);