@cosmicdrift/kumiko-samples 0.338.0

package/samples/apps/use-all-bundled/scripts/gen-sample-index.ts

@@ -0,0 +1,290 @@
+#!/usr/bin/env bun
+// @runtime dev
+// biome-ignore-all lint/suspicious/noConsole: CLI script
+//
+// Scans samples/ for bundled-feature references and merges curated overrides.
+// docs.kumiko.rocks feature-reference reads the output (sample-index.json).
+//
+// Usage: bun run scripts/gen-sample-index.ts
+
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const APP_ROOT = resolve(HERE, "..");
+const SAMPLES_ROOT = resolve(APP_ROOT, "../..");
+const MANIFEST_PATH = resolve(APP_ROOT, "feature-manifest.json");
+const OVERRIDES_PATH = resolve(SAMPLES_ROOT, "sample-index.overrides.json");
+export const INDEX_PATH = resolve(SAMPLES_ROOT, "sample-index.json");
+
+const USE_ALL_BUNDLED_SLUG = "apps-use-all-bundled";
+
+const SUMMARY_SECTION_RE =
+  /##\s+(?:What (?:it shows|this sample demonstrates|you learn here)|What this shows)[^\n]*\n+([\s\S]*?)(?=\n## |\n---|$)/i;
+
+export type SampleIndexOverride = {
+  readonly primarySample: string;
+  readonly whenToUse: string;
+  readonly sampleBlurb: string;
+  readonly screenshot?: string | null;
+};
+
+export type SampleIndexOverrides = Readonly<Record<string, SampleIndexOverride>>;
+
+export type SampleIndexFeature = {
+  readonly samples: readonly string[];
+  readonly hasVisualOutput: boolean;
+  readonly readmeSummary?: string;
+  readonly primarySample?: string;
+  readonly whenToUse?: string;
+  readonly sampleBlurb?: string;
+  readonly screenshot?: string | null;
+};
+
+export type SampleIndex = {
+  readonly source: string;
+  readonly featureCount: number;
+  readonly features: Readonly<Record<string, SampleIndexFeature>>;
+};
+
+type MutableFeatureRow = {
+  samples: Set<string>;
+  hasVisualOutput: boolean;
+  readmeSummary?: string;
+  primarySample?: string;
+  whenToUse?: string;
+  sampleBlurb?: string;
+  screenshot?: string | null;
+};
+
+function toSlug(relPath: string): string {
+  return relPath.replace(/\//g, "-");
+}
+
+function sampleDirFromSlug(slug: string): string {
+  if (slug.startsWith("recipes-")) {
+    return join(SAMPLES_ROOT, "recipes", slug.slice("recipes-".length));
+  }
+  if (slug.startsWith("apps-")) {
+    return join(SAMPLES_ROOT, "apps", slug.slice("apps-".length));
+  }
+  throw new Error(`unknown sample slug: ${slug}`);
+}
+
+// A commented-out example import ("// import { x } from '.../file-provider-s3-env';")
+// must not register the sample as an actual consumer of that feature — strip
+// full-line `//` comments before matching.
+function stripLineComments(text: string): string {
+  return text
+    .split("\n")
+    .filter((line) => !line.trim().startsWith("//"))
+    .join("\n");
+}
+
+export function extractFeaturesFromText(rawText: string): Set<string> {
+  const text = stripLineComments(rawText);
+  const feats = new Set<string>();
+  for (const m of text.matchAll(/kumiko-bundled-features\/([a-z0-9-]+)/g)) {
+    const name = m[1];
+    if (name) feats.add(name);
+  }
+  for (const m of text.matchAll(/r\.requires\(\s*["']([a-z0-9-]+)["']/g)) {
+    const name = m[1];
+    if (name) feats.add(name);
+  }
+  for (const m of text.matchAll(/r\.optionalRequires\(\s*["']([a-z0-9-]+)["']/g)) {
+    const name = m[1];
+    if (name) feats.add(name);
+  }
+  return feats;
+}
+
+function collectSourceFiles(sampleDir: string): readonly string[] {
+  const files: string[] = [];
+  // usage.ts covers self-hosting recipes (e.g. ledger) that mount a bundled
+  // feature directly and carry no host src/feature.ts.
+  for (const rel of ["src/feature.ts", "src/run-config.ts", "src/usage.ts", "bin/main.ts"]) {
+    const p = join(sampleDir, rel);
+    if (existsSync(p)) files.push(p);
+  }
+  const featuresDir = join(sampleDir, "src/features");
+  if (existsSync(featuresDir)) {
+    walkTsFiles(featuresDir, files);
+  }
+  return files;
+}
+
+function walkTsFiles(dir: string, out: string[]): void {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === "__tests__" || entry.name === "node_modules") continue;
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkTsFiles(p, out);
+    } else if (
+      (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) &&
+      !entry.name.includes(".test.")
+    ) {
+      out.push(p);
+    }
+  }
+}
+
+function isVisualSample(dir: string): boolean {
+  return (
+    existsSync(join(dir, "src/client.tsx")) ||
+    existsSync(join(dir, "public")) ||
+    existsSync(join(dir, "e2e/screenshot.spec.ts")) ||
+    existsSync(join(dir, "e2e/screenshots.spec.ts"))
+  );
+}
+
+function cleanMarkdownLine(line: string): string {
+  return line
+    .replace(/^\*\*([^*]+)\*\*:?\s*/, "$1: ")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+    .replace(/`([^`]+)`/g, "$1")
+    .trim();
+}
+
+export function extractReadmeSummary(readmePath: string): string | undefined {
+  if (!existsSync(readmePath)) return undefined;
+  const raw = readFileSync(readmePath, "utf-8");
+  const body = raw.replace(/^---[\s\S]*?---\n/, "").replace(/^#\s+.+\n+/, "");
+
+  const sectionMatch = SUMMARY_SECTION_RE.exec(body);
+  if (sectionMatch?.[1]) {
+    // Accumulate consecutive lines of the FIRST paragraph/bullet in the
+    // section (stop at a blank line, a table row, or a code fence) — a
+    // single-line return truncated any summary that wrapped onto a second
+    // physical line in the source README.
+    const collected: string[] = [];
+    for (const line of sectionMatch[1].split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("```") || trimmed.startsWith("|")) break;
+      if (trimmed === "") {
+        if (collected.length > 0) break;
+        continue;
+      }
+      if (trimmed.startsWith("#")) continue;
+      collected.push(
+        collected.length === 0 && trimmed.startsWith("- ") ? trimmed.slice(2) : trimmed,
+      );
+    }
+    if (collected.length > 0) return cleanMarkdownLine(collected.join(" "));
+  }
+
+  const para: string[] = [];
+  for (const line of body.split("\n")) {
+    if (line.startsWith("#")) continue;
+    if (line.trim() === "") {
+      if (para.length > 0) break;
+      continue;
+    }
+    if (line.startsWith("```")) break;
+    para.push(line.trim());
+  }
+  const joined = para.join(" ");
+  return joined.length > 0 ? joined.slice(0, 320) : undefined;
+}
+
+function scanSamples(): Map<string, MutableFeatureRow> {
+  const byFeature = new Map<string, MutableFeatureRow>();
+
+  function ensure(feat: string): MutableFeatureRow {
+    let row = byFeature.get(feat);
+    if (!row) {
+      row = { samples: new Set(), hasVisualOutput: false };
+      byFeature.set(feat, row);
+    }
+    return row;
+  }
+
+  function walk(dir: string, rel: string): void {
+    for (const name of readdirSync(dir)) {
+      if (name.startsWith(".") || name === "node_modules") continue;
+      const p = join(dir, name);
+      const r = rel ? `${rel}/${name}` : name;
+      if (!statSync(p).isDirectory()) continue;
+
+      const slug = toSlug(r);
+      const sourceFiles = collectSourceFiles(p);
+      if (sourceFiles.length > 0) {
+        const feats = new Set<string>();
+        for (const file of sourceFiles) {
+          for (const f of extractFeaturesFromText(readFileSync(file, "utf-8"))) {
+            feats.add(f);
+          }
+        }
+        const visual = isVisualSample(p);
+        for (const feat of feats) {
+          const row = ensure(feat);
+          row.samples.add(slug);
+          if (visual) row.hasVisualOutput = true;
+        }
+      }
+      walk(p, r);
+    }
+  }
+
+  walk(join(SAMPLES_ROOT, "recipes"), "recipes");
+  walk(join(SAMPLES_ROOT, "apps"), "apps");
+  return byFeature;
+}
+
+export function loadOverrides(): SampleIndexOverrides {
+  if (!existsSync(OVERRIDES_PATH)) return {};
+  return JSON.parse(readFileSync(OVERRIDES_PATH, "utf-8")) as SampleIndexOverrides;
+}
+
+export function buildSampleIndex(): SampleIndex {
+  const manifest = JSON.parse(readFileSync(MANIFEST_PATH, "utf-8")) as {
+    features: readonly { name: string }[];
+  };
+  const bundledNames = new Set(manifest.features.map((f) => f.name));
+  const overrides = loadOverrides();
+  const scanned = scanSamples();
+
+  const features: Record<string, SampleIndexFeature> = {};
+
+  for (const name of bundledNames) {
+    const row = scanned.get(name);
+    const override = overrides[name];
+    const samples = row ? [...row.samples].sort() : [];
+    const dedicated = samples.filter((s) => s !== USE_ALL_BUNDLED_SLUG);
+    if (dedicated.length === 0 && !override) continue;
+
+    const primarySample = override?.primarySample ?? dedicated[0];
+    let readmeSummary: string | undefined;
+    if (primarySample) {
+      readmeSummary = extractReadmeSummary(join(sampleDirFromSlug(primarySample), "README.md"));
+    }
+
+    features[name] = {
+      samples: dedicated.length > 0 ? dedicated : samples,
+      hasVisualOutput: row?.hasVisualOutput ?? false,
+      ...(readmeSummary ? { readmeSummary } : {}),
+      ...(override?.primarySample ? { primarySample: override.primarySample } : {}),
+      ...(override?.whenToUse ? { whenToUse: override.whenToUse } : {}),
+      ...(override?.sampleBlurb != null ? { sampleBlurb: override.sampleBlurb } : {}),
+      ...(override && "screenshot" in override ? { screenshot: override.screenshot ?? null } : {}),
+    };
+  }
+
+  return {
+    source:
+      "samples/apps/use-all-bundled/scripts/gen-sample-index.ts + sample-index.overrides.json",
+    featureCount: Object.keys(features).length,
+    features,
+  };
+}
+
+export function serializeSampleIndex(index: SampleIndex): string {
+  return `${JSON.stringify(index, null, 2)}\n`;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const index = buildSampleIndex();
+  writeFileSync(INDEX_PATH, serializeSampleIndex(index), "utf-8");
+  console.log(`sample-index.json: ${index.featureCount} features → ${INDEX_PATH}`);
+}

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

@@ -0,0 +1,16 @@
+// Reine Konstanten — kein Framework-Import, damit der E2E-Login-Helper
+// (Playwright-Worker) sie lesen kann, ohne die vitest-Importchain aus
+// `@cosmicdrift/kumiko-framework/testing` mitzuziehen (kollidiert mit
+// Playwrights expect über Object.prototype-Symbole).
+
+export const ADMIN_EMAIL = "admin@kumiko.dev";
+export const ADMIN_PASSWORD = "kumiko-admin";
+
+// Zwei feste Tenants, damit der TenantSwitcher sichtbar rendert (>1 Tenant).
+// Plain strings — server.ts macht den `as TenantId`-Cast lokal.
+export const DEV_TENANT_ID = "00000000-0000-4000-8000-000000000001";
+export const BETA_TENANT_ID = "00000000-0000-4000-8000-000000000002";
+
+// Fixed id of the first seeded note, so the tags-section screenshot can navigate
+// straight to /note-edit/<id> (the other seeded notes get minted uuids).
+export const DEMO_NOTE_ID = "00000000-0000-4000-8000-00000000d001";

package/samples/apps/use-all-bundled/src/app/cap-overview-caps.ts

@@ -0,0 +1,71 @@
+import type { CapSpec } from "@cosmicdrift/kumiko-bundled-features/cap-overview";
+import { noteEntryTable } from "@cosmicdrift/kumiko-bundled-features/notes-history";
+import { tagEntity } from "@cosmicdrift/kumiko-bundled-features/tags";
+import { tenantMembershipsTable } from "@cosmicdrift/kumiko-bundled-features/tenant";
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
+import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
+
+const tagTable = buildEntityTable("tag", tagEntity);
+
+const NOTE_LIMIT_BY_TIER: Readonly<Record<string, number>> = { free: 10, pro: 100 };
+const TAG_LIMIT_BY_TIER: Readonly<Record<string, number>> = { free: 5, pro: 50 };
+const SEAT_LIMIT_BY_TIER: Readonly<Record<string, number>> = { free: 5, pro: 20 };
+const DEFAULT_LIMIT = 10;
+
+// Four example caps built from entities this sample already mounts
+// (notes-history, tags, tenant-membership) — demonstrates the caller-supplied
+// CapSpec contract cap-overview reads against, the same shape a real app
+// would provide for its own usage tables.
+export const CAP_OVERVIEW_CAPS: readonly CapSpec[] = [
+  {
+    id: "notes",
+    label: "cap-overview.caps.notes",
+    limit: (tier) => NOTE_LIMIT_BY_TIER[tier] ?? DEFAULT_LIMIT,
+    usage: async (db, tenantId) => {
+      const rows = await selectMany(db, noteEntryTable, { tenantId: [tenantId] });
+      return rows.length;
+    },
+    icon: "file",
+  },
+  {
+    id: "tags",
+    label: "cap-overview.caps.tags",
+    limit: (tier) => TAG_LIMIT_BY_TIER[tier] ?? DEFAULT_LIMIT,
+    usage: async (db, tenantId) => {
+      const rows = await selectMany(db, tagTable, { tenantId: [tenantId] });
+      return rows.length;
+    },
+    icon: "hash",
+    accentColor: "var(--color-status-ok)",
+  },
+  {
+    id: "seats",
+    label: "cap-overview.caps.seats",
+    limit: (tier) => SEAT_LIMIT_BY_TIER[tier] ?? DEFAULT_LIMIT,
+    usage: async (db, tenantId) => {
+      const rows = await selectMany(db, tenantMembershipsTable, { tenantId: [tenantId] });
+      return rows.length;
+    },
+    usageBatch: async (db, tenantIds) => {
+      const rows = await selectMany(db, tenantMembershipsTable, { tenantId: [...tenantIds] });
+      const seatsByTenant = new Map<TenantId, number>();
+      for (const row of rows) {
+        seatsByTenant.set(row.tenantId, (seatsByTenant.get(row.tenantId) ?? 0) + 1);
+      }
+      return seatsByTenant;
+    },
+    icon: "users",
+  },
+  {
+    // Unlimited usage meter: counted but never capped, no percent/badge.
+    id: "apiCalls",
+    label: "cap-overview.caps.apiCalls",
+    limit: () => null,
+    usage: async (db, tenantId) => {
+      const rows = await selectMany(db, noteEntryTable, { tenantId: [tenantId] });
+      return rows.length;
+    },
+    icon: "gauge",
+  },
+];

package/samples/apps/use-all-bundled/src/app/cap-overview-labels-feature.ts

@@ -0,0 +1,18 @@
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+// Labels for the four example caps (notes, tags, seats, apiCalls) wired up in
+// cap-overview-caps.ts. Cap ids are the app's choice, so their labels are
+// too — cap-overview itself carries no vocabulary for app-owned caps, same
+// reasoning as collection-labels-feature.ts for content collections.
+export const capOverviewLabelsFeature = defineFeature("cap-overview-labels", (r) => {
+  r.describe("Labels for the example caps this sample app mounts into cap-overview.");
+  r.translations({
+    keys: {
+      "cap-overview.caps.notes": { de: "Notizen", en: "Notes" },
+      "cap-overview.caps.tags": { de: "Tags", en: "Tags" },
+      "cap-overview.caps.seats": { de: "Plätze", en: "Seats" },
+      "cap-overview.caps.apiCalls": { de: "API-Aufrufe", en: "API calls" },
+    },
+  });
+  return {};
+});

package/samples/apps/use-all-bundled/src/app/client.tsx

@@ -0,0 +1,126 @@
+// Browser entry for the screenshot render path. Registers the ClientFeatures
+// of bundled features that ship their own /web renderer. Entity-backed
+// screens (tenant-list, user-list, page-list) render generically without a
+// plugin; privacy-center + tier-admin + user-profile (fw#2312) supply their
+// components via their own Client-Plugin — the app only adds its own
+// APP_TRANSLATIONS overrides here.
+//
+// APP_TRANSLATIONS: die entity-backed Admin-Screens (tenant/user/managed-pages)
+// haben kein /web-Plugin, das ihre Spalten-Labels mitbrächte. Sie nutzen die
+// `<feature>:entity:<e>:field:*`-Convention und überlassen die Labels bewusst
+// der App (siehe user/screens.ts). use-all-bundled IST diese App.
+//
+// adminShellClient + tenant/audit/jobs/config: WorkspaceShell needs the
+// admin-shell overview components and Settings-Hub i18n; mirror admin-console
+// client registration for features that run-config already mounts server-side.
+
+import { adminShellClient } from "@cosmicdrift/kumiko-bundled-features/admin-shell/web";
+import { auditClient } from "@cosmicdrift/kumiko-bundled-features/audit/web";
+import { emailPasswordClient } from "@cosmicdrift/kumiko-bundled-features/auth-email-password/web";
+import { authMfaClient, MfaVerifyScreen } from "@cosmicdrift/kumiko-bundled-features/auth-mfa/web";
+import { billingFoundationClient } from "@cosmicdrift/kumiko-bundled-features/billing-foundation/web";
+import { capOverviewClient } from "@cosmicdrift/kumiko-bundled-features/cap-overview/web";
+import { complianceProfilesClient } from "@cosmicdrift/kumiko-bundled-features/compliance-profiles/web";
+import { configClient } from "@cosmicdrift/kumiko-bundled-features/config/web";
+import { customFieldsClient } from "@cosmicdrift/kumiko-bundled-features/custom-fields/web";
+import { deliveryClient } from "@cosmicdrift/kumiko-bundled-features/delivery/web";
+import { featureTogglesClient } from "@cosmicdrift/kumiko-bundled-features/feature-toggles/web";
+import { foldersClient } from "@cosmicdrift/kumiko-bundled-features/folders/web";
+import { jobsClient } from "@cosmicdrift/kumiko-bundled-features/jobs/web";
+import { tagsClient } from "@cosmicdrift/kumiko-bundled-features/tags/web";
+import { textBlocksClient } from "@cosmicdrift/kumiko-bundled-features/template-resolver/web";
+import { tenantClient } from "@cosmicdrift/kumiko-bundled-features/tenant/web";
+import { tierEngineClient } from "@cosmicdrift/kumiko-bundled-features/tier-engine/web";
+import { userDataRightsClient } from "@cosmicdrift/kumiko-bundled-features/user-data-rights/web";
+import { userProfileClient } from "@cosmicdrift/kumiko-bundled-features/user-profile/web";
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine/types";
+import { localeDeClient } from "@cosmicdrift/kumiko-locale-de/web";
+import type { TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import { type ClientFeatureDefinition, createKumikoApp } from "@cosmicdrift/kumiko-renderer-web";
+import { AppShell } from "./shell";
+
+const APP_TRANSLATIONS: TranslationsByLocale = {
+  en: {
+    "tenant:entity:tenant:field:key": "Key",
+    "tenant:entity:tenant:field:name": "Name",
+    "tenant:entity:tenant:field:isEnabled": "Enabled",
+    "user:entity:user:field:email": "Email",
+    "user:entity:user:field:displayName": "Display name",
+    "user:entity:user:field:status": "Status",
+    "user:entity:user:field:emailVerified": "Email verified",
+    "managed-pages:entity:page:field:slug": "Slug",
+    "managed-pages:entity:page:field:lang": "Language",
+    "managed-pages:entity:page:field:title": "Title",
+    "managed-pages:entity:page:field:published": "Published",
+    "managed-pages:actions.edit": "Edit",
+    "managed-pages:actions.delete": "Delete",
+    "notes-demo:entity:note:field:title": "Title",
+    "notes-demo:section.note": "Note",
+    "notes-demo:section.tags": "Tags",
+    "notes-demo:actions.edit": "Edit",
+    "notes-demo:actions.delete": "Delete",
+    "notes-demo:confirms.note-delete": "Delete this note?",
+    "screen:note-list.title": "Notes",
+    "screen:note-edit.title": "Note",
+  },
+  de: {
+    "tenant:entity:tenant:field:key": "Schlüssel",
+    "tenant:entity:tenant:field:name": "Name",
+    "tenant:entity:tenant:field:isEnabled": "Aktiv",
+    "user:entity:user:field:email": "E-Mail",
+    "user:entity:user:field:displayName": "Anzeigename",
+    "user:entity:user:field:status": "Status",
+    "user:entity:user:field:emailVerified": "E-Mail bestätigt",
+    "managed-pages:entity:page:field:slug": "Slug",
+    "managed-pages:entity:page:field:lang": "Sprache",
+    "managed-pages:entity:page:field:title": "Titel",
+    "managed-pages:entity:page:field:published": "Veröffentlicht",
+    "managed-pages:actions.edit": "Bearbeiten",
+    "managed-pages:actions.delete": "Löschen",
+    "notes-demo:entity:note:field:title": "Titel",
+    "notes-demo:section.note": "Notiz",
+    "notes-demo:section.tags": "Tags",
+    "notes-demo:actions.edit": "Bearbeiten",
+    "notes-demo:actions.delete": "Löschen",
+    "notes-demo:confirms.note-delete": "Diese Notiz löschen?",
+    "screen:note-list.title": "Notizen",
+    "screen:note-edit.title": "Notiz",
+  },
+};
+
+const appScreens: ClientFeatureDefinition = {
+  name: "app-screens",
+  translations: APP_TRANSLATIONS,
+};
+
+createKumikoApp({
+  shell: AppShell,
+  clientFeatures: [
+    localeDeClient(),
+    emailPasswordClient({ mfaVerifyScreen: MfaVerifyScreen }),
+    authMfaClient(),
+    adminShellClient(),
+    tenantClient(),
+    auditClient(),
+    billingFoundationClient(),
+    jobsClient(),
+    deliveryClient(),
+    configClient(),
+    tierEngineClient(),
+    capOverviewClient(),
+    userProfileClient(),
+    userDataRightsClient(),
+    customFieldsClient(),
+    foldersClient(),
+    complianceProfilesClient(),
+    featureTogglesClient(),
+    // tag-list management screen (TagManager) + TagSection/TagFilter extension
+    // slots + tag i18n. Required for the dev-only notesFeature host to render.
+    tagsClient(),
+    // template-resolver text-block tree + editor under the app-owned "content"
+    // nav node. Points at SYSTEM_TENANT because that is where the legal and
+    // marketing copy is seeded.
+    textBlocksClient({ navId: "app-screens:nav:content", tenantId: SYSTEM_TENANT_ID }),
+    appScreens,
+  ],
+});

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

@@ -0,0 +1,16 @@
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+// Nav labels for the two content collections this app mounts. Collection ids
+// are the app's choice, so their labels are too — a bundled feature cannot ship
+// a translation key for a collection it never named. Every app that declares a
+// collection carries its labels the same way.
+export const collectionLabelsFeature = defineFeature("collection-labels", (r) => {
+  r.describe("Nav labels for the content collections mounted by this sample app.");
+  r.translations({
+    keys: {
+      "templateResolver:nav.snippets": { de: "Bausteine", en: "Snippets" },
+      "templateResolver:nav.signatures": { de: "Signaturen", en: "Signatures" },
+    },
+  });
+  return {};
+});

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

@@ -0,0 +1,75 @@
+// @runtime dev
+//
+// Dev-/Screenshot-Server für das use-all-bundled Sample. runDevApp mischt im
+// auth-Mode die 4 Standard-Features (config/user/tenant/auth) automatisch via
+// composeFeatures(includeBundled) dazu — exakt die 4, die APP_FEATURES bewusst
+// auslässt — und seedet den Admin im onAfterSetup. So rendert EINE App alle
+// bundled-feature-Screens für die Doku-Previews.
+//
+// globalRoles SystemAdmin: schaltet die Plattform-Screens frei (tenant-list,
+// user-list, tier-admin, GDPR-Inspector). anonymousAccess + extraContext.text
+// Content: die öffentlichen legal-pages-Routen (/legal/*).
+
+import { createTemplateResolverApi } from "@cosmicdrift/kumiko-bundled-features/template-resolver";
+import type { RunDevAppOptions } from "@cosmicdrift/kumiko-dev-server";
+import { SYSTEM_TENANT_ID, type TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import { APP_FEATURES, AUTH_COMPOSE_OPTIONS } from "../run-config";
+import { ADMIN_EMAIL, ADMIN_PASSWORD, BETA_TENANT_ID, DEV_TENANT_ID } from "./auth-constants";
+import { notesFeature } from "./notes-feature";
+import { appScreensFeature } from "./screens-feature";
+import { seedScreenshotData } from "./seed";
+
+// tier-admin rendert mit dem bare tierEngineFeature (aus APP_FEATURES) den
+// ehrlichen Empty-State ("no TierMap configured"). Eine konfigurierte tierMap
+// würde den Resolver auf jedem Write aktivieren (inkl. Login) und braucht
+// per-Tenant Tier-Assignments — disproportional für einen Preview-Screenshot.
+
+export const devAppOptions: RunDevAppOptions = {
+  // notesFeature is dev-only (app-owned tag host) — see notes-feature.ts for why
+  // it stays out of APP_FEATURES. appScreensFeature places the user-profile screen.
+  features: [...APP_FEATURES, appScreensFeature, notesFeature],
+  port: Number.parseInt(process.env["PORT"] ?? "4186", 10),
+  clientEntry: "./src/app/client.tsx",
+  htmlPath: "./public/index.html",
+  watchDirs: ["./src", "../../../packages/*/src"],
+  anonymousAccess: { defaultTenantId: SYSTEM_TENANT_ID },
+  extraContext: ({ db }) => ({ templateResolver: createTemplateResolverApi(db) }),
+  seeds: [seedScreenshotData],
+  auth: {
+    admin: {
+      email: ADMIN_EMAIL,
+      password: ADMIN_PASSWORD,
+      displayName: "Admin",
+      // Platform-operator: schaltet die SystemAdmin-gegateten Screens frei.
+      globalRoles: ["SystemAdmin"],
+      memberships: [
+        {
+          tenantId: DEV_TENANT_ID as TenantId,
+          tenantKey: "dev",
+          tenantName: "Dev Tenant",
+          // TenantAdmin alongside Admin: sessionChecker re-derives roles from
+          // this membership row on every write (buildSessionRoles), discarding
+          // any roles override baked into a hand-signed SessionUser — without
+          // it, seedCustomFieldsAndFolders's TenantAdmin-gated writes 403.
+          roles: ["Admin", "TenantAdmin"],
+        },
+        {
+          tenantId: BETA_TENANT_ID as TenantId,
+          tenantKey: "beta",
+          tenantName: "Beta Tenant",
+          roles: ["User"],
+        },
+      ],
+    },
+    // Coverage for auth-self-registration toggle (#1521 Option A).
+    signup: AUTH_COMPOSE_OPTIONS.signup,
+    // Registers invite-create so the seed can dispatch real invitations —
+    // the delivery-log screenshot needs real attempts, not projection writes.
+    invite: AUTH_COMPOSE_OPTIONS.invite,
+    // Same three option objects kumiko.config.ts feeds composeFeatures, so the
+    // linted feature list and the running dev app stay the same registry.
+    passwordReset: AUTH_COMPOSE_OPTIONS.passwordReset,
+    emailVerification: AUTH_COMPOSE_OPTIONS.emailVerification,
+    accountUnlock: AUTH_COMPOSE_OPTIONS.accountUnlock,
+  },
+};