# Prompt: Entnahmephase-Simulator (Cash/Depot-Bucket-Strategie)

Baue mir einen interaktiven Finanzsimulator für die Entnahmephase der Rente als
React-Artifact (single file, Tailwind + inline styles für Farb-Tokens, recharts
für Charts). Zielgruppe: technisch versierter Nutzer, der Wert auf Nachvollziehbarkeit
und keine Marketing-Optik legt. Unten die komplette fachliche und gestalterische Spezifikation.

## Kontext / Ausgangslage

Kein Ansparphasen-Modell nötig — die Simulation startet direkt am Renteneintritt
mit zwei einstellbaren Startwerten: einem Cash-Topf (Tagesgeld/Festgeld/Geldmarktfonds)
und einem Aktien-Depot. Der Cash-Topf dient als Puffer, aus dem vorrangig gelebt wird;
in guten Börsenjahren wird er aus dem Depot wieder aufgefüllt, in schlechten nicht oder
nur teilweise. Das Ganze ist eine klassische "Bucket-Strategie", ergänzt um klare,
simulierbare Auffüll- und Notfallregeln.

## Simulationsmethode: Block-Bootstrap + kalibrierte Monte-Carlo-Mischung

Kein reines Zufallsrenditemodell (feste Normalverteilung), sondern eine Mischung:

- **Historische Datenbasis:** MSCI World Net Total Return in USD, Jahresrenditen 1970–2025
  (56 Werte), als hartcodiertes Array `HIST_RETURNS = [{year, ret}, ...]`. Aus 2009–2025
  liegen exakte veröffentlichte Werte vor; 1970–2008 sind plausible, aus mehreren Quellen
  konsistente Näherungswerte (MSCI selbst bezeichnet Daten vor 1986 als zurückgerechnet/
  backtested). Das im UI und im Code als Kommentar transparent machen — keine falsche
  Präzision vortäuschen. `HIST_MEAN` und `HIST_STD` werden aus diesem Array berechnet
  (arithmetisches Mittel bzw. Standardabweichung der Jahresrenditen in %). 
  Hier die Werte, damit die nicht nochmal neu recherchiert werden müssen: 
  
  const HIST_RETURNS = [
  { year: 1970, ret: 2.4 }, { year: 1971, ret: 18.4 }, { year: 1972, ret: 22.4 },
  { year: 1973, ret: -14.7 }, { year: 1974, ret: -23.2 }, { year: 1975, ret: 33.5 },
  { year: 1976, ret: 13.4 }, { year: 1977, ret: 3.7 }, { year: 1978, ret: 21.1 },
  { year: 1979, ret: 12.7 }, { year: 1980, ret: 21.5 }, { year: 1981, ret: -4.8 },
  { year: 1982, ret: 8.6 }, { year: 1983, ret: 20.4 }, { year: 1984, ret: 3.4 },
  { year: 1985, ret: 38.3 }, { year: 1986, ret: 39.4 }, { year: 1987, ret: 15.3 },
  { year: 1988, ret: 21.1 }, { year: 1989, ret: 15.9 }, { year: 1990, ret: -17.0 },
  { year: 1991, ret: 17.2 }, { year: 1992, ret: -5.0 }, { year: 1993, ret: 20.7 },
  { year: 1994, ret: 3.9 }, { year: 1995, ret: 19.5 }, { year: 1996, ret: 12.8 },
  { year: 1997, ret: 13.2 }, { year: 1998, ret: 22.8 }, { year: 1999, ret: 22.8 },
  { year: 2000, ret: -13.2 }, { year: 2001, ret: -16.5 }, { year: 2002, ret: -19.5 },
  { year: 2003, ret: 30.8 }, { year: 2004, ret: 12.8 }, { year: 2005, ret: 8.8 },
  { year: 2006, ret: 18.0 }, { year: 2007, ret: 7.1 }, { year: 2008, ret: -40.7 },
  { year: 2009, ret: 30.79 }, { year: 2010, ret: 12.34 }, { year: 2011, ret: -5.54 },
  { year: 2012, ret: 15.83 }, { year: 2013, ret: 26.68 }, { year: 2014, ret: 4.94 },
  { year: 2015, ret: -0.87 }, { year: 2016, ret: 7.51 }, { year: 2017, ret: 22.40 },
  { year: 2018, ret: -8.71 }, { year: 2019, ret: 27.67 }, { year: 2020, ret: 15.90 },
  { year: 2021, ret: 21.82 }, { year: 2022, ret: -18.14 }, { year: 2023, ret: 23.79 },
  { year: 2024, ret: 18.67 }, { year: 2025, ret: 21.60 },
];
  
