fix: eingeklappter Knoten vertritt seinen Teilbaum auf dem günstigsten Pfad

D38 hielt fest, ein eingeklappter Zweig dürfe Pfadknoten verbergen, „die
Inversion an den sichtbaren Knoten bleibt richtig". Zu kurz gedacht: Die LINIE
blieb eben nicht richtig. Sie fädelt durch die cheap-leaf-Knoten im DOM; ein
eingeklappter Pfadknoten ist zwar `cheap`, aber kein Blatt (seine Pfad-Kinder
existieren im Modell) — also bekam er keine Station, und die Linie umging den
ganzen Zweig.

Im Beispiel nachgemessen: „Concept" war `node cheap folded`, verbarg zwei
Pfadknoten, trug keinen Punkt; die Linie begann erst bei „PWA". Das Bild
behauptete damit, in diesem Zweig sei nichts zu tun — eine Aussage über den
Plan, nicht über die Ansicht. Genau die Grenze, die D38 sonst zieht.

Regel: Eingeklappt überspringt cheapCls() die Blatt-Prüfung und fragt den
Teilbaum (hidesCheap). Liegt darin etwas auf dem Pfad, ist der Knoten dessen
tiefste noch sichtbare Station. Beim Aufklappen geben die Kinder sie zurück —
gemessen 6 -> 7 -> 6 Stationen beim Hin- und Herklappen.

Auch ohne eigene Pfad-Mitgliedschaft: Ein per :#… gezogenes Ziel kann unter
einem +-Knoten liegen, der selbst nicht gebraucht wird (D42). Eingeklappt ist
dieser der einzige sichtbare Griff auf nötige Arbeit — er wird Station und
zählt als cheap, tritt also nicht zurück. Ihn auszublassen wäre die Lüge.

4 neue Tests (208 gesamt). SPEC §9, D38 (Nachtrag) und frontend/CLAUDE.md
nachgezogen; die alte „hinnehmbar"-Stelle in D38 ist als falsch markiert statt
gelöscht.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

frontend/CLAUDE.md

@@ -303,7 +303,15 @@ verworfene Elemente. Quelle sind ES-Module unter `src/`; `index.html` ist der
   Dokumentwechsel geleert) und übergibt `collapsedSet` an den Renderer; der
   lässt eingeklappte Kinder **weg** (nicht CSS-verstecken — Export, Messungen
   und Pfadlinie bleiben so von selbst konsistent), meldet deren Warnungen aber
