feat: eingeklappter Vorfahr vertritt die Cursor-Zeile im Diagramm (D38-Nachtrag 4)

Liegt der Knoten der Cursor-Zeile in einem eingeklappten Teilbaum, hebt
nodeOfLine() den nächsten sichtbaren Vorfahren hervor — Cursor-Mitlaufen,
Alt+Klick, Alt+Enter und der Mobil-Umschalter erben es über die eine
Auflösungsstelle. Ausgeblendete verworfene Elemente heben weiterhin nichts
hervor (SPEC §9). Zeilen-Map als lineTargets() headless in model.js, 5 neue
Tests.

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

frontend/src/app.js

@@ -1,6 +1,6 @@
 import './style.css';
 import { parse, setFoldMark, expandShortIds, shortIdClosed } from './parser.js';
-import { computeCheapPlan, freshProdSet, initialCollapsed, nodeKeys, effectiveStatus, atMostM } from './model.js';
+import { computeCheapPlan, freshProdSet, initialCollapsed, nodeKeys, effectiveStatus, atMostM, lineTargets } from './model.js';
 import { esc, renderTreeHtml, TIP_RULE } from './render.js';
 import { formatWarning, warningText } from './warnings.js';
 import { padUrls } from './remote.js';
@@ -92,6 +92,10 @@ let newsDay = null, newsKeySet = null;
    Textmarken, gelten nur für die Sitzung und fallen beim Dokumentwechsel weg.
    `foldByLine` ist der Zustand des letzten Renders für Klick/Tastatur. */
 let foldOverrides = new Map(), foldByLine = new Map();
+/* Zeile -> Zeile des sichtbaren Vertreters (D38-Nachtrag 4): Für Zeilen in
+   eingeklappten Teilbäumen zeigt sie auf den nächsten sichtbaren Vorfahren;
+   `nodeOfLine()` greift darauf zurück, wenn die Zeile keinen DOM-Knoten hat. */
+let lineTargetMap = new Map();
 
 /* ---------- Renderer (Anbindung an den DOM) ----------
    parse -> Wurzeln filtern (verworfene) -> günstigen Pfad markieren ->
@@ -117,6 +121,7 @@ function render(){
     out.innerHTML = `<div class="empty">${esc(t('empty'))}</div>`;
     freshSet = new Set();
     foldByLine = new Map();
+    lineTargetMap = new Map();
   } else {
     /* Günstigster Pfad auf der Dependency Closure (D42): scheitert die exakte
        Suche an zu vielen gekoppelten Gruppen, wird die gierige Schätzung
@@ -168,6 +173,9 @@ function render(){
        „alles offen" derselbe Zustand — der Knopf säße dann gedrückt da, ohne
        dass etwas zugeklappt ist. */
     foldSmallBtn.setAttribute('aria-pressed', foldSmallExact && foldSmallAny ? 'true' : 'false');
+    /* Aus DENSELBEN Mengen wie das Rendern — die Map muss dieselbe Faltung
+       beschreiben, die gleich im DOM steht (dieselbe Regel wie bei freshSet). */
+    lineTargetMap = lineTargets(roots, collapsedSet, showDiscarded);
     const r = renderTreeHtml(roots, {t, showDiscarded, cheapPath: cheapPathOn, cheapSet, showIds,
                                      freshSet, collapsedSet,
                                      effStatus: effectiveStatus(roots)});
