Terminplaner: Einstellungen und Branchen-Vorlagen

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

test/termineEinstellungen.test.js

@@ -0,0 +1,788 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  neueId,
+  normalisiereEinstellung,
+  oeffentlicheEinstellung,
+  knopfText,
+  istVerbraucher,
+  brauchtZustimmungVorzeitig,
+  preisText,
+  preisHinweis,
+  zahlungText,
+} from '../server/services/termine/einstellungen.js'
+import { VORLAGEN, vorlagenListe, ausVorlage } from '../server/services/termine/vorlagen.js'
+import { BUNDESLAENDER } from '../server/services/termine/feiertage.js'
+
+const NOW = new Date('2026-10-02T10:00:00.000Z') // Berlin: 2026-10-02 12:00
+const TAG = 86400000
+
+const R1 = 'r_aaaaaaa1'
+const R2 = 'r_aaaaaaa2'
+const S1 = 's_bbbbbbb1'
+const S2 = 's_bbbbbbb2'
+
+/** Kleinste gueltige Eingabe; alles andere kommt aus den Vorgaben. */
+const basis = () => ({
+  betrieb: { name: 'Salon Müller', email: 'info@salon.de' },
+  ressourcen: [{ id: R1, name: 'Anna', plan: { 1: [['09:00', '12:30'], ['13:30', '18:00']] } }],
+  leistungen: [{ id: S1, name: 'Damenschnitt', dauer: 45, ressourcen: [R1] }],
+})
+
+const pruefe = (eingabe, optionen = {}) => normalisiereEinstellung(eingabe, { now: NOW, ...optionen })
+const gueltig = (eingabe, optionen) => {
+  const erg = pruefe(eingabe, optionen)
+  assert.equal(erg.fehler, undefined, JSON.stringify(erg.fehler))
+  return erg.einstellung
+}
+const fehlerVon = (eingabe, optionen) => {
+  const erg = pruefe(eingabe, optionen)
+  assert.equal(erg.einstellung, undefined)
+  assert.ok(erg.fehler && typeof erg.fehler === 'object')
+  return erg.fehler
+}
+
+const BETRIEB = {
+  name: 'Salon Müller',
+  email: 'Info@Salon.de',
+  telefon: '06301 1234',
+  adresse: 'Hauptstr. 1, 67722 Winnweiler',
+  kleinunternehmer: false,
+  websiteUrl: 'https://salon.de',
+  impressumUrl: 'https://salon.de/impressum',
+  datenschutzUrl: 'https://salon.de/datenschutz',
+}
+
+// ---------------------------------------------------------------- IDs
+
+test('neueId: Praefix, 8 Zeichen aus a-z0-9, unterschiedlich; unbekannter Praefix wirft', () => {
+  const ids = new Set()
+  for (const p of ['r', 's', 'a']) {
+    for (let i = 0; i < 50; i += 1) {
+      const id = neueId(p)
+      assert.match(id, new RegExp(`^${p}_[a-z0-9]{8}$`))
+      ids.add(id)
+    }
+  }
+  assert.equal(ids.size, 150)
+  assert.throws(() => neueId('x'))
+  assert.throws(() => neueId())
+})
+
+// ---------------------------------------------------------------- Vorlagen
+
+test('Vorlagen: neun Schluessel in fester Reihenfolge, Liste mit Name und Beschreibung', () => {
+  const keys = ['salon', 'kosmetik', 'beratung', 'werkstatt', 'handwerk', 'tattoo', 'fotograf', 'hundesalon', 'sonstiges']
+  assert.deepEqual(Object.keys(VORLAGEN), keys)
+  const liste = vorlagenListe()
+  assert.deepEqual(liste.map((v) => v.key), keys)
+  for (const eintrag of liste) {
+    assert.deepEqual(Object.keys(eintrag).sort(), ['beschreibung', 'key', 'name'])
+    assert.ok(eintrag.name.length > 2 && eintrag.beschreibung.length > 10)
+  }
+})
+
+test('Vorlagen: jede ergibt eine gueltige, stabile Einstellung', () => {
+  for (const key of Object.keys(VORLAGEN)) {
+    const e = ausVorlage(key, BETRIEB, NOW)
+    assert.equal(e.vorlage, key)
+    assert.equal(e.betrieb.name, 'Salon Müller')
+    assert.equal(e.betrieb.email, 'info@salon.de')
+    assert.equal(e.betrieb.websiteUrl, 'https://salon.de/')
+    assert.ok(e.leistungen.length >= 2 && e.leistungen.length <= 5, `${key}: ${e.leistungen.length} Leistungen`)
+    assert.ok(e.ressourcen.length >= 1)
+    assert.ok(e.leistungen.every((l) => l.aktiv && l.ressourcen.length >= 1))
+    assert.ok(e.ressourcen.every((r) => Object.keys(r.plan).length >= 1 && r.feedToken.length === 43))
+    assert.equal(e.zahlung.modus, 'vorort')
+    // erneutes Normalisieren aendert nichts (Token und Storno-Version bleiben)
+    const nochmal = gueltig(e, { bisher: e })
+    assert.deepEqual(nochmal, e, key)
+  }
+})
+
+test('Vorlagen: Anfrage bei tattoo/handwerk/fotograf, sonst sofort; Werkstatt mit zwei Plaetzen', () => {
+  for (const key of Object.keys(VORLAGEN)) {
+    const e = ausVorlage(key, BETRIEB, NOW)
+    const erwartet = ['tattoo', 'handwerk', 'fotograf'].includes(key) ? 'anfrage' : 'sofort'
+    assert.ok(e.leistungen.every((l) => l.buchungsart === erwartet), key)
+  }
+  const werkstatt = ausVorlage('werkstatt', BETRIEB, NOW)
+  assert.equal(werkstatt.ressourcen.length, 2)
+  assert.ok(werkstatt.ressourcen.every((r) => r.typ === 'platz'))
+})
+
+test('Vorlagen: Stornotext Variante 1 mit Frist aus den Regeln und 50 Prozent, Widerrufssatz bleibt', () => {
+  for (const key of Object.keys(VORLAGEN)) {
+    const e = ausVorlage(key, BETRIEB, NOW)
+    const text = e.storno.text
+    assert.ok(text.startsWith(`Sie können Ihren Termin bis ${e.regeln.absageBisStd} Stunden vorher kostenlos absagen oder verschieben (Link in der Bestätigungsmail).`), key)
+    assert.ok(text.includes('berechnen wir für den freigehaltenen Termin 50 % des Preises.'), key)
+    assert.ok(text.includes('Dem Kunden bleibt der Nachweis vorbehalten, dass uns kein oder ein geringerer Aufwand entstanden ist.'), key)
+    assert.ok(text.endsWith('Ihr gesetzliches Widerrufsrecht bleibt unberührt.'), key)
+    assert.ok(!text.includes('{{'), key)
+    assert.equal(e.storno.version, '2026-10-02-1')
+  }
+})
+
+test('Vorlagen: zwei Aufrufe ergeben verschiedene IDs und Feed-Token; Kleinunternehmer wird uebernommen', () => {
+  const a = ausVorlage('salon', BETRIEB, NOW)
+  const b = ausVorlage('salon', { ...BETRIEB, kleinunternehmer: true }, NOW)
+  assert.notEqual(a.ressourcen[0].id, b.ressourcen[0].id)
+  assert.notEqual(a.ressourcen[0].feedToken, b.ressourcen[0].feedToken)
+  assert.equal(a.betrieb.kleinunternehmer, false)
+  assert.equal(b.betrieb.kleinunternehmer, true)
+})
+
+test('Vorlagen: unbekannter Schluessel wirft, fehlende Betriebsangaben werfen mit Feldfehlern', () => {
+  assert.throws(() => ausVorlage('gibtsnicht', BETRIEB, NOW), /Unbekannte Vorlage/)
+  assert.throws(() => ausVorlage('__proto__', BETRIEB, NOW), /Unbekannte Vorlage/)
+  assert.throws(() => ausVorlage('salon', {}, NOW), (err) => {
+    assert.ok(err.fehler['betrieb.name'] && err.fehler['betrieb.email'])
+    return true
+  })
+})
+
+test('Vorlagen: VORLAGEN ist eingefroren', () => {
+  assert.throws(() => { VORLAGEN.salon.leistungen.push({}) })
+  assert.throws(() => { VORLAGEN.neu = {} })
+})
+
+// ---------------------------------------------------------------- Normalisieren: Grundlagen
+
+test('Vorgaben werden aufgefuellt', () => {
+  const e = gueltig(basis())
+  assert.equal(e.schema, 1)
+  assert.equal(e.vorlage, null)
+  assert.deepEqual(e.betrieb, {
+    name: 'Salon Müller', email: 'info@salon.de', telefon: '', kleinunternehmer: false, adresse: '',
+    impressumUrl: null, datenschutzUrl: null, agbUrl: null, websiteUrl: null,
+  })
+  assert.equal(e.anrede, 'sie')
+  assert.match(e.farbe, /^#[0-9a-f]{6}$/)
+  assert.ok(BUNDESLAENDER.includes(e.bundesland))
+  assert.equal(e.feiertageGeschlossen, true)
+  assert.deepEqual(e.sonderoeffnungen, {})
+  assert.deepEqual(e.abwesenheiten, [])
+  assert.deepEqual(e.regeln, { raster: 15, vorlaufMin: 120, horizontTage: 60, absageBisStd: 24, maxOffeneJeEmail: 3, personWaehlbar: true })
+  assert.deepEqual(e.gastFelder, { telefon: 'optional', nachricht: 'aus', zusatz: [] })
+  assert.deepEqual(e.erinnerung, { anbieten: true, stundenVorher: 24 })
+  assert.deepEqual(e.storno, { text: '', version: '' })
+  assert.deepEqual(e.recht, { gaesteSind: 'verbraucher', freizeit: false })
+  assert.deepEqual(e.zahlung, { modus: 'vorort', vorOrtArten: ['bar', 'ec', 'kreditkarte'] })
+  assert.equal(e.aufbewahrungTage, 90)
+  assert.deepEqual(e.leistungen[0], {
+    id: S1, name: 'Damenschnitt', beschreibung: '', dauer: 45, pufferNach: 0, preisArt: 'keiner', preisCent: 0,
+    buchungsart: 'sofort', ressourcen: [R1], aktiv: true, reihenfolge: 1,
+  })
+  assert.deepEqual(e.ressourcen[0].plan, { 1: [['09:00', '12:30'], ['13:30', '18:00']] })
+  assert.equal(e.ressourcen[0].typ, 'person')
+  assert.equal(e.ressourcen[0].aktiv, true)
+})
+
+test('Eingabe wird nicht veraendert; Nicht-Objekte werden abgelehnt', () => {
+  const eingabe = basis()
+  const kopie = structuredClone(eingabe)
+  gueltig(eingabe)
+  assert.deepEqual(eingabe, kopie)
+  for (const unsinn of [null, undefined, 'x', 5, [], true]) {
+    assert.deepEqual(Object.keys(fehlerVon(unsinn)), ['_'])
+  }
+})
+
+test('now ist Pflicht', () => {
+  assert.throws(() => normalisiereEinstellung(basis(), {}), /now/)
+  assert.throws(() => normalisiereEinstellung(basis()), /now/)
+  assert.throws(() => normalisiereEinstellung(basis(), { now: 'heute' }), /now/)
+})
+
+test('Pflichtfelder: Betriebsname und Betriebs-E-Mail', () => {
+  const f = fehlerVon({})
+  assert.ok(f['betrieb.name'])
+  assert.ok(f['betrieb.email'])
+  assert.ok(fehlerVon({ betrieb: { name: '   ', email: 'a@b.de' } })['betrieb.name'])
+  assert.ok(fehlerVon({ betrieb: { name: 'X' } })['betrieb.email'])
+})
+
+test('Betriebsname wird auf 80 Zeichen gekuerzt, Steuerzeichen fliegen raus', () => {
+  const e = gueltig({ ...basis(), betrieb: { name: `  Sa\u0000lon\n\tMüller\u202E ${'x'.repeat(100)}`, email: 'a@b.de' } })
+  assert.ok(e.betrieb.name.startsWith('Salon Müller xxx'))
+  assert.equal([...e.betrieb.name].length, 80)
+  assert.ok(!/[\u0000-\u001f\u202E]/.test(e.betrieb.name))
+})
+
+test('E-Mail: genau ein Postfach, klein und getrimmt', () => {
+  assert.equal(gueltig({ ...basis(), betrieb: { name: 'X', email: '  Info@Salon.DE ' } }).betrieb.email, 'info@salon.de')
+  for (const schlecht of ['a@b.de, c@d.de', 'a@b.de;c@d.de', '<a@b.de>', '"a"@b.de', 'a b@c.de', 'ohne-at.de', 'a@b', 'a@@b.de', '@b.de', 'a@.de', `${'x'.repeat(250)}@b.de`]) {
+    assert.ok(fehlerVon({ ...basis(), betrieb: { name: 'X', email: schlecht } })['betrieb.email'], schlecht)
+  }
+})
+
+test('URLs: nur https, kein javascript:, keine Zugangsdaten, hoechstens 300 Zeichen', () => {
+  const mit = (feld, wert) => ({ ...basis(), betrieb: { name: 'X', email: 'a@b.de', [feld]: wert } })
+  const f = fehlerVon(mit('impressumUrl', 'javascript:alert(1)'))
+  assert.ok(f['betrieb.impressumUrl'])
+  for (const feld of ['impressumUrl', 'datenschutzUrl', 'agbUrl', 'websiteUrl']) {
+    for (const schlecht of ['http://salon.de', 'javascript:alert(1)', 'java\nscript:alert(1)', 'data:text/html,x', 'https://user:pw@salon.de', 'https://user@salon.de', '//salon.de', 'salon.de', `https://salon.de/${'a'.repeat(300)}`, 'https://sa lon.de', 5]) {
+      assert.ok(fehlerVon(mit(feld, schlecht))[`betrieb.${feld}`], `${feld}: ${schlecht}`)
+    }
+    assert.equal(gueltig(mit(feld, 'https://salon.de/impressum')).betrieb[feld], 'https://salon.de/impressum')
+    assert.equal(gueltig(mit(feld, '')).betrieb[feld], null)
+    assert.equal(gueltig(mit(feld, null)).betrieb[feld], null)
+  }
+})
+
+test('Farbe, Anrede, Bundesland werden geprueft', () => {
+  assert.equal(gueltig({ ...basis(), farbe: '#AABBCC' }).farbe, '#aabbcc')
+  for (const schlecht of ['red', '#abc', '#12345g', 'ffffff', 5]) assert.ok(fehlerVon({ ...basis(), farbe: schlecht }).farbe, String(schlecht))
+  assert.equal(gueltig({ ...basis(), anrede: 'du' }).anrede, 'du')
+  assert.ok(fehlerVon({ ...basis(), anrede: 'ihr' }).anrede)
+  for (const land of BUNDESLAENDER) assert.equal(gueltig({ ...basis(), bundesland: land }).bundesland, land)
+  for (const schlecht of ['XX', 'rp', 'Bayern', 'BUND', 'ALL', 5]) assert.ok(fehlerVon({ ...basis(), bundesland: schlecht }).bundesland, String(schlecht))
+  assert.ok(fehlerVon({ ...basis(), feiertageGeschlossen: 'ja' }).feiertageGeschlossen)
+})
+
+// ---------------------------------------------------------------- Wochenplan
+
+test('Fenster: Minuten muessen Vielfache von 5 sein (09:07 => Fehler am Plan-Pfad)', () => {
+  const eingabe = basis()
+  eingabe.ressourcen[0].plan = { 1: [['09:07', '12:00']] }
+  assert.ok(fehlerVon(eingabe)['ressourcen.0.plan.1'])
+})
+
+test('Fenster: Format, Bereich, Ende nach Beginn, 24:00 nur als Ende', () => {
+  const mit = (fenster) => { const e = basis(); e.ressourcen[0].plan = { 3: fenster }; return e }
+  for (const schlecht of [
+    [['9:00', '12:00']], [['09:00', '12:00:00']], [['25:00', '26:00']], [['09:60', '12:00']], [['12:00', '12:00']], [['12:00', '09:00']],
+    [['24:00', '24:00']], [['09:00']], [['09:00', '12:00', '13:00']], ['09:00-12:00'], [[9, 12]], 'montags', [['09:00', '24:05']],
+  ]) {
+    assert.ok(fehlerVon(mit(schlecht))['ressourcen.0.plan.3'], JSON.stringify(schlecht))
+  }
+  assert.deepEqual(gueltig(mit([['18:00', '24:00']])).ressourcen[0].plan, { 3: [['18:00', '24:00']] })
+  assert.deepEqual(gueltig(mit([['00:00', '00:05']])).ressourcen[0].plan, { 3: [['00:00', '00:05']] })
+})
+
+test('Fenster: Ueberlappung und falsche Reihenfolge => Fehler am Pfad ressourcen.0.plan.1', () => {
+  const mit = (fenster) => { const e = basis(); e.ressourcen[0].plan = { 1: [['08:00', '08:30']], 2: fenster }; return e }
+  const ueberlappt = basis()
+  ueberlappt.ressourcen[0].plan = { 1: [['09:00', '12:00'], ['11:00', '15:00']] }
+  assert.match(fehlerVon(ueberlappt)['ressourcen.0.plan.1'], /überlappen/)
+  const unsortiert = basis()
+  unsortiert.ressourcen[0].plan = { 1: [['13:00', '15:00'], ['09:00', '12:00']] }
+  assert.match(fehlerVon(unsortiert)['ressourcen.0.plan.1'], /aufsteigend/)
+  // direkt aneinander ist keine Ueberlappung
+  assert.deepEqual(gueltig(mit([['09:00', '12:00'], ['12:00', '15:00']])).ressourcen[0].plan[2], [['09:00', '12:00'], ['12:00', '15:00']])
+})
+
+test('Wochenplan: nur Wochentage 1 bis 7; leere Tage entfallen', () => {
+  const e = basis()
+  e.ressourcen[0].plan = { 0: [['09:00', '10:00']] }
+  assert.ok(fehlerVon(e)['ressourcen.0.plan.0'])
+  e.ressourcen[0].plan = { 8: [['09:00', '10:00']] }
+  assert.ok(fehlerVon(e)['ressourcen.0.plan.8'])
+  e.ressourcen[0].plan = { 1: [], 2: [['09:00', '10:00']] }
+  assert.deepEqual(gueltig(e).ressourcen[0].plan, { 2: [['09:00', '10:00']] })
+  e.ressourcen[0].plan = 'immer'
+  assert.ok(fehlerVon(e)['ressourcen.0.plan'])
+})
+
+// ---------------------------------------------------------------- Ressourcen und Leistungen
+
+test('IDs: Format, Praefix, Eindeutigkeit; Eintraege ohne ID bekommen eine', () => {
+  const e = basis()
+  e.ressourcen.push({ name: 'Ben' })
+  e.leistungen.push({ name: 'Herrenschnitt', dauer: 30, ressourcen: [R1] })
+  const ok = gueltig(e)
+  assert.match(ok.ressourcen[1].id, /^r_[a-z0-9]{8}$/)
+  assert.match(ok.leistungen[1].id, /^s_[a-z0-9]{8}$/)
+
+  const falsch = basis()
+  falsch.ressourcen[0].id = 'x_aaaaaaa1'
+  assert.ok(fehlerVon(falsch)['ressourcen.0.id'])
+  const zuKurz = basis()
+  zuKurz.leistungen[0].id = 's_abc'
+  assert.ok(fehlerVon(zuKurz)['leistungen.0.id'])
+  const grossbuchstaben = basis()
+  grossbuchstaben.leistungen[0].id = 's_BBBBBBB1'
+  assert.ok(fehlerVon(grossbuchstaben)['leistungen.0.id'])
+  const doppelt = basis()
+  doppelt.ressourcen.push({ id: R1, name: 'Doppelt' })
+  assert.ok(fehlerVon(doppelt)['ressourcen.1.id'])
+  const doppelteLeistung = basis()
+  doppelteLeistung.leistungen.push({ id: S1, name: 'Nochmal', dauer: 30, ressourcen: [R1] })
+  assert.ok(fehlerVon(doppelteLeistung)['leistungen.1.id'])
+})
+
+test('Ressource: Name Pflicht, Typ person|platz, Reihenfolge der Liste bleibt', () => {
+  const e = basis()
+  e.ressourcen = [{ id: R1, name: '' }]
+  e.leistungen = []
+  assert.ok(fehlerVon(e)['ressourcen.0.name'])
+  e.ressourcen = [{ id: R1, name: 'A', typ: 'zimmer' }]
+  assert.ok(fehlerVon(e)['ressourcen.0.typ'])
+  e.ressourcen = [{ id: R2, name: 'Platz 2', typ: 'platz' }, { id: R1, name: 'Platz 1', typ: 'platz' }]
+  assert.deepEqual(gueltig(e).ressourcen.map((r) => r.id), [R2, R1])
+})
+
+test('Leistung: Pflichtfelder, Dauer und Pause in 5-Minuten-Schritten, Summe hoechstens 500', () => {
+  const mit = (aenderung) => { const e = basis(); Object.assign(e.leistungen[0], aenderung); return e }
+  assert.ok(fehlerVon(mit({ name: '' }))['leistungen.0.name'])
+  assert.ok(fehlerVon(mit({ dauer: undefined }))['leistungen.0.dauer'])
+  for (const dauer of [0, 4, 7, 485, 481, -5, 30.5, '30']) assert.ok(fehlerVon(mit({ dauer }))['leistungen.0.dauer'], String(dauer))
+  for (const dauer of [5, 480, 45]) assert.equal(gueltig(mit({ dauer })).leistungen[0].dauer, dauer)
+  for (const pufferNach of [-5, 3, 125, 121, '5']) assert.ok(fehlerVon(mit({ pufferNach }))['leistungen.0.pufferNach'], String(pufferNach))
+  for (const pufferNach of [0, 5, 120]) assert.equal(gueltig(mit({ pufferNach })).leistungen[0].pufferNach, pufferNach)
+  assert.ok(fehlerVon(mit({ dauer: 480, pufferNach: 25 }))['leistungen.0.dauer'])
+  assert.equal(gueltig(mit({ dauer: 480, pufferNach: 20 })).leistungen[0].pufferNach, 20)
+})
+
+test('Leistung: Preis, Preisart und Buchungsart', () => {
+  const mit = (aenderung) => { const e = basis(); Object.assign(e.leistungen[0], aenderung); return e }
+  assert.ok(fehlerVon(mit({ preisArt: 'gratis' }))['leistungen.0.preisArt'])
+  assert.ok(fehlerVon(mit({ buchungsart: 'online' }))['leistungen.0.buchungsart'])
+  for (const preisCent of [-1, 1000001, 4.5, '45']) assert.ok(fehlerVon(mit({ preisArt: 'fest', preisCent }))['leistungen.0.preisCent'], String(preisCent))
+  const fest = gueltig(mit({ preisArt: 'fest', preisCent: 4500 })).leistungen[0]
+  assert.equal(fest.preisCent, 4500)
+  assert.equal(gueltig(mit({ preisArt: 'ab', preisCent: 1000000 })).leistungen[0].preisCent, 1000000)
+  // ohne Preis wird die Zahl nicht mitgeschleppt
+  assert.equal(gueltig(mit({ preisArt: 'keiner', preisCent: 999 })).leistungen[0].preisCent, 0)
+  assert.equal(gueltig(mit({ buchungsart: 'anfrage' })).leistungen[0].buchungsart, 'anfrage')
+})
+
+test('Leistung: Beschreibung gekuerzt, Reihenfolge folgt der Liste', () => {
+  const e = basis()
+  e.leistungen[0].beschreibung = 'y'.repeat(500)
+  e.leistungen.push({ id: S2, name: 'Zweite', dauer: 15, ressourcen: [R1] })
+  const ok = gueltig(e)
+  assert.equal([...ok.leistungen[0].beschreibung].length, 300)
+  assert.deepEqual(ok.leistungen.map((l) => l.reihenfolge), [1, 2])
+})
+
+test('Leistung ohne aktive Ressource ist abgelehnt (aktiv, inaktiv, leer, unbekannt)', () => {
+  const ohne = basis()
+  ohne.leistungen[0].ressourcen = []
+  assert.ok(fehlerVon(ohne)['leistungen.0.ressourcen'])
+
+  const inaktiv = basis()
+  inaktiv.ressourcen[0].aktiv = false
+  assert.ok(fehlerVon(inaktiv)['leistungen.0.ressourcen'])
+
+  const unbekannt = basis()
+  unbekannt.leistungen[0].ressourcen = ['r_zzzzzzz9']
+  assert.ok(fehlerVon(unbekannt)['leistungen.0.ressourcen'])
+
+  const gemischt = basis()
+  gemischt.ressourcen.push({ id: R2, name: 'Ben', aktiv: false })
+  gemischt.leistungen[0].ressourcen = [R2, R1, R1]
+  assert.deepEqual(gueltig(gemischt).leistungen[0].ressourcen, [R2, R1])
+
+  // eine inaktive Leistung darf ohne aktive Ressource bleiben
+  const ruhend = basis()
+  ruhend.leistungen[0].aktiv = false
+  ruhend.leistungen[0].ressourcen = []
+  assert.equal(gueltig(ruhend).leistungen[0].aktiv, false)
+})
+
+// ---------------------------------------------------------------- Entfernen mit kuenftigen Terminen
+
+test('Entfernen einer Leistung mit kuenftigen Terminen => Fehler mit Anzahl', () => {
+  const bisher = gueltig(basis())
+  const neu = basis()
+  neu.leistungen = []
+  const f = fehlerVon(neu, { bisher, kuenftigeTermine: { leistungen: { [S1]: 3 }, ressourcen: {} } })
+  assert.equal(f[`leistungen.${S1}`], 'Für diese Leistung gibt es noch 3 künftige Termine. Deaktiviere sie stattdessen.')
+  const einzahl = fehlerVon(neu, { bisher, kuenftigeTermine: { leistungen: { [S1]: 1 }, ressourcen: {} } })
+  assert.equal(einzahl[`leistungen.${S1}`], 'Für diese Leistung gibt es noch 1 künftigen Termin. Deaktiviere sie stattdessen.')
+  // ohne kuenftige Termine darf sie weg, ebenso ohne Angabe
+  assert.deepEqual(gueltig(neu, { bisher, kuenftigeTermine: { leistungen: { [S1]: 0 }, ressourcen: {} } }).leistungen, [])
+  assert.deepEqual(gueltig(neu, { bisher }).leistungen, [])
+  assert.deepEqual(gueltig(neu, { bisher, kuenftigeTermine: { leistungen: { [S2]: 9 } } }).leistungen, [])
+})
+
+test('Entfernen einer Ressource mit kuenftigen Terminen => Fehler mit Anzahl (Person und Platz)', () => {
+  const bisher = gueltig(basis())
+  const neu = basis()
+  neu.ressourcen = []
+  neu.leistungen[0].aktiv = false
+  neu.leistungen[0].ressourcen = []
+  const f = fehlerVon(neu, { bisher, kuenftigeTermine: { leistungen: {}, ressourcen: { [R1]: 4 } } })
+  assert.equal(f[`ressourcen.${R1}`], 'Für diese Person gibt es noch 4 künftige Termine. Deaktiviere sie stattdessen.')
+
+  const platzBasis = basis()
+  platzBasis.ressourcen[0].typ = 'platz'
+  const platzBisher = gueltig(platzBasis)
+  const f2 = fehlerVon(neu, { bisher: platzBisher, kuenftigeTermine: { ressourcen: { [R1]: 2 } } })
+  assert.equal(f2[`ressourcen.${R1}`], 'Für diesen Platz gibt es noch 2 künftige Termine. Deaktiviere ihn stattdessen.')
+
+  assert.equal(gueltig(neu, { bisher, kuenftigeTermine: { leistungen: {}, ressourcen: { [R1]: 0 } } }).ressourcen.length, 0)
+})
+
+test('Deaktivieren ist trotz kuenftiger Termine erlaubt', () => {
+  const bisher = gueltig(basis())
+  const neu = basis()
+  neu.leistungen[0].aktiv = false
+  neu.ressourcen.push({ id: R2, name: 'Ben' })
+  neu.ressourcen[0].aktiv = false
+  neu.leistungen[0].ressourcen = [R2]
+  const e = gueltig(neu, { bisher, kuenftigeTermine: { leistungen: { [S1]: 5 }, ressourcen: { [R1]: 5 } } })
+  assert.equal(e.leistungen[0].aktiv, false)
+  assert.equal(e.ressourcen[0].aktiv, false)
+})
+
+// ---------------------------------------------------------------- Feed-Token
+
+test('feedToken: Client-Wert wird ignoriert, bisheriger bleibt, neue Ressourcen bekommen einen', () => {
+  const eins = gueltig({ ...basis(), ressourcen: [{ ...basis().ressourcen[0], feedToken: 'vom-client' }] })
+  assert.notEqual(eins.ressourcen[0].feedToken, 'vom-client')
+  assert.match(eins.ressourcen[0].feedToken, /^[A-Za-z0-9_-]{43}$/)
+
+  const zwei = basis()
+  zwei.ressourcen[0].feedToken = 'vom-client'
+  zwei.ressourcen.push({ id: R2, name: 'Ben', feedToken: eins.ressourcen[0].feedToken })
+  const nachher = gueltig(zwei, { bisher: eins })
+  assert.equal(nachher.ressourcen[0].feedToken, eins.ressourcen[0].feedToken)
+  assert.match(nachher.ressourcen[1].feedToken, /^[A-Za-z0-9_-]{43}$/)
+  assert.notEqual(nachher.ressourcen[1].feedToken, eins.ressourcen[0].feedToken)
+})
+
+// ---------------------------------------------------------------- Abwesenheiten, Sonderoeffnungen
+
+test('Abwesenheiten: von <= bis, gueltige Tage, bekannte Ressource oder null', () => {
+  const mit = (a) => ({ ...basis(), abwesenheiten: [a] })
+  const ok = gueltig(mit({ ressourceId: null, von: '2026-12-27', bis: '2026-12-31', titel: 'Betriebsurlaub' })).abwesenheiten
+  assert.equal(ok.length, 1)
+  assert.match(ok[0].id, /^a_[a-z0-9]{8}$/)
+  assert.deepEqual({ ...ok[0], id: 'x' }, { id: 'x', ressourceId: null, von: '2026-12-27', bis: '2026-12-31', titel: 'Betriebsurlaub' })
+  assert.equal(gueltig(mit({ ressourceId: R1, von: '2026-12-27', bis: '2026-12-27' })).abwesenheiten[0].ressourceId, R1)
+  assert.ok(fehlerVon(mit({ von: '2026-12-31', bis: '2026-12-27' }))['abwesenheiten.0.bis'])
+  assert.ok(fehlerVon(mit({ von: '2026-02-30', bis: '2026-03-01' }))['abwesenheiten.0.von'])
+  assert.ok(fehlerVon(mit({ von: '27.12.2026', bis: '2026-12-31' }))['abwesenheiten.0.von'])
+  assert.ok(fehlerVon(mit({ von: '2026-12-01' }))['abwesenheiten.0.bis'])
+  assert.ok(fehlerVon(mit({ ressourceId: 'r_zzzzzzz9', von: '2026-12-27', bis: '2026-12-31' }))['abwesenheiten.0.ressourceId'])
+  assert.ok(fehlerVon(mit({ id: 'r_aaaaaaa1', von: '2026-12-27', bis: '2026-12-31' }))['abwesenheiten.0.id'])
+})
+
+test('Sonderoeffnungen: gueltiger Tag, Fenster wie im Plan, leere Liste = geschlossen', () => {
+  const mit = (s) => ({ ...basis(), sonderoeffnungen: s })
+  assert.deepEqual(gueltig(mit({ '2026-12-24': [['09:00', '13:00']], '2026-12-31': [] })).sonderoeffnungen, {
+    '2026-12-24': [['09:00', '13:00']], '2026-12-31': [],
+  })
+  assert.deepEqual(gueltig(mit({ '2026-12-24': [['09:00', '24:00']] })).sonderoeffnungen['2026-12-24'], [['09:00', '24:00']])
+  assert.ok(fehlerVon(mit({ '2026-13-01': [['09:00', '13:00']] }))['sonderoeffnungen.2026-13-01'])
+  assert.ok(fehlerVon(mit({ 'morgen': [['09:00', '13:00']] }))['sonderoeffnungen.morgen'])
+  assert.ok(fehlerVon(mit({ '2026-12-24': [['09:03', '13:00']] }))['sonderoeffnungen.2026-12-24'])
+  assert.ok(fehlerVon(mit({ '2026-12-24': [['09:00', '13:00'], ['12:00', '14:00']] }))['sonderoeffnungen.2026-12-24'])
+  assert.ok(fehlerVon(mit([['09:00', '13:00']]))['sonderoeffnungen'])
+})
+
+// ---------------------------------------------------------------- Regeln, Gastfelder, Erinnerung, Zahlung
+
+test('Regeln: Wertebereiche', () => {
+  const mit = (r) => ({ ...basis(), regeln: r })
+  assert.deepEqual(gueltig(mit({ raster: 30, vorlaufMin: 0, horizontTage: 365, absageBisStd: 336, maxOffeneJeEmail: 10, personWaehlbar: false })).regeln,
+    { raster: 30, vorlaufMin: 0, horizontTage: 365, absageBisStd: 336, maxOffeneJeEmail: 10, personWaehlbar: false })
+  for (const raster of [5, 10, 15, 20, 30, 60]) assert.equal(gueltig(mit({ raster })).regeln.raster, raster)
+  for (const raster of [0, 1, 25, 45, 90, '15']) assert.ok(fehlerVon(mit({ raster }))['regeln.raster'], String(raster))
+  for (const vorlaufMin of [-1, 20161, 1.5]) assert.ok(fehlerVon(mit({ vorlaufMin }))['regeln.vorlaufMin'], String(vorlaufMin))
+  assert.equal(gueltig(mit({ vorlaufMin: 20160 })).regeln.vorlaufMin, 20160)
+  for (const horizontTage of [0, 366, -1]) assert.ok(fehlerVon(mit({ horizontTage }))['regeln.horizontTage'], String(horizontTage))
+  assert.equal(gueltig(mit({ horizontTage: 1 })).regeln.horizontTage, 1)
+  for (const absageBisStd of [-1, 337]) assert.ok(fehlerVon(mit({ absageBisStd }))['regeln.absageBisStd'], String(absageBisStd))
+  assert.equal(gueltig(mit({ absageBisStd: 0 })).regeln.absageBisStd, 0)
+  for (const maxOffeneJeEmail of [0, 11]) assert.ok(fehlerVon(mit({ maxOffeneJeEmail }))['regeln.maxOffeneJeEmail'], String(maxOffeneJeEmail))
+  assert.ok(fehlerVon(mit({ personWaehlbar: 'ja' }))['regeln.personWaehlbar'])
+})
+
+test('Gastfelder: aus|optional|pflicht, bis zu 5 Zusatzfelder', () => {
+  const mit = (g) => ({ ...basis(), gastFelder: g })
+  assert.deepEqual(gueltig(mit({ telefon: 'pflicht', nachricht: 'optional' })).gastFelder, { telefon: 'pflicht', nachricht: 'optional', zusatz: [] })
+  assert.ok(fehlerVon(mit({ telefon: 'vielleicht' }))['gastFelder.telefon'])
+  assert.ok(fehlerVon(mit({ nachricht: 'an' }))['gastFelder.nachricht'])
+
+  const zusatz = [
+    { key: 'kennzeichen', label: 'Kennzeichen', typ: 'text', pflicht: true },
+    { key: 'reifen', label: 'Reifen', typ: 'auswahl', optionen: ['Sommer', 'Winter', 'Sommer'], pflicht: false },
+  ]
+  const ok = gueltig(mit({ zusatz })).gastFelder.zusatz
+  assert.deepEqual(ok, [
+    { key: 'kennzeichen', label: 'Kennzeichen', typ: 'text', optionen: [], pflicht: true },
+    { key: 'reifen', label: 'Reifen', typ: 'auswahl', optionen: ['Sommer', 'Winter'], pflicht: false },
+  ])
+
+  const sechs = Array.from({ length: 6 }, (_, i) => ({ key: `feld${i}`, label: `Feld ${i}`, typ: 'text' }))
+  assert.ok(fehlerVon(mit({ zusatz: sechs }))['gastFelder.zusatz'])
+  assert.equal(gueltig(mit({ zusatz: sechs.slice(0, 5) })).gastFelder.zusatz.length, 5)
+
+  for (const key of ['Kennzeichen', 'a-b', '', 'x'.repeat(21), 'ä', '__proto__', 'constructor', 'prototype']) {
+    assert.ok(fehlerVon(mit({ zusatz: [{ key, label: 'X', typ: 'text' }] }))['gastFelder.zusatz.0.key'], key)
+  }
+  assert.ok(fehlerVon(mit({ zusatz: [{ key: 'a', label: 'X' }, { key: 'a', label: 'Y' }] }))['gastFelder.zusatz.1.key'])
+  assert.ok(fehlerVon(mit({ zusatz: [{ key: 'a', label: '' }] }))['gastFelder.zusatz.0.label'])
+  assert.ok(fehlerVon(mit({ zusatz: [{ key: 'a', label: 'X', typ: 'datei' }] }))['gastFelder.zusatz.0.typ'])
+  assert.ok(fehlerVon(mit({ zusatz: [{ key: 'a', label: 'X', typ: 'auswahl', optionen: [] }] }))['gastFelder.zusatz.0.optionen'])
+  const elf = Array.from({ length: 11 }, (_, i) => `Option ${i}`)
+  assert.ok(fehlerVon(mit({ zusatz: [{ key: 'a', label: 'X', typ: 'auswahl', optionen: elf }] }))['gastFelder.zusatz.0.optionen'])
+  assert.equal(gueltig(mit({ zusatz: [{ key: 'a', label: 'X', typ: 'auswahl', optionen: elf.slice(0, 10) }] })).gastFelder.zusatz[0].optionen.length, 10)
+})
+
+test('Erinnerung, Recht, Aufbewahrung', () => {
+  for (const stundenVorher of [2, 12, 24, 48]) assert.equal(gueltig({ ...basis(), erinnerung: { stundenVorher } }).erinnerung.stundenVorher, stundenVorher)
+  for (const stundenVorher of [1, 6, 36, 72, '24']) assert.ok(fehlerVon({ ...basis(), erinnerung: { stundenVorher } })['erinnerung.stundenVorher'], String(stundenVorher))
+  assert.equal(gueltig({ ...basis(), erinnerung: { anbieten: false } }).erinnerung.anbieten, false)
+  assert.ok(fehlerVon({ ...basis(), erinnerung: { anbieten: 'nein' } })['erinnerung.anbieten'])
+
+  assert.deepEqual(gueltig({ ...basis(), recht: { gaesteSind: 'gemischt', freizeit: true } }).recht, { gaesteSind: 'gemischt', freizeit: true })
+  assert.ok(fehlerVon({ ...basis(), recht: { gaesteSind: 'firmen' } })['recht.gaesteSind'])
+  assert.ok(fehlerVon({ ...basis(), recht: { freizeit: 1 } })['recht.freizeit'])
+
+  for (const tage of [14, 365, 90]) assert.equal(gueltig({ ...basis(), aufbewahrungTage: tage }).aufbewahrungTage, tage)
+  for (const tage of [13, 366, 0, 90.5]) assert.ok(fehlerVon({ ...basis(), aufbewahrungTage: tage }).aufbewahrungTage, String(tage))
+})
+
+test('Zahlung: nur vorort; online/beides => "Online-Zahlung kommt bald"; Zahlarten geprueft', () => {
+  const mit = (z) => ({ ...basis(), zahlung: z })
+  assert.equal(fehlerVon(mit({ modus: 'online' }))['zahlung.modus'], 'Online-Zahlung kommt bald')
+  assert.equal(fehlerVon(mit({ modus: 'beides' }))['zahlung.modus'], 'Online-Zahlung kommt bald')
+  assert.ok(fehlerVon(mit({ modus: 'bitcoin' }))['zahlung.modus'])
+  assert.equal(gueltig(mit({ modus: 'vorort' })).zahlung.modus, 'vorort')
+  assert.deepEqual(gueltig(mit({ vorOrtArten: ['paypal', 'bar', 'bar', 'ueberweisung', 'ec', 'kreditkarte'] })).zahlung.vorOrtArten,
+    ['bar', 'ec', 'kreditkarte', 'ueberweisung', 'paypal'])
+  assert.deepEqual(gueltig(mit({ vorOrtArten: [] })).zahlung.vorOrtArten, [])
+  assert.ok(fehlerVon(mit({ vorOrtArten: ['bar', 'bitcoin'] }))['zahlung.vorOrtArten'])
+  assert.ok(fehlerVon(mit({ vorOrtArten: 'bar' }))['zahlung.vorOrtArten'])
+})
+
+// ---------------------------------------------------------------- Storno
+
+test('Storno: Version YYYY-MM-DD-n nur bei geaendertem Text (Tag aus now, Berlin)', () => {
+  const a = gueltig({ ...basis(), storno: { text: 'Absage bis 24 Stunden vorher.', version: 'vom-client' } })
+  assert.deepEqual(a.storno, { text: 'Absage bis 24 Stunden vorher.', version: '2026-10-02-1' })
+
+  // unveraenderter Text: Version bleibt, auch wenn der Client eine andere schickt
+  const b = gueltig({ ...basis(), storno: { text: 'Absage bis 24 Stunden vorher.', version: '1999-01-01-9' } }, { bisher: a })
+  assert.equal(b.storno.version, '2026-10-02-1')
+
+  // geaenderter Text am selben Tag: n + 1
+  const c = gueltig({ ...basis(), storno: { text: 'Absage bis 48 Stunden vorher.' } }, { bisher: b })
+  assert.equal(c.storno.version, '2026-10-02-2')
+
+  // naechster Tag: wieder 1; kurz nach Mitternacht Berlin zaehlt als neuer Tag
+  const d = gueltig({ ...basis(), storno: { text: 'Absage bis 12 Stunden vorher.' } }, { bisher: c, now: new Date('2026-10-02T22:30:00.000Z') })
+  assert.equal(d.storno.version, '2026-10-03-1')
+  const e = gueltig({ ...basis(), storno: { text: 'Absage bis 6 Stunden vorher.' } }, { bisher: d, now: new Date('2026-10-03T10:00:00.000Z') })
+  assert.equal(e.storno.version, '2026-10-03-2')
+
+  // Text entfernt: Text leer, Version bleibt; spaeter neuer Text zaehlt weiter
+  const f = gueltig(basis(), { bisher: e, now: new Date('2026-10-03T11:00:00.000Z') })
+  assert.deepEqual(f.storno, { text: '', version: '2026-10-03-2' })
+  const g = gueltig({ ...basis(), storno: { text: 'Wieder da.' } }, { bisher: f, now: new Date('2026-10-03T12:00:00.000Z') })
+  assert.equal(g.storno.version, '2026-10-03-3')
+})
+
+test('Storno: Zeilenumbrueche bleiben, andere Steuerzeichen nicht; auf 2000 Zeichen gekuerzt', () => {
+  const e = gueltig({ ...basis(), storno: { text: `Zeile 1\r\nZeile\u0007 2\n\n\n\nZeile 3 ${'x'.repeat(3000)}` } })
+  assert.ok(e.storno.text.startsWith('Zeile 1\nZeile 2\n\nZeile 3 xxx'))
+  assert.equal([...e.storno.text].length, 2000)
+})
+
+// ---------------------------------------------------------------- Obergrenzen
+
+test('Obergrenzen: 20 Ressourcen, 50 Leistungen, 100 Abwesenheiten, 200 Sonderoeffnungen', () => {
+  const ressourcen = (n) => Array.from({ length: n }, (_, i) => ({ name: `R${i}` }))
+  assert.equal(gueltig({ ...basis(), ressourcen: ressourcen(20), leistungen: [] }).ressourcen.length, 20)
+  assert.ok(fehlerVon({ ...basis(), ressourcen: ressourcen(21), leistungen: [] }).ressourcen)
+
+  const leistungen = (n) => Array.from({ length: n }, (_, i) => ({ name: `L${i}`, dauer: 30, ressourcen: [R1] }))
+  assert.equal(gueltig({ ...basis(), leistungen: leistungen(50) }).leistungen.length, 50)
+  assert.ok(fehlerVon({ ...basis(), leistungen: leistungen(51) }).leistungen)
+
+  const abwesenheiten = (n) => Array.from({ length: n }, () => ({ von: '2026-12-01', bis: '2026-12-02' }))
+  assert.equal(gueltig({ ...basis(), abwesenheiten: abwesenheiten(100) }).abwesenheiten.length, 100)
+  assert.ok(fehlerVon({ ...basis(), abwesenheiten: abwesenheiten(101) }).abwesenheiten)
+
+  const tage = (n) => Object.fromEntries(Array.from({ length: n }, (_, i) => [new Date(Date.UTC(2027, 0, 1 + i)).toISOString().slice(0, 10), [['09:00', '12:00']]]))
+  assert.equal(Object.keys(gueltig({ ...basis(), sonderoeffnungen: tage(200) }).sonderoeffnungen).length, 200)
+  assert.ok(fehlerVon({ ...basis(), sonderoeffnungen: tage(201) }).sonderoeffnungen)
+})
+
+test('Obergrenze: Gesamtgroesse hoechstens 200 000 Zeichen (Fehler unter "_")', () => {
+  const uhr = (min) => `${String(Math.floor(min / 60)).padStart(2, '0')}:${String(min % 60).padStart(2, '0')}`
+  // 144 Fenster je Tag (jeweils 5 Minuten, dazwischen 5 Minuten Luecke)
+  const tag = Array.from({ length: 144 }, (_, i) => [uhr(i * 10), uhr(i * 10 + 5)])
+  const wochenplan = Object.fromEntries([1, 2, 3, 4, 5, 6, 7].map((n) => [n, tag]))
+  const ressourcen = (n) => Array.from({ length: n }, (_, i) => ({ name: `R${i}`, plan: wochenplan }))
+
+  const zuGross = { ...basis(), ressourcen: ressourcen(20), leistungen: [] }
+  const f = fehlerVon(zuGross)
+  assert.ok(f._)
+  assert.deepEqual(Object.keys(f), ['_'])
+
+  const noch = { ...basis(), ressourcen: ressourcen(8), leistungen: [] }
+  const e = gueltig(noch)
+  assert.ok(JSON.stringify(e).length <= 200000)
+  assert.ok(JSON.stringify(e).length > 100000)
+
+  // Die Grenzen der Einzellisten zusammen bleiben darunter
+  const gross = basis()
+  gross.leistungen = Array.from({ length: 50 }, () => ({ name: 'N'.repeat(100), beschreibung: 'b'.repeat(300), dauer: 30, ressourcen: [R1] }))
+  gross.abwesenheiten = Array.from({ length: 100 }, () => ({ titel: 't'.repeat(80), von: '2026-12-01', bis: '2026-12-02' }))
+  gross.storno = { text: 's'.repeat(2000) }
+  assert.ok(JSON.stringify(gueltig(gross)).length < 200000)
+})
+
+// ---------------------------------------------------------------- Texte
+
+test('knopfText: verbindlich + Preis, verbindlich ohne Preis, Anfrage (und Bestaetigungsseite)', () => {
+  const mitPreis = { buchungsart: 'sofort', preisArt: 'fest', preisCent: 4500 }
+  const abPreis = { buchungsart: 'sofort', preisArt: 'ab', preisCent: 4500 }
+  const ohnePreis = { buchungsart: 'sofort', preisArt: 'keiner', preisCent: 0 }
+  const anfrage = { buchungsart: 'anfrage', preisArt: 'fest', preisCent: 4500 }
+  assert.equal(knopfText(mitPreis), 'Zahlungspflichtig buchen')
+  assert.equal(knopfText(abPreis), 'Zahlungspflichtig buchen')
+  assert.equal(knopfText(ohnePreis), 'Termin buchen')
+  assert.equal(knopfText(anfrage), 'Termin anfragen')
+  assert.equal(knopfText(mitPreis, { bestaetigen: true }), 'Zahlungspflichtig bestätigen')
+  assert.equal(knopfText(ohnePreis, { bestaetigen: true }), 'Termin bestätigen')
+  assert.equal(knopfText(anfrage, { bestaetigen: true }), 'Anfrage absenden')
+  assert.equal(knopfText(mitPreis, { bestaetigen: false }), 'Zahlungspflichtig buchen')
+  // Preis 0 gilt als kein Preis
+  assert.equal(knopfText({ buchungsart: 'sofort', preisArt: 'fest', preisCent: 0 }), 'Termin buchen')
+})
+
+test('istVerbraucher: nicht nur Unternehmer und keine Freizeitleistung', () => {
+  assert.equal(istVerbraucher({ recht: { gaesteSind: 'verbraucher', freizeit: false } }), true)
+  assert.equal(istVerbraucher({ recht: { gaesteSind: 'gemischt', freizeit: false } }), true)
+  assert.equal(istVerbraucher({ recht: { gaesteSind: 'unternehmer', freizeit: false } }), false)
+  assert.equal(istVerbraucher({ recht: { gaesteSind: 'verbraucher', freizeit: true } }), false)
+})
+
+test('brauchtZustimmungVorzeitig: verbindlich + Preis + Verbraucher + Beginn in weniger als 14 Tagen', () => {
+  const verbraucher = { recht: { gaesteSind: 'verbraucher', freizeit: false } }
+  const unternehmer = { recht: { gaesteSind: 'unternehmer', freizeit: false } }
+  const freizeit = { recht: { gaesteSind: 'verbraucher', freizeit: true } }
+  const mitPreis = { buchungsart: 'sofort', preisArt: 'fest', preisCent: 4500 }
+  const inTagen = (n) => new Date(NOW.getTime() + n * TAG)
+
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, mitPreis, inTagen(3), NOW), true)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, mitPreis, inTagen(20), NOW), false)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, mitPreis, inTagen(14), NOW), false)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, mitPreis, new Date(inTagen(14).getTime() - 1), NOW), true)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, mitPreis, inTagen(0), NOW), true)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, { ...mitPreis, preisArt: 'ab' }, inTagen(3), NOW), true)
+  // Unternehmer, Freizeit, kein Preis, Anfrage: keine Zustimmung noetig
+  assert.equal(brauchtZustimmungVorzeitig(unternehmer, mitPreis, inTagen(3), NOW), false)
+  assert.equal(brauchtZustimmungVorzeitig(freizeit, mitPreis, inTagen(3), NOW), false)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, { ...mitPreis, preisArt: 'keiner', preisCent: 0 }, inTagen(3), NOW), false)
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, { ...mitPreis, buchungsart: 'anfrage' }, inTagen(3), NOW), false)
+  // ungueltiger Beginn: lieber die Zustimmung verlangen
+  assert.equal(brauchtZustimmungVorzeitig(verbraucher, mitPreis, new Date('kaputt'), NOW), true)
+})
+
+test('preisText, preisHinweis, zahlungText', () => {
+  assert.equal(preisText({ preisArt: 'fest', preisCent: 4500 }), '45,00 €')
+  assert.equal(preisText({ preisArt: 'ab', preisCent: 4500 }), 'ab 45,00 €')
+  assert.equal(preisText({ preisArt: 'fest', preisCent: 4505 }), '45,05 €')
+  assert.equal(preisText({ preisArt: 'fest', preisCent: 5 }), '0,05 €')
+  assert.equal(preisText({ preisArt: 'fest', preisCent: 123456 }), '1.234,56 €')
+  assert.equal(preisText({ preisArt: 'fest', preisCent: 1000000 }), '10.000,00 €')
+  assert.equal(preisText({ preisArt: 'keiner', preisCent: 0 }), '')
+  assert.equal(preisText({ preisArt: 'keiner', preisCent: 4500 }), '')
+  assert.equal(preisText({ preisArt: 'fest', preisCent: 0 }), '')
+
+  assert.equal(preisHinweis({ betrieb: { kleinunternehmer: false } }), 'inkl. USt')
+  assert.equal(preisHinweis({ betrieb: {} }), 'inkl. USt')
+  assert.equal(preisHinweis({ betrieb: { kleinunternehmer: true } }), 'kein Ausweis der USt nach § 19 UStG')
+
+  assert.equal(zahlungText({ zahlung: { modus: 'vorort', vorOrtArten: ['bar', 'ec', 'kreditkarte'] } }), 'Bezahlung vor Ort: bar, EC-Karte, Kreditkarte')
+  assert.equal(zahlungText({ zahlung: { modus: 'vorort', vorOrtArten: ['ueberweisung', 'paypal'] } }), 'Bezahlung vor Ort: Überweisung, PayPal')
+  assert.equal(zahlungText({ zahlung: { modus: 'vorort', vorOrtArten: [] } }), 'Bezahlung vor Ort')
+})
+
+// ---------------------------------------------------------------- Oeffentliche Sicht
+
+test('oeffentlicheEinstellung: genau die vereinbarten Felder, ohne feedToken und interne Angaben', () => {
+  const e = ausVorlage('salon', { ...BETRIEB, agbUrl: 'https://salon.de/agb' }, NOW)
+  const oe = oeffentlicheEinstellung(e, NOW)
+  assert.deepEqual(Object.keys(oe).sort(), [
+    'anrede', 'betrieb', 'erinnerung', 'farbe', 'gastFelder', 'heute', 'leistungen', 'personWaehlbar', 'preisHinweis',
+    'regeln', 'ressourcen', 'storno', 'widerruf', 'zahlung',
+  ])
+  assert.equal(oe.heute, '2026-10-02')
+  assert.deepEqual(oe.betrieb, {
+    name: 'Salon Müller', telefon: '06301 1234', adresse: 'Hauptstr. 1, 67722 Winnweiler',
+    impressumUrl: 'https://salon.de/impressum', datenschutzUrl: 'https://salon.de/datenschutz',
+  })
+  assert.equal(oe.anrede, 'sie')
+  assert.equal(oe.farbe, e.farbe)
+  assert.deepEqual(oe.regeln, { horizontTage: e.regeln.horizontTage, absageBisStd: e.regeln.absageBisStd })
+  assert.equal(oe.personWaehlbar, e.regeln.personWaehlbar)
+  assert.deepEqual(oe.zahlung, { modus: 'vorort', text: 'Bezahlung vor Ort: bar, EC-Karte, Kreditkarte' })
+  assert.equal(oe.preisHinweis, 'inkl. USt')
+  assert.deepEqual(oe.storno, { text: e.storno.text, version: e.storno.version })
+  assert.equal(oe.widerruf, true)
+  assert.deepEqual(oe.erinnerung, { anbieten: true, stundenVorher: 24 })
+  assert.deepEqual(oe.gastFelder, e.gastFelder)
+  assert.deepEqual(oe.ressourcen, e.ressourcen.map((r) => ({ id: r.id, name: r.name, typ: r.typ })))
+
+  const leistung = oe.leistungen[0]
+  assert.deepEqual(Object.keys(leistung).sort(), [
+    'beschreibung', 'buchungsart', 'dauer', 'id', 'knopf', 'name', 'preis', 'preisArt', 'ressourcen', 'verbraucher',
+  ])
+  assert.equal(leistung.knopf, knopfText(e.leistungen[0]))
+  assert.equal(leistung.preis, preisText(e.leistungen[0]))
+  assert.equal(leistung.verbraucher, true)
+
+  const json = JSON.stringify(oe)
+  for (const geheim of ['feedToken', e.ressourcen[0].feedToken, 'info@salon.de', 'agb', 'customerId', 'projectId', 'featureId', 'pufferNach', 'preisCent', 'aufbewahrungTage', 'sonderoeffnungen', 'abwesenheiten', 'feiertage', 'vorOrtArten', 'vorlage', 'kleinunternehmer', 'vorlaufMin', 'maxOffeneJeEmail', 'raster']) {
+    assert.ok(!json.includes(geheim), `oeffentlich enthaelt ${geheim}`)
+  }
+})
+
+test('oeffentlicheEinstellung: nur aktive Leistungen mit aktiver Ressource, nur aktive Ressourcen', () => {
+  const e = gueltig({
+    ...basis(),
+    ressourcen: [
+      { id: R1, name: 'Anna', plan: { 1: [['09:00', '12:00']] } },
+      { id: R2, name: 'Ben', typ: 'platz', aktiv: false, plan: { 1: [['09:00', '12:00']] } },
+    ],
+    leistungen: [
+      { id: S1, name: 'Beide', dauer: 30, ressourcen: [R2, R1] },
+      { id: S2, name: 'Ruht', dauer: 30, ressourcen: [R1], aktiv: false },
+      { id: 's_bbbbbbb3', name: 'Nur Ben', dauer: 30, ressourcen: [R2], aktiv: false },
+    ],
+  })
+  const oe = oeffentlicheEinstellung(e, NOW)
+  assert.deepEqual(oe.ressourcen, [{ id: R1, name: 'Anna', typ: 'person' }])
+  assert.deepEqual(oe.leistungen.map((l) => l.id), [S1])
+  assert.deepEqual(oe.leistungen[0].ressourcen, [R1])
+
+  // Ressource nachtraeglich deaktiviert (Daten aus dem Speicher): Leistung ohne aktive Ressource verschwindet
+  const roh = structuredClone(e)
+  roh.ressourcen[0].aktiv = false
+  assert.deepEqual(oeffentlicheEinstellung(roh, NOW).leistungen, [])
+  assert.equal(oeffentlicheEinstellung(roh, NOW).widerruf, false)
+})
+
+test('oeffentlicheEinstellung: storno null ohne Text, widerruf nur bei sofort + Verbraucher, Kleinunternehmer-Hinweis', () => {
+  const sofort = gueltig(basis())
+  assert.equal(oeffentlicheEinstellung(sofort, NOW).storno, null)
+  assert.equal(oeffentlicheEinstellung(sofort, NOW).widerruf, true)
+
+  const anfrage = gueltig({ ...basis(), leistungen: [{ id: S1, name: 'A', dauer: 30, ressourcen: [R1], buchungsart: 'anfrage' }] })
+  assert.equal(oeffentlicheEinstellung(anfrage, NOW).widerruf, false)
+
+  const unternehmer = gueltig({ ...basis(), recht: { gaesteSind: 'unternehmer' } })
+  assert.equal(oeffentlicheEinstellung(unternehmer, NOW).widerruf, false)
+  assert.equal(oeffentlicheEinstellung(unternehmer, NOW).leistungen[0].verbraucher, false)
+
+  const freizeit = gueltig({ ...basis(), recht: { freizeit: true } })
+  assert.equal(oeffentlicheEinstellung(freizeit, NOW).widerruf, false)
+
+  const klein = gueltig({ ...basis(), betrieb: { name: 'X', email: 'a@b.de', kleinunternehmer: true } })
+  assert.equal(oeffentlicheEinstellung(klein, NOW).preisHinweis, 'kein Ausweis der USt nach § 19 UStG')
+})
+
+test('oeffentlicheEinstellung: heute ist der Berliner Tag (kurz nach Mitternacht)', () => {
+  const e = gueltig(basis())
+  assert.equal(oeffentlicheEinstellung(e, new Date('2026-10-02T22:30:00.000Z')).heute, '2026-10-03')
+  assert.equal(oeffentlicheEinstellung(e, new Date('2026-10-02T21:59:00.000Z')).heute, '2026-10-02')
+})