-  weiter (`walkFolded`, zählt zugleich fürs „▸ n"). Umklappen: Klick aufs
+  weiter (`walkFolded`, zählt zugleich fürs „▸ n").
+  **Auf dem günstigsten Pfad vertritt ein eingeklappter Knoten seinen
+  Teilbaum** (D38-Nachtrag): `cheapCls(n, cheapSet, collapsed)` überspringt für
+  ihn die Blatt-Prüfung und fragt `hidesCheap()` — sonst umginge die Pfad-Linie
+  den ganzen Zweig, als wäre dort nichts zu tun. Gilt auch ohne eigene
+  Pfad-Mitgliedschaft (ein per `:#…` gezogenes Ziel unter einem `+`-Knoten):
+  Dann ist er der einzige sichtbare Griff darauf und zählt als `cheap`.
+  `extraCls()` muss dieselbe Eingeklappt-Bedingung bilden wie `itemHtml`
+  (nur mit sichtbaren Kindern). Umklappen: Klick aufs
   `.fold`-Zeichen (preventDefault — es sitzt bei Link-Knoten im `<a>`) oder
   ←/→ am fokussierten Knoten; nach `render()` den Fokus per `data-line`
   wiederherstellen. Export/Druck: „▸ n" bleibt, das ▾ offener Knoten fällt weg

frontend/src/model.js

@@ -168,7 +168,25 @@ export function computeCheapSet(roots){
 }
 /* CSS-Klassen für den günstigen Pfad. Leere `cheapSet` (Pfad aus) ⇒ ''.
    Endknoten (kein Kind liegt auf dem Pfad) bekommt zusätzlich 'cheap-leaf'. */
-export function cheapCls(n, cheapSet){
+/* Liegt im Teilbaum eines Knotens etwas auf dem Pfad? Gebraucht für
+   eingeklappte Knoten (siehe `cheapCls`). Verworfene sind nie in `cheapSet`
+   (SPEC §9), es braucht also keine eigene Filterung. */
+export function hidesCheap(n, cheapSet){
+  for(const k of n.children || []){
+    if(cheapSet.has(k) || hidesCheap(k, cheapSet)) return true;
+  }
+  return false;
+}
+
+export function cheapCls(n, cheapSet, collapsed){
+  /* Eingeklappt steht der Knoten stellvertretend für seinen ganzen Teilbaum
+     (SPEC §9/D38): Liegt darin etwas auf dem Pfad, ist er dessen tiefste noch
+     SICHTBARE Station — sonst überspränge die Linie den Zweig, als wäre dort
+     nichts zu tun. Das gilt auch, wenn er selbst nicht gebraucht wird, sein
+     Teilbaum aber schon (eine per `:#…` gezogene Alternative, D42): Er ist
+     dann der einzige sichtbare Griff auf nötige Arbeit und darf deshalb auch
+     nicht von der Inversion ausgeblasst werden. */
+  if(collapsed) return (cheapSet.has(n) || hidesCheap(n, cheapSet)) ? 'cheap cheap-leaf' : '';
   if(!cheapSet.has(n)) return '';
   const leaf = !pathChildren(n).some(k => cheapSet.has(k));
   return leaf ? 'cheap cheap-leaf' : 'cheap';

frontend/src/render.js

@@ -21,7 +21,12 @@ import { gateOf, needsBreakdown, visibleChildren, cheapCls } from './model.js';
    gegenüber der zuletzt gesehenen Fassung (D28, `freshSet` optional) und
    optionale Knoten (`+`, SPEC §3/D29 — trägt den hohlen Kreis am Abzweig). */
 function extraCls(n, opts){
-  const cheap = cheapCls(n, opts.cheapSet);
+  /* Dieselbe Bedingung wie in `itemHtml`: eingeklappt ist ein Knoten nur, wenn
+     er überhaupt sichtbare Kinder hat. Der Pfad braucht sie hier, weil ein
+     eingeklappter Knoten seine verborgenen Pfad-Knoten vertritt (D38). */
+  const collapsed = !!(opts.collapsedSet && opts.collapsedSet.has(n))
+                 && visibleChildren(n, opts.showDiscarded).length > 0;
+  const cheap = cheapCls(n, opts.cheapSet, collapsed);
   const fresh = opts.freshSet && opts.freshSet.has(n) ? 'fresh' : '';
   return [cheap, fresh, n.optional ? 'opt' : '', n.focus ? 'focusmark' : ''].filter(Boolean).join(' ');
 }

frontend/tests/fold.test.js

@@ -126,3 +126,64 @@ describe('Renderer — eingeklappte Teilbäume', () => {
       .toEqual(['A', 'A2', 'W']);
   });
 });
+
+/* Der eingeklappte Knoten vertritt seinen Teilbaum auch auf dem günstigsten
+   Pfad (SPEC §9, D38-Nachtrag): Sonst überspränge die Pfad-Linie den ganzen
+   Zweig, als wäre dort nichts zu tun. */
+describe('Günstigster Pfad an eingeklappten Knoten', () => {
+  /* Nimmt die BEREITS geparsten Wurzeln: `collapsedSet` und `cheapSet` prüfen
+     auf Objektidentität — ein zweiter Parse-Durchlauf liefert andere Objekte
+     und die Mengen träfen nie zu (dieselbe Falle wie in D28). */
+  const cheapRender = (r, collapsedSet) =>
+    renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
+      cheapSet: computeCheapSet(r), collapsedSet: collapsedSet || new Set()}).html;
+  /* Labels der Stationen (`cheap-leaf`) in Dokumentreihenfolge — genau die
+     Menge, durch die drawCheapPath() die Linie fädelt. Gelesen aus dem
+     `aria-label` (erstes Glied = Label): Im Knoteninneren steht bei
+     eingeklappten Knoten das Falt-Zeichen vor dem Text. */
+  const stations = html =>
+    [...html.matchAll(/class="node[^"]*cheap-leaf[^"]*"[^>]*aria-label="([^",]*)/g)]
+      .map(m => m[1]);
+
+  const TXT = `[ ] W (XS)\n  - [ ] A (S)\n    - [ ] A1 (S)\n    - [ ] A2 (S)\n  - [ ] B (S)`;
+
+  it('macht den eingeklappten Knoten zur Station statt den Zweig zu überspringen', () => {
+    const r = roots(TXT);
+    const a = r[0].children[0];
+    expect(stations(cheapRender(r))).toEqual(['A1', 'A2', 'B']);       /* offen */
+    expect(stations(cheapRender(r, new Set([a])))).toEqual(['A', 'B']); /* zu */
+  });
+
+  it('gibt die Station beim Aufklappen wieder an die Kinder ab', () => {
+    const r = roots(TXT);
+    const a = r[0].children[0];
+    const zu  = stations(cheapRender(r, new Set([a])));
+    const auf = stations(cheapRender(r, new Set()));
+    expect(zu).not.toContain('A1');
+    expect(auf).toContain('A1');
+    expect(auf).not.toContain('A');
+  });
+
+  it('vertritt auch einen Teilbaum, den der Knoten selbst nicht braucht', () => {
+    /* `+ O` ist entbehrlich und nicht auf dem Pfad — sein Kind wird aber per
+       Abhängigkeit gezogen (D42). Eingeklappt ist `O` der einzige sichtbare
+       Griff darauf und darf deshalb weder fehlen noch ausgeblasst sein. */
+    const txt = `[ ] W (XS)\n  - [ ] N (S) :#t\n  + [ ] O (S)\n    - [ ] #t: T (S)`;
+    const r = roots(txt);
+    const o = r[0].children[1];
+    const set = computeCheapSet(r);
+    expect([...set].map(n => n.label).sort()).toEqual(['N', 'T', 'W']);  /* O selbst nicht */
+    const {html} = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
+      cheapSet: set, collapsedSet: new Set([o])});
+    expect(stations(html)).toContain('O');
+  });
+
+  it('macht einen eingeklappten Knoten ohne Pfad im Teilbaum NICHT zur Station', () => {
+    const txt = `[ ] W (XS)\n  - [ ] N (S)\n  + [ ] O (S)\n    - [ ] P (S)`;
+    const r = roots(txt);
+    const o = r[0].children[1];
+    const {html} = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
+      cheapSet: computeCheapSet(r), collapsedSet: new Set([o])});
+    expect(stations(html)).toEqual(['N']);
+  });
+});