DOSSIER-STANDALONE/ROADMAP.md

# Browser-BIM für Wohnbau — Architektur & Produkt-Roadmap

> **Historisches Dokument (Tag-1-Vision, Stand 2026-06-28).** Vieles hier als
> „Phase 2–5"/„Backlog" gelistete ist inzwischen längst gebaut (Treppen, Dächer,
> Stützen, SIA-416, Swisstopo, OSM, Layouts, Ausschnitte, Kamera-Presets …), und
> mehrere Technologie-Entscheidungen liefen anders (eigene Rust/WASM-Engines
> statt Three.js/OpenCascade.js/web-ifc, siehe unten §4/§8). Für den aktuellen
> Ist-Zustand: **[STATUS.md](STATUS.md)** (Bestandsaufnahme + Mist-Liste) und
> **[ARCHITECTURE.md](ARCHITECTURE.md)** (aktuelle Architektur). Dieses Dokument
> bleibt als ursprüngliche Produktvision/Phasenplan stehen, wird aber nicht mehr
> laufend nachgeführt.
>
> Arbeitstitel: **cad** (Name später: **Dossier**)
> Ausrichtung: **BIM-first** · Nische: **Wohnbau / Einfamilienhäuser**
> Stand: 2026-06-28

## 1. Produktvision

Ein **browserbasiertes BIM-Werkzeug** für Wohnbau, das zwei Dinge verbindet:

1. **Einfaches 3D-Gebäudemodell** — aus semantischen Bauteilen: Wände, Türen, Fenster, Treppen, Decken, Dächer, Räume.
2. **Schöne, normgerechte 2D-Pläne** — Grundrisse, Schnitte, Ansichten — automatisch aus dem Modell abgeleitet.

**Kernversprechen:** *Das schönste und einfachste Werkzeug, um ein Wohnhaus zu modellieren und daraus perfekte Pläne zu ziehen.* Nicht Revit nachbauen — radikaler Fokus auf Wohnbau + Plan-Qualität.

**Markt-Beleg:** Arcol, Snaptrude, TestFit zeigen, dass browserbasiertes BIM real ist und Nutzer schlanke, schöne Tools wollen statt der schwerfälligen Giganten (Revit/ArchiCAD).

---

## 2. Das mentale Modell — warum BIM anders ist als CAD

| | mechanisches CAD | **BIM (unser Weg)** |
|---|---|---|
| Bausteine | generische Volumenkörper | **semantische Bauteile** (Wand, Tür, Fenster…) |
| Beziehungen | keine | Tür *hostet* in Wand & schneidet Öffnung; Wände *verbinden* sich |
| Geschosse | — | **Stockwerke** als erste Klasse |
| 2D-Plan | Hidden-Line-Projektion | **symbolische Darstellung** (Schwenkbögen, Schraffuren, Lauflinien) |
| Standard | STEP | **IFC** |

---

## 2b. Kern-Prinzip: ein Modell, viele Darstellungen

Das **wichtigste Architektur-Prinzip**: Das semantische Modell ist die *eine
Wahrheit*; jede Ansicht (3D, Grundriss, Schnitt) ist eine **abgeleitete
Darstellung**. Im Spike steht das bereits. Daraus folgen direkt die Kern-Wünsche:

- **Modelldarstellungen / Detailgrade** — derselbe Tür/Fenster wird je nach
  `detailLevel` (grob / mittel / fein) unterschiedlich gezeichnet (≙ Revit
  „Detailgrad", ArchiCAD „Modelldarstellung"). Grob: Öffnung + Linie. Fein:
  Rahmen, Blatt, Schwenkbogen, Anschlag.
- **Editierbare Stile** — Wandfarben, Linienstärken, Türlinien, Schraffuren als
  **Stil-Schicht**, erst beim Rendern angewandt (nicht in die Geometrie
  eingebacken). Pro Kategorie *und* pro Element überschreibbar.
- **Mehrschichtige Bauteile** — Wände/Decken mit **Schichtaufbau** (`layers[]`:
  Material + Dicke + Priorität). 3D und Plan lesen dieselben Schichten.
- **In 2D *und* 3D zeichnen** — beide sind editierbare Sichten auf *ein* Modell;
  Werkzeuge mutieren das Modell, alle Sichten re-derivieren reaktiv.

Schwierigkeit: Detailgrade/Stile/Schichten sind 🟢 gut machbar; 2D+3D-Editieren
🟡 mittel; **mehrschichtige Wand-Verschneidung** 🔴 der härteste Teil (Risiko #1).

---

## 2c. Arbeitsweise & Dokumentmodell (DOSSIER-Modell) ⭐

Referenz: **DOSSIER** (Rhino-Plugin des Nutzers, https://git.kgva.ch/karim/DOSSIER).
Dieses Projekt ist die **Standalone-Browser-Variante** davon. Zwei *unabhängige* Achsen:

- **Zeichnungsebenen** — die obersten Dokument-Abschnitte, zwei Arten:
  - **Geschosse** (EG, 1OG …): `hoehe` (Geschosshöhe), `schnitthoehe` (Schnitthöhe),
    `okff` (Niveau, akkumuliert), `visible`/`locked`.
  - **Schnitte / Ansichten** (`type:"schnitt"`): Schnittlinie `linePts`, Richtung
    `dirSign`, Höhenbereich, Tiefe.
  - Ein **Geschoss** wird **im 3D-View ODER im Plan-View** betrachtet (Umschalter,
    *keine* getrennten Daten). Plan-View = Clipping-Ebene auf `okff + schnitthoehe`.
- **Ebenen** — das **Grafik-Kategorien-Schema**, in *jedem* Geschoss vorhanden;
  Baum-Knoten mit pro Ebene einstellbaren **Darstellungseinstellungen** (in den
  „Ebeneneinstellungen…"): **Stift** = Typ/Linienstil + Farbe + Dicke (lw);
  **Schraffur** = Typ + Skalierung + Rotation + **Stiftstärke der Schraffurlinien**.
  Modell: `{code, name, visible, locked, lineStyleId|{type,color,lw}, hatchId|{type,scale,angle,lineWeight}, children}`.
  Codes 1:1 wie DOSSIER:
  `00 Raster · 01 Vermessung · 20 Wände (└21 Türen/Fenster) · 30 Decken · 31 Dächer
  · 40 Treppen (└41 Treppen-2D) · 50 Tragwerk · 60 Räume · 80 Plangrafik …`
- **Elemente** (Wand, Decke, Treppe, Öffnung, Plangrafik, Text) liegen **auf den
  Ebenen** und kennen ihr **Geschoss** *und* ihre **Ebene (Code)**.
- **2D-Zeichnen** (Linie, Polylinie, Rechteck, Kreis, Bogen, Text) findet auf der
  Ebene `80 Plangrafik` (bzw. passender Kategorie) statt.

**Ansichtstypen = Kamera-Projektion + optionaler Schnitt** (vereinheitlicht):

| Typ | Projektion | Schnitt |
|---|---|---|
| **Grundriss** | Top-View (orthogonal) | horizontal auf `okff + schnitthöhe` |
| **Schnitt** | Front-View in eine Richtung (orthogonal) | vertikale Schnittebene (Geschnittenes + dahinter) |
| **Ansicht** | Front-View in eine Richtung (orthogonal) | kein Schnitt (Fassade außen) |
| **Perspektive** | 3D perspektivisch | — |

Sichtbarkeit pro Ansicht über Ein-/Ausschalten von Ebenen & Zeichnungsebenen.

Persistenz (DOSSIER): zwei getrennte JSON-Bäume `dossier_zeichnungsebenen` und
`dossier_ebenen`; Elemente tragen `geschoss`-id + Ebenen-`code`. Plan-View nutzt
eine Clipping-Ebene; weitere Konzepte: Overrides (regelbasiert), Ausschnitte
(View-Snapshots), Massstab (pro Viewport), Layer-Kombinationen, SIA-Räume.

## 2d. Resource Manager & Prioritäts-Verschneidung 🔴

Verwaltete Ressourcen-Bibliotheken wie in Vectorworks, jeweils mit eigenem Manager:

- **Line Manager** — Linienstile (Stärke, Farbe, Strichelung), wiederverwendbar.
- **Hatch Manager** — Schraffurstile (Muster, Maßstab, Winkel, Linienstil).
- **Component Manager** — Baustoffe mehrschichtiger Bauteile. Pro Component:
  **Schraffur** (→ Hatch Manager), **3D-Textur**, Farbe und
  **Verschneidungs-Priorität** (`joinPriority`).

Alles verweist per id auf diese Bibliotheken (Components nutzen Hatches, Hatches
nutzen Linienstile, 2D-Objekte & Ebenen-Defaults nutzen Linienstile/Schraffuren) —
zentral änderbar.

Regel: **höhere Priorität verschneidet sich zuerst / läuft durch.** Beispiel an
einer T-Ecke (Beton-Wand mit Innen- und Außenputz):

- **Beton** (höchste Prio) läuft in der Mitte **durch** den Stoß.
- **Putze** (niedrige Prio) **verbinden** sich jeweils auf ihrer Seite mit dem
  angrenzenden Putz, gehen aber **nirgends durch** den Beton.

Das ist die anspruchsvollste Verschneidungs-Logik (Revit „Layer Priority /
Wrapping", Vectorworks „Component-Verschneidung"). Wir bauen sie stufenweise auf
der bereits funktionierenden L-Ecken-Gehrung auf.

---

## 3. Zwei Wege zum 2D-Plan (zentrale Architektur-Erkenntnis)

Architektur-Pläne entstehen auf **zwei verschiedenen Wegen** — das prägt die ganze Engine:

**A) Grundriss = aus dem semantischen 2D-Footprint + Symbolik**
Ein Grundriss ist ein horizontaler Schnitt auf ~1 m. Statt ein 3D-Mesh zu zerschneiden, generieren wir ihn **direkt aus den Parametern**: Wand-Achsen + Dicken → Linien; Öffnungen → Lücken + Tür-/Fenstersymbol; Treppe → Lauflinie. Schnell, exakt, sauber, vektorbasiert.

**B) Schnitt & Ansicht = aus 3D-Projektion (HLR)**
Vertikale Schnitte und Ansichten brauchen echte 3D-Projektion mit verdeckten Kanten (Hidden Line Removal) durch das zusammengebaute Gebäude.

→ Wir brauchen **beides**: einen sauberen 2D-Symbol-Renderer *und* einen Projektions-Pfad.

---

## 4. Tech-Stack

| Schicht | Wahl | Begründung |
|---|---|---|
| BIM-Datenmodell | **eigenes parametrisches Gebäudemodell** (TS) | web-ifc ist stark beim *Lesen/Anzeigen* von IFC, schwächer beim *Authoring/Editieren*. Für ein Editier-Tool brauchen wir ein eigenes, editierbares Modell. |
| IFC-Interop | **web-ifc** (ThatOpen, WASM) | Import/Export nach IFC — Brücke zu Revit/ArchiCAD. |
| 3D-Rendering | **Three.js** | Standard; ThatOpen baut darauf auf, also kompatibel. |
| Geometrie-Booleans | **OpenCascade.js** (Öffnungen) *oder* Manifold | Tür/Fenster schneidet Loch in Wand. OCC = exakt (B-Rep), Manifold = schnell (Mesh). Entscheidung in Phase 0. |
| Projektion/HLR | **OpenCascade.js** (`HLRBRep`) | Saubere Linien für Schnitte/Ansichten. |
| 2D-Pläne | **SVG** + eigener Symbol-Renderer | Vektor, druckbar, exportierbar (DXF/PDF). |
| Frontend | **React + TypeScript + Vite** | Schnelles HMR, großes Ökosystem. |
| Worker-Bridge | **Comlink** | Schwere Geometrie im Web Worker, UI bleibt flüssig. |
| State | **Zustand** o.ä. | Passt zum komplexen Dokumentmodell. |
| Persistenz (später) | Postgres + Object Storage | Versionierbare Projekte. |

---

## 5. Datenmodell (grob)

Vectorworks-orientiert: **Design Layers** (Modell-Eingabe) und **Drawing Layers**
(abgeleitete Ausgabe). Bauteile beziehen ihren Aufbau aus **Components** (verwaltet
im Component Manager).

```
Project
 ├─ Resources            // verwaltete Bibliotheken (Vectorworks-Stil)
 │   ├─ LineStyles[]       // Line Manager: { id, name, weight, color, dash }
 │   ├─ Hatches[]          // Hatch Manager: { id, name, pattern, scale, angle, lineStyleId }
 │   └─ Components[]       // Component Manager: wiederverwendbare Baustoffe
 │         Component { id, name, hatchId, texture3d, color, joinPriority }
 │                      // joinPriority: höher = verschneidet sich zuerst (geht durch)
 ├─ Grids (Achsraster)   (optional)
 ├─ Types                                                  // mehrschichtige Aufbauten
 │   ├─ WallType  { id, name, layers: Layer[] }
 │   └─ SlabType  { id, name, layers: Layer[] }
 │        Layer = { componentId, thickness }              // Priorität liegt am Component
 │
 ├─ DesignLayers ("Ebenen")   // hier wird modelliert & 2D gezeichnet
 │   DesignLayer { id, name, elevation(z), height(Δz),
 │                 defaultLineStyle, defaultHatch,
 │                 elements:  Wall | Door | Window | Slab | Stair | Roof | Space ,
 │                 draw2d:    Line | Polyline | Rect | Circle | Arc | Text }
 │     Wall   { axis, wallTypeId, height }
 │     Door   { hostWall, position, width, height, swing, symbolId }
 │     Window { hostWall, position, width, height, sill }
 │     Slab   { boundary, slabTypeId }   ·   Space { boundary, name }  // Fläche auto
 │
 └─ DrawingLayers ("Zeichnungsebenen")   // abgeleitete Ausgabe
     DrawingLayer { id, name,
                    type: plan | section | elevation | drawing,
                    cutHeight(z),          // bei plan: Schnitthöhe
                    sectionLine,           // bei section
                    sourceDesignLayers[],
                    detailLevel: coarse|medium|fine,
                    scale, styleOverrides, dims[], labels[], annotations[] }
```
3D *und* jede Drawing Layer werden **aus den Design Layers abgeleitet**. `cutHeight`,
`detailLevel`, `Styles` und `Component`-Eigenschaften steuern, *wie* abgeleitet wird.

---

## 6. Die harten Risiken (früh angehen)

1. **Wand-Verbindungen / Cleanup** ⚠️ — Wo Wände aufeinandertreffen, müssen sie sauber verschneiden. **L-Ecken-Gehrung: ✅ erledigt.** Offen & berüchtigt schwer: **Prioritäts-basierte T-/X-Stöße bei mehrschichtigen Wänden** (Beton durch, Putz verbindet seitlich, geht nicht durch — siehe 2d). → stufenweise auf der Gehrung aufbauen.
2. **Gehostete Öffnungen** — Tür/Fenster muss synchron mit der Wand bleiben (verschieben, schneiden). → Saubere Host-Beziehung im Modell.
3. **Symbolischer Plan-Renderer** — normgerechte Darstellung (Schwenkbögen, Schraffuren der geschnittenen Bauteile, Lauflinien). → Eigenes Regelwerk; früh prototypen.
4. **Schnitt-/Ansichts-Projektion (HLR)** durch ganzes Gebäude — Performance. → Worker + Caching.
5. **IFC-Treue** — verlustarmer Round-Trip. → Früh mit echten IFC-Dateien testen.
6. **Geschoss-übergreifende Elemente** (Treppen, Lufträume).

---

## 7. Phasen-Roadmap

### Phase 0 — Spike: das größte Risiko zuerst
**Ziel:** Beweisen, dass der symbolische Plan-Pfad im Browser funktioniert.
- Eine Wand zeichnen, eine Tür platzieren → Öffnung wird geschnitten (3D).
- Daraus **Grundriss als SVG** generieren: Wand-Schnittlinien + Tür-**Schwenkbogen**.
- ✅ *Erfolg:* sauberer, schöner Grundriss-Ausschnitt aus einem semantischen Modell.

### Phase 1 — MVP: durchgehende Wohnbau-Scheibe
- **Dokumentmodell (Vectorworks-Stil):** Design Layers ("Ebenen") + Drawing Layers
  ("Zeichnungsebenen", Typ plan/section/elevation, mit `cutHeight`).
- **Resource Manager:** Line Manager, Hatch Manager, Component Manager (mit
  `joinPriority`, Schraffur, 3D-Textur).
- **Wände** mehrschichtig (✅) mit Eck-Gehrung (✅); **Prioritäts-T-Stöße** (Risiko #1).
- **Türen & Fenster** gehostet in Wänden (Risiko #2).
- **2D-Zeichnen:** Linie, Polylinie, Rechteck, Kreis, Bogen mit Stilen.
- **Decken/Böden** (Slabs); 3D-Viewport + **live Grundriss**, Basis-Bemaßung.
- → aus DOSSIER (§11): Wand-Referenzlage (mid/left/right), Öffnungs-Detailgrad mit Dokument-Override, Decken-Aussparungen, Element-Übersicht (BIM-Tree).
- ✅ Ein einfaches Haus modellieren → saubere Pläne pro Geschoss.

### Phase 2 — Vollständiger Bauteil-Satz Wohnbau
- **Treppen** (mit Lauflinie im Plan), **Dächer**, Geländer.
- **Räume/Spaces** mit automatischer Flächenberechnung & Raumstempel.
- Stützen/Unterzüge (falls nötig).
- Materialien & einfache Visualisierung.
- → aus DOSSIER (§11): Treppen-Typen (gerade/L/Wendel) + geschoss­übergreifend, Dach-Typen (Pult/Sattel/Walm/Mansarde), Stützen-Profile, **SIA-416-Räume** + CSV, Raumstempel-Builder, Stil-Kataloge (Wände/Öffnungen).

### Phase 3 — Plan-/Dokumentations-Modul ⭐ (Differenzierung)
**Hier gewinnen wir. Maximale Politur.**
- **Grundrisse, Schnitte (HLR, Risiko #4), Ansichten.**
- **Automatische Bemaßung** (Außenketten, Achsen, Öffnungen) + manuelle.
- Schraffuren geschnittener Bauteile, Raumstempel, Beschriftungen, Symbole.
- **Plansätze/Sheets** mit Titelblock, Maßstäben, Layout.
- Schöne Typografie & Linienführung — genau das, was die Großen vermasseln.
- → aus DOSSIER (§11): **Massstab pro Viewport** (Auto-DPI, Plotweight-/Schraffur-Skalierung), Section-Style (3D-Schnittflächen), Ausschnitte (View-Snapshots) + Layer-Kombinationen, Kamera-Presets (Kardinal/Iso, **Norden-Rotation**), Detail-Bindung an Ausschnitt, Multi-Page-PDF @DPI, regelbasierte Overrides, Rich-Text-Annotationen.

### Phase 4 — Interop (Import/Export)
- **Import:** **DWG/DXF** (2D-Pläne/Bestand), **IFC** (BIM-Bestand), **STL/OBJ**
  (Mesh-Referenzmodelle), **XYZ** (Punktwolken aus Vermessung).
- **Export:** **IFC** (Brücke zu Revit/ArchiCAD), **DWG/DXF**, **glTF/OBJ**.
- Round-Trip-Tests mit echten Dateien (Risiko #5).
- → aus DOSSIER (§11): **Swisstopo-Import** (swissBUILDINGS3D / swissALTI3D / SWISSIMAGE, LV95↔WGS84) ⭐ CH, OSM-Overpass-Kontext, Terrain-Mesh-Generator.

### Phase 5 — Persistenz & Konten
- Accounts, Projekte speichern/laden, Versionierung, Auto-Save.
- → aus DOSSIER (§11): Projekt-Persistierung auf Browser-Storage migrieren (IndexedDB statt doc.Strings); Presets/Favoriten cross-projekt (LocalStorage, Export/Import).

### Phase 6 — Export & Kollaboration
- Export: **PDF**, **DXF** (Pläne); **IFC**, **glTF** (3D).
- Teilen per Link, Kommentare, später Echtzeit-Co-Editing.

### Phase 7 — Produktisierung
- Performance-Härtung (große Modelle), Onboarding, Pricing, PWA/Offline.

---

## 8. Offene Fragen
- Booleans: OpenCascade (exakt) vs. Manifold (schnell) — Entscheidung in Phase 0.
- Welche Normen für Plandarstellung (SIA / DIN / …)? → beeinflusst Symbolik. *(Hinweis: User ist in der Schweiz → SIA prüfen.)*
- Wie viel Statik/Bauphysik (gar nicht / später)?
- Pricing-Modell (Freemium, pro Seat?).

---

## 9. Nächster konkreter Schritt
**Phase 0 starten:** Projekt scaffolden + Spike bauen — Wand + Tür mit geschnittener Öffnung → schöner Grundriss-Ausschnitt als SVG (mit Schwenkbogen). Das entschärft Risiko #1–#3 (Modell, Hosting, Symbolik) auf einmal.

---

## 10. Leitentscheidungen & UI-Architektur

### 10a. Leitentscheidungen aus der Recherche (Details in `docs/`, Index `docs/README.md`)
1. **Pure-Ableitungs-Architektur** als Fundament — ein semantisches Modell, alle Sichten abgeleitet, Darstellung erst beim Rendern (Store + Undo früh).
2. **OCCT/replicad im Web Worker** früh als Spike — kritischer Pfad für Schnitt/Ansicht (HLR), exakte Wand-Booleans und IFC. WASM-Größe + HLR-Kosten (pro Ansicht cachen) validieren.
3. **Component-getriebene Prioritäts-Verschneidung** (`joinPriority` am Component): höchstes gemeinsames Material läuft durch, Rest mitert. 2D-Plan analytisch, exakte 3D-Booleans im Worker.
4. **SVG/Paper-Space-Maßstabsmodell** — Strichstärke/Text/Hatch in mm, `dpi=96·devicePixelRatio`, ein Serializer für Bildschirm + PDF + DXF.
5. **CH-Spezifika als Differenzierer** ohne Backend — SIA-416 (reine Logik) + serverloser Swisstopo-Flow (CORS-offen, Parzelle/EGRID, Norden-Rotation, Origin-Shift).

### 10b. Panel-System (dockbar, Tabs, erweiterbar) — NEU
- **Docks links & rechts**; Panels in **Tab-Strips** gruppierbar (z. B. Zeichnungsebenen & Ebenen als Tabs eines Docks).
- **Panel-Registry** → eigene Panels und spätere **Plugins** registrieren sich und erscheinen als Panel.
- **Verschiebbar & floatend (am Tab gegriffen):** Ein Panel wird **am Tab selbst** (im Tab-Strip) gezogen → innerhalb des Docks **umsortieren**, ins andere Dock ziehen, oder aus dem Dock lösen. Andocken am **linken/rechten Rand** (Andock-Zonen beim Ziehen hervorheben); wird nicht angedockt, **schwebt** das Panel als freies (verschieb- und größenveränderbares) **Floating-Fenster** über dem Arbeitsbereich. Float-Position/Größe + Dock-Zustand werden gespeichert.
- **Fenster-Layouts speicherbar** (localStorage, benannte Layouts; Standard-Layout als Default).
- Der **Ressourcen-Manager** wird ebenfalls ein Panel (rechtes Dock).
- Pro Layer-Panel oben ein **Anzeige-Modus-Dropdown**: *nur aktive · alle anzeigen · aktive + andere grau* (DOSSIER/Vectorworks „Layer Options") — wirkt auf Plan & 3D.

### 10c. Plan-Navigation
- Grundriss/Schnitt/Ansicht: **Pan** (ziehen), **Zoom** (Mausrad zum Cursor), **Einpassen** — analog zum 3D-Viewport. SVG-`viewBox`-Transform.

### 10d. Backend & Kollaboration (Details: `docs/backend.md`)
- **Jetzt:** client-only (IndexedDB + Datei-Export/Import), kein Server. Modell JSON-serialisierbar + Edits als Operationen → **CRDT-fähig** halten.
- **Phase 5:** **Supabase self-hosted** (Docker Compose: Postgres + Auth + Storage) für Konten/Projekte/Dateien.
- **Phase 6:** **Yjs + Hocuspocus** (CRDT-Sync-Container, persistiert nach Postgres) für Echtzeit-Kollaboration. Alles self-hosted.
- Empfehlung: Stack **noch nicht** aufsetzen (würde den Modellierer ausbremsen); Weiche ist gestellt, Einführung additiv.

### 10e. Top-Bar & Footer/Status-Leiste (Vectorworks-Stil) — NEU
- **Top-Bar (Oberleiste, wie DOSSIER `toolbar.py`/`ToolbarApp.jsx`):** Ansichts-Umschalter (Grundriss/Perspektive/Schnitt/Ansicht), Render-/Darstellungsmodus, aktives Geschoss + aktive Ebene, Snapping-Schalter, Massstab, Werkzeug-Kontext, Einstellungen/Ressourcen.
- **Footer/Status-Leiste (wie Vectorworks unten):** Cursor-Koordinaten **X/Y/Z**, Einheit, aktueller **Massstab** (1:N) + **Zoom %**, aktives Geschoss/Ebene, **Snap-Status**, kurzer Werkzeug-Hinweis links.
- Beide an das Panel-/Dock-Layout angedockt; Inhalte aus dem Modell abgeleitet.

### 10f. Maus-Interaktion & Kontextmenü — NEU
- **Maus-Schema:** **Mitte = navigieren** (Plan: Pan · 3D: Orbit, `Shift`+Mitte: Pan) · **Links = Auswahl** (Einzelklick + **Markierrahmen/Aufziehrahmen** für Mehrfachauswahl im 2D) · **Rechts = Kontextmenü** · **Rad = Zoom** (zum Cursor).
  - Marquee: Aufziehen von links→rechts = nur vollständig umschlossene Elemente; rechts→links = auch berührte (wie CAD-üblich).
- **Eigenes Kontextmenü-System** (gestylt, dunkel, wiederverwendbar) — kein Browser-Menü.
- **Ebenen-Kontextmenü 1:1 wie DOSSIER** (Einträge aus `layers_panel.py`/`DrawingLevelsApp.jsx` übernehmen) — auch auf Zeichnungsebenen.
- Kontextmenü generisch, damit Plan-Elemente, Panels & spätere Plugins eigene Einträge registrieren können.

---

## 11. Aus DOSSIER übernehmen — Backlog

Konkret im DOSSIER-Rhino-Plugin umgesetzte Features, die sich für den Standalone-Port lohnen. Bereits abgedeckt (Layer-Modell, mehrschichtige Wände, Prioritäts-Stöße, Component-/Line-/Hatch-Manager, Ansichtstypen, Detailgrade) ist hier **nicht** erneut gelistet — nur das Zusätzliche. Aufwand: S/M/L. Phase verweist auf §7.

> **⭐ CH-Schätze (Schweiz-spezifisch, kaum woanders verfügbar):**
> - **Swisstopo-Geodaten** — swissBUILDINGS3D (3D-Bestand), swissALTI3D (präzises Höhenmodell), SWISSIMAGE (10-cm-Orthofoto), offene STAC-APIs ohne Auth, inkl. **LV95↔WGS84**-Transformation. Echter Standort-Kontext per Knopfdruck statt manuellem CAD-Import.
> - **SIA-416-Flächen** — Raum-Klassifikation (HNF/NNF/VF/FF/GF/AGF) mit automatischer Bilanz + CSV/Excel-Export. Pflicht für CH-Energie-/Flächennachweise.
> - **Norden-Rotation** bei Kamera-Presets — Georeferenzierung passend zu Swisstopo/swissBUILDINGS.

### Bauteile

| Feature | Nutzen | Aufwand | Phase |
|---|---|---|---|
| Wand-Referenzlage (mid/left/right) | Achse intuitiv auf Aussenkante/Mitte legen; hilft beim Import fremder Dateien | S | 1 |
| Öffnungs-Detailgrad + Dokument-Override (`aktive_darstellung`) | LoD je Massstab (1:500 Rechteck → 1:50 Glas/Sims) global umschaltbar; kritisch für Mixed-Scale | M | 2 |
| Fenster/Tür mit Rahmen, Brüstung, Sims, Glas, Flügelzahl | Öffnung als vollwertiges Bauteil statt nur Loch; Render-Realismus | M | 2 |
| Tür-Schwenkbogen (Öffnungswinkel + Anschlagseite) | Öffnungsbahnen für Möblierung/Kollision; Standard-Plansymbol | M | 2 |
| Decken-Aussparungen (Treppenauge, Schächte, Kamin) | Konstruktiv echte Deckenöffnungen, nicht nur sichtbar | M | 1–2 |
| Decken UK/OK-Override | Abhängungen, schräge Brüstungen, abweichende Raumhöhen | S | 1 |
| Treppen-Typen gerade/L/Wendel + Stufen/Lauflinie/Podest | Volle Vertikalerschliessung, volumetrisch korrekt, Plan-Symbole | M | 2 |
| Treppe geschoss­übergreifend (`geschoss_end`, Höhen-Override) | Atrien, Rampen, Mehr-Geschoss-Läufe (Risiko #6) | S | 2 |
| Treppen-2D-Symbol mit Auf-/Abpfeil + Schnitt | Normgerechtes Plansymbol (Richtung, Stufenzahl, Lauflinie) | M | 2 |
| Dach-Typen Pult/Sattel/Walm/Mansarde + Neigung(en) | 3D-Volumen mit Gefälle, Kubatur, Material; Mansarde später (L) | M–L | 2–3 |
| Stützen-Profile (Quadrat/Rechteck/Rund/I/Rohr) + Drehung | Beton- und Stahltragwerk mit echtem Querschnitt | M | 2 |
| Träger achs-basiert, hängt unter Decken-OK | Unterzug folgt Deckenoberkante, weniger Fehler bei Updates | S | 2 |
| **SIA-416-Räume** (HNF/NNF/VF/FF/GF/AGF) + Bilanz-CSV ⭐ | CH-Flächennachweis, Excel-Export | M | 2 |
| Raum-Stempel-Builder (Drag-&-Drop-Felder) + Fläche-Rundung + Personen | Projekt-eigene Stempel-Layouts ohne Code; lesbare Listen; Brandschutz | M | 2–3 |
| Element-Übersicht (BIM-Tree Geschoss→Kind→Element, Suche, Zoom) | Inhaltsverzeichnis bei 100+ Elementen; Shift-Klick = Zoom | S | 1 |
| Stil-Kataloge Wände & Öffnungen (Presets) | Standard-Typen 1-Klick; globaler Stilwechsel | M | 2 |
| Grip-Editing (Wand-Endpunkte, Schnitt-Symbole im Plan) | Direktes Ziehen statt Dialog; 2D/3D-Sync; wichtig im Browser | L | 3–4 |

### Darstellung / Ressourcen

| Feature | Nutzen | Aufwand | Phase |
|---|---|---|---|
| Regelbasierte Overrides (Layer-/Tag-/Name-Regel, Priorität, Templates) | Automatische Farb-/Strich-/Linientyp-Anpassung; wiederverwendbar (vertieft §2c „Overrides") | M | 3 |
| Section-Style für 3D-Schnittflächen (Schraffur + Schnittkante/Silhouette) | 3D-Schnitt-Rendering im Viewport, nicht nur 2D-Plan | M | 4 |
| Massstabs-abhängige Linientyp-/Plotweight-Skalierung | Linientypen & Strichstärken bei 1:N korrekt sichtbar; PDF-Treue | M | 3–4 |
| Material-Bibliothek mit PBR (Rauheit/Reflexion/Transparenz) + Templates | Vertieft Component-Manager um Renderqualität; Seeds Beton/Holz/Dämmung | M | 3 |
| Rich-Text-Annotationen (Bold/Italic/Hoch-/Tiefstellung, Maskierung, Rahmen) | Bemaßungs-Indizes, formatierte Beschriftungen auf Canvas | M | 3 |
| LoD-bewusste Stil-UI (zeigt nur passende Controls je Geometrie-Typ) | Weniger kognitive Last (keine Füll-Optionen bei 3D-Auswahl) | S | 1 |

### Pläne / Output

| Feature | Nutzen | Aufwand | Phase |
|---|---|---|---|
| **Massstab pro Viewport** mit Auto-DPI + Schraffur-/Strich-Skalierung | Exakte Masse & lesbare Strichstärken ohne manuelle Kalibrierung | M | 3 |
| Ausschnitte / View-Snapshots (Kamera + Darstellung + Massstab) | Navigation über 50+ Ansichten; ersetzt Ordner-Wildwuchs (vertieft §2c) | M | 3 |
| Layer-Kombinationen als Presets (live oder eingefroren) | Bauphasen/Varianten/MEP per Klick statt manuellem Toggling (vertieft §2c) | S | 3 |
| Kamera-Presets (Kardinal N/O/S/W, Iso-Oktanten, **Norden-Rotation** ⭐) | Schnelle Ansichtswechsel; Georeferenzierung für Swisstopo | S | 3 |
| Detail↔Ausschnitt-Bindung + „Alle aktualisieren" | Titelblock/Detail synchron umbenennen; 1-Klick-Sync aller Schnitte | M | 3 |
| Multi-Page-PDF-Export @DPI (Vektor) | Druckfertige Plansätze — Kern-Output (ergänzt Phase-3-Sheets) | M | 3 |
| 9-Punkt-Bemaßung/Objekt-Info (lesen + verschieben/skalieren/rotieren) | Direktes Dimensionieren ohne Properties-Panel | M | 3 |

### Kontext / Daten

| Feature | Nutzen | Aufwand | Phase |
|---|---|---|---|
| **Swisstopo-Import** (swissBUILDINGS3D/ALTI3D/SWISSIMAGE) ⭐ CH | Authentischer Standort-Kontext, offene APIs, kein Auth | M | 4 |
| LV95↔WGS84-Transformation ⭐ CH | Karten-Anzeige + präzise CH-Koordinaten; Formeln direkt portierbar | S | 4 |
| OSM-Overpass-Import (Strassen/Gebäude/Wasser/Grün, 7 Kategorien) | Weltweiter, kostenloser Kontext; ergänzt Swisstopo | M | 4 |
| Terrain-Mesh-Generator (Mesh/TIN/NURBS-Patch/Höhenlinien, Volumen für Schnitt) | Geländemodell aus Höhendaten; Section-Cut-Füllung; portierbar zu Three.js | L | 4 |
| Auto-Zoom auf Import + Nullpunkt-Verschiebung (LV95→0/0/0) | Modellierungsgenauigkeit trotz Millionen-Koordinaten; UX-Standard | S | 4 |
| Projekt-Persistierung browser-nativ (IndexedDB statt doc.Strings) | Projekt kapselt seine Einstellungen lokal | M | 5 |
| Cross-Projekt-Presets (LocalStorage-Favoriten, Export/Import, Team-Sharing) | Einmal speichern, überall nutzen | S | 5 |