Ranggefuege: Rollen, die aufeinander aufbauen

Bisher trug jede Rolle ihre Rechte vollstaendig selbst. Bei achtzehn Rollen
und zweiundzwanzig Rechten heisst das, dass eine hoehere Rangrolle die ganze
Liste der darunterliegenden noch einmal abhaken muss - beim Anlegen
fehleranfaellig und bei jeder spaeteren Aenderung doppelt zu pflegen.

Ein Gefuege ist eine benannte, geordnete Folge von Rollen. Jede Sprosse
erbt alles von jeder Sprosse unter ihr, verwaltet wird nur noch das, was
oben dazukommt. Geerbt wird nicht nur die Rechteliste, sondern auch
Freigabestufe und Anmeldung: sonst waere eine Befoerderung unter Umstaenden
eine Herabstufung, naemlich immer dann, wenn Discord beim Befoerdern die
alte Rangrolle abnimmt.

Die Ordnung ist bewusst eine Reihenfolge und kein Zeiger je Rolle - ueber
ganzen Zahlen gibt es keinen Zyklus, den man abfangen muesste. Aufloesen
eines Gefueges laesst die Rollen stehen und nimmt nur das Geerbte weg.

Die Rechnung steht als reine Funktion in lib/auth/ladders.ts und wird an
drei Stellen benutzt: bei der Rechteaufloesung, in der Verwaltung und in
der Vorschau des Editors, die im Browser mitrechnet. Eine Vorschau, die den
Stand vor dem Verschieben zeigt, waere schlimmer als keine.

Die Rollenseite zeigt Geerbtes kursiv und gesperrt an, damit dort niemand
blind Kaestchen setzt, die laengst gesetzt sind.

Nebenbei: Aenderungen an der Rollenzuordnung landen jetzt im Protokoll, mit
Vorher und Nachher. Wer Rollen aendert, aendert die Rechte anderer - genau
dafuer ist es da.

web/lib/auth/effective.ts

@@ -7,6 +7,7 @@ import {
   type EffectivePermissions,
   type Permission,
 } from '@/lib/auth/permissions'
+import { highestRungPerLadder } from '@/lib/auth/ladders'
 
 /** Höchste Freigabestufe. */
 const MAX_CLEARANCE = 5
