# Die elf Abschnitte

Jede Modellseite hat **genau diese zehn Abschnitte, in genau dieser Reihenfolge, mit
genau diesen `id`-Werten**. Der Validator prüft das mechanisch.

Warum so streng: Wer zwei Modellseiten nebeneinander öffnet, muss dieselbe Information
an derselben Stelle finden. Die Gestaltung ist frei, die Landkarte nicht.

Die Reihenfolge folgt einer Entscheidung: **Ergebnisse zuerst, Technik danach.** Wer die
Seite öffnet, will sehen, was das Modell gebaut hat — nicht, wie schnell es dabei war.

---

## 1 · `#kopf` — Wer ist das

| Pflicht | Inhalt |
|---|---|
| ✔ | Deine selbstgezeichnete Marke als `<svg id="modell-marke">` — Spezifikation in [marke.md](marke.md) |
| ✔ | Modellname, Quantisierung, Hardware, Datum des Laufs |
| ✔ | **Ein Satz** Fazit, wörtlich aus `run.json` → `text.fazit` |

Kein Fließtext, keine Einleitung. Wer hier landet, weiß in drei Sekunden, um welches
Modell es geht und wie der Lauf ausging.

## 2 · `#architektur` — Was für ein Modell das ist

Wer auf dieser Seite landet, kennt dein Modell vielleicht nicht. Hier steht in
wenigen Sätzen, was es ist — und zwar **belegt**, nicht aus dem Gedächtnis.