- **Block-Bootstrap:** Für jeden Simulationslauf werden zusammenhängende Blöcke von
  `blockLen` (Regler, 2–15 Jahre, Default 7) aufeinanderfolgenden historischen Jahren
  zufällig gezogen (Startindex zufällig, zyklisch mit Modulo über das Array, damit
  auch am Rand des Arrays saubere Blöcke entstehen) und aneinandergereiht, bis die
  benötigte Pfadlänge erreicht ist. Das erhält Autokorrelation und mehrjährige
  Baissen/Boomphasen, die eine reine Zufallsziehung pro Jahr nicht abbildet.
- **Parametrischer Anteil:** Ein einstellbarer Anteil der Läufe (Regler `bootstrapAnteil`,
  0–100 %, Default 75 %) nutzt stattdessen Jahr-für-Jahr-Ziehungen aus einer Normalverteilung
  mit Mittelwert `HIST_MEAN` und Standardabweichung `HIST_STD` (Box-Muller-Transformation
  für die Zufallsziehung). Das deckt Extremszenarien ab, die in den 56 historischen Jahren
  nicht vorkamen. Die Entscheidung Bootstrap vs. parametrisch erfolgt pro Simulationslauf
  (nicht pro Jahr) via `Math.random() < bootstrapAnteil/100`.
- Inflation läuft unabhängig davon als eigene Zufallsvariable: jedes Jahr eine eigene
  Normalverteilungs-Ziehung (Box-Muller) mit Regler-Werten für Erwartung (Default 2,3 %)
  und Volatilität (Default 1,4 %).

## Cash-Topf-Regeln (Bucket-Logik)

Ablauf pro Simulationsjahr, in dieser Reihenfolge:

1. **Laufender Bedarf decken:** Erst aus dem Cash-Topf; reicht der nicht, wird der Rest
   zusätzlich aus dem Depot gedeckt (Notfall-Deckung). Wird dabei das Depot negativ,
   auf 0 klemmen und den Lauf als "ruiniert" markieren.
2. **Cash-Verzinsung:** Der verbleibende Cash-Bestand wird jährlich verzinst mit
   Inflation plus einer einstellbaren Realverzinsung (Regler `cashRealYield`,
   0–1,5 %, Default 0,35 % — typisch für Tagesgeld/Festgeld über Inflation).
3. **Depot-Wachstum:** Mit der für dieses Jahr gezogenen Rendite (Bootstrap oder
   parametrisch).
4. **Vier-Stufen-Auffüllregel** basierend auf der *realen* Depotrendite dieses Jahres
   (`rReal = (1+r)/(1+infl) - 1`, in Prozent):
   - über Schwelle "sehr gutes Jahr" (Regler, Default 15 %): Auffüllung = Jahresbedarf ×
     Extra-Faktor (Regler, 1,0–2,5, Default 1,5) — antizyklisch mehr abschöpfen.
   - zwischen Schwelle "gutes Jahr" (Default 5 %) und "sehr gut": Auffüllung = exakt
     der Jahresbedarf (1:1 ersetzen, was entnommen wurde).
   - zwischen Schwelle "mäßiges Jahr" (Default 0 %, Range −10 % bis "gutes Jahr") und
     "gut": Auffüllung = 50 % des Jahresbedarfs.
   - darunter (negative reale Rendite): keine Auffüllung, Depot bleibt unangetastet.
5. **Notfall-Untergrenze** (Regler `cashFloor`, Default 40.000 €) hat **Vorrang** vor der
   Vier-Stufen-Logik: Fällt der Cash-Topf nach der geplanten Auffüllung darunter,
   wird zwangsweise bis zur Untergrenze aufgefüllt — egal wie schlecht die Börse steht.
6. **Kappungs-Obergrenze** (Regler `cashCeiling`, Default 100.000 €) hat ebenfalls Vorrang
   (aber nachrangig zur Untergrenze): Läge der Cash-Topf nach Auffüllung darüber,
   wird die Auffüllung entsprechend gekappt — egal wie gut die Börse steht.
