@cosmicdrift/kumiko-bundled-features 0.1.0

package/src/legal-pages/__tests__/legal-pages.integration.ts

@@ -0,0 +1,361 @@
+import type { TextContentApi } from "@cosmicdrift/kumiko-bundled-features/text-content";
+import {
+  createTextContentApi,
+  createTextContentFeature,
+  textBlockEntity,
+} from "@cosmicdrift/kumiko-bundled-features/text-content";
+import { seedTextBlock } from "@cosmicdrift/kumiko-bundled-features/text-content/seeding";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createEntityTable,
+  setupTestStack,
+  type TestStack,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { createLegalPagesFeature, runLegalPagesBootCheck } from "../feature";
+import { renderMarkdownToHtml, wrapInLayout } from "../markdown";
+
+let stack: TestStack;
+let db: DbConnection;
+
+const textFeature = createTextContentFeature();
+const legalFeature = createLegalPagesFeature();
+
+beforeAll(async () => {
+  // legal-pages braucht zwei wirings:
+  //   1. anonymousAccess für die /legal/*-Routes (laufen ohne JWT)
+  //   2. extraContext.textContent damit der Boot-Check + interner
+  //      Cross-Feature-Lookup ohne direct DB-Coupling funktioniert
+  stack = await setupTestStack({
+    features: [textFeature, legalFeature],
+    anonymousAccess: { defaultTenantId: SYSTEM_TENANT_ID },
+    extraContext: ({ db }) => ({
+      textContent: createTextContentApi(db),
+    }),
+  });
+  db = stack.db;
+  await createEntityTable(db, textBlockEntity);
+  await createEventsTable(db);
+
+  // Seed legal blocks für SYSTEM_TENANT in DE
+  await seedTextBlock(db, {
+    tenantId: SYSTEM_TENANT_ID,
+    slug: "imprint",
+    lang: "de",
+    title: "Impressum",
+    body: "## Angaben gemäß § 5 TMG\n\n**Marc Frost**\n\nSlevogtstr. 10, Leipzig",
+  });
+  await seedTextBlock(db, {
+    tenantId: SYSTEM_TENANT_ID,
+    slug: "privacy",
+    lang: "de",
+    title: "Datenschutzerklärung",
+    body: "## 1. Überblick\n\nWir verarbeiten **keine Tracking-Cookies**.",
+  });
+  await seedTextBlock(db, {
+    tenantId: SYSTEM_TENANT_ID,
+    slug: "imprint",
+    lang: "en",
+    title: "Imprint",
+    body: "## Provider\n\n**Marc Frost**\n\nLeipzig, Germany",
+  });
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+describe("legal-pages :: GET /legal/impressum", () => {
+  test("returns rendered HTML for DE imprint", async () => {
+    const res = await stack.app.request("/legal/impressum");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("text/html");
+    const body = await res.text();
+    expect(body).toContain("<title>Impressum</title>");
+    expect(body).toContain('lang="de"');
+    expect(body).toContain("Marc Frost");
+    expect(body).toContain("<h2>"); // markdown-rendered ## heading
+  });
+});
+
+describe("legal-pages :: GET /legal/datenschutz", () => {
+  test("returns rendered HTML for DE privacy", async () => {
+    const res = await stack.app.request("/legal/datenschutz");
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain("<title>Datenschutzerklärung</title>");
+    expect(body).toContain("Tracking-Cookies");
+    expect(body).toContain("<strong>"); // markdown bold
+  });
+});
+
+describe("legal-pages :: GET /legal/imprint (EN)", () => {
+  test("returns rendered HTML for EN imprint", async () => {
+    const res = await stack.app.request("/legal/imprint");
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain('lang="en"');
+    expect(body).toContain("Leipzig");
+  });
+});
+
+describe("legal-pages :: GET /legal/privacy (EN, not seeded)", () => {
+  test("returns 404 with helpful message when block missing", async () => {
+    const res = await stack.app.request("/legal/privacy");
+    expect(res.status).toBe(404);
+    const body = await res.text();
+    expect(body).toContain("Privacy Policy");
+    expect(body).toContain("Tenant-Admin");
+  });
+});
+
+describe("legal-pages :: edge-cases", () => {
+  test("Block existiert mit body=null → Route returnt 404 statt leerer HTML", async () => {
+    // seedTextBlock erlaubt body=null als legitimer Stub-State.
+    // Routes sollen das als "not configured" behandeln, NICHT als
+    // valides leeres Page rendern (würde DSGVO-pflichtige Page als
+    // existent vortäuschen).
+    await seedTextBlock(db, {
+      tenantId: SYSTEM_TENANT_ID,
+      slug: "imprint",
+      lang: "fr",
+      title: "Mentions légales",
+      body: null,
+    });
+    // Keine /legal/imprint-fr-Route registriert (LEGAL_ROUTES ist
+    // de+en) — wir adden nicht extra. Stattdessen testen wir das
+    // Verhalten via direct getBlock-Lookup gegen einen leeren
+    // privacy-en Block (existiert noch nicht im stack-setup).
+    await seedTextBlock(db, {
+      tenantId: SYSTEM_TENANT_ID,
+      slug: "privacy",
+      lang: "en",
+      title: "Privacy Policy",
+      body: null,
+    });
+    const res = await stack.app.request("/legal/privacy");
+    expect(res.status).toBe(404);
+    const body = await res.text();
+    expect(body).toContain("Tenant-Admin");
+  });
+
+  test("Markdown-Body mit <script> wird NICHT escaped (dokumentiertes XSS-Verhalten, siehe README)", async () => {
+    // Bewusstes Verhalten: marked.parse rendered HTML 1:1, kein
+    // DOMPurify-Layer aktuell. Dokumentiert in legal-pages/README.md
+    // ('XSS — bewusst aktuell nicht gesichert'). Test pinnt das
+    // Verhalten — wenn es sich ändert (z.B. DOMPurify dazu), schlägt
+    // dieser Test fehl und der Wechsel ist dokumentiert.
+    await seedTextBlock(db, {
+      tenantId: SYSTEM_TENANT_ID,
+      slug: "imprint",
+      lang: "de",
+      title: "Impressum",
+      body: "## XSS-Test\n\n<script>window.x=1</script>\n\nDanach.",
+    });
+    const res = await stack.app.request("/legal/impressum");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    // Aktuelles Verhalten: script-tag bleibt unescaped im Output
+    expect(html).toContain("<script>window.x=1</script>");
+  });
+});
+
+describe("legal-pages :: cache-control", () => {
+  test("sets public cache header for 5min", async () => {
+    const res = await stack.app.request("/legal/impressum");
+    expect(res.headers.get("cache-control")).toBe("public, max-age=300");
+  });
+});
+
+describe("markdown render helpers", () => {
+  test("renderMarkdownToHtml converts markdown to HTML", () => {
+    const html = renderMarkdownToHtml("# Title\n\n**bold**");
+    expect(html).toContain("<h1>");
+    expect(html).toContain("<strong>bold</strong>");
+  });
+
+  test("wrapInLayout produces valid HTML5 with title + lang", () => {
+    const html = wrapInLayout({ title: "Test", bodyHtml: "<p>x</p>", lang: "de" });
+    expect(html).toContain("<!doctype html>");
+    expect(html).toContain('lang="de"');
+    expect(html).toContain("<title>Test</title>");
+    expect(html).toContain("<p>x</p>");
+  });
+
+  test("wrapInLayout escapes title to prevent XSS", () => {
+    const html = wrapInLayout({
+      title: "<script>alert(1)</script>",
+      bodyHtml: "x",
+      lang: "en",
+    });
+    expect(html).not.toContain("<script>alert(1)</script>");
+    expect(html).toContain("&lt;script&gt;");
+  });
+});
+
+// Boot-Check direkt (ohne dev-server-Job-Runner-Path) — verifiziert
+// dass die Logik fehlende Blocks im SYSTEM_TENANT erkennt. Der eigentliche
+// runOnBoot-Trigger lebt im JobRunner und wird in jobs-feature integration-
+// tests separately exercised.
+describe("legal-pages :: SYSTEM_TENANT-routing (production-bug-regression)", () => {
+  test("legal-pages serven SYSTEM_TENANT-Texte auch wenn tenantResolver einen anderen Tenant zurückgibt", async () => {
+    // Simuliert publicstatus's Setup: host-basierter tenantResolver der
+    // tenant-subdomain → tenant-tenantId resolved. Ohne den X-Tenant-Fix
+    // würde /legal/impressum für tenant-x.example.com tenant-x's
+    // (leeren) imprint-Block abfragen → 404. Mit Fix immer SYSTEM_TENANT.
+    const otherTenantId = "22222222-2222-4222-8222-222222222222";
+    const hostScopedStack = await setupTestStack({
+      features: [createTextContentFeature(), createLegalPagesFeature()],
+      anonymousAccess: {
+        // Resolver gibt IMMER einen anderen Tenant zurück — wenn legal-
+        // pages den respektieren würde, wäre der DB-Lookup leer.
+        tenantResolver: () => otherTenantId,
+        tenantExists: async (id) => id === otherTenantId || id === SYSTEM_TENANT_ID,
+      },
+      extraContext: ({ db }) => ({
+        textContent: createTextContentApi(db),
+      }),
+    });
+    try {
+      await createEntityTable(hostScopedStack.db, textBlockEntity);
+      await createEventsTable(hostScopedStack.db);
+
+      // Block NUR im SYSTEM_TENANT seeden — NICHT im otherTenantId
+      await seedTextBlock(hostScopedStack.db, {
+        tenantId: SYSTEM_TENANT_ID,
+        slug: "imprint",
+        lang: "de",
+        title: "System-Impressum",
+        body: "## Plattform\n\nMarc Frost",
+      });
+
+      const res = await hostScopedStack.app.request("/legal/impressum");
+      expect(res.status).toBe(200);
+      const body = await res.text();
+      expect(body).toContain("System-Impressum");
+      expect(body).toContain("Marc Frost");
+    } finally {
+      await hostScopedStack.cleanup();
+    }
+  });
+});
+
+describe("legal-pages :: runLegalPagesBootCheck (direct unit-tests)", () => {
+  // Direkter Test der Boot-Check-Logik mit constructed ctx-Objects —
+  // keine JobRunner-Coupling, keine Test-Stacks. Das ist die echte
+  // Verhalten-Test-Surface; r.job() ist nur thin shell darum.
+
+  type Block = { slug: string; lang: string; title: string; body: string | null };
+
+  function fakeTextContent(blocks: readonly Block[]): {
+    api: TextContentApi;
+    calls: { tenantId: string; slug: string; lang: string }[];
+  } {
+    const calls: { tenantId: string; slug: string; lang: string }[] = [];
+    return {
+      calls,
+      api: {
+        getBlock: async ({ tenantId, slug, lang }) => {
+          calls.push({ tenantId, slug, lang });
+          const block = blocks.find((b) => b.slug === slug && b.lang === lang);
+          if (!block) return null;
+          return { ...block, updatedAt: new Date() };
+        },
+      },
+    };
+  }
+
+  test("alle Pflicht-Blocks vorhanden → log.info, kein throw", async () => {
+    const { api } = fakeTextContent([
+      { slug: "imprint", lang: "de", title: "I", body: "body" },
+      { slug: "privacy", lang: "de", title: "P", body: "body" },
+    ]);
+    const infos: string[] = [];
+    const warns: string[] = [];
+    await expect(
+      runLegalPagesBootCheck({
+        textContent: api,
+        log: { info: (m) => infos.push(m), warn: (m) => warns.push(m) },
+      }),
+    ).resolves.toBeUndefined();
+    expect(infos).toHaveLength(1);
+    expect(infos[0]).toContain("alle Pflicht-Blocks vorhanden");
+    expect(warns).toHaveLength(0);
+  });
+
+  test("missing blocks + NODE_ENV=production → throws mit slug-Liste", async () => {
+    const { api } = fakeTextContent([]);
+    const originalEnv = process.env["NODE_ENV"];
+    process.env["NODE_ENV"] = "production";
+    try {
+      await expect(runLegalPagesBootCheck({ textContent: api })).rejects.toThrow(
+        /Boot-Validation failed.*imprint\/de.*privacy\/de/s,
+      );
+    } finally {
+      if (originalEnv === undefined) delete process.env["NODE_ENV"];
+      else process.env["NODE_ENV"] = originalEnv;
+    }
+  });
+
+  test("missing blocks + NODE_ENV!=production → log.warn, kein throw", async () => {
+    const { api } = fakeTextContent([]);
+    const warns: string[] = [];
+    const originalEnv = process.env["NODE_ENV"];
+    process.env["NODE_ENV"] = "development";
+    try {
+      await expect(
+        runLegalPagesBootCheck({
+          textContent: api,
+          log: { warn: (m) => warns.push(m) },
+        }),
+      ).resolves.toBeUndefined();
+      expect(warns).toHaveLength(1);
+      expect(warns[0]).toContain("missing 2 required text-block(s)");
+      expect(warns[0]).toContain("imprint/de");
+      expect(warns[0]).toContain("privacy/de");
+    } finally {
+      if (originalEnv === undefined) delete process.env["NODE_ENV"];
+      else process.env["NODE_ENV"] = originalEnv;
+    }
+  });
+
+  test("ctx ohne textContent → InternalError mit Wiring-Hinweis", async () => {
+    await expect(runLegalPagesBootCheck({})).rejects.toThrow(/textContent missing.*extraContext/s);
+  });
+
+  test("Block existiert aber body ist null → wird als missing gezählt", async () => {
+    const { api } = fakeTextContent([
+      { slug: "imprint", lang: "de", title: "I", body: null },
+      { slug: "privacy", lang: "de", title: "P", body: "body" },
+    ]);
+    const warns: string[] = [];
+    const originalEnv = process.env["NODE_ENV"];
+    process.env["NODE_ENV"] = "development";
+    try {
+      await runLegalPagesBootCheck({
+        textContent: api,
+        log: { warn: (m) => warns.push(m) },
+      });
+      expect(warns[0]).toContain("missing 1 required text-block(s)");
+      expect(warns[0]).toContain("imprint/de");
+      expect(warns[0]).not.toContain("privacy/de");
+    } finally {
+      if (originalEnv === undefined) delete process.env["NODE_ENV"];
+      else process.env["NODE_ENV"] = originalEnv;
+    }
+  });
+
+  test("alle Lookups erfolgen gegen SYSTEM_TENANT_ID (nie tenant-scoped)", async () => {
+    const { api, calls } = fakeTextContent([
+      { slug: "imprint", lang: "de", title: "I", body: "x" },
+      { slug: "privacy", lang: "de", title: "P", body: "x" },
+    ]);
+    await runLegalPagesBootCheck({ textContent: api });
+    expect(calls).toHaveLength(2);
+    for (const call of calls) {
+      expect(call.tenantId).toBe(SYSTEM_TENANT_ID);
+    }
+  });
+});

package/src/legal-pages/constants.ts

@@ -0,0 +1,36 @@
+// Feature name
+export const LEGAL_PAGES_FEATURE = "legal-pages" as const;
+
+// Required slugs that must exist as text-blocks for production-boot.
+// Pro Sprache + Slug eine Pflicht-Kombo. Wer mehr Sprachen will, ergänzt
+// die Liste — Boot-Check wird dynamisch aus der Liste generiert.
+export const LEGAL_REQUIRED_BLOCKS = [
+  { slug: "imprint", lang: "de" },
+  { slug: "privacy", lang: "de" },
+] as const;
+
+// Optionale Blocks die NICHT Boot-fail-relevant sind, aber die Routes
+// servieren falls vorhanden. EN-Versionen sind in DACH-Apps oft nur
+// "nice-to-have".
+export const LEGAL_OPTIONAL_BLOCKS = [
+  { slug: "imprint", lang: "en" },
+  { slug: "privacy", lang: "en" },
+] as const;
+
+// Public-Route-Mapping: URL-Path → (slug, lang). DE nutzt die deutschen
+// Standard-Bezeichnungen, EN die englischen.
+export const LEGAL_ROUTES = [
+  { path: "/legal/impressum", slug: "imprint", lang: "de", titleFallback: "Impressum" },
+  {
+    path: "/legal/datenschutz",
+    slug: "privacy",
+    lang: "de",
+    titleFallback: "Datenschutzerklärung",
+  },
+  { path: "/legal/imprint", slug: "imprint", lang: "en", titleFallback: "Imprint" },
+  { path: "/legal/privacy", slug: "privacy", lang: "en", titleFallback: "Privacy Policy" },
+] as const;
+
+export const LegalPagesErrors = {
+  bootMissingBlock: "legal_pages_boot_missing_block",
+} as const;

package/src/legal-pages/feature.ts

@@ -0,0 +1,187 @@
+import {
+  requireTextContent,
+  type TextContentApi,
+} from "@cosmicdrift/kumiko-bundled-features/text-content";
+import {
+  defineFeature,
+  type FeatureDefinition,
+  SYSTEM_TENANT_ID,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { LEGAL_REQUIRED_BLOCKS, LEGAL_ROUTES } from "./constants";
+import { renderMarkdownToHtml, wrapInLayout } from "./markdown";
+
+// QN-Konstante als dokumentierter Public-Contract des text-content-
+// Features. Ein magic-string statt eines Code-Imports ist hier explizit
+// gewollt: Cross-Feature-Calls gehen nur über stable Public-API
+// (handler-name + payload-shape), nicht über interne Module-Refs. Wenn
+// text-content's Handler-Name sich ändert, ist das ein semver-major
+// und muss in beiden Features synchronisiert werden — gleiches Risiko
+// wie bei jedem API-Endpunkt.
+const TEXT_CONTENT_BY_SLUG_QN = "text-content:query:by-slug";
+
+// Wire-Body-Shape von /api/query — das, was bySlugQuery returnt.
+type ByslugQueryBody = {
+  data: { title: string; body: string | null } | null;
+};
+
+// legal-pages — Opt-in-Wrapper um text-content für DACH-Compliance.
+// Liefert vier feste Public-HTML-Routes (/legal/impressum,
+// /legal/datenschutz, /legal/imprint, /legal/privacy) mit
+// Markdown→HTML-Rendering und einen Boot-Check der in Production hart
+// fehlt wenn die DE-Pflicht-Blocks nicht geseedet sind.
+//
+// Cross-Feature-Decoupling:
+//   • Routes nutzen app.fetch zu "/api/query" mit dem QN-string
+//     `text-content:query:by-slug` — kein Code-Import von text-content
+//   • Boot-Check nutzt ctx.textContent (über extraContext) — symmetrisch
+//     zum config/tenant-Pattern
+//   • Single Type-Import (TextContentApi) bleibt — type-only verstößt
+//     nicht gegen Cross-Feature-Coupling
+//
+// Voraussetzungen für Production:
+//   • App-Bootstrap muss extraContext: { textContent: createTextContentApi(db) }
+//     setzen — sonst wirft Boot-Check beim Start
+//   • anonymousAccess: { defaultTenantId: SYSTEM_TENANT_ID } — sonst
+//     antworten die Routes mit 503
+export type LegalPagesWrapLayout = (opts: {
+  readonly title: string;
+  readonly bodyHtml: string;
+  readonly lang: string;
+}) => string;
+
+export type LegalPagesOptions = {
+  /** Custom Layout-Wrapper für die /legal/*-Routes. Default: minimaler
+   *  HTML-Skeleton aus markdown.ts (`wrapInLayout`). Apps die ihr eigenes
+   *  Marketing-Layout (Header/Footer/Theme) auch um Legal-Body legen
+   *  wollen, übergeben hier ihre Render-Function. */
+  readonly wrapLayout?: LegalPagesWrapLayout;
+};
+
+export function createLegalPagesFeature(opts: LegalPagesOptions = {}): FeatureDefinition {
+  const wrapLayout = opts.wrapLayout ?? wrapInLayout;
+  return defineFeature("legal-pages", (r) => {
+    r.requires("text-content");
+
+    // 4 Public-HTML-Routes
+    for (const route of LEGAL_ROUTES) {
+      r.httpRoute({
+        method: "GET",
+        path: route.path,
+        anonymous: true,
+        handler: async (c, { app }) => {
+          const url = new URL(c.req.url);
+          // Architektur: 1 App = X Tenants = 1 Impressum. Egal welche
+          // Subdomain der Visitor besucht (apex, admin.*, tenant-x.*) —
+          // legal-pages serven IMMER die SYSTEM_TENANT-Texte. Deshalb
+          // explizit X-Tenant-Header setzen statt host weiterreichen
+          // (sonst würde ein host-basierter anonymousAccess-Resolver
+          // die tenant-Subdomain auf tenant-tenantId resolven und
+          // tenant-x's leere imprint-Tabelle abfragen → 404).
+          const queryRes = await app.fetch(
+            new Request(`${url.origin}/api/query`, {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                "X-Tenant": SYSTEM_TENANT_ID,
+              },
+              body: JSON.stringify({
+                type: TEXT_CONTENT_BY_SLUG_QN,
+                payload: { slug: route.slug, lang: route.lang },
+              }),
+            }),
+          );
+
+          if (!queryRes.ok) {
+            return c.text("legal page unavailable", 503);
+          }
+
+          const body: ByslugQueryBody = await queryRes.json();
+          const data = body.data;
+          if (!data?.body) {
+            return c.text(
+              `${route.titleFallback} not configured. Tenant-Admin must set this text-block.`,
+              404,
+            );
+          }
+
+          const html = wrapLayout({
+            title: data.title || route.titleFallback,
+            bodyHtml: renderMarkdownToHtml(data.body),
+            lang: route.lang,
+          });
+
+          return c.body(html, 200, {
+            "content-type": "text/html; charset=utf-8",
+            "cache-control": "public, max-age=300",
+          });
+        },
+      });
+    }
+
+    // Boot-Check via ctx.textContent (extraContext-Pattern, symmetrisch
+    // zu requireConfigResolver in config). App-Bootstrap muss textContent
+    // wired haben — der Helper gibt einen klaren Wiring-Hinweis wenn nicht.
+    //
+    // Body als named function extrahiert (`runLegalPagesBootCheck`) damit
+    // die Logik direkt unit-testbar ist statt nur indirekt über Routes.
+    // Pattern: thin job-shell ruft testable function — keine Test-Coupling
+    // zum JobRunner.
+    r.job(
+      "legal-pages-boot-check",
+      {
+        trigger: { manual: true },
+        runOnBoot: true,
+        runIn: "api",
+      },
+      async (_payload, ctx) => runLegalPagesBootCheck(ctx),
+    );
+
+    return {};
+  });
+}
+
+// Minimal-shape für die Boot-Check-Logik — nur die Felder die der Check
+// braucht. Akzeptiert HandlerContext + AppContext + jeden anderen
+// Container der textContent + log mitbringt. Macht den Check direkt
+// unit-testbar mit constructed ctx-Objects.
+export type LegalPagesBootCheckCtx = {
+  readonly textContent?: TextContentApi;
+  readonly log?: {
+    readonly info?: (msg: string) => void;
+    readonly warn?: (msg: string) => void;
+  };
+};
+
+// Exportiert für direkte Tests. Wirft InternalError wenn ctx.textContent
+// nicht gewired ist (Hinweis auf fehlenden extraContext). Wirft Error
+// in NODE_ENV=production wenn Pflicht-Blocks fehlen, sonst log.warn.
+// Logged log.info wenn alles vorhanden ist (kein silent-skip).
+export async function runLegalPagesBootCheck(ctx: LegalPagesBootCheckCtx): Promise<void> {
+  const textContent: TextContentApi = requireTextContent(ctx, "legal-pages-boot-check");
+  const missing: { slug: string; lang: string }[] = [];
+
+  for (const required of LEGAL_REQUIRED_BLOCKS) {
+    const block = await textContent.getBlock({
+      tenantId: SYSTEM_TENANT_ID,
+      slug: required.slug,
+      lang: required.lang,
+    });
+    if (!block?.body) {
+      missing.push({ slug: required.slug, lang: required.lang });
+    }
+  }
+
+  if (missing.length === 0) {
+    ctx.log?.info?.("legal-pages boot-check: alle Pflicht-Blocks vorhanden");
+  } else {
+    const message =
+      `legal-pages: missing ${missing.length} required text-block(s) in SYSTEM_TENANT: ` +
+      missing.map((m) => `${m.slug}/${m.lang}`).join(", ") +
+      ". Seed via text-content:write:set or seedTextBlock helper.";
+
+    if (process.env["NODE_ENV"] === "production") {
+      throw new Error(`Boot-Validation failed: ${message}`);
+    }
+    ctx.log?.warn?.(message);
+  }
+}

package/src/legal-pages/index.ts

@@ -0,0 +1,13 @@
+export {
+  LEGAL_OPTIONAL_BLOCKS,
+  LEGAL_PAGES_FEATURE,
+  LEGAL_REQUIRED_BLOCKS,
+  LEGAL_ROUTES,
+  LegalPagesErrors,
+} from "./constants";
+export {
+  createLegalPagesFeature,
+  type LegalPagesBootCheckCtx,
+  runLegalPagesBootCheck,
+} from "./feature";
+export { renderMarkdownToHtml, wrapInLayout } from "./markdown";

package/src/legal-pages/markdown.ts

@@ -0,0 +1,69 @@
+import { Marked } from "marked";
+
+// Markdown→HTML mit eigener `marked`-Instance. GFM aus, breaks aus —
+// Legal-Pages sind strukturiert genug dass GFM-Tables/Strikethrough/
+// Task-Lists nicht nötig sind. Headers + Listen + Links + Code reichen.
+//
+// Instance statt globaler `marked.setOptions()` damit andere Features
+// die `marked` als runtime-dep nutzen ihre eigenen Optionen behalten —
+// modul-level side-effect auf shared library wäre brittle bei mehreren
+// Konsumenten.
+//
+// XSS-Schutz: marked rendered tags 1:1, also kann ein böswilliger Text-
+// Editor (TenantAdmin) <script>-Tags reinschreiben. Aktuell akzeptiert
+// weil nur trusted Roles (TenantAdmin/SystemAdmin) Texte setzen können —
+// bei einem Multi-Author-Setup müsste DOMPurify oder isomorphic-dompurify
+// dazu. Dokumentiert in README, Phase-2-Hardening.
+const markdownRenderer = new Marked({
+  gfm: false,
+  breaks: false,
+});
+
+export function renderMarkdownToHtml(markdown: string): string {
+  // @cast-boundary render-helper marked.parse return-type ist
+  // `string | Promise<string>` — mit `{ async: false }` runtime-garantiert
+  // sync (string). Cast nur API-Vertragsfix, kein Type-Loss.
+  return markdownRenderer.parse(markdown, { async: false }) as string;
+}
+
+// Layout-Wrapper für Legal-Pages — minimaler HTML-Skeleton mit Inline-
+// CSS damit die Pages auch ohne App-Layout sauber aussehen. Apps die
+// das in ihr eigenes Layout integrieren wollen, nutzen text-content's
+// by-slug-query direkt und rendern selbst.
+export function wrapInLayout(opts: { title: string; bodyHtml: string; lang: string }): string {
+  return `<!doctype html>
+<html lang="${escapeHtmlAttr(opts.lang)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(opts.title)}</title>
+<style>
+  body { font-family: system-ui, -apple-system, sans-serif; max-width: 720px;
+         margin: 2rem auto; padding: 0 1rem; line-height: 1.6; color: #222; }
+  h1, h2, h3 { line-height: 1.2; margin-top: 2rem; }
+  h1 { font-size: 1.8rem; } h2 { font-size: 1.4rem; } h3 { font-size: 1.15rem; }
+  a { color: #0066cc; }
+  code { background: #f4f4f4; padding: 0.1rem 0.3rem; border-radius: 3px; }
+  hr { border: 0; border-top: 1px solid #ddd; margin: 2rem 0; }
+</style>
+</head>
+<body>
+<main>
+${opts.bodyHtml}
+</main>
+</body>
+</html>`;
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function escapeHtmlAttr(s: string): string {
+  return escapeHtml(s);
+}