2D-Plan-Renderer auf WebGL2 (GPU) + akkumulierter Funktionsstand

Neuer GPU-Renderer fuer den Grundriss (src/plan/glPlan/): Earcut-Tessellierung
(konkav-faehig), gehrte Linienzuege (Miter), echte Papier-mm-Strichbreiten im
Massstab (repliziert den SVG-printStrokeVb-Pfad), Hybrid mit scharfem SVG-Text-
Overlay. GPU ist der Standardpfad; der SVG-Renderer bleibt automatischer Fallback,
falls WebGL2/Shader nicht verfuegbar sind. Imperativer Pan (rAF + CSS-transform)
fuer fluessige Interaktion ohne React-Re-Render je Frame.

Enthaelt zudem den bisher nicht committeten Arbeitsstand des Browser-BIM
(Oeffnungen, Treppen, Raeume, Decken, DXF-Export, Materialbibliothek, Kontext-
Import, Tauri-Compute-Boundary-PoC).

src/compute/index.ts

@@ -0,0 +1,101 @@
+// Compute-Grenze: der EINE Einstiegspunkt für rechenintensive Operationen.
+// Läuft die App unter Tauri, werden Ops an einen Rust-`#[tauri::command]`
+// geroutet; sonst greift die bestehende TS-Implementierung. In dieser PoC ist
+// nur `computeJoins` real an Rust angebunden — die übrigen Funktionen sind
+// dünne Pass-throughs auf ihre TS-Impls (Grenze etabliert, Migration
+// inkrementell).
+
+import type { Project, Wall } from "../model/types";
+import { getWallType, wallTypeThickness } from "../model/types";
+import { wallReferenceOffset } from "../model/wall";
+import { computeJoins as computeJoinsTS } from "../model/joins";
+import type { WallCuts } from "../model/joins";
+import type { Line } from "../model/geometry";
+import { detectRooms as detectRoomsTS } from "../geometry/roomBoundary";
+import type { WallSegment, DetectRoomsOptions } from "../geometry/roomBoundary";
+import { parseDwg as parseDwgTS } from "../io/dwgParser";
+import type { DxfImportResult } from "../io/dxfParser";
+import type { Vec2 } from "../model/types";
+
+// Tauri-invoke, wenn vorhanden — sonst null (Browser/kein Tauri). Dynamischer,
+// GEGUARDETER Import, damit der Build ohne @tauri-apps/api grün bleibt.
+async function tauriInvoke<T>(cmd: string, args: Record<string, unknown>): Promise<T | null> {
+  try {
+    // @ts-ignore optionales Paket
+    const mod = await import(/* @vite-ignore */ "@tauri-apps/api/core").catch(() => null);
+    if (!mod || typeof (mod as any).invoke !== "function") return null;
+    return await (mod as any).invoke(cmd, args) as T;
+  } catch {
+    return null;
+  }
+}
+
+/** Serialisierbare Wand-Repräsentation für den Rust-Kern. */
+interface FlatWall {
+  id: string;
+  start: Vec2;
+  end: Vec2;
+  thickness: number;
+  referenceOffset: number;
+}
+
+/** Rohantwort des Rust-Befehls `compute_joins`. */
+interface RustWallCut {
+  wallId: string;
+  startCut: Line | null;
+  endCut: Line | null;
+}
+
+/**
+ * Gehrungs-Schnittlinien pro Wand. Unter Tauri via Rust-Kern, sonst TS-Fallback.
+ * Die Signatur ist synchron-kompatibel zur TS-Impl, aber async (Rust-Aufruf).
+ */
+export async function computeJoins(
+  project: Project,
+  walls: Wall[],
+): Promise<Map<string, WallCuts>> {
+  try {
+    const flattened: FlatWall[] = walls.map((w) => {
+      const thickness = wallTypeThickness(getWallType(project, w));
+      return {
+        id: w.id,
+        start: w.start,
+        end: w.end,
+        thickness,
+        referenceOffset: wallReferenceOffset(w, thickness),
+      };
+    });
+
+    const res = await tauriInvoke<RustWallCut[]>("compute_joins", {
+      input: { walls: flattened },
+    });
+    if (res != null) {
+      const map = new Map<string, WallCuts>();
+      for (const c of res) {
+        map.set(c.wallId, { startCut: c.startCut, endCut: c.endCut });
+      }
+      return map;
+    }
+  } catch {
+    // fällt unten in den TS-Pfad
+  }
+  console.warn("Rust compute_joins nicht verfügbar, TS-Fallback");
+  return computeJoinsTS(project, walls);
+}
+
+// ── Pass-throughs (noch reines TS; bereit für spätere Rust-Migration) ─────────
+
+/** Raumerkennung aus Wandsegmenten. Aktuell TS; Grenze für spätere Migration. */
+export async function detectRooms(
+  walls: WallSegment[],
+  options: DetectRoomsOptions = {},
+): Promise<Vec2[][]> {
+  return detectRoomsTS(walls, options);
+}
+
+/** DWG-Import (LibreDWG-WASM). Aktuell TS; Grenze für spätere Migration. */
+export async function parseShapeFromDwg(
+  data: ArrayBuffer,
+): Promise<DxfImportResult> {
+  return parseDwgTS(data);
+}