B · Oberfläche und Ablauf (Bereich B des Auftrags „Klassenraum")

Stand: 2026-10-06, Zweig ausbau-1.2, nichts committet, nichts gepusht. Grundlage: tools/auftraege/KLASSENRAUM.md (der Auftrag), tools/auftraege/COMMON.md, AGENTS.md, A – Codec und Determinismus.md (Bereich A), D – Prüfung, Abnahme und Reihenfolge.md.

Was hier steht: die verbindliche Festlegung für Ansichten, DOM, Klassennamen, Texte, Startseiten-Eingabe, Beamer-Lesbarkeit, Ablauf des Klassenraum-Auftrags, Ergebnis-Code, Lehrer-Eingabe, Ampel, Export/Import und den Server-Schalter – jede Festlegung mit Datei:Zeile-Beleg.

Belege: Nachweise/Klassenraum/B-ui.md (liegt nicht im Repo) (Klassenliste, Tokens, Rauchtest-Analyse, Lesbarkeitsrechnung, Textliste, Belegverzeichnis). Entwürfe und Gegenprüfungen: Nachweise/Klassenraum/B-ansichten.md, B-texte-ablauf.md, B-ampel-eingabe.md, B-gegenpruefung.md, B-gegenpruefung-dom-css-tokens.md, B-gegenpruefung-ampel-export.md.

Dieses Dokument legt fest, es baut nicht. Änderungen an src/**, tests/**, tools/*.py und bauen.py sind in dieser Sitzung nicht gemacht worden (Regel aus Liesmich.md:29-30). Bezugsstand von Bereich A: A – Codec und Determinismus.md, 51.843 Bytes, 822 Zeilen, geändert 06.10.2026 23:53:41 – alle A-Belege wurden darauf nachgezogen.

0 · Die drei Entscheidungen, die alles andere bestimmen

E2 ist die einzige Festlegung, die fremden Code berührt (Vorschlag, keine Änderung, siehe Abschnitt 6.4).

1 · Registrierung der Ansichten

1.1 Die echte Signatur

/* src/ui/app.js:3 */
UI.app.registrieren(name, {titel, symbol, zeigen(container), wieder?(container), verlassen?(), zaehler?()})

Der Rumpf (src/ui/app.js:57-63) füllt fehlende Felder mit {name, titel: name, symbol: "info"} (src/ui/app.js:60) und hängt die Ansicht in die Karte ansichten; ein zweiter Aufruf mit demselben Namen ersetzt die alte Ansicht und baut sie neu auf (src/ui/app.js:61).

• titel – Beschriftung im Andock-Knopf und in der Befehlspalette (src/ui/app.js:106-107).
• symbol – Name aus der Symbol-Liste in src/ui/geraetebilder.js:67-116; ein unbekannter Name fällt still auf info zurück (src/ui/geraetebilder.js:120).
• zeigen(container) – baut das DOM der Ansicht; der Rahmen legt es in div.ansicht mit data-ansicht="<name>" (src/ui/app.js:95).
• wieder(container) – wird nur gerufen, wenn der Knoten schon existiert (src/ui/app.js:98).
• verlassen() – wird vor dem Ansichtswechsel gerufen (src/ui/app.js:88), ebenso beim Abbau der Vollansicht (src/ui/app.js:235).
• zaehler() – Zahl am Andock-Knopf, in try/catch gelesen (src/ui/app.js:117-118).

1.2 Anmeldung und Reihenfolge

Beide Ansichten melden sich in einem Start-Haken an – dasselbe Muster wie Heute (src/ui/hub.js:170-173), Postfach (src/ui/spiel.js:842-845) und die Karriere-Ansichten (src/ui/karriere.js:475-479):

/* src/ui/klassenraum.js (neu), am Dateiende */
(UI.startHaken ||= []).push(() => {
  UI.app.registrieren("klassenraum", {titel: "Klasse", symbol: "kunden", zeigen: lehrerZeigen, wieder: lehrerWieder});
  UI.app.registrieren("mitarbeit",   {titel: "Auftrag", symbol: "akte",   zeigen: schuelerZeigen, wieder: schuelerWieder});
  UI.app.einstellungAbschnitt("Klassenraum", klassenraumAbschnitt);   /* Abschnitt 11 */
  Spiel.klassenraum.tauglicheFertigkeiten?.();                        /* nur, wenn A die Zusatzfunktion liefert */
});

• Dateiname src/ui/klassenraum.js (Auftrag KLASSENRAUM.md:19). Der Bau lädt in einem Ordner erst die Kopfdatei, dann alphabetisch, und hängt nur app.js/start.js ans Ende (COMMON.md:7, bauen.py:60-61); klassenraum.js liegt damit zwischen karriere.js und klang.js und vor spiel.js. Für den Testlauf gilt dasselbe (tests/run.js:32-34): alle .js des Ordners werden geladen, SCHICHTEN bestimmt nur Kopf- und Schlussdateien (tests/run.js:25). Eine Ergänzung von tests/run.js ist nicht nötig – die entgegenstehende Vermutung aus B-ansichten.md ist in B-gegenpruefung.md widerlegt.
• Reihenfolge im Haken: klassenraum zuerst, dann mitarbeit. Der Rahmen ruft die Haken in Eintragsreihenfolge (src/ui/start.js:49), und UI.modus("voll") kommt erst danach (src/ui/start.js:58) – beim ersten dockZeichnen() (src/ui/app.js:227) stehen beide Knöpfe also schon.
• Symbolnamen (beide existieren, keine Erfindung): kunden = src/ui/geraetebilder.js:71, akte = src/ui/geraetebilder.js:115. labor (:70), heute (:69), postfach (:68), wiki (:72), lernstand (:73), shop (:74) sind besetzt; klassenraum und mitarbeit sind keine Symbolnamen.

1.3 Wo sie in der Andock-Leiste stehen – und warum dort

REIHE (src/ui/app.js:21) bleibt unangetastet:

const REIHE = ["heute", "postfach", "labor", "kunden", "wiki", "lernstand", "shop"];

liste() liefert zuerst die Namen aus REIHE, die es gibt, dann alle übrigen in Anmeldeordnung (src/ui/app.js:79-82). Ergebnis:

heute · postfach · labor · kunden · wiki · lernstand · shop · klasse · auftrag

Warum hinten? Der Klassenraum ist Vorführ-Ebene, nicht Alltagsweg: der Auftrag nennt ihn ausdrücklich „Novelty-Ebene" (KLASSENRAUM.md:1) und „die Vorführung, nicht das Geschäft" (KLASSENRAUM.md:7). Eine Schülerin arbeitet über die Startseiten-Eingabezeile (Abschnitt 4) oder über die Palette; beide Ansichten sind über Strg+K erreichbar, weil die Palette ihre Einträge aus UI.app.liste() baut (src/ui/palette.js:47).

Andock-Platz gerechnet: Der Andock-Streifen rollt selbst (overflow-y:auto, src/stil/rahmen.css:40), ein Knopf ist mindestens 58 px hoch, der Abstand 4 px, das Polster oben und unten 10 px (src/stil/rahmen.css:40-41).

Bei 600 px Fensterhöhe (546 px verfügbar) rollt der Streifen – das ist der bestehende Zustand des Andock-Streifens, keine neue Last. Der Rauchtest prüft bei 1366/768, 960/700 und 720/640 (tools/rauch.py:45); bei 700 bzw. 640 px Höhe bleibt es bei 574 gegen 646 bzw. 586 px.

1.4 Kein Zähler

zaehler wird nicht gesetzt. Ein Zähler müsste den Spielstand lesen (Spiel.ungelesen(), src/ui/spiel.js:844) und würde die Klassenraum-Ansicht an die Karriere koppeln – die Sitzung liegt aber in store "klassenraum" (KLASSENRAUM.md:40, Datenschema A – Codec und Determinismus.md:671-688).

2 · DOM-Struktur, Klassennamen, Tokens

Gebaut wird ausschließlich mit h()/$(…) aus src/ui/dom.js: class setzt el.className, onclick wird zu addEventListener("click", …), Kinder werden flach angehängt, null/false fällt weg (src/ui/dom.js:7-20). Haus-Form ist „ein Wurzelknoten, der die Fläche füllt" (src/ui/hub.js:24-26, :63-66).

Präfix kl- für alles Neue. Begründung: kl- ist frei (im Bestand gibt es nur .klein, .klickbar, .klingelt – Einzelwörter ohne Bindestrich), der Dateiname klassenraum.css passt dazu, und klassen.py akzeptiert genau Wörter der Form [a-z][a-z0-9]*(-[a-z0-9]+)+ (tools/klassen.py:47).

Gerüst statt Neuaufbau: zeigen baut das Gerüst einmal, wieder füllt nur die veränderlichen Behälter. Ein c.replaceChildren(…) über die ganze Ansicht (Haus-Form, src/ui/hub.js:63) würde die Eingabefelder wegwerfen, die man gerade benutzt.

2.1 Lehrer-Ansicht klassenraum (Dock-Beschriftung „Klasse", h2 „Klassenraum")

div.kl-lehrer                          ← zeigen-Container (scrollt selbst, .ansicht hat overflow:auto)
└ div.kl-spalte                        ← zentrierte Spalte, width:min(660px,100%)
  ├ header.kl-kopf  → h2 "Klassenraum" · p.kl-klein "..."
  ├ div.kl-werkzeug                    ← GERÜST, bleibt stehen
  │ ├ span.kl-etikett "Auftrag"
  │ ├ select.kl-feld                   ← (1) Auftrag aus Spiel.ticketReihe()
  │ └ button.knopf.knopf-haupt "Code anzeigen"        ← (2)
  ├ div.kl-karte                       ← Behälter A, bei jeder Sitzungsänderung neu gefüllt
  │ ├ span.kl-etikett "Auftragscode für die Klasse"
  │ ├ div.kl-gross → span.kl-code "NL-4F7K-2Q"        ← die einzige vergrößerte Schrift
  │ ├ div.kl-block → span.kl-detail · button.knopf.kl-knopf "Code kopieren"   ← (3)
  │ ├ div.kl-block → span.kl-detail "Klassenraum-Abdruck" + span.kl-code      ← Abschnitt 6.5
  │ └ div.kl-block → span.kl-hinweis   ← Leer-/Fehler-/Erfolgszeile
  ├ div.kl-ampel                       ← Behälter B
  │ ├ div.kl-summe → span.kl-lampe.kl-rot|kl-gelb|kl-gruen · span.kl-detail
  │ └ div.kl-tafel → div.kl-zeile × n → span.kl-platz · Text · Text
  └ div.kl-form                        ← Werkzeugzeile unten
    ├ span.kl-etikett "Ergebnis-Codes"
    ├ textarea.kl-feld                 ← (4) Block oder einzelne Codes
    └ span.kl-knoepfe → button.knopf.kl-knopf "Eintragen" (5) · "Datei…" (6)

Sichtbare Bedienelemente: 6 (select, „Code anzeigen", „Code kopieren", textarea, „Eintragen", „Datei…") – genau die Grenze von R12 (tools/ethos.py:304-316). Lampen, Tafel, Beschriftungen sind span/div und zählen nicht. Diese Zahl ist der Engpass der ganzen Ansicht: kommt ein siebtes Bedienelement dazu (z. B. ein eigener „Einfügen"-Knopf), wird python tools/ethos.py --dom rot. Deshalb liegen Export und Import auf einem Knopf „Datei…", der einen Dialog öffnet (UI.app.dialogOeffnen, src/ui/app.js:241-260).

2.2 Schüler-Ansicht mitarbeit (Titel „Auftrag")

div.kl-schueler
└ div.kl-spalte
  ├ header.kl-kopf → h2 "Mitarbeit" · p.kl-klein "..."
  ├ form.kl-form                       ← GERÜST
  │ ├ span.kl-etikett "Auftragscode"
  │ ├ input.kl-feld                     ← (1) placeholder "NL-4F7K-2Q", type="text"
  │ ├ input.kl-feld (Platzkennung)      ← (2) type="text", inputmode="numeric", maxlength 2
  │ └ button.knopf.knopf-haupt "Auftrag öffnen"   ← (3)
  └ div.kl-karte                       ← Behälter B: Zustandszeile, Fehler, angenommener Auftrag
    ├ span.kl-etikett "Stand"
    ├ span.kl-hinweis
    └ div.kl-block → span.kl-detail "Klassenraum-Abdruck" + span.kl-code   ← Abschnitt 6.5

Sichtbare Bedienelemente: 3. Nach dem Öffnen wechselt die Fläche ins Labor (src/ui/spiel.js:56); die Ansicht bleibt im Andock stehen und zeigt beim Zurückkommen den Zustand neu (wieder).

2.3 Tabelle „Klasse → CSS-Regel"

30 neue Klassen, 30 Regelblöcke in src/stil/klassenraum.css – eine Regel je Klasse, keine Regel ohne Klasse (gezählt wie tools/klassen.py:30-49 es zählt: jedes Wort in class:/classList/className/ closest/querySelector/$(…), das auf [a-z][a-z0-9]*(-[a-z0-9]+)+ passt, braucht eine Regel in src/stil/*.css).

Neue Klassen der Startseiten-Eingabezeile (Abschnitt 4, drei weitere, ebenfalls in src/stil/klassenraum.css): kl-start, kl-start-etikett, kl-start-feld, kl-start-knopf – damit 34 Klassen / 34 Regelblöcke.

Gegenprobe: python tools/klassen.py muss nach dem Bau 0 Klassen ohne CSS-Regel melden – der Ist-Stand ist heute 0 (in dieser Sitzung gemessen, siehe B-ui.md). Jede Klasse oben ist neu; kollidiert eine mit einer bestehenden Regel aus src/stil/*.css, meldet klassen.py sie nicht, aber ethos.py möglicherweise als Dopplung (R10, tools/ethos.py:269-283) – deshalb steht jede Regel genau einmal.

2.4 Tokens – ausschließlich aus src/stil/basis.css

Kein neues Farb- oder Größensystem (KLASSENRAUM.md:20), keine Farb-Literale (ethos R1, tools/ethos.py:151-159), kein !important außerhalb von basis.css (R7, tools/ethos.py:235-241).

Nicht benutzt (absichtlich): --radius-xs (:32, nur für code/kbd in basis.css:86-87), --accent-ink (:17), --glas (:40), --leiste-bg (:41), --kopf-h/--dock-b (:42, liest nur rahmen.css:4). Es gibt kein Token --akzent-* – die Schreibweise in einem früheren Entwurf war falsch.

Die ethos-Falle (R3): font-size wird nur geprüft, wenn der Wert mit Zahl + px/em/rem/% beginnt (tools/ethos.py:184-185, :192-194); die sechs erlaubten Werte sind {11, 12, 13, 15, 20, 28} px (tools/ethos.py:42). Ein clamp(…) am Anfang wird übersprungen – die Beamer-Schrift (Abschnitt 5) rutscht dadurch durch die Prüfung, obwohl sie größer ist als jeder Wert der Skala. Das ist der bewusste, offen benannte Kompromiss: die Alternative wäre ein neuer Skalenwert in tests/stil-stand.json (den darf nur die Leitung ändern). Alle anderen Schriftgrößen der neuen Regeln bleiben in der Skala (11, 13, 15, 28).

R4 (Abstand): nur {0, 4, 8, 12, 16, 24, 32} px (tools/ethos.py:43, :199-208). Ein Wert wie 28px als Polster wäre sofort rot. R11 (Einheit): Längenzahlen brauchen eine Einheit, 0 und calc/min/max/clamp sind ausgenommen (tools/ethos.py:286-297) – height:120px ist in Ordnung, height:100 nicht.

2.5 Leer- und Fehlerzustände

2.6 Ohne Karriere-Spielstand (Leiter-Hinweis 2)

Befund am Code: Spiel.st ist ein Getter, der beim ersten Zugriff Spiel.laden() ruft (src/spiel/zustand.js:82-86, Getter in :84). Spiel.laden() legt einen leeren Stand an, wenn keiner da ist (:138-140), füllt das Postfach (:148) und speichert (:149). Ein frischer Schulrechner hat also sofort einen gültigen Stand: stufe: 1, euro: 0, postfach: [] → nach postfachAuffuellen 2–3 Tickets (Ziel aus Spiel.postfachZiel(), src/spiel/postfach.js:14).

Was daraus folgt (Festlegung):

1. Die Klassenraum-Ansicht darf nicht Spiel._st als Sperre benutzen (so macht es der Hub, src/ui/hub.js:26). Sie liest die Sitzung aus store "klassenraum" und braucht den Spielstand nicht.
2. Vor dem Öffnen eines Auftrags muss if (!Spiel._st) Spiel.laden(); stehen. Grund: Spiel.instanzErstellen liest const st = Spiel.st (src/spiel/postfach.js:63) und legt die Instanz in st.postfach ab (:98) – auch wenn der Getter selbst laden würde, ist der ausdrückliche Ruf die ehrliche Variante (Muster: src/spiel/post.js:40, src/spiel/ticket.js:194).
3. Auftrag über der Karriere-Stufe ist kein Problem: Das Niveau kommt nicht aus st.stufe, sondern aus Spiel.niveauFuer(def) (src/spiel/lernen.js:19-26): bei Spiel.einst.wahl === "auto" aus dem Lernstand, sonst aus der Wahl der Spielerin, nie unter def.stufe (:24-25). Der Klassenraum-Auftrag läuft auf einem fremden Rechner also mit dessen eigenem Niveau – das ist gewollt („kein Unterschied im Spielgefühl", KLASSENRAUM.md:43). Wer für die ganze Klasse dasselbe Niveau will, setzt wahl in den Einstellungen (Spiel.einst.wahl, src/spiel/lernen.js:20-21) – ein Klassenraum-Auftrag über der Stufe des Geräts ist damit kein Fehler, sondern läuft auf dem Niveau dieses Geräts.

3 · Alle Texte wörtlich

Anrede durchgehend „du" (COMMON.md:9). Herkunft je Text in Klammern: [Auftrag] = wörtlich aus KLASSENRAUM.md, [A] = Text aus A – Codec und Determinismus.md (dort gemessen, also der Text, den der Code wirklich liefert), [B] = hier festgelegt (der Auftrag verlangt den Inhalt, gibt aber keinen Wortlaut).

3.1 Startseite (Abschnitt 4)

3.2 Schüler-Ansicht mitarbeit

Fehlertexte kommen aus A und werden nicht neu erfunden ({fehler, grund}, A – Codec und Determinismus.md:156-186). Der Code von Bereich A liefert wörtlich:

Achtung, Abweichung vom Auftrag (offen): Der Auftrag nennt als Beispiel wörtlich „Prüfziffer stimmt nicht — hast du ein O statt 0 getippt?" (KLASSENRAUM.md:43) und legt damit zwei Fehlerarten in einen Satz. A hat daraus zwei Klassen gemacht und zwei eigene Sätze formuliert (Zeile „Fremdzeichen" und „Prüfziffer" oben). Die Oberfläche zeigt A's Text – eine zweite Wahrheit im UI wäre schlimmer als die Abweichung. Der Satz des Auftrags bleibt hier wörtlich stehen, damit die Leitung entscheiden kann (Abschnitt 12, offener Punkt O3).

3.3 Lehrer-Ansicht klassenraum

3.4 Erfolgs- und Fehlermeldungen der Lehrer-Eingabe

3.5 Server und Firewall (Abschnitt 11)

3.6 Ergebnis-Code im Spiel (Abschnitt 7)

Es gibt keine Texte für den Fall „Ergebnis-Code nötig, aber Klassenraum-Auftrag nicht erkannt" – A liefert dafür {fehler:"auftrag", grund:"Dieser Auftrag kam nicht über einen Klassenraum-Code."} (A – Codec und Determinismus.md:545); in diesem Fall wird kein Toast gezeigt (der Auftrag war dann kein Klassenraum-Auftrag).

4 · Startseite: die Code-Eingabezeile

4.1 Wo die „Startseite" wirklich ist

Die sichtbare Startseite ist die Ansicht heute – der Hub (src/ui/hub.js:2, „die ruhige Startseite"). Wer neu ist, landet zuerst im Labor (src/ui/spiel.js:855), mit Fortschritt in heute (src/ui/spiel.js:856); angemeldet wird heute in src/ui/hub.js:170-174.

Der Auftrag nennt src/ui/start.js (KLASSENRAUM.md:22). Dort steht die Startseite aber nicht: start.js ist der Startvorgang (UI.starten, src/ui/start.js:44-107) und die Sandbox (src/ui/start.js:6-42). Der Ortsname im Auftrag ist an dieser Stelle ungenau.

Festlegung: Die Zeile wird in src/ui/hub.js ergänzt – als ein zusätzliches Kind in c.replaceChildren(h("div", {class:"hb-seite"}, kopf, feier, karte, KLASSE, kacheln, ziel)) (src/ui/hub.js:63-66) und damit sichtbar unter der Auftragskarte und über den Kacheln. Das ist eine additive Änderung an einer fremden Datei und braucht die Freigabe der Leitung (Abschnitt 12, O2); alternativ kann die Zeile aus src/ui/klassenraum.js kommen, wenn hub.js den Hub über einen Bus-Kanal anbietet – den gibt es heute nicht.

/* src/ui/hub.js, zwischen `karte` und `kacheln` (Zeile 65) */
klassenraumZeile(),   /* liefert null, wenn Spiel.klassenraum fehlt – dann ändert sich nichts */

4.2 Aussehen und Verhalten

/* neue Funktion in src/ui/klassenraum.js; Klassen kl-start* (Abschnitt 2.3) */
function klassenraumZeile(){
  if (typeof Spiel.klassenraum === "undefined") return null;        /* Bereich A fehlt → kein DOM */
  const feld = h("input", {type: "text", class: "kl-start-feld", placeholder: "NL-4F7K-2Q",
    spellcheck: "false", autocomplete: "off", autocapitalize: "characters", "aria-label": "Klassenraum-Code"});
  const los = () => { const r = Spiel.klassenraum.ausCode(feld.value); ... };   /* Abschnitt 6 */
  return h("div", {class: "kl-start"},
    h("label", {class: "kl-start-etikett", for: ...}, "Klassenraum-Code"),
    feld,
    h("button", {type: "button", class: "hb-oder-zeile kl-start-knopf", onclick: los}, "Öffnen"));
}

4.3 Beleg, dass der Rauchtest nicht bricht

tools/rauch.py klickt mit echten Mausereignissen und misst zusätzlich Lage, Überlauf und leere Flächen (tools/rauch.py:1-24). Die Fallzahl ist 36 – nachgezählt: BREITEN hat 3 Einträge (tools/rauch.py:45), je Breite läuft 1 Fall „erster Auftrag" (:415) plus 11 Fälle aus FAELLE (:176-186) in der Schleife :421; die Summe druckt :437. 3 × 12 = 36.

Verboten, damit 36/36 bleibt (Kurzliste):

1. Keine Klasse primaer und keine Klasse hb-annehmen in der neuen Zeile.
2. Kein input[type=search].
3. Keine leere Fläche als Eingabe-Attrappe (nur echte input/textarea – tools/rauch.py:157).
4. Kein Overlay, kein position:fixed, nichts über der Zeichenfläche.
5. Kein seitliches Scrollen, keine feste Breite über min(660px,100%) hinaus.
6. Keine JS-Ausnahme (die Zeile prüft typeof Spiel.klassenraum).
7. ABSICHT in tools/rauch.py:103 nicht erweitern (das wäre das Werkzeug an die Oberfläche anpassen).

Ehrlich: Der Rauchtest ist in dieser Sitzung nicht gelaufen. Edge bricht in der Werkzeug-Sandbox in seiner eigenen Prozess-Sandbox ab (Nachweise/Klassenraum/D-messung.md:105-133). Die Aussage oben ist deshalb eine Analyse des echten Skripts, keine Messung. Die 36 ist hergeleitet und nachgezählt (Abschnitt 4.3, erster Absatz), der Ist-Stand 36/36 stammt aus AGENTS.md.

5 · Beamer-Lesbarkeit – Rechnung und Schriftgrößen

5.1 Rechnung

Annahmen, alle offen benannt:

• Betrachtungsabstand 3 m (Zielvorgabe des Auftrags, KLASSENRAUM.md:43).
• Sehwinkel: 20 Bogenminuten sind die untere Grenze für sicheres Erkennen einzelner Zeichen, 25 die bequeme (A – Codec und Determinismus.md nennt keine Werte; die Werte sind Setzung, siehe „nicht geprüft"). 1 Bogenminute bei 3 m = tan(1/60°) · 3000 mm = 0,8727 mm.
• Zeichenhöhe: gemeint ist die Versalhöhe (Großbuchstaben – der Code ist durchgehend groß). Für die Haus-Monospace (--mono, src/stil/basis.css:35) wird sie mit 0,70 em angenommen.
• Zeichenbreite Monospace: 0,60 em (typisch für JetBrains Mono/Consolas).

Zeichenzahl des Auftragscodes: 10 – NL-XXXX-XX ist „immer genau 10 Zeichen (inkl. Trennstriche)" (A – Codec und Determinismus.md:42-47, über alle 2²⁰ Nutzlasten gemessen). Der Ergebnis-Code ist ebenfalls 10 Zeichen (E-XXXX-XXX, :513). Die frühere Annahme „12 Zeichen" war falsch.

Breite des Codes: 10 · 0,60 em = 6,0 em – bei 94 px sind das 564 px.

5.2 Schriftgröße je Fensterbreite

Der Code soll nicht umbrechen (er ist ein Stück Papier, kein Fließtext), also gilt: font-size ≤ verfügbare Breite / 6,0.

Festlegung (die Regel für .kl-gross bzw. .kl-code):

.kl-gross{
  /* die EINZIGE Schrift außerhalb der ethos-Skala – über clamp(), siehe 2.4 */
  font: 800 clamp(28px, 5vw, 118px)/1.05 var(--mono);
  display: grid; place-items: center; overflow: visible;
}
.kl-code{ letter-spacing: .08em; white-space: nowrap; }

clamp(28px, 5vw, 118px) ergibt bei 1366 px 68,3 px, bei 960 px 48,0 px, bei 720 px 36,0 px und am Deckel 118 px. Das ist die Schreibweise, die tools/ethos.py:184-194 überspringt (Abschnitt 2.4).

5.3 Was das aus drei Metern wirklich heißt

Die Versalhöhe hängt an der Projektionsgröße, nicht an der Fensterbreite. Ein typischer Klassenraumprojektor zeigt bei 1920 px nativer Breite etwa 2,0 m Bildbreite – das sind 1,042 mm je px. Damit:

Ehrliche Schlüsse:

• Aus drei Metern ist der Code über einen Projektor in jeder geprüften Fensterbreite lesbar – auch bei 720 px (30 Bogenminuten).
• Ohne Projektor (Bildschirm 1:1, 96 dpi) sind selbst 68 px nur 14,4 Bogenminuten – drei Meter sind am nackten Monitor nicht zu schaffen. Wer das will, braucht 94 px Schrift bei einem Fenster ab 1920 px (das ist im Deckel enthalten) oder muss näher heran.
• Die Rechnung ist eine Rechnung, keine Messung am Beamer (Abschnitt 12).

6 · Ablauf „Klassenraum-Auftrag"

6.1 Die Aufrufkette (so, und nur so)

/* src/ui/klassenraum.js – der Öffnungsweg des Auftrags; Vorlage: A – Codec und Determinismus.md:591-594 */
const c = Spiel.klassenraum.ausCode(eingabe);          // Abschnitt 1: 0,4 ms, reine Rechnung, keine Ausnahme
if (!c) return;                                        // nichts eingetippt
if (c.fehler) return hinweis(c.grund);                 // Tippfehler, fremde Fassung, Länge …
if (!Spiel._st) Spiel.laden();                         // frischer Schulrechner (Abschnitt 2.6)
const inst = c.skill
  ? Spiel.instanzErstellen({gen: {skill: c.skill, seed: c.seed}, quelle: "klassenraum", ohneFlow: true})
  : Spiel.instanzErstellen({ticketId: c.ticketId, seed: c.seed, quelle: "klassenraum", ohneFlow: true});
inst.klassenraum = {sitzung: c.sitzung, platz: Spiel.klassenraum.platz() ?? 0, code: c.code};
UI.spiel.oeffnen(inst.iid);                            // NICHT Spiel.oeffnen allein

Reihenfolge und Wirkung, jede Zeile belegt:

Kein Postfach-Umweg, kein Spiel.postfachAuffuellen, kein zweiter Speicher.

6.2 Was im Postfach und im Hub sichtbar wird

6.3 Der Titel „Klassenraum-Auftrag"

def.titel kommt aus dem Bauplan (src/daten/basis.js:145, Feld titel in der festen Fassung) und ist über Object.defineProperty als Getter angelegt (src/daten/basis.js:148-151) – ein Object.assign würde ihn auswerten und den Titel verlieren. Ein zusätzliches Feld am Bauplan gibt es nicht; spec.titel ist die einzige Quelle.

Festlegung: Der Titel wird in der Anzeige überschrieben, an genau zwei Stellen, und zwar über einen additiven Haken auf Spiel.defVon – dieselbe Technik, mit der Spiel.ergaenzer den Spielstand erweitert (src/spiel/zustand.js:11, :142-144):

/* src/spiel/klassenraum.js, ganz am Ende der Datei – NICHT auf oberster Ebene (Ladereihenfolge, COMMON.md:7) */
function titelHaken(){
  if (Spiel.defVon.klassenraumHaken) return;               /* idempotent */
  const alt = Spiel.defVon;
  const neu = function(id, inst){
    const d = alt(id, inst);
    if (!d) return d;                                       /* null bleibt null */
    if (!inst || inst.quelle !== "klassenraum") return d;
    if (inst.krDef && inst.krDef.ticketId === d.id) return inst.krDef.def;
    const kopie = Object.create(d);                         /* Getter bleiben Getter */
    Object.defineProperty(kopie, "titel", {value: "Klassenraum-Auftrag", enumerable: true, configurable: true});
    inst.krDef = {ticketId: d.id, def: kopie};
    return kopie;
  };
  Object.defineProperty(neu, "klassenraumHaken", {value: true});
  Spiel.defVon = neu;
}
(UI.startHaken ||= []).push(() => { titelHaken(); /* … die registrieren-Aufrufe aus 1.2 */ });

Warum so und nicht anders (jede Alternative mit ihrem Preis):

Nebenbedingung: Spiel.defVon wird an vielen Stellen gerufen (src/spiel/postfach.js:116). Der Haken liefert die Kopie je Instanz gemerkt (inst.krDef), ist also stabil; ohne inst (z. B. Spiel.ticketDef(o.ticketId) in src/spiel/postfach.js:75) verhält er sich wie vorher. Ob Identitätsvergleiche auf defVon-Ergebnisse existieren, ist nicht geprüft (Abschnitt 12).

6.4 Was NICHT passieren darf (Leiter-Hinweis 1)

Der Auftrag soll die Karriere nicht anfassen (Entscheidung E2). Der Ist-Zustand am Code:

Spiel.abschliessen hat einen frühen Ausstieg für den nicht bestandenen Fall (src/spiel/abnahme.js:92-95); er ist die natürliche Stelle für einen zweiten:

/* VORSCHLAG an die Leitung – src/spiel/abnahme.js, direkt nach der Abnahme (Zeile 91/92):
   Der Klassenraum-Auftrag wird abgenommen, aber nicht verbucht. */
if (inst.quelle === "klassenraum") {
  Spiel.sofortSpeichern();
  return {bestanden: abnahme.bestanden, abnahme, lernen: null, def, inst, klassenraum: true,
          sterne: abnahme.bestanden ? abnahme.sterne : 0};
}

Der Eingriff ist vier Zeilen in einer fremden Datei und ändert für alle anderen Quellen nichts. Er ist in dieser Sitzung nicht gemacht (Regel Liesmich.md:29-30); ohne ihn gilt der Ist-Zustand: der Klassenraum-Auftrag zählt als erledigt, gibt Lohn und Sterne, und Spiel.istErledigt(id) (src/spiel/postfach.js:52) kann ihn der Karriere „wegnehmen", weil er nur die Ticket-ID kennt (src/spiel/postfach.js:154). Das ist die wichtigste offene Entscheidung des Bereichs B (O4).

6.5 Der Klassenraum-Abdruck (Leiter-Hinweis 3)

Definition: der Netzkennwert aus Bereich A – 6 Zeichen aus dem Code-Alphabet, gebildet über eine kanonische Abbildung des Netzes (Geräte, Kabel, Konfiguration; ohne Laufzeitzustand und ohne Reihenfolgen) per FNV-1a (A – Codec und Determinismus.md:395-438, Funktion netzkennwert in :359-364). Gemessen: gleiches Netz → gleicher Kennwert (YYBR4E), eine geänderte IP → anderer Kennwert.

Festlegung:

• Quelle ist das geladene Netz, nicht der Code: Spiel.klassenraum.netzkennwert(inst.netz) – inst.netz ist das Netz der laufenden Instanz (src/spiel/postfach.js:90, :92). Aus dem Code gerechnet wäre der Vergleich zirkulär (beide Geräte zeigten nur, dass sie denselben Code gelesen haben).
• Wo: in beiden Ansichten, je eine Zeile, kopierbar:
  • Lehrkraft: in kl-karte, unter der Abdruck-Beschriftung „Klassenraum-Abdruck XXXXXX – auf beiden Geräten muss er gleich sein."
  • Schülerin: in kl-karte als Teil der Zustandszeile, „Klassenraum-Abdruck XXXXXX – vergleich ihn mit deinem Nachbarn."
• Form: span.kl-detail (Beschriftung) + span.kl-code (Wert). Der Wert ist markierbar (user-select:all, wie .hb-teilen in src/stil/hub.css:31) und über den Kopierknopf holbar.
• Wann er steht: sobald ein Auftrag geöffnet ist. Vor dem Öffnen gibt es kein Netz, also keinen Abdruck – dann steht „— — — — —" mit dem Hinweis „Abdruck erscheint, sobald der Auftrag offen ist."
• Was er nicht ist: kein Prüfmittel gegen Manipulation, nur ein Vergleichsabdruck (A – Codec und Determinismus.md:429). Er gehört nicht in die Ergebnis-Codes (die tragen nur Sitzung, Platz, Sterne, Fehlversuche, Dauer, A – Codec und Determinismus.md:584-594).

7 · Ergebnis-Code im Spiel

7.1 Wo er erscheint

Der Abnahmepfad der Oberfläche ist eine Funktion: abnahmeAnfordern() (src/ui/spiel.js:380-411). Sie ruft Spiel.abnahme(inst) (:382), dann Spiel.abschliessen(inst, ab) (:387), spielt die Funktionsprobe (:405) und zeigt am Ende ergebnisZeigen(erg) (:409) – das Ergebnisfenster (src/ui/spiel.js:444-526, Wurzel sp-ergebnis in :495, Knopfzeile sp-knoepfe in 591, Toasts dort nicht).

Spiel.abschliessen schreibt inst.zeitMs ein letztes Mal fort (src/spiel/abnahme.js:90) und meldet ticket-geloest (src/spiel/abnahme.js:148) – das ist der Haken für den Ergebnis-Code, denn Spiel.klassenraum.ergebnisCode(inst, abnahme) muss nach abschliessen laufen (A – Codec und Determinismus.md:541-554).

Festlegung: kein Eingriff in src/ui/spiel.js. Der Code hängt sich additiv an den Bus:

/* src/ui/klassenraum.js */
Bus.an("ticket-geloest", d => {
  const inst = d && d.inst;
  if (!inst || inst.quelle !== "klassenraum" || !inst.klassenraum) return;   /* kein Klassenraum-Auftrag */
  const ab = inst.letzteAbnahme;                                            /* siehe unten */
  const code = Spiel.klassenraum.ergebnisCode(inst, ab);
  if (code && code.fehler) return;                                          /* still: kein Auftrag → kein Code */
  const text = `Ergebnis-Code: ${code}`;
  UI.toast(text, "ok", {id: "klassenraum-code", titel: "Für die Lehrkraft", dauer: 20000,
    aktion: {text: "Kopieren", fn: () => UI.hub.kopieren(code, "Ergebnis-Code kopiert – gib ihn deiner Lehrkraft.")}});
});

UI.toast(text, art, {aktion:{text, fn}, dauer, titel, id}) – echte Signatur mit Aktionsknopf (src/ui/toast.js:3, :50-53); mit Aktion bleibt der Toast länger stehen (:58) und die Aktionsknöpfe zählen nicht als sichtbare Bedienelemente der Klassenraum-Ansicht (R12 zählt dokumentweit, tools/ethos.py:304). Die Kopier-Rückmeldung kommt aus UI.hub.kopieren(text, ok) (src/ui/hub.js:122-126).

Damit abnahme verfügbar ist, merkt sich der Bus-Hörer die letzte Abnahme: Bus.an("ticket-geloest") liefert sie nicht mit (src/spiel/abnahme.js:148). Zwei Wege, beide ohne fremde Datei:

1. Empfohlen: den Aufruf Spiel.abnahme ebenfalls additiv umhängen (abnahmeHaken(), Muster wie titelHaken() in 6.3) und inst.letzteAbnahme = abnahme merken. Spiel.abnahme gibt das Objekt zurück (src/spiel/abnahme.js:40-44), der Haken ist drei Zeilen.
2. Ohne Haken: Spiel.klassenraum.ergebnisCode(inst, {bestanden: true, sterne: <aus st.erledigt>}) – nicht empfohlen, weil die Sterne dann aus einer zweiten Quelle kämen.

7.2 Dezent beim zweiten Ansehen

• Der Toast hat die id klassenraum-code – ein zweiter Toast mit derselben id ersetzt den ersten (src/ui/toast.js:39), es stapeln sich also keine Codes.
• Es gibt keine dauerhafte Zeile im Labor und keine Änderung an sp-ergebnis: der Code verschwindet mit dem Toast (Standarddauer 20 s, mit Aktion 8 s Grunddauer + Halten bei Mauszeiger, src/ui/toast.js:58-61).
• Wer ihn später braucht: Spiel.klassenraum.sitzung() liefert die Sitzung samt Ergebnissen (A – Codec und Determinismus.md:480) – die Lehrkraft sieht ihn in ihrer Tafel, die Schülerin kann ihn nicht erneut anzeigen. Das ist Absicht (Datensparsamkeit, KLASSENRAUM.md:39).

8 · Lehrer-Eingabe: mehrere Codes

8.1 Ein Feld, Block oder einzeln

Festlegung: ein textarea (6 Zeilen), abgeschickt mit dem Knopf „Eintragen" oder Strg+Enter; Enter macht einen Zeilenumbruch.

Begründung: (a) Der Auftrag nennt „mehrere Codes nacheinander oder als Block" (KLASSENRAUM.md:44) – der Block ist der häufigere Fall (28 Ergebnisse in einem Zug). (b) Die Zeilennummer ist die natürliche Fehleradresse („Zeile 4: …"), und die gibt es nur, wenn die Zeilenstruktur im textarea erhalten bleibt. (c) Enter muss zum Vorbereiten und Korrigieren frei bleiben. (d) Ein textarea zählt für R12 wie ein input (tools/ethos.py:304) – die Zahl der Bedienelemente ändert sich nicht.

8.2 Zerlegung, Prüfung, Doppelte

/* Zerlegung eines Blocks – Muster: src/ui/konsole.js:176-179, src/ui/inspektor.js:216-217 */
const zeilen = String(block).replace(/\r/g, "").split("\n");         // Zeilennummer = Index + 1
for (let i = 0; i < zeilen.length; i++) {
  const stuecke = zeilen[i].split(/[\s,;]+/).filter(Boolean);        // Leerzeichen, Komma, Semikolon
  for (const stueck of stuecke) { /* ein Ergebnis-Code je Stück */ }
}

• Bindestriche sind keine Trenner – sie gehören zum gedruckten Code (A normalisiert sie weg, A – Codec und Determinismus.md:52).
• Normalisierung ist Aufgabe von A (toUpperCase, alles außer [0-9A-Z] entfernen, :47-52). Die Oberfläche reicht jedes Stück wörtlich an Spiel.klassenraum.ergebnisLesen(stueck) bzw. ergebnisEintragen(stueck) weiter – kein zweites toUpperCase im UI (eine Wahrheit).
• Ergebnis je Zeile (keine Toasts je Zeile, keine Dialoge):

• Teilweiser Erfolg ist Erfolg: jede Zeile wird einzeln eingetragen; gültige landen in der Sitzung, auch wenn andere Zeilen scheitern. ergebnisEintragen ist idempotent („derselbe Code zweimal ändert nichts", KLASSENRAUM.md:32, gemessen byte-identisch A – Codec und Determinismus.md:560-561), ein zweiter Durchgang ist also gefahrlos. Darüber steht die Summenzeile „18 eingetragen · 2 doppelt · 1 fremde Sitzung · 1 unlesbar".
• Doppelte werden erkannt, nicht gezählt: der Schlüssel ist der Platz; „erster Eintrag gewinnt" (A – Codec und Determinismus.md:557-569). Die Ampel zählt Ergebnisse, nicht Eingaben.

9 · Die Ampel

9.1 Definition

Doppelte zählen einmal – die Ampel zählt Plätze, nicht Eingaben (Abschnitt 8.2).

9.2 Median-Dauer: gerade Anzahl, fehlende Dauern, Rundung

• Grundmenge: nur gültige Dauern – typeof d === "number" && isFinite(d) && d > 0. Eine fehlende oder 0-Dauer zählt für „fertig", nicht für den Median. Grund: inst.zeitMs startet bei 0 (src/spiel/postfach.js:96); ein Lauf, der sofort abgebrochen wurde, würde den Median sonst nach unten ziehen. Die Dauer entsteht erst beim Abschluss (src/spiel/abnahme.js:90) und wird von A in 10-s-Schritten kodiert (A – Codec und Determinismus.md:593).
• Welche Einheit? Die Rohquelle inst.zeitMs ist Millisekunden (src/spiel/postfach.js:96, Zuwachs in src/spiel/abnahme.js:90, Grenze 2 min in src/spiel/ticket.js:9) und wird **nirgends zentral** umgerechnet – jede Anzeigestelle teilt selbst: Math.round((inst.zeitMs || 0) / 1000) (src/spiel/tagebuch.js:36, src/spiel/tagesraetsel.js:74). Der Ergebnis-Code liefert deshalb dauerS in Sekunden (A – Codec und Determinismus.md:551): die Ampel arbeitet durchgehend in Sekunden und teilt nicht noch einmal. Haus-Vorlage für M:SS: `${Math.floor(s / 60)}:${String(Math.round(s % 60)).padStart(2, "0")}` (src/spiel/tagebuch.js:52).
• Regel bei gerader Anzahl: oberer Median – der Wert an der 0-basierten Stelle floor(n/2) der aufsteigend sortierten Liste. Bei n = 4 ist das der dritte Wert (Index 2), bei n = 5 der dritte (Index 2), bei n = 6 der vierte.
• Rundung: auf ganze Sekunden, kaufmännisch (Math.round). Anzeige als M:SS (Beispiel: „1:50"). Keine Minutenrundung – die Dauer einer Übung ist kurz.
• Warum oberer Median und nicht der Mittelwert der beiden mittleren? (a) Er ist **immer ein wirklich vorgekommener Wert**: A liefert 10-s-Stufen, ein Mittel aus 4:10 und 4:20 wäre 4:15 – eine Zeit, die in keiner Zeile steht und die die Lehrkraft nicht nachzählen kann. (b) Er braucht keine „×,5"-Sonderregel. (c) Er sagt den Satz, den die Lehrkraft braucht: „nach 4:20 war mindestens die Hälfte fertig." Preis, ehrlich: bei gerader Anzahl liegt er um bis zu eine Rangstufe über dem „echten" Median. Achtung, es gibt bereits eine andere Regel im Haus: Spiel.tagebuch.auswertung rechnet bei gerader Anzahl den Mittelwert der beiden mittleren und zeigt in Minuten (src/spiel/tagebuch.js:53, 54) – die Ampel folgt ihr bewusst nicht (Begründung a–c), und das ist eine Festlegung, keine Ableitung (offener Punkt O9).
• Kein gültiger Wert: Anzeige „Median –".

Beispiele (nachgerechnet):

9.3 Farben und Schwellen

Rot (--bad) ist im Normalbetrieb aus. Der Auftrag schließt Zeit- und Sperrlogik aus (KLASSENRAUM.md:66); rot hat im Haus einen Frist-Auslöser. Eine rote Lampe ohne Anlass wäre ein Urteil ohne Grund – deshalb greift .kl-lampe.kl-rot nur beim fehlgeschlagenen Import. Farbe trägt nie allein die Aussage (die Summenzeile steht als Text daneben).

9.4 Plattzahl – was fehlt (O1)

A's Sitzung kennt keine Platzzahl (A – Codec und Determinismus.md:671-688: genau 14 Felder, kein plaetze). Ohne sie kann die Ampel „offen" nicht rechnen und nie grün werden. Vorschlag an A:

/* Sitzung erweitern: */ plaetze: 0        // 0 = nicht eingestellt; 1..31
/* und in erzeugen({…, plaetze}) mit aufnehmen; Obergrenze 31, weil platz 5 Bit hat
   (A – Codec und Determinismus.md:551-553) */

Die Oberfläche liest sitzung.plaetze || 0; ist es 0, zeigt sie gelb und „Plätze nicht eingestellt" statt einer erfundenen Zahl. Die Lehrkraft stellt die Platzzahl dort ein, wo sie den Auftrag erzeugt (ein select 1..31, Standard = leer) – ohne neues Bedienelement in der Ampel (R12).

10 · Export und Import als Datei

10.1 Die echten APIs

Plattform.datei.exportieren(name, text)   /* → Promise<boolean> (Browser) | Promise (Tauri) */
Plattform.datei.importieren()             /* → Promise<string|null>  null = abgebrochen */

• Verteiler: src/plattform/plattform.js:28-31 (Objekt datei mit beiden Funktionen).
• Browser: exportieren baut einen Blob und klickt einen <a download> (src/plattform/plattform-browser.js:45-51); importieren erzeugt ein verstecktes input[type=file] mit accept=".json,application/json" und liest per FileReader (:52-58). Abbruch ⇒ null (:55).
• Desktop: invoke("exportieren", {name, inhalt}) bzw. invoke("importieren") (src/plattform/plattform-tauri.js:73-74).
• Plattform.kann("datei") ist keine Fähigkeitsprüfung: der Schlüssel fehlt in der NEIN-Liste des Browsers (src/plattform/plattform-browser.js:8-15) und antwortet dort deshalb {ja:true} (:60); Tauri antwortet für unbekannte Schlüssel ebenfalls {ja:true} (src/plattform/plattform-tauri.js:77). Der Dateiweg wird also nicht abgefragt, sondern mit try/catch und .catch abgesichert.

10.2 Dateiname und Inhalt

• Name: klassenraum-<JJJJ-MM-TT>.json – Datum aus heute() (Haus-Form YYYY-MM-DD, src/kern/basis.js:18), Muster wie beim Spielstand-Export (src/ui/karriere.js:405).
• Inhalt: Spiel.klassenraum.exportieren() liefert den JSON-String (A – Codec und Determinismus.md:480, Format :692-700: `{format:"netzwerk-labor/klassenraum", fassung, programm, zeit, sitzung}`).
• Vorher store.sofort() – das Hausmuster vor einem Export (src/kern/basis.js:85-86, src/ui/karriere.js:403); hier nicht nötig, weil die Sitzung in store "klassenraum" liegt und exportieren() sie selbst liest. Schadet aber nicht.
• Ohne Sitzung: {fehler:"sitzung", grund:"Es läuft keine Sitzung – nichts zu exportieren."} (A – Codec und Determinismus.md:624) → Toast „Es läuft keine Sitzung – nichts zu exportieren."

10.3 Fehlerfälle

10.4 Ablage

Die Sitzung liegt in store "klassenraum" (KLASSENRAUM.md:40), nicht in store "labor" – Spiel.st ist der Spielstand (src/spiel/zustand.js:157) und bleibt unberührt. Schlüssel im Speicher: klassenraum mit den Feldern fassung, programm, sitzung, platz, letzte, zuletzt, zaehler (A – Codec und Determinismus.md:634-662).

store.get/set sind Haus-Bordmittel (src/kern/basis.js:74-75) und liefern bzw. speichern tiefe Kopien – die Sitzung kann also nicht versehentlich von außen verändert werden. Muster für einen eigenen Schlüssel: store.set("sandbox", {v: 1, netz}) (src/ui/start.js:38).

11 · Einstellungen: Schalter „Klassenraum-Server"

11.1 Die echten Signaturen

UI.app.einstellungAbschnitt(titel, fn)         /* src/ui/app.js:267-270; fn(container) zeichnet den Abschnitt */
UI.app.einstellungen()                          /* src/ui/app.js:339-348; eigene + fremde Abschnitte */
/* Bausteine im Modul (nicht exportiert): */
zeile(titel, text, steuer, kann)                /* src/ui/app.js:281-286 */
schalter(an, fn, titel)                         /* src/ui/app.js:287-291; role="switch", aria-checked */

einstellungAbschnitt und einstellungen liegen im Rückgabeobjekt von UI.app (src/ui/app.js:401-403) – zeile und schalter nicht. Ein neuer Abschnitt muss deshalb entweder in src/ui/app.js liegen (verboten) oder seine Zeile selbst bauen. Festlegung: der Abschnitt baut seine Zeile mit demselben DOM wie zeile() (div.einst-zeile > div.einst-text > strong+span) und seinen Schalter mit demselben DOM wie schalter() (button.schalter mit span) – Klassen aus src/stil/rahmen.css, keine neuen (.einst-zeile :159, .einst-text :160, .schalter :172-175). Damit sieht der Abschnitt aus wie die vorhandenen und klassen.py bleibt unberührt.

Anmeldung im selben Start-Haken wie die Ansichten (Abschnitt 1.2), Muster src/ui/hub.js:170-173:

UI.app.einstellungAbschnitt("Klassenraum", klassenraumAbschnitt);

Der Abschnitt erscheint nach den eigenen Abschnitten (Darstellung, Erklärtiefe, Leiste, src/ui/app.js:341) und nach „Spieltagebuch" (src/ui/hub.js:172).

11.2 Der Schalter und sein Wert

• Titel: „Klassenraum-Server (nur Desktop)", Standard: aus.
• Wert: klassenraumServer im vorhandenen store "einst" (denselben Speicher benutzen Thema, Bewegung, Ton, Ereignisse, Anpassung – src/ui/app.js:302-314; gelesen über einst(), src/ui/app.js:35). „Aus" ist gratis: einst() mischt keine Vorgaben, ein fehlender Schlüssel ist undefined und damit falsch – keine Migration nötig.
• Schreiben: einstSetzen ist privat (src/ui/app.js:38, nicht im Rückgabeobjekt :401-403). Der Abschnitt schreibt deshalb direkt: const e = store.get("einst", {}) || {}; e.klassenraumServer = an; store.set("einst", e); – dasselbe Muster wie die Leisten-Einstellungen (src/ui/app.js:320) und wie Spiel.einstSetzen (src/spiel/zustand.js:184).
• Nur Desktop: Plattform.name === "tauri" entscheidet (src/plattform/plattform-tauri.js:47, src/plattform/plattform-browser.js:18); das Hausmuster dafür steht in src/ui/app.js:326 und :346. Im Browser wird die Zeile gesperrt dargestellt (.einst-zeile.gesperrt, src/stil/rahmen.css:164) mit dem Text „Nur das Desktop-Programm kann das." – genau wie der Autostart-Schalter (src/ui/app.js:332-335).
• Firewall-Hinweis: wörtlich als text-Argument unter dem Titel (Abschnitt 3.5). **Genau eine Stelle**, kein zweiter Hinweis, kein Toast beim Einschalten.
• Ohne erreichbaren Server: keine Meldung (KLASSENRAUM.md:48). Der Schalter zeigt die Einstellung, nicht die Wirklichkeit – eine Statusabfrage gibt es heute nicht (Abschnitt 12).

12 · Offene Punkte und was nicht geprüft wurde

12.1 Offene Punkte (Entscheidung nötig)

12.2 Was in dieser Sitzung nicht geprüft wurde (ehrlich)

13 · Anhang: Belege in einem Blick