@@ -1399,8 +1407,18 @@ document.querySelector('.diagram').addEventListener('scroll', closeNodeTip, {pas
    `data-desc-lines` (vom Renderer, gefüllt aus `node.descLines`). */
 function nodeOfLine(line){
   if(line == null) return null;
-  return out.querySelector('.node[data-line="' + line + '"]')
+  const el = out.querySelector('.node[data-line="' + line + '"]')
       || out.querySelector('.node[data-desc-lines~="' + line + '"]');
+  if(el) return el;
+  /* Kein DOM-Knoten: Die Zeile liegt in einem eingeklappten Teilbaum — dann
+     vertritt der nächste sichtbare Vorfahr sie (SPEC §9, D38-Nachtrag 4),
+     für die Cursor-Hervorhebung wie für den Alt+Klick. Ausgeblendete
+     verworfene Elemente stehen nicht in der Map und heben weiter nichts
+     hervor. */
+  const target = lineTargetMap.get(line);
+  return target != null && target !== line
+    ? out.querySelector('.node[data-line="' + target + '"]')
+    : null;
 }
 
 /* Text -> Diagramm: Knoten der Cursor-Zeile hervorheben (`caretLine` steht oben). */

frontend/src/model.js

@@ -327,6 +327,31 @@ export function nodeKeys(roots){
   return map;
 }
 
+/* Textzeile -> Zeile des Knotens, der sie im Diagramm VERTRITT (SPEC §9,
+   D38-Nachtrag 4): der Knoten selbst, solange er sichtbar ist; liegt er in
+   einem eingeklappten Teilbaum, der nächste sichtbare Vorfahr — der
+   eingeklappte Knoten vertritt seinen Teilbaum, auch für die
+   Cursor-Hervorhebung und den Alt+Klick aus dem Text. Beschreibungs- und
+   Fortsetzungszeilen (`descLines`) zählen zu ihrem Knoten. Ausgeblendete
+   verworfene Elemente fehlen in der Map (visibleChildren) und heben damit
+   weiterhin nichts hervor — die SPEC-§9-Regel bleibt. */
+export function lineTargets(roots, collapsed, showDiscarded){
+  const map = new Map();
+  /* `anchor` ist null, solange wir im Sichtbaren sind; darunter die Zeile des
+     äußersten eingeklappten Knotens — tiefere Faltungen ändern sie nicht. */
+  const walk = (ns, anchor) => {
+    for(const n of ns){
+      const target = anchor ?? n.line;
+      if(n.line != null) map.set(n.line, target);
+      if(n.descLines) n.descLines.forEach(l => map.set(l, target));
+      const next = anchor ?? (collapsed.has(n) ? n.line : null);
+      walk(visibleChildren(n, showDiscarded), next);
+    }
+  };
+  walk(roots, null);
+  return map;
+}
+
 /* ---------- Faltmarken (SPEC §1/§9, D38) ----------
    Anfangszustand der Faltung aus den Textmarken: `>` klappt den Knoten ein.
    `<` (und mit `rescueFocus` auch die Fokusmarke `!!!`) holt den eigenen

frontend/tests/fold.test.js

@@ -282,3 +282,55 @@ describe('atMostM — Auswahl für „Größe M und kleiner zuklappen"', () => {
     expect(atMostM(w.children[0].children[0])).toBe(true);
   });
 });
+
+/* Zeile -> sichtbarer Vertreter (SPEC §9, D38-Nachtrag 4): Liegt der Knoten
+   der Cursor-Zeile in einem eingeklappten Teilbaum, vertritt ihn der nächste
+   sichtbare Vorfahr — für die Hervorhebung wie für den Alt+Klick. */
+import { lineTargets } from '../src/model.js';
+
+describe('lineTargets — der eingeklappte Knoten vertritt seine Zeilen', () => {
+  const byLabel = (ns, label) => {
+    for(const n of ns){
+      if(n.label === label) return n;
+      const hit = byLabel(n.children, label);
+      if(hit) return hit;
+    }
+    return null;
+  };
+  const txt = 'A\n  - B\n    - C\n      - D\n  - [-] E\n    - F';
+
+  it('sichtbare Knoten zeigen auf sich selbst', () => {
+    const r = roots(txt);
+    const map = lineTargets(r, new Set(), true);
+    expect(map.get(1)).toBe(1);
+    expect(map.get(3)).toBe(3);
+  });
+
+  it('Zeilen unter einem eingeklappten Knoten zeigen auf ihn', () => {
+    const r = roots(txt);
+    const map = lineTargets(r, new Set([byLabel(r, 'B')]), true);
+    expect(map.get(2)).toBe(2);   /* der eingeklappte selbst ist sichtbar */
+    expect(map.get(3)).toBe(2);
+    expect(map.get(4)).toBe(2);
+  });
+
+  it('bei verschachtelter Faltung gilt der ÄUSSERSTE eingeklappte Vorfahr', () => {
+    const r = roots(txt);
+    const map = lineTargets(r, new Set([byLabel(r, 'B'), byLabel(r, 'C')]), true);
+    expect(map.get(4)).toBe(2);
+  });
+
+  it('Beschreibungs- und Fortsetzungszeilen wandern mit ihrem Knoten', () => {
+    const t2 = 'A\n  - B mit einem \\\n    langen Titel\n    " Notiz';
+    const r = roots(t2);
+    const map = lineTargets(r, new Set([byLabel(r, 'A')]), true);
+    expect(map.get(3)).toBe(1);   /* Fortsetzung */
+    expect(map.get(4)).toBe(1);   /* "-Zeile */
+  });
+
+  it('ausgeblendete verworfene Elemente fehlen — sie heben weiter nichts hervor', () => {
+    const r = roots(txt);
+    expect(lineTargets(r, new Set(), false).has(6)).toBe(false);
+    expect(lineTargets(r, new Set(), true).get(6)).toBe(6);
+  });
+});