7. Auffüllbetrag kann nie größer sein als das verfügbare Depot (auf 0 klemmen).
8. **Ruin-Kriterium:** Cash und Depot beide ≤ 0 am Ende eines Jahres.

## Bedarf / Entnahmehöhe

- Basiswert: "Jährlicher Bedarf" in heutiger Kaufkraft (Regler, Default 20.000 €).
- Wächst grundsätzlich Jahr für Jahr mit der jeweils gezogenen Inflation (nominal,
  nicht real/deflationiert — die tatsächlich fließenden Euro-Beträge inkl. Teuerung
  sind relevant, nicht auf heutige Kaufkraft zurückgerechnete Werte).
- **Optionale Einmalausgabe:** Checkbox, mit Jahr (1..Rentendauer) und Betrag
  (Default 30.000 €, z. B. Autokauf), wird in dem betreffenden Jahr einmalig
  zusätzlich zum laufenden Bedarf entnommen.
- **Optionaler Ratchet-Mechanismus** (Checkbox, Default aus): Alle `ratchetIntervall`
  Jahre (Default 5) wird der Jahresbedarf komplett neu berechnet als
  `ratchetProzent` % (Regler, 2–8 %, Default 4,8 %) des dann aktuellen
  Gesamtvermögens (Cash + Depot) — läuft's gut, steigt die Entnahme, läuft's
  schlecht, sinkt sie automatisch mit. Dazwischen wächst der Betrag normal mit
  der Inflation. Zusatz-Checkbox "Nie sinken lassen": erzwingt, dass der neu
  berechnete Wert nie unter den inflationsfortgeschriebenen vorherigen Wert fällt
  (reiner Aufwärts-Ratchet statt freier Neuberechnung in beide Richtungen).

## Weitere Parameter

- Renteneintrittsalter (Regler, nur für Achsenbeschriftung, Default 63).
- Rentendauer in Jahren (Regler, Default 22).
- Anzahl Simulationsläufe: Buttons für 500 / 1.500 / 5.000.

## Ergebnis-Aufbereitung

Für jedes Simulationsjahr werden über alle Läufe Perzentile berechnet (P10, P25, P50,
P75, P90) — sowohl für das Gesamtvermögen (Cash+Depot) als auch getrennt für Cash-
und Depot-Median. Zusätzlich pro Jahr die tatsächlich entnommene Summe (kann unter dem
Soll-Bedarf liegen, wenn beide Töpfe nicht mehr reichen) und daraus eine Lebenszeit-
Gesamtsumme aller Entnahmen (Median/P10/P90) sowie zum Vergleich die ungekürzte
Soll-Gesamtsumme.

**Erfolgsquote** = Anteil der Läufe, die nicht ruiniert wurden (in %).

## Charts (recharts, ComposedChart)

1. **Gesamtvermögen über Zeit:** Fächerdiagramm, P10–P90-Band (hell) und P25–P75-Band
   (dunkler) via der Stacked-Area-Trick (transparente Basis-Area + gefüllte Differenz-Area,
   gleicher `stackId`), Median als durchgezogene Linie. X-Achse = Alter. Referenzlinie bei
   Einmalausgabe-Jahr, falls aktiv.
2. **Cash vs. Depot Median-Verlauf:** Zwei Linien (Cash farblich abgesetzt von Depot),
   plus gestrichelte Referenzlinien bei Notfall-Untergrenze und Kappungs-Obergrenze,
   damit sichtbar wird, wie oft der Cash-Topf an die Leitplanken stößt.
3. **Entnahme pro Jahr (nominal):** P10/P50/P90-Linien der tatsächlich entnommenen
   Beträge, gestrichelte Referenzlinie beim heutigen Bedarf (Jahr 1) zum Vergleich.
4. **Erfolgsquoten-Meter:** Kein Standard-Kreisdiagramm, sondern ein horizontaler
   Instrumenten-Balken mit drei Farbzonen (kritisch <70 %, grenzwertig 70–90 %,
   sicher ≥90 %) und einem Marker-Strich an der aktuellen Position — Optik wie ein
   Regelkarten-/Aktionsgrenzen-Diagramm, keine verspielte Tachometergrafik.