@@ -41,6 +42,11 @@ function bootstrapAdmin(userId: string): EffectivePermissions {
  * Löst die Rechte eines Nutzers aus `UserRole` × `RoleMapping` auf:
  * höchste Stufe aller Rollen, Vereinigung aller Rechte.
  *
+ * Steht eine Rolle in einem Ranggefüge, zählt zusätzlich alles, was die
+ * Sprossen unter ihr gewähren. Das trägt den Fall, dass beim Befördern in
+ * Discord die alte Rangrolle abgenommen wird: die neue allein muss dann schon
+ * genügen. Siehe lib/auth/ladders.ts.
+ *
  * `hasMembership` ist eine Ergänzung gegenüber docs/03-auth-und-rechte.md und
  * bildet den Türsteher ab: auf dem AfiS-Discord sind auch Gäste, die keine
  * Akte sehen dürfen. Siehe docs/13-entscheidungen.md.
@@ -73,6 +79,30 @@ export async function resolvePermissions(userId: string): Promise<EffectivePermi
       ? []
       : await db.roleMapping.findMany({
           where: { discordRoleId: { in: roleIds } },
+          select: {
+            clearanceLevel: true,
+            permissions: true,
+            grantsMembership: true,
+            ladderId: true,
+            ladderRank: true,
+          },
+        })
+
+  // Steht eine der Rollen in einem Ranggefüge, gilt auch alles darunter. Das
+  // wird **nachgeladen** statt in JavaScript aus der ganzen Tabelle gefiltert:
+  // die Bedingung steht in der Abfrage, so wie bei jedem anderen Zugriff auch.
+  // Siehe lib/auth/ladders.ts für den Grund der Vererbung.
+  const hoechste = highestRungPerLadder(mappings)
+  const geerbt =
+    hoechste.size === 0
+      ? []
+      : await db.roleMapping.findMany({
+          where: {
+            OR: [...hoechste].map(([ladderId, rang]) => ({
+              ladderId,
+              ladderRank: { lte: rang },
+            })),
+          },
           select: { clearanceLevel: true, permissions: true, grantsMembership: true },
         })
 
@@ -80,7 +110,7 @@ export async function resolvePermissions(userId: string): Promise<EffectivePermi
   let hasMembership = false
   const permissions = new Set<Permission>()
 
-  for (const mapping of mappings) {
+  for (const mapping of [...mappings, ...geerbt]) {
     if (mapping.clearanceLevel > clearanceLevel) clearanceLevel = mapping.clearanceLevel
     if (mapping.grantsMembership) hasMembership = true
     for (const value of mapping.permissions) {

web/lib/auth/ladders.ts

@@ -0,0 +1,123 @@
+import { isPermission, type Permission } from '@/lib/auth/permissions'
+
+/**
+ * Ranggefüge: Rollen, die aufeinander aufbauen.
+ *
+ * Eine Leiter ist eine benannte, geordnete Folge von Rollen, in der jede
+ * Sprosse alles kann, was jede Sprosse unter ihr kann. Der Grund ist die
+ * Pflege: ohne das trägt jede höhere Rangrolle die Rechte aller niedrigeren
+ * noch einmal als Kopie, und jede spätere Änderung ist an mehreren Stellen
+ * nachzuziehen - oder eben nicht, und dann laufen sie auseinander.
+ *
+ * Geerbt wird **alles**, was eine Rolle gewährt, nicht nur die Kästchen:
+ * Rechte, Freigabestufe und der Türsteher. Eine höhere Sprosse darf nie
+ * weniger wert sein als eine niedrigere, sonst wäre eine Beförderung unter
+ * Umständen eine Herabstufung - und genau das passiert, wenn beim Befördern in
+ * Discord die alte Rangrolle abgenommen wird, was dort üblich ist.
+ *
+ * Die Vererbung ist bewusst eine **Ordnung** und kein Zeiger je Rolle: über
+ * ganzen Zahlen gibt es keinen Zyklus, den man abfangen müsste.
+ */
+
+/** Das, was eine Rolle gewährt - so viel, wie für die Rechnung nötig ist. */
+export type LadderRung = {
+  discordRoleId: string
+  clearanceLevel: number
+  permissions: readonly string[]
+  grantsMembership: boolean
+  ladderId: string | null
+  ladderRank: number | null
+}
+
+/** Dasselbe, nachdem die Sprossen darunter eingerechnet sind. */
+export type ResolvedRung = {
+  clearanceLevel: number
+  permissions: Set<Permission>
+  grantsMembership: boolean
+  /** Nur das Geerbte, für die Anzeige im Adminbereich. */
+  inherited: Set<Permission>
+  /** Die Stufe der eigenen Zeile, falls die geerbte höher liegt. */
+  ownClearanceLevel: number
+}
+
+function leer(): ResolvedRung {
+  return {
+    clearanceLevel: 0,
+    permissions: new Set<Permission>(),
+    grantsMembership: false,
+    inherited: new Set<Permission>(),
+    ownClearanceLevel: 0,
+  }
+}
+
+/**
+ * Was eine einzelne Rolle gewährt, einschliesslich aller Sprossen unter ihr.
+ *
+ * `alle` muss nur die Rollen enthalten, die für diese Rechnung infrage kommen -
+ * die Leiter selbst genügt. Rollen ohne Leiter erben nichts und werden von
+ * keiner Leiter berührt.
+ */
+export function withInherited(rolle: LadderRung, alle: readonly LadderRung[]): ResolvedRung {
+  const ergebnis = leer()
+
+  ergebnis.clearanceLevel = rolle.clearanceLevel
+  ergebnis.ownClearanceLevel = rolle.clearanceLevel
+  ergebnis.grantsMembership = rolle.grantsMembership
+  for (const wert of rolle.permissions) {
+    if (isPermission(wert)) ergebnis.permissions.add(wert)
+  }
+
+  if (rolle.ladderId === null || rolle.ladderRank === null) return ergebnis
+
+  for (const andere of alle) {
+    if (andere.ladderId !== rolle.ladderId) continue
+    if (andere.ladderRank === null || andere.ladderRank > rolle.ladderRank) continue
+    if (andere.discordRoleId === rolle.discordRoleId) continue
+
+    if (andere.clearanceLevel > ergebnis.clearanceLevel) {
+      ergebnis.clearanceLevel = andere.clearanceLevel
+    }
+    if (andere.grantsMembership) ergebnis.grantsMembership = true
+    for (const wert of andere.permissions) {
+      if (!isPermission(wert)) continue
+      if (!ergebnis.permissions.has(wert)) ergebnis.inherited.add(wert)
+      ergebnis.permissions.add(wert)
+    }
+  }
+
+  return ergebnis
+}
+
+/**
+ * Dasselbe für einen ganzen Satz Rollen auf einmal, als Tabelle nach
+ * Rollen-ID. Für die Adminansicht, die jede Rolle mit ihrem tatsächlichen
+ * Ergebnis zeigen muss - sonst steht in der Vorschau etwas anderes, als der
+ * Nutzer später bekommt.
+ */
+export function resolveAll(alle: readonly LadderRung[]): Map<string, ResolvedRung> {
+  const tabelle = new Map<string, ResolvedRung>()
+  for (const rolle of alle) {
+    tabelle.set(rolle.discordRoleId, withInherited(rolle, alle))
+  }
+  return tabelle
+}
+
+/**
+ * Die höchste Sprosse je Leiter, die jemand mit diesen Rollen trägt.
+ *
+ * Damit lässt sich das Geerbte in **einer** weiteren Abfrage nachladen, statt
+ * die ganze Zuordnungstabelle zu holen und in JavaScript zu filtern.
+ */
+export function highestRungPerLadder(
+  rollen: readonly Pick<LadderRung, 'ladderId' | 'ladderRank'>[],
+): Map<string, number> {
+  const hoechste = new Map<string, number>()
+  for (const rolle of rollen) {
+    if (rolle.ladderId === null || rolle.ladderRank === null) continue
+    const bisher = hoechste.get(rolle.ladderId)
+    if (bisher === undefined || rolle.ladderRank > bisher) {
+      hoechste.set(rolle.ladderId, rolle.ladderRank)
+    }
+  }
+  return hoechste
+}

web/lib/i18n/admin.ts

@@ -88,6 +88,7 @@ export const adminText = {
   intro: 'Rollen, Vorlagen, Regeln und das Protokoll der Abteilung.',
   sections: {
     roles: 'Rollen',
+    ladders: 'Ranggefüge',
     departments: 'Abteilungen',
     templates: 'Vorlagen',
     policy: 'Änderungsrichtlinie',
@@ -96,6 +97,7 @@ export const adminText = {
   } as Record<string, string>,
   descriptions: {
     roles: 'Welche Discord-Rolle welche Freigabestufe und welche Rechte trägt.',
+    ladders: 'Rollen, die aufeinander aufbauen. Die obere kann alles, was die untere kann.',
     departments: 'Die Abteilungen der Foundation. Zugeordnet wird in der Personalakte.',
     templates: 'Aufbau der Fallakten und Dokumente, Bausteine und Fassungen.',
     policy: 'Ob und wie lange Verlaufseinträge nachträglich geändert werden dürfen.',
@@ -143,6 +145,10 @@ export const roleAdminText = {
   } as Record<string, string>,
   optIn:
     'Dieses Recht ist im Auslieferungszustand keiner Rolle zugeordnet. Vergib es bewusst.',
+  inLadder: 'Im Gefüge',
+  inheritedFrom: 'Geerbt aus dem Gefüge',
+  inheritedNote: 'Kursiv gesetzte Rechte kommen aus dem Ranggefüge und werden dort verwaltet.',
+  clearanceRaised: 'Durch das Gefüge tatsächlich Stufe',
   preview: {
     heading: 'Vorschau',
     intro: 'Was jemand mit dieser Stufe sieht, wenn er keine weiteren Rollen hat.',
@@ -213,3 +219,45 @@ export const vitalsText = {
     FCP: 'unter 1,0 s',
   } as Record<string, string>,
 } as const
+
+export const ladderAdminText = {
+  heading: 'Ranggefüge',
+  intro:
+    'Rollen, die aufeinander aufbauen. Jede Rolle in einem Gefüge kann alles, was die Rollen unter ihr können - Rechte, Freigabestufe und die Anmeldung. Bei einer höheren Rangrolle hakst du deshalb nur noch das ab, was neu dazukommt.',
+  why: 'Das trägt auch den üblichen Fall, dass beim Befördern die alte Rangrolle in Discord abgenommen wird: die neue allein genügt dann schon.',
+  empty: 'Noch kein Gefüge angelegt.',
+  noRoles:
+    'Noch keine Rollen eingelesen. Der Worker spiegelt sie, sobald er am Discord-Gateway hängt.',
+  create: 'Gefüge anlegen',
+  creating: 'Wird angelegt',
+  name: 'Name',
+  namePlaceholder: 'Dienstgrade',
+  note: 'Notiz',
+  notePlaceholder: 'Wofür dieses Gefüge steht',
+  save: 'Reihenfolge speichern',
+  saving: 'Wird gespeichert',
+  saved: 'Gespeichert',
+  rename: 'Umbenennen',
+  remove: 'Gefüge auflösen',
+  removing: 'Wird aufgelöst',
+  confirmRemove:
+    'Gefüge auflösen? Die Rollen bleiben bestehen, verlieren aber alles, was sie nur geerbt haben. Das wirkt sofort für alle.',
+  confirmSave: 'Reihenfolge ändern? Das ändert sofort, was die Träger dieser Rollen dürfen.',
+  addRole: 'Rolle aufnehmen',
+  none: '— keine —',
+  rungs: 'Sprossen, unten die niedrigste',
+  bottom: 'unterste Sprosse',
+  top: 'oberste Sprosse',
+  up: 'Höher',
+  down: 'Tiefer',
+  drop: 'Herausnehmen',
+  emptyLadder: 'Noch keine Rolle in diesem Gefüge.',
+  inherits: 'erbt',
+  inheritsNothing: 'erbt nichts, unterste Sprosse',
+  ownOnly: 'eigene Rechte',
+  effectiveClearance: 'Stufe wirksam',
+  raisedBy: 'angehoben durch das Gefüge',
+  nameInvalid: 'Name fehlt oder ist zu lang.',
+  nameTaken: 'Ein Gefüge mit diesem Namen gibt es schon.',
+  tooLong: 'Zu viele Sprossen für ein Gefüge.',
+} as const

web/lib/i18n/common.ts

@@ -33,6 +33,9 @@ export const actionErrorsText = {
   'department-name-missing': 'Die Abteilung braucht einen Namen.',
   'clearance-too-low': 'Deine Freigabestufe reicht dafür nicht.',
   'no-permission': 'Dir fehlt das nötige Recht.',
+  'ladder-name-invalid': 'Das Gefüge braucht einen Namen, höchstens 80 Zeichen.',
+  'ladder-name-taken': 'Ein Gefüge mit diesem Namen gibt es schon.',
+  'ladder-too-long': 'Zu viele Sprossen für ein Gefüge.',
   'read-only': 'Der Datensatz ist schreibgeschützt.',
   closed: 'Der Vorgang ist abgeschlossen. Änderungen brauchen ein eigenes Recht.',
   'reason-required': 'Begründung nötig, mindestens 10 Zeichen.',

web/lib/i18n/de.ts

@@ -50,6 +50,7 @@ import {
   adminText,
   auditText,
   roleAdminText,
+  ladderAdminText,
   templateAdminText,
   settingsText,
   vitalsText,
@@ -63,6 +64,7 @@ export const de = {
   admin: adminText,
   audit: auditText,
   roleAdmin: roleAdminText,
+  ladderAdmin: ladderAdminText,
   clearance: clearanceText,
   case: caseText,
   section: sectionText,

web/lib/roles/ladders.ts

@@ -0,0 +1,261 @@
+import type { Prisma } from '@afis/db'
+import { db } from '@/lib/db'
+import { AccessError } from '@/lib/errors'
+import { writeAudit } from '@/lib/audit/write'
+import { invalidateAll } from '@/lib/auth/effective'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import { resolveAll, type LadderRung } from '@/lib/auth/ladders'
+
+/**
+ * Verwaltung der Ranggefüge.
+ *
+ * Wer Leitern ändert, ändert die Rechte jedes Trägers - deshalb steht hinter
+ * jeder Schreibfunktion ein Protokolleintrag (harte Regel 3) und `roles.manage`
+ * als Recht. Die Rechnung selbst steht in lib/auth/ladders.ts; hier steht nur,
+ * wie sie in die Datenbank kommt.
+ */
+
+/** Höchstzahl Sprossen je Leiter. Achtzehn Rollen sind der ganze Bestand. */
+export const MAX_RUNGS = 30
+
+const NAME_MAX = 80
+const NOTE_MAX = 300
+
+function darf(p: EffectivePermissions): void {
+  if (!p.isAdmin && !p.permissions.has('roles.manage')) {
+    throw new AccessError('no-permission')
+  }
+}
+
+function pruefeName(name: string): string {
+  const sauber = name.trim()
+  if (sauber.length === 0 || sauber.length > NAME_MAX) {
+    throw new AccessError('ladder-name-invalid')
+  }
+  return sauber
+}
+
+export type LadderRoleView = {
+  discordRoleId: string
+  label: string
+  ladderRank: number
+  isPresent: boolean
+  /** Was in der eigenen Zeile steht. */
+  ownPermissions: string[]
+  ownClearanceLevel: number
+  /** Was durch die Leiter dazukommt. */
+  inheritedPermissions: string[]
+  effectiveClearanceLevel: number
+  effectiveGrantsMembership: boolean
+}
+
+export type LadderView = {
+  id: string
+  name: string
+  note: string | null
+  roles: LadderRoleView[]
+}
+
+/**
+ * Alle Leitern mit ihren Sprossen, von unten nach oben.
+ *
+ * Die Rollen einer Leiter werden vollständig geladen, weil die Vererbung nur
+ * mit allen Sprossen zu rechnen ist - es sind je Leiter eine Handvoll.
+ */
+export async function listLadders(p: EffectivePermissions): Promise<LadderView[]> {
+  darf(p)
+
+  const leitern = await db.roleLadder.findMany({
+    orderBy: { name: 'asc' },
+    include: {
+      roles: {
+        orderBy: [{ ladderRank: 'asc' }, { label: 'asc' }],
+        select: {
+          discordRoleId: true,
+          label: true,
+          clearanceLevel: true,
+          permissions: true,
+          grantsMembership: true,
+          ladderId: true,
+          ladderRank: true,
+          isPresent: true,
+        },
+      },
+    },
+  })
+
+  return leitern.map((leiter) => {
+    const aufgeloest = resolveAll(leiter.roles as LadderRung[])
+    return {
+      id: leiter.id,
+      name: leiter.name,
+      note: leiter.note,
+      roles: leiter.roles.map((rolle) => {
+        const ergebnis = aufgeloest.get(rolle.discordRoleId)
+        return {
+          discordRoleId: rolle.discordRoleId,
+          label: rolle.label,
+          ladderRank: rolle.ladderRank ?? 0,
+          isPresent: rolle.isPresent,
+          ownPermissions: rolle.permissions,
+          ownClearanceLevel: rolle.clearanceLevel,
+          inheritedPermissions: [...(ergebnis?.inherited ?? [])].sort(),
+          effectiveClearanceLevel: ergebnis?.clearanceLevel ?? rolle.clearanceLevel,
+          effectiveGrantsMembership: ergebnis?.grantsMembership ?? rolle.grantsMembership,
+        }
+      }),
+    }
+  })
+}
+
+async function protokoll(
+  client: Pick<typeof db, 'auditLog'>,
+  p: EffectivePermissions,
+  ladderId: string,
+  meta: Prisma.InputJsonValue,
+): Promise<void> {
+  await writeAudit(client, {
+    actorId: p.userId,
+    action: 'roles.update',
+    targetType: 'RoleLadder',
+    targetId: ladderId,
+    clearanceAtTime: p.clearanceLevel,
+    meta,
+  })
+}
+
+export async function createLadder(
+  p: EffectivePermissions,
+  input: { name: string; note?: string },
+): Promise<string> {
+  darf(p)
+  const name = pruefeName(input.name)
+  const note = input.note?.trim().slice(0, NOTE_MAX) || null
+
+  const vorhanden = await db.roleLadder.findUnique({ where: { name }, select: { id: true } })
+  if (vorhanden) throw new AccessError('ladder-name-taken')
+
+  const leiter = await db.$transaction(async (tx) => {
+    const angelegt = await tx.roleLadder.create({
+      data: { name, note, createdById: p.userId },
+      select: { id: true },
+    })
+    await protokoll(tx, p, angelegt.id, { created: name })
+    return angelegt
+  })
+
+  invalidateAll()
+  return leiter.id
+}
+
+export async function updateLadder(
+  p: EffectivePermissions,
+  input: { id: string; name: string; note?: string },
+): Promise<void> {
+  darf(p)
+  const name = pruefeName(input.name)
+  const note = input.note?.trim().slice(0, NOTE_MAX) || null
+
+  const vorhanden = await db.roleLadder.findUnique({
+    where: { name },
+    select: { id: true },
+  })
+  if (vorhanden && vorhanden.id !== input.id) throw new AccessError('ladder-name-taken')
+
+  await db.$transaction(async (tx) => {
+    const alt = await tx.roleLadder.findUnique({
+      where: { id: input.id },
+      select: { name: true },
+    })
+    if (!alt) throw new AccessError('not-found')
+
+    await tx.roleLadder.update({ where: { id: input.id }, data: { name, note } })
+    await protokoll(tx, p, input.id, { renamedFrom: alt.name, renamedTo: name })
+  })
+
+  invalidateAll()
+}
+
+/**
+ * Leiter auflösen. Die Rollen bleiben, sie stehen danach wieder für sich.
+ *
+ * Das ist der Grund für `ON DELETE SET NULL` statt eines Verbots: eine Leiter
+ * loszuwerden darf nicht daran scheitern, dass Rollen darin stehen. Dass die
+ * Träger dabei Rechte verlieren, ist gewollt und steht im Protokoll.
+ */
+export async function deleteLadder(p: EffectivePermissions, id: string): Promise<void> {
+  darf(p)
+
+  await db.$transaction(async (tx) => {
+    const leiter = await tx.roleLadder.findUnique({
+      where: { id },
+      select: { name: true, roles: { select: { discordRoleId: true } } },
+    })
+    if (!leiter) throw new AccessError('not-found')
+
+    await tx.roleMapping.updateMany({
+      where: { ladderId: id },
+      data: { ladderId: null, ladderRank: null },
+    })
+    await protokoll(tx, p, id, {
+      deleted: leiter.name,
+      releasedRoles: leiter.roles.map((r) => r.discordRoleId),
+    })
+    await tx.roleLadder.delete({ where: { id } })
+  })
+
+  invalidateAll()
+}
+
+/**
+ * Die Sprossen einer Leiter neu setzen: Zugehörigkeit und Reihenfolge in einem
+ * Zug, von unten nach oben.
+ *
+ * In **einem** Zug, weil jeder Zwischenzustand ein anderer Rechtestand wäre.
+ * Rollen, die vorher in dieser Leiter standen und jetzt nicht mehr in der Liste
+ * sind, fallen heraus - eine Rolle steht in höchstens einer Leiter.
+ */
+export async function setLadderRoles(
+  p: EffectivePermissions,
+  input: { id: string; roleIds: readonly string[] },
+): Promise<void> {
+  darf(p)
+
+  const reihenfolge = [...new Set(input.roleIds)]
+  if (reihenfolge.length > MAX_RUNGS) throw new AccessError('ladder-too-long')
+
+  await db.$transaction(async (tx) => {
+    const leiter = await tx.roleLadder.findUnique({
+      where: { id: input.id },
+      select: { name: true },
+    })
+    if (!leiter) throw new AccessError('not-found')
+
+    if (reihenfolge.length > 0) {
+      const bekannt = await tx.roleMapping.findMany({
+        where: { discordRoleId: { in: reihenfolge } },
+        select: { discordRoleId: true },
+      })
+      if (bekannt.length !== reihenfolge.length) throw new AccessError('not-found')
+    }
+
+    // Erst alles lösen, dann neu setzen. Sonst müsste die Reihenfolge der
+    // Schreibvorgänge stimmen, damit keine Rolle zwischenzeitlich in zwei
+    // Leitern steht.
+    await tx.roleMapping.updateMany({
+      where: { ladderId: input.id },
+      data: { ladderId: null, ladderRank: null },
+    })
+
+    for (const [rang, discordRoleId] of reihenfolge.entries()) {
+      await tx.roleMapping.update({
+        where: { discordRoleId },
+        data: { ladderId: input.id, ladderRank: rang },
+      })
+    }
+
+    await protokoll(tx, p, input.id, { ladder: leiter.name, rungs: reihenfolge })
+  })
+
+  invalidateAll()
+}