| Pflicht | Inhalt |
|---|---|
| ✔ | Zwei bis vier Sätze über die Architektur: Bauart (dicht oder Mixture-of-Experts), Parameterzahl, aktive Parameter, native Kontextlänge, Besonderheiten wie Multi-Token-Prediction |
| ✔ | **Mindestens ein Verweis** auf Modellkarte oder Herstellerseite — `links.modellkarte`, `links.hersteller`, `links.architektur` aus `run.json` |
| ✔ | Ein Satz dazu, was davon für **diesen Lauf** zählt (z. B. „nur rund sechs Milliarden Parameter sind je Token aktiv — deshalb läuft ein 177-B-Modell überhaupt auf dieser Maschine") |
| wenn vorhanden | Das Architekturschaubild **des Herstellers** — siehe unten |

### Die Zahlen hier sind die Ausnahme

Überall sonst gilt: jede Zahl steht in `run.json`. Hier nicht, denn
Parameterzahl und Kontextlänge sind keine Messwerte dieses Laufs, sondern
Angaben des Herstellers. **Dafür brauchst du eine Quelle.** Der Validator
lässt Zahlen in diesem Abschnitt nur durch, wenn er darin mindestens einen
Link nach außen findet.

Schreibe keine Zahl, die du nicht auf der verlinkten Seite gelesen hast. „Rund
177 Milliarden" ist in Ordnung, wenn dort 177 B steht. Eine Schichtenzahl, die
du für plausibel hältst, ist es nicht.

### Das Schaubild zeichnest du NICHT selbst

Ein Modell, das seine eigene Architektur malt, erzeugt glaubwürdig aussehende
Erfindung — genau die Sorte Bild, die diese Seite nicht zeigt. Der Validator
lehnt ein umfangreiches eigenes `<svg>` in diesem Abschnitt ab.

Erlaubt ist die Abbildung **des Herstellers**:

1. **Such auf der Modellkarte**, nicht im Blog. Die Modellkarte kommt als
   fertiges HTML und ist mit `fetch` lesbar. Herstellerblogs sind es oft
   nicht: sie laden ihren Inhalt erst im Browser nach, und `fetch` bekommt
   dann eine leere Hülle, die für jede Adresse gleich aussieht. Den Blog
   nimmst du als Quellenangabe, die Zahlen liest du auf der Modellkarte.

   Steht in `run.json` bei `links.architektur` ein `null`, ist das kein
   Fehler. Dann ist die Modellkarte deine Quelle.

2. **Lade das Bild über das Terminal.** Die Werkzeuge zum Abrufen und
   Schreiben arbeiten mit Text; ein PNG kommt darüber nicht heil an. Nimm
   die Kommandozeile:

       curl.exe -L -o media/arch/<slug>.png "<Bildadresse>"

   Sieh danach nach, wie groß die Datei geworden ist. Ein paar hundert Byte
   heißen, dass du eine Fehlerseite geladen hast und kein Bild.

3. Leg daneben `media/arch/<slug>.quelle.txt` mit Adresse und Abrufdatum.

4. Bette sie mit `width`, `height`, `loading="lazy"` ein und schreib die
   Quelle **sichtbar** darunter, mit Link auf das Original.

   **Der Pfad lautet `../../media/arch/<datei>`.** Nicht `media/arch/...` —
   deine Seite liegt am Ende unter `dist/m/<slug>/`, der Ordner `media` zwei
   Ebenen darüber. Genauso machen es die Bilder in allen anderen
   Abschnitten.

Findest du keine: **dann kein Bild.** Der Abschnitt funktioniert auch als
Text. Kein Bild ist besser als ein erfundenes.

---

## 3 · `#urteil` — Die Zahlen auf einen Blick

Alle Kennzahlen aus `run.json` → `messwerte`, als Zahlenreihe oder Kacheln:

`decode.median` · `decode.p10`–`decode.p90` · `decode.peak` · `prefill.median` ·
`tokens` · `laufzeit_min` · `selbstkorrekturen`

**Wo ein Wert `null` ist, schreibst du „nicht gemessen" — niemals eine Zahl.**
Das ist die wichtigste Regel der ganzen Seite. Eine erfundene Zahl macht die
komplette Messreihe wertlos.

Jede Zahl bekommt ihre Einheit und, wo vorhanden, den Link auf `belege.rohprotokoll`.

## 4 · `#artefakt` — Was das Modell gebaut hat

**Der wichtigste Abschnitt.** Hier steht das Ergebnis, nicht die Leistung.

| Pflicht | Inhalt |
|---|---|
| ✔ | Jede Datei aus `medien.videos[]` als `<video autoplay muted loop playsinline preload="none" poster="…">` |
| ✔ | Jede Datei aus `medien.bilder[]` als `<img loading="lazy" width="…" height="…">` |
| ✔ | Eine Bildunterschrift je Medium: was ist zu sehen |
| wenn `medien.demo` gefüllt | der Spielblock, genau nach der Vorlage unten |
| wenn `medien.demo` **null** | **kein** `<iframe>` — stattdessen ein Satz, warum nicht gespielt werden kann |

`width` und `height` sind Pflicht an jedem Bild und jedem iframe — ohne sie springt
das Layout beim Laden. Die Maße stehen in `run.json`.

### Der spielbare Build

Ist `medien.demo` gefüllt, liegt der Build unter `demo/` **neben** dieser Seite.
Der Rahmen sieht **genau so** aus — jede Abweichung meldet `pruefe.mjs` als Fehler:

```html
<iframe id="demo" src="about:blank" data-src="demo/index.html"
        title="…" width="…" height="…"
        sandbox="allow-scripts" allow="fullscreen"></iframe>
```

Vier Regeln, jede aus einem Grund:

- **`src="about:blank"`, das Ziel in `data-src`.** Der Build wiegt mehr als die übrige
  Seite; er lädt erst, wenn jemand tippt. `loading="lazy"` genügt dafür nicht — das lädt,
  sobald der Abschnitt in Sicht kommt, und das ist am Telefon nach zwei Wischern.
- **`sandbox="allow-scripts"`, sonst nichts.** Vor allem **kein** `allow-same-origin`:
  Spiel und Seite teilen sich den Ursprung, und mit diesem Zusatz dürfte der Rahmen sein
  eigenes `sandbox`-Attribut entfernen, sich neu laden und danach diese Seite umschreiben.
  Ohne ihn bekommt der Build einen undurchsichtigen Ursprung — kein Zugriff auf die Seite,
  keine Cookies, kein Speicher.
- **Kein `autoplay` in `allow`.** Ein Spiel, das im Bus von selbst Ton macht, ist ein
  Fehler. Der Ton beginnt nach der ersten Berührung im Rahmen.
- **Ein Knopf `id="demo-halt"`, der den Rahmen aus dem Dokument nimmt.** Nur das gibt
  WebGL, Zeitgeber und Ton wirklich frei; ein leergesetztes `src` tut das nicht.

Die Größe auf der Seite ist `medien.demo.uebertragung_mb` — was über die Leitung geht,
nicht was auf der Platte liegt. Der Generator misst nach und meldet, wenn beide Zahlen
auseinanderlaufen.

**Ist `medien.demo` null, gibt es keinen Rahmen und keinen Startknopf.** Ein Build kann zu
schwer sein, absolute Pfade tragen oder von einem fremden Server nachladen — dann sagt der
Abschnitt in einem Satz, was der Fall ist, und Video und Bilder bleiben stehen. Ein Knopf,
der ins Leere führt, lässt die Seite kaputt aussehen statt ehrlich.

## 5 · `#vision` — Bilderkennung

Aus `run.json` → `vision`. Wenn `vision` fehlt oder `null` ist, bleibt der Abschnitt
trotzdem stehen und sagt in einem Satz: „Für diesen Lauf liegt kein Bilderkennungs-Test vor."

| Pflicht wenn vorhanden | Inhalt |
|---|---|
| ✔ | `vision.nachbau_svg` — der eigene SVG-Nachbau des Diagramms, direkt eingebettet |
| ✔ | `vision.a1` — Trefferquote beim Ablesen: richtig von möglich |
| ✔ | `vision.b` — Preisschilder: Präzision, Recall, **Halluzinationen** |
| ✔ | Das Prüfbild daneben, damit man vergleichen kann |

Die Halluzinationsrate wird nicht versteckt. Sie ist die interessanteste Zahl des
ganzen Tests.

## 6 · `#tempo` — Geschwindigkeit über Kontexttiefe

Aus `run.json` → `tiefe`. Ein Diagramm, selbst gezeichnet als SVG.

- x-Achse Kontexttiefe, y-Achse Rate. **Nie zwei y-Achsen.**
- Achsenbereich nur so weit wie gemessen. Wenn die Messung bei 31 K beginnt, beginnt
  die Achse bei 31 K — nicht bei 0.
- Wenn `tiefe` fehlt: Abschnitt steht, sagt „für diesen Lauf nicht erhoben", fertig.

Ein Hilfszeichner liegt in [copy-exact/diagramm.js](copy-exact/diagramm.js) bereit.
Ob du ihn benutzt oder selbst zeichnest, schreibst du auf die Seite — beides ist in
Ordnung, aber es soll sichtbar sein.

## 7 · `#konfig` — Wie man das nachstellt

| Pflicht | Inhalt |
|---|---|
| ✔ | `konfiguration.startzeile` in einem `<pre>`, unverändert, mit Kopierknopf |
| ✔ | Kontextgröße, KV-Cache-Typ, `-ub`, spekulatives Dekodieren, Build-Hash |

Der Kopierknopf ist ein `<button data-copy="startzeile">`; `common.js` verdrahtet ihn
selbst. Das `<pre>` bekommt `id="startzeile"`.

## 8 · `#qualitaet` — Wie gut ist das Ergebnis

Aus `run.json` → `qualitaet`. Objektive Größen (Tests grün, Bundlegröße, Konsolenfehler)
und die Rubriknote **getrennt** ausweisen. Die Note ist eine Meinung und wird als solche
gekennzeichnet: „vorläufig".

## 9 · `#fehler` — Was schiefging

Aus `run.json` → `fehler[]`. Ungeschönt. Ein Modell, dessen Seite keine Fehler zeigt,
wirkt nicht besser, sondern unglaubwürdig.

Wenn die Liste leer ist: „Keine Selbstkorrekturen protokolliert." Nicht schönreden,
nicht weglassen.

## 10 · `#quellen` — Wo das Modell herkommt

Alle Links aus `run.json` → `links`, als erkennbare Liste:

| Link | Feld |
|---|---|
| Modellgewichte (Hugging Face / Unsloth) | `links.gewichte` |
| Modellkarte des Herstellers | `links.modellkarte` |
| Herstellerseite | `links.hersteller` |
| Messdaten-Repo | `links.repo` |
| Rohprotokoll dieses Laufs | `belege.rohprotokoll` |

Jeder externe Link trägt `target="_blank" rel="noopener"`. Fehlt ein Feld, entfällt
der Eintrag — kein toter Link, keine erfundene URL.

## 11 · `#nachbau` — Selbst ausprobieren

Kurz und praktisch: die drei Schritte von „Modell laden" bis „läuft in VS Code",
der Zitierhinweis aus `run.json` → `zitat`, und der Hinweis auf die Lizenz.

---

## Was der Validator prüft

```
npm run pruefe -- <slug>
```

1. Alle zehn `id`-Werte vorhanden, in der richtigen Reihenfolge
2. Kopf- und Fußblock zeichengenau unverändert
3. `<svg id="modell-marke">` vorhanden, quadratisch, ohne `<image>`, unter 4 KB
4. **Jede Zahl auf der Seite kommt in `run.json` vor** — sonst Fehler mit Zeilennummer
5. Kein `<script src=…>` außer den beiden aus dem Fußblock
6. Kein `<link href=…>` außer Google Fonts
7. Jedes `<img>` und `<iframe>` hat `width` und `height`
8. Die Datei ist gültiges HTML und öffnet ohne Konsolenfehler
9. **Kein Textblock steht ohne eigene Fläche über dem bewegten Hintergrund**