5. **Sensitivitäts-Sweep (on-demand, per Button):** X-Achse = Jahresbedarf (einstellbarer
   Range + Schrittzahl), Y-Achse = Erfolgsquote (0–100 %), mit Referenzlinien bei 70 %/90 %
   und einer vertikalen Markierung des aktuell eingestellten Bedarfs. Läuft NICHT bei jeder
   Reglerbewegung automatisch mit (zu teuer), sondern nur auf Knopfdruck, dafür mit
   reduzierter Läufezahl pro Punkt (z. B. `min(numSims, 800)`), um Tempo zu halten.

## Design-Sprache

Kein generisches SaaS-Dashboard-Look. Ziel: "technisches Instrumentenpanel /
Ingenieurs-Arbeitsblatt"

- **Schrift:** IBM Plex Sans für Fließtext/Labels, IBM Plex Mono für alle Zahlen,
  Achsenbeschriftungen und Eingabewerte (via Google-Fonts-Link, per `useEffect` in
  `<head>` injiziert, mit sauberen Font-Fallbacks für den Fall, dass der Import scheitert).
- **Farben** (als JS-Konstanten-Objekt, nicht als Tailwind-Arbitrary-Values, da kein
  JIT-Compiler in der Artifact-Umgebung läuft):
  - Hintergrund: kühles, helles Grau-Grün (`#EEF1EF`), Panels weiß mit dezentem Rahmen
    (`#D3DAD6`).
  - Haupt-Akzent: gedecktes Petrol/Teal (`#2F5D62`) für Depot, Median-Linien, aktive
    Buttons.
  - Cash-Akzent: gedecktes Ocker/Braun (`#8A6A3C`), klar unterscheidbar vom Teal.
  - Signalfarben: gedecktes Grün (`#3F7A52`), Amber (`#C08A2E`), Ziegelrot (`#A8432F`)
    für die drei Erfolgsquote-Zonen — keine grellen Ampelfarben.
- **Layout:** Zweispaltig (Reglerpanel links, fest ~340px; Charts rechts, flexibel),
  auf Schmalbildschirmen (<860px) einspaltig stapelnd. Regler-Panel in nummerierte
  Abschnitte gegliedert (01 Startwerte, 02 Bedarf, 03 Cash-Topf-Regeln, 04 Marktmodell),
  jeweils mit Mono-Font-Sektionslabel und dünner Trennlinie.
- **Regler:** Alle numerischen Eingaben als `<input type="range">` mit Live-Wert-Anzeige
  rechtsbündig in Mono-Font, kein separates Eingabefeld nötig außer beim Sweep-Bereich
  (dort Zahlenfelder, da Grenzen weiter auseinanderliegen).
- Tooltips in Charts: eigene Komponenten (kein recharts-Default-Tooltip), Mono-Font,
  weißer Hintergrund, dezenter Schatten, zeigen alle relevanten Perzentile untereinander.

## Technische Vorgaben

- Single-file React-Komponente, `export default function`, kein externer State,
  keine Browser-Storage-APIs.
- recharts für alle Charts (`ComposedChart`, `Area`, `Line`, `XAxis`, `YAxis`,
  `CartesianGrid`, `Tooltip`, `ReferenceLine`, `ResponsiveContainer`).
- Formatierung aller Euro-Beträge über `Intl.NumberFormat('de-DE', {style:'currency',
  currency:'EUR', maximumFractionDigits:0})`, kompakte Achsenbeschriftung über
  `notation:'compact'`.
- Simulation ist reiner JS-Code (keine externen Statistik-Bibliotheken nötig),
  Box-Muller-Transformation selbst implementiert für Normalverteilungs-Ziehungen.
- Vor Auslieferung den JSX-Code tatsächlich auf Syntaxfehler prüfen (z. B. mit einem
  Babel-Parse-Durchlauf), nicht nur visuell gegenlesen — typische Fallstricke sind
  gerade Anführungszeichen innerhalb von JSX-String-Attributen (z. B. deutsche
  „Gänsefüßchen" in Labels), die die Attribut-Syntax brechen.

## Erklärtext

Am Ende der Chart-Spalte ein knapper Fließtext-Absatz (kein Bullet-Fazit), der die
aktuell aktiven Regler-Einstellungen dynamisch einbindet (Blocklänge, Bootstrap-Anteil,
Ratchet-Status, Leitplanken-Werte in Euro) und in einfachen Worten erklärt, was die
Simulation gerade tut — inklusive des Hinweises auf die Datenqualität vor 2009.