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 (Bestandsaufnahme + Mist-Liste) und 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