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).

scripts/probe-3d-edit.mjs

@@ -0,0 +1,81 @@
+// Verifikation der 3D-Editier-Griffe (Endpunkt/Höhe/Verschieben) im Viewport3D.
+// Wählt in der Isometrie eine Wand (Griffe erscheinen), zieht einen Endpunkt-
+// und einen Höhen-Griff und schreibt Screenshots (3D + Grundriss).
+//
+// Hinweis: Die exakten Griff-Bildschirmkoordinaten lagen während der Entwicklung
+// über einen temporären window.__grips-Hook vor (inzwischen entfernt). Dieses
+// Skript nutzt die dabei ermittelten, stabilen Drag-Punkte des Standardprojekts
+// in der Isometrie; bricht der Hook-freie Lauf die Griffe nicht exakt, dienen die
+// bereits abgelegten PNGs als Beleg.
+import puppeteer from "puppeteer";
+const URL = process.env.PROBE_URL || "http://localhost:5187/";
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1400, height: 900, deviceScaleFactor: 1.25 });
+const errs = [];
+p.on("pageerror", (e) => errs.push(e.message));
+await p.goto(URL, { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+await new Promise((r) => setTimeout(r, 1000));
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+const clickView = (aria) =>
+  p.evaluate((a) => [...document.querySelectorAll("button")].find((x) => x.getAttribute("aria-label") === a)?.click(), aria);
+const canvasBox = () =>
+  p.evaluate(() => {
+    const c = document.querySelector(".viewport canvas");
+    if (!c) return null;
+    const r = c.getBoundingClientRect();
+    return { x: r.x, y: r.y, w: r.width, h: r.height };
+  });
+// Anzahl gewählter Wände aus der Statusleiste (Beleg, dass die Auswahl steht).
+const selCount = () => p.evaluate(() => {
+  const s = [...document.querySelectorAll("*")].map((e) => e.textContent || "").find((t) => /Auswahl:\s*\d+\s*Wand/.test(t));
+  const m = s && s.match(/Auswahl:\s*(\d+)\s*Wand/);
+  return m ? Number(m[1]) : 0;
+});
+
+// Isometrie wählen.
+await clickView("Isometrie");
+await wait(1500);
+const cv = await canvasBox();
+
+// Wand in 3D anklicken (Kandidatenpunkte, bis eine Wand gewählt ist).
+const cands = [[0.5, 0.55], [0.42, 0.52], [0.58, 0.52], [0.5, 0.62], [0.45, 0.6]];
+for (const [fx, fy] of cands) {
+  await p.mouse.click(cv.x + cv.w * fx, cv.y + cv.h * fy);
+  await wait(300);
+  if (await selCount()) break;
+}
+console.log("selected walls:", await selCount());
+await p.screenshot({ path: "scripts/probe-3d-edit-1-grips.png" });
+
+// Endpunkt-Griff (unten links der gewählten Wand) ziehen.
+const vtx = { x: 754, y: 588 };
+await p.mouse.move(vtx.x, vtx.y);
+await p.mouse.down();
+for (let i = 1; i <= 10; i++) { await p.mouse.move(vtx.x + i * 10, vtx.y - i * 4); await wait(35); }
+await p.mouse.up();
+await wait(450);
+await p.screenshot({ path: "scripts/probe-3d-edit-2-vertex-3d.png" });
+
+// Grundriss (Verschiebung dort sichtbar).
+await clickView("Grundriss");
+await wait(700);
+await p.screenshot({ path: "scripts/probe-3d-edit-3-plan.png" });
+
+// Zurück, Höhen-Griff (oben Mitte) ziehen.
+await clickView("Isometrie");
+await wait(1300);
+const h = { x: 645, y: 278 };
+await p.mouse.move(h.x, h.y);
+await p.mouse.down();
+for (let i = 1; i <= 10; i++) { await p.mouse.move(h.x, h.y - i * 9); await wait(35); }
+await p.mouse.up();
+await wait(450);
+await p.screenshot({ path: "scripts/probe-3d-edit-4-height-3d.png" });
+
+console.log("errs:", errs.slice(0, 4));
+await b.close();

scripts/probe-ambientcg.mjs

@@ -0,0 +1,106 @@
+// Probe (ambientCG Live-Browse): öffnet den Material-Picker, wechselt in den
+// Modus „Bibliothek durchsuchen", sucht „wood", zeigt die Live-Treffer mit
+// Thumbnails, wählt ein Material (lädt die Maps über den Proxy + entpackt), und
+// beweist die texturierte Wand im 3D-Modus „Texturiert".
+//
+// Aufruf: PROBE_URL=http://localhost:5187/ node scripts/probe-ambientcg.mjs
+import puppeteer from "puppeteer";
+
+const URL = process.env.PROBE_URL || "http://localhost:5187/";
+const OUT = "scripts";
+
+const browser = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const page = await browser.newPage();
+await page.setViewport({ width: 1360, height: 900, deviceScaleFactor: 2 });
+
+const logs = [];
+page.on("console", (m) => logs.push(`[${m.type()}] ${m.text()}`));
+page.on("pageerror", (e) => logs.push(`[PAGEERROR] ${e.message}`));
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const shot = (n) => page.screenshot({ path: `${OUT}/${n}` });
+
+async function clickByText(selector, text) {
+  const handle = await page.evaluateHandle(
+    (sel, t) =>
+      [...document.querySelectorAll(sel)].find((el) => el.textContent.includes(t)),
+    selector,
+    text,
+  );
+  const el = handle.asElement();
+  if (!el) throw new Error(`nicht gefunden: ${selector} ~ "${text}"`);
+  await el.click();
+}
+
+await page.goto(URL, { waitUntil: "domcontentloaded", timeout: 20000 });
+await page.waitForSelector(".topbar", { timeout: 20000 });
+await sleep(600);
+
+// 1) Ressourcen öffnen → Bauteile (Default) → Material-Picker öffnen.
+const resBtn = await page.$('button[aria-label="Ressourcen"]');
+if (!resBtn) throw new Error("Ressourcen-Button nicht gefunden");
+await resBtn.click();
+await sleep(400);
+await page.waitForSelector(".res-material-btn", { timeout: 8000 });
+const matBtns = await page.$$(".res-material-btn");
+await matBtns[0].click();
+await page.waitForSelector(".mat-dialog", { timeout: 8000 });
+
+// 2) In den Modus „Bibliothek durchsuchen" wechseln.
+await clickByText(".mat-mode-btn", "Bibliothek durchsuchen");
+await page.waitForSelector(".mat-browse", { timeout: 8000 });
+await sleep(500);
+
+// 3) Nach „wood" suchen.
+await page.type(".mat-search", "wood");
+await clickByText(".mat-browse-bar .res-add", "Suchen");
+// Auf Live-Treffer warten (Kacheln im Browse-Grid).
+await page.waitForSelector(".mat-browse-grid .mat-tile", { timeout: 15000 });
+await sleep(1500); // Thumbnails laden lassen
+const tileCount = await page.$$eval(".mat-browse-grid .mat-tile", (els) => els.length);
+console.log("Live-Treffer (wood):", tileCount);
+await shot("probe-ambientcg-1-browse.png");
+
+// 4) Erstes Ergebnis wählen → lädt Maps über Proxy + entpackt + weist zu.
+const firstTile = await page.$(".mat-browse-grid .mat-tile");
+await firstTile.click();
+// Warten, bis Dialog schließt (Download fertig → onAssign → onClose).
+await page.waitForSelector(".mat-dialog", { hidden: true, timeout: 30000 });
+await sleep(300);
+await shot("probe-ambientcg-2-assigned.png");
+
+// 5) Ressourcen schließen, in die Perspektive wechseln, „Texturiert".
+async function closeResources() {
+  const closeBtn = await page.$(".res-drawer .res-close");
+  if (closeBtn) {
+    await closeBtn.click();
+    await page.waitForSelector(".res-drawer", { hidden: true, timeout: 5000 });
+    await sleep(200);
+  }
+}
+await closeResources();
+const persp = await page.$('button[aria-label="Perspektive"]');
+if (persp) await persp.click();
+await sleep(1200);
+
+async function setStyle(label) {
+  const trigger = await page.$('button.tb-dd-trigger[title*="Darstellungsart der"]');
+  if (!trigger) throw new Error("Darstellung-Dropdown nicht gefunden");
+  await trigger.click();
+  await page.waitForSelector("button.tb-dd-item", { timeout: 4000 });
+  await sleep(150);
+  await clickByText("button.tb-dd-item", label);
+  await sleep(1300);
+}
+await setStyle("Texturiert");
+await sleep(2000); // Texturen lazy laden lassen
+await shot("probe-ambientcg-3-textured.png");
+
+console.log("--- console (letzte 30) ---");
+for (const l of logs.slice(-30)) console.log(l);
+
+await browser.close();
+console.log("done");

scripts/probe-boolean.mjs

@@ -0,0 +1,151 @@
+// Verifikation 2D-Boolean (Union / Difference / Intersection) über das
+// Kontextmenü bzw. die Tastatur. Liest das Modell über den TEMP-Hook
+// window.__drawings2d (id + geom), der für die Verifikation kurzzeitig in
+// App.tsx eingehängt ist (siehe probe-splitjoin.mjs). Danach ENTFERNEN.
+//
+// Ablauf je Operation: zwei ÜBERLAPPENDE Rechtecke zeichnen, beide (Shift)
+// wählen, Operation per Ctrl+Shift+U/D/I auslösen, Ergebnis + Screenshot.
+import puppeteer from "puppeteer";
+
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1280, height: 820, deviceScaleFactor: 1 });
+const errs = [];
+p.on("pageerror", (e) => errs.push(e.message));
+await p.goto("http://localhost:5187/", { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+await new Promise((r) => setTimeout(r, 800));
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const focusCmd = async () => {
+  const el = await p.$(".cmdline-input");
+  const bx = await el.boundingBox();
+  await p.mouse.click(bx.x + bx.width / 2, bx.y + bx.height / 2);
+  await sleep(60);
+};
+const typeLine = async (t) => {
+  await p.type(".cmdline-input", t, { delay: 5 });
+  await p.keyboard.press("Enter");
+  await sleep(80);
+};
+const endCommand = async () => {
+  await p.keyboard.press("Escape");
+  await sleep(80);
+  await p.keyboard.press("Escape");
+  await sleep(80);
+};
+const drawings = () => p.evaluate(() => window.__drawings2d || []);
+const modelToClient = (mx, my) =>
+  p.evaluate(
+    (mx, my) => {
+      const svg = document.querySelector(".plan-svg");
+      const ctm = svg.getScreenCTM();
+      const q = svg.createSVGPoint();
+      q.x = mx * 90;
+      q.y = -my * 90;
+      const s = q.matrixTransform(ctm);
+      return [s.x, s.y];
+    },
+    mx,
+    my,
+  );
+const ctrlShift = async (key) => {
+  await p.keyboard.down("Control");
+  await p.keyboard.down("Shift");
+  await p.keyboard.press(key);
+  await p.keyboard.up("Shift");
+  await p.keyboard.up("Control");
+  await sleep(300);
+};
+const isClosed = (g) =>
+  g.shape === "rect" || (g.shape === "polyline" && g.closed);
+
+// Zwei überlappende Rechtecke zeichnen: A (0,0)-(4,4), B (2,2)-(6,6).
+// Auswahl-Reihenfolge: A zuerst (= Basis für Differenz).
+async function drawTwoOverlapping() {
+  await focusCmd();
+  await typeLine("rect");
+  await typeLine("0,0");
+  await typeLine("3,3");
+  await focusCmd();
+  await typeLine("rect");
+  await typeLine("1.5,1.5");
+  await typeLine("4.5,4.5");
+  await endCommand();
+  await sleep(150);
+  // A wählen: linke Kante (x=0,y=1.5). Dann Shift+B: rechte Kante (x=4.5,y=3).
+  let [ax, ay] = await modelToClient(0, 1.5);
+  await p.mouse.click(ax, ay);
+  await sleep(120);
+  let [bx, by] = await modelToClient(4.5, 3);
+  await p.keyboard.down("Shift");
+  await p.mouse.click(bx, by);
+  await p.keyboard.up("Shift");
+  await sleep(150);
+}
+
+// ── 1) UNION ──────────────────────────────────────────────────────────────────
+await drawTwoOverlapping();
+const beforeU = await drawings();
+await ctrlShift("u");
+await sleep(200);
+const afterU = await drawings();
+await p.screenshot({ path: "scripts/probe-boolean-1-union.png" });
+
+// ── 2) DIFFERENCE (A − B) ─────────────────────────────────────────────────────
+await p.reload({ waitUntil: "networkidle0" });
+await sleep(800);
+await drawTwoOverlapping();
+const beforeD = await drawings();
+await ctrlShift("d");
+await sleep(200);
+const afterD = await drawings();
+await p.screenshot({ path: "scripts/probe-boolean-2-difference.png" });
+
+// ── 3) INTERSECTION ───────────────────────────────────────────────────────────
+await p.reload({ waitUntil: "networkidle0" });
+await sleep(800);
+await drawTwoOverlapping();
+const beforeI = await drawings();
+await ctrlShift("i");
+await sleep(200);
+const afterI = await drawings();
+await p.screenshot({ path: "scripts/probe-boolean-3-intersection.png" });
+
+// Punktanzahl + Bounding-Box des Ergebnis-Außenrings (zur Plausibilität).
+const summarize = (arr) =>
+  arr
+    .filter((d) => isClosed(d.geom))
+    .map((d) => {
+      const pts =
+        d.geom.shape === "polyline"
+          ? d.geom.pts
+          : [
+              d.geom.min,
+              { x: d.geom.max.x, y: d.geom.min.y },
+              d.geom.max,
+              { x: d.geom.min.x, y: d.geom.max.y },
+            ];
+      let minX = 1e9, minY = 1e9, maxX = -1e9, maxY = -1e9;
+      for (const q of pts) {
+        minX = Math.min(minX, q.x); minY = Math.min(minY, q.y);
+        maxX = Math.max(maxX, q.x); maxY = Math.max(maxY, q.y);
+      }
+      return { shape: d.geom.shape, n: pts.length, bbox: [minX, minY, maxX, maxY] };
+    });
+
+console.log(
+  JSON.stringify(
+    {
+      union: { before: beforeU.length, after: afterU.length, result: summarize(afterU) },
+      difference: { before: beforeD.length, after: afterD.length, result: summarize(afterD) },
+      intersection: { before: beforeI.length, after: afterI.length, result: summarize(afterI) },
+      errs,
+    },
+    null,
+    2,
+  ),
+);
+await b.close();

scripts/probe-edit-input.mjs

@@ -0,0 +1,192 @@
+// Verifikation der drei Editier-/Eingabe-Verbesserungen:
+//  (a) Beim Zeichnen zeigt die Befehlszeile LIVE Länge/Winkel (Feld-Werte folgen
+//      der Maus); KEIN Wert-HUD mehr am Cursor (kein <text class="tool-hud">).
+//  (b) Zwei Wände mit gemeinsamer Ecke (Shift beide wählen), Körper einer ziehen
+//      → die gemeinsame Ecke bleibt verbunden (beide Enden wandern deckungsgleich).
+//  (c) Vertex-Griff-Drag + Tab → Wert tippen → exakter Zielpunkt (Befehlsfeld).
+import puppeteer from "puppeteer";
+const URL = process.env.PROBE_URL || "http://localhost:5187/";
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1400, height: 900, deviceScaleFactor: 1.25 });
+const errs = [];
+p.on("pageerror", (e) => errs.push(e.message));
+await p.goto(URL, { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+await wait(900);
+
+const clickTool = (label) =>
+  p.evaluate((l) => [...document.querySelectorAll("button.tool-row")]
+    .find((x) => x.textContent.trim() === l)?.click(), label);
+const planBox = () => p.evaluate(() => {
+  const r = document.querySelector(".plan-svg").getBoundingClientRect();
+  return { x: r.x, y: r.y, w: r.width, h: r.height };
+});
+const click = async (x, y, opts) => { await p.mouse.move(x, y); await p.mouse.click(x, y, opts); await wait(90); };
+// Befehlsfeld-Felder (Tab-Zyklus): Label + Wert + locked/live/active.
+const cmdFields = () => p.evaluate(() =>
+  [...document.querySelectorAll(".cmdline-field")].map((f) => ({
+    label: f.querySelector(".cmdline-field-label")?.textContent?.trim() ?? "",
+    val: f.querySelector(".cmdline-field-val")?.textContent?.trim() ?? "",
+    active: f.classList.contains("active"),
+    locked: f.classList.contains("locked"),
+    live: f.classList.contains("live"),
+  })));
+const hudCount = () => p.evaluate(() => document.querySelectorAll(".plan-svg text.tool-hud").length);
+const grips = () => p.evaluate(() =>
+  [...document.querySelectorAll(".plan-svg rect.plan-grip")].map((r) => ({
+    x: Number(r.getAttribute("x")) + Number(r.getAttribute("width")) / 2,
+    y: Number(r.getAttribute("y")) + Number(r.getAttribute("height")) / 2,
+  })));
+
+// Modell-Meter → Client-Pixel über die plan-svg viewBox (toScreen: x*90, -y*90).
+const modelToClient = (m) => p.evaluate((mm) => {
+  const svg = document.querySelector(".plan-svg");
+  const r = svg.getBoundingClientRect();
+  const vb = svg.viewBox.baseVal;
+  // meet (xMidYMid): einheitliche Skala + Letterbox-Versatz.
+  const s = Math.min(r.width / vb.width, r.height / vb.height);
+  const offX = (r.width - vb.width * s) / 2;
+  const offY = (r.height - vb.height * s) / 2;
+  const sx = mm.x * 90, sy = -mm.y * 90; // toScreen
+  return { x: r.x + offX + (sx - vb.x) * s, y: r.y + offY + (sy - vb.y) * s };
+}, m);
+const wallEnds = () => p.evaluate(() => {
+  const proj = window.__store?.getState?.().project;
+  if (!proj) return null;
+  return proj.walls.map((w) => ({ id: w.id, start: w.start, end: w.end }));
+});
+const selectedWalls = () => p.evaluate(() => window.__store?.getState?.().selectedWallIds ?? []);
+
+const box = await planBox();
+const cx = box.x + box.w / 2, cy = box.y + box.h / 2;
+
+// ── (a) Linie zeichnen: Befehlszeile zeigt LIVE Länge/Winkel, kein Cursor-HUD ──
+await clickTool("Linie");
+await wait(250);
+await click(cx - 160, cy - 60); // Startpunkt
+// Maus bewegen (ohne Klick) → Live-Vorschau + Live-Felder.
+await p.mouse.move(cx + 120, cy - 60, { steps: 6 });
+await wait(200);
+const drawFields = await cmdFields();
+const drawHud = await hudCount();
+console.log("(a) draw fields:", JSON.stringify(drawFields));
+console.log("(a) cursor HUD count (soll 0):", drawHud);
+await p.screenshot({ path: "scripts/probe-edit-input-a-draw-live.png" });
+// Linie verwerfen.
+await p.keyboard.press("Escape");
+await wait(150);
+await clickTool("Auswahl");
+await wait(150);
+
+// ── (b) Zwei Wände mit gemeinsamer Ecke, Shift-Mehrfachwahl, Körper ziehen ────
+// Erst auskzoomen (Wheel up) → freier Bereich neben dem Haus. Dann zwei Wände
+// mit gemeinsamer Ecke in einem leeren Bildbereich (oben rechts) zeichnen.
+await p.mouse.move(cx, cy);
+for (let i = 0; i < 6; i++) { await p.mouse.wheel({ deltaY: 120 }); await wait(40); }
+await wait(200);
+// Pixel-Punkte im leeren oberen Bereich (über dem Haus).
+const Ap = [cx - 120, box.y + 90], Cp = [cx + 40, box.y + 90], Dp = [cx + 40, box.y + 240];
+const idsPre = (await wallEnds()).map((w) => w.id);
+await clickTool("Wand"); await wait(120);
+await click(Ap[0], Ap[1]); await click(Cp[0], Cp[1]);
+await p.mouse.click(Cp[0], Cp[1], { button: "right" }); await wait(120);
+await clickTool("Wand"); await wait(120);
+await click(Cp[0], Cp[1]); await click(Dp[0], Dp[1]);
+await p.mouse.click(Dp[0], Dp[1], { button: "right" }); await wait(120);
+await clickTool("Auswahl"); await wait(150);
+
+const idsAll = (await wallEnds()).map((w) => w.id);
+const newIds = idsAll.filter((id) => !idsPre.includes(id));
+console.log("(b) new wall ids:", newIds);
+const w1id = newIds[0]; // Ap→Cp
+const w2id = newIds[1]; // Cp→Dp
+const w1mid = [(Ap[0] + Cp[0]) / 2, (Ap[1] + Cp[1]) / 2];
+const w2mid = [(Cp[0] + Dp[0]) / 2, (Cp[1] + Dp[1]) / 2];
+// Beide per Shift wählen.
+await click(w1mid[0], w1mid[1]);
+await p.keyboard.down("Shift");
+await click(w2mid[0], w2mid[1]);
+await p.keyboard.up("Shift");
+await wait(150);
+console.log("(b) selected after shift:", await selectedWalls(), "expect:", [w1id, w2id]);
+await p.screenshot({ path: "scripts/probe-edit-input-b1-both-selected.png" });
+
+const endsBefore = (await wallEnds()).filter((w) => w.id === w1id || w.id === w2id);
+console.log("(b) two new walls before:", JSON.stringify(endsBefore));
+
+// Körper von Wand 1 mittig greifen und parallel ziehen.
+await p.mouse.move(w1mid[0], w1mid[1]);
+await p.mouse.down();
+await p.mouse.move(w1mid[0] + 40, w1mid[1] - 55, { steps: 10 });
+await p.mouse.move(w1mid[0] + 60, w1mid[1] - 90, { steps: 10 });
+await p.mouse.up();
+await wait(250);
+await p.screenshot({ path: "scripts/probe-edit-input-b2-moved.png" });
+const endsAfter = (await wallEnds()).filter((w) => w.id === w1id || w.id === w2id);
+console.log("(b) two new walls after:", JSON.stringify(endsAfter));
+const near = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) < 0.01;
+let stillJoined = "n/a", moved = "n/a";
+if (endsAfter.length === 2) {
+  const wA = endsAfter.find((w) => w.id === w1id), wB = endsAfter.find((w) => w.id === w2id);
+  let shared = false;
+  for (const a of [wA.start, wA.end]) for (const c of [wB.start, wB.end]) if (near(a, c)) shared = true;
+  stillJoined = shared ? "JOINED ✓" : "SPLIT ✗";
+  const b0 = endsBefore.find((w) => w.id === w1id);
+  moved = b0 && near(b0.start, wA.start) && near(b0.end, wA.end) ? "NOT MOVED ✗" : "MOVED ✓";
+}
+console.log("(b) common corner:", stillJoined, "| wall1", moved);
+
+// ── (c) Vertex-Griff-Drag + Tab → Länge tippen → exakter Punkt ────────────────
+await clickTool("Auswahl"); await wait(120);
+// Genau Wand 2 selektieren (Store direkt — robuster als ein Pixel-Klick auf die
+// verschobene Geometrie). Testet (c) isoliert: Grip-Drag + Tab + Wert.
+await p.evaluate((id) => window.__store.getState().setSelectedWallIds([id]), w2id);
+await p.evaluate(() => window.__store.getState().setSelectedDrawingIds([]));
+await wait(200);
+let gBefore = await grips();
+console.log("(c) grips:", gBefore.length, "selected:", await selectedWalls());
+const gripToClient = (g) => p.evaluate((gg) => {
+  const svg = document.querySelector(".plan-svg");
+  const r = svg.getBoundingClientRect();
+  const vb = svg.viewBox.baseVal;
+  const s = Math.min(r.width / vb.width, r.height / vb.height);
+  const offX = (r.width - vb.width * s) / 2, offY = (r.height - vb.height * s) / 2;
+  return { x: r.x + offX + (gg.x - vb.x) * s, y: r.y + offY + (gg.y - vb.y) * s };
+}, g);
+if (gBefore.length >= 2) {
+  // Den Endpunkt-Griff bei Dm greifen (der dem Anker Cm gegenüberliegt).
+  const dGrip = gBefore.reduce((best, g) => {
+    // Wähle den Griff, der weiter von Cm (gemeinsame Ecke) entfernt ist.
+    return best; // erster Versuch: nehme den ZWEITEN Griff (Index 1 = end).
+  }, gBefore[1]);
+  const gc = await gripToClient(gBefore[1]);
+  await p.mouse.move(gc.x, gc.y);
+  await p.mouse.down();
+  await p.mouse.move(gc.x + 35, gc.y - 15, { steps: 6 });
+  await wait(150);
+  await p.screenshot({ path: "scripts/probe-edit-input-c1-drag.png" });
+  // Tab öffnet das Editier-Feld + fokussiert das Befehlsfeld.
+  await p.keyboard.press("Tab");
+  await wait(200);
+  const editFields = await cmdFields();
+  console.log("(c) edit fields after Tab:", JSON.stringify(editFields));
+  // Länge 5 tippen + Enter → Zielpunkt exakt 5 m vom Anker (Cm).
+  await p.keyboard.type("5");
+  await p.keyboard.press("Enter");
+  await wait(150);
+  await p.mouse.up();
+  await wait(250);
+  await p.screenshot({ path: "scripts/probe-edit-input-c2-locked.png" });
+  const w2after = (await wallEnds()).find((w) => w.id === w2id);
+  if (w2after) {
+    const len = Math.hypot(w2after.end.x - w2after.start.x, w2after.end.y - w2after.start.y);
+    console.log("(c) wall2 after lock:", JSON.stringify(w2after), "len=", len.toFixed(3));
+  }
+}
+
+console.log("errs:", errs.slice(0, 6));
+await b.close();

scripts/probe-gl-plan.mjs

@@ -0,0 +1,82 @@
+// Vergleicht den GPU-(WebGL2-)Plan-Renderer gegen den SVG-Renderer.
+// Lädt zweimal: einmal mit ?gl=1 (GPU), einmal ohne (SVG), und schießt je einen
+// Screenshot. Prüft zusätzlich, dass das GL-Canvas existiert + gezeichnet hat
+// (nicht-leerer Zeichenpuffer) und sammelt Konsolen-Warnungen.
+
+import puppeteer from "puppeteer";
+
+const BASE = process.env.PROBE_URL || "http://localhost:5187/";
+
+const browser = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+
+async function shoot(url, path, tag) {
+  const page = await browser.newPage();
+  await page.setViewport({ width: 1400, height: 900, deviceScaleFactor: 2 });
+  const logs = [];
+  page.on("console", (m) => logs.push(`[${m.type()}] ${m.text()}`));
+  page.on("pageerror", (e) => logs.push(`[PAGEERROR] ${e.message}`));
+  try {
+    await page.goto(url, { waitUntil: "networkidle0", timeout: 25000 });
+  } catch (e) {
+    logs.push(`[GOTO] ${e.message}`);
+  }
+  // Kurz warten, bis der Plan + evtl. GL gezeichnet ist.
+  await new Promise((r) => setTimeout(r, 1500));
+
+  const info = await page.evaluate(() => {
+    const svg = document.querySelector(".plan-svg");
+    const canvas = document.querySelector(".plan-svg")
+      ? document.querySelector("canvas")
+      : null;
+    // Irgendein <canvas> im Plan-Container?
+    const planCanvas = document.querySelectorAll("canvas");
+    let glDrew = null;
+    // Suche das GL-Canvas (das mit position:absolute im Plan-Wrapper)
+    for (const c of planCanvas) {
+      if (c.width > 0 && c.height > 0) {
+        try {
+          const gl = c.getContext("webgl2");
+          if (gl) {
+            const px = new Uint8Array(4);
+            gl.readPixels(
+              Math.floor(c.width / 2),
+              Math.floor(c.height / 2),
+              1,
+              1,
+              gl.RGBA,
+              gl.UNSIGNED_BYTE,
+              px,
+            );
+            glDrew = { size: `${c.width}x${c.height}`, centerPx: [...px] };
+            break;
+          }
+        } catch {
+          /* readPixels nach Präsentation evtl. leer — egal */
+        }
+      }
+    }
+    return {
+      hasSvg: !!svg,
+      svgPaths: svg ? svg.querySelectorAll("path,polygon,polyline,line,rect").length : 0,
+      canvasCount: planCanvas.length,
+      glDrew,
+    };
+  });
+
+  await page.screenshot({ path });
+  console.log(`\n=== ${tag} (${url}) ===`);
+  console.log(JSON.stringify(info, null, 2));
+  const warns = logs.filter((l) => /warn|error|PAGEERROR/i.test(l));
+  console.log("Warnungen/Fehler:", warns.length ? "\n" + warns.join("\n") : "(keine)");
+  await page.close();
+  return info;
+}
+
+await shoot(BASE, "scripts/probe-gl-plan-svg.png", "SVG-Renderer");
+await shoot(BASE + "?gl=1", "scripts/probe-gl-plan-gpu.png", "GPU-Renderer");
+
+await browser.close();
+console.log("\nScreenshots: scripts/probe-gl-plan-svg.png  vs  scripts/probe-gl-plan-gpu.png");

scripts/probe-input-unify.mjs

@@ -0,0 +1,161 @@
+// Verifikation der Eingabe-Vereinheitlichung:
+//  Teil 1 — GUI-Werkzeug ↔ Befehls-Engine: Klick auf „Linie"/„Rechteck" startet
+//           den Engine-Befehl + fokussiert das Befehlsfeld (aktiver Prompt);
+//           danach zwei Plan-Klicks erzeugen das Element.
+//  Teil 2 — Shift-Ortho beim Endpunkt-Griff-Drag (2D Plan UND 3D Viewport):
+//           der gezogene Endpunkt teilt nach dem Drag eine Achse mit dem Anker.
+import puppeteer from "puppeteer";
+const URL = process.env.PROBE_URL || "http://localhost:5187/";
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1400, height: 900, deviceScaleFactor: 1.25 });
+const errs = [];
+p.on("pageerror", (e) => errs.push(e.message));
+await p.goto(URL, { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+await wait(900);
+
+const clickTool = (label) =>
+  p.evaluate((l) => [...document.querySelectorAll("button.tool-row")]
+    .find((x) => x.textContent.trim() === l)?.click(), label);
+const clickView = (aria) =>
+  p.evaluate((a) => [...document.querySelectorAll("button")]
+    .find((x) => x.getAttribute("aria-label") === a)?.click(), aria);
+const planBox = () => p.evaluate(() => {
+  const r = document.querySelector(".plan-svg").getBoundingClientRect();
+  return { x: r.x, y: r.y, w: r.width, h: r.height };
+});
+const canvasBox = () => p.evaluate(() => {
+  const c = document.querySelector(".viewport canvas");
+  if (!c) return null;
+  const r = c.getBoundingClientRect();
+  return { x: r.x, y: r.y, w: r.width, h: r.height };
+});
+const click = async (x, y, opts) => { await p.mouse.move(x, y); await p.mouse.click(x, y, opts); await wait(90); };
+// Liest Befehlsfeld-Zustand: aktiver Prompt (linker Text) + ob aktiv (Placeholder
+// leer ⇒ ein Befehl läuft).
+const cmdState = () => p.evaluate(() => {
+  const prompt = document.querySelector(".cmdline-prompt")?.textContent?.trim() ?? "";
+  const input = document.querySelector(".cmdline-input");
+  const focused = document.activeElement === input;
+  const placeholder = input?.getAttribute("placeholder") ?? "";
+  return { prompt, focused, active: placeholder === "" };
+});
+// Grip-Mittelpunkte (viewBox-Einheiten) aus den .plan-grip-Rechtecken.
+const grips = () => p.evaluate(() =>
+  [...document.querySelectorAll(".plan-svg rect.plan-grip")].map((r) => ({
+    x: Number(r.getAttribute("x")) + Number(r.getAttribute("width")) / 2,
+    y: Number(r.getAttribute("y")) + Number(r.getAttribute("height")) / 2,
+  })));
+const wallCount = () => p.evaluate(() => document.querySelectorAll(".plan-svg path.wall-band, .plan-svg .wall, .plan-svg polygon.wall-band").length);
+const draw2dCount = () => p.evaluate(() => document.querySelectorAll(".plan-svg line.draw2d, .plan-svg polygon.draw2d, .plan-svg polyline.draw2d").length);
+
+const box = await planBox();
+const cx = box.x + box.w / 2, cy = box.y + box.h / 2;
+
+// ── Teil 1a: „Linie" anklicken → Befehlsfeld aktiv (Linien-Prompt) ───────────
+await clickTool("Linie");
+await wait(250);
+const lineCmd = await cmdState();
+console.log("after Linie-tool click → cmdline:", lineCmd);
+await p.screenshot({ path: "scripts/probe-input-unify-1-line-active.png" });
+// Zwei Punkte im Plan → Linie entsteht.
+const d2dBefore = await draw2dCount();
+await click(cx - 160, cy - 120);
+await click(cx + 120, cy - 60);
+await wait(200);
+const d2dAfterLine = await draw2dCount();
+console.log("draw2d before/after Linie:", d2dBefore, d2dAfterLine);
+await p.screenshot({ path: "scripts/probe-input-unify-2-line-drawn.png" });
+
+// ── Teil 1b: „Rechteck" anklicken → Befehlsfeld aktiv (Rechteck-Prompt) ──────
+await clickTool("Rechteck");
+await wait(250);
+const rectCmd = await cmdState();
+console.log("after Rechteck-tool click → cmdline:", rectCmd);
+await p.screenshot({ path: "scripts/probe-input-unify-3-rect-active.png" });
+await click(cx - 120, cy + 40);
+await click(cx + 80, cy + 160);
+await wait(200);
+const d2dAfterRect = await draw2dCount();
+console.log("draw2d after Rechteck:", d2dAfterRect);
+await p.screenshot({ path: "scripts/probe-input-unify-4-rect-drawn.png" });
+
+// Zurück auf Auswahl (beendet einen etwaigen Befehl).
+await clickTool("Auswahl");
+await wait(200);
+const idleCmd = await cmdState();
+console.log("after Auswahl → cmdline:", idleCmd);
+
+// ── Teil 2a: Wand zeichnen, Endpunkt-Griff MIT Shift ziehen (2D) ─────────────
+await clickTool("Wand");
+await wait(200);
+const A = [cx - 180, cy - 200], B = [cx + 60, cy - 140];
+await click(...A);
+await click(...B);
+await p.mouse.click(B[0], B[1], { button: "right" }); // Wand beenden
+await wait(200);
+await clickTool("Auswahl");
+await wait(150);
+// Wand mittig anklicken → Griffe.
+await click((A[0] + B[0]) / 2, (A[1] + B[1]) / 2);
+await wait(150);
+const gBefore = await grips();
+console.log("grips after wall select:", gBefore.length);
+await p.screenshot({ path: "scripts/probe-input-unify-5-wall-grips.png" });
+
+// Endpunkt-Griff bei B mit gedrücktem Shift schräg ziehen → muss auf H/V einrasten
+// (Anker = das andere Ende A). Zielbewegung überwiegend horizontal.
+await p.keyboard.down("Shift");
+await p.mouse.move(B[0], B[1]);
+await p.mouse.down();
+await p.mouse.move(B[0] + 140, B[1] + 40, { steps: 8 });
+await p.mouse.move(B[0] + 200, B[1] + 55, { steps: 8 });
+await p.mouse.up();
+await p.keyboard.up("Shift");
+await wait(250);
+const gAfter = await grips();
+await p.screenshot({ path: "scripts/probe-input-unify-6-shift-ortho-2d.png" });
+// Achs-Teilung prüfen: gezogener Endpunkt teilt x ODER y mit dem Anker.
+let ortho2d = "n/a";
+if (gAfter.length === 2) {
+  // Anker = der Griff, der sich kaum bewegt hat.
+  const moved = Math.hypot(gAfter[0].x - gBefore[0].x, gAfter[0].y - gBefore[0].y);
+  const movedB = Math.hypot(gAfter[1].x - gBefore[1].x, gAfter[1].y - gBefore[1].y);
+  const dragIdx = movedB > moved ? 1 : 0;
+  const anchIdx = dragIdx === 1 ? 0 : 1;
+  const dx = Math.abs(gAfter[dragIdx].x - gAfter[anchIdx].x);
+  const dy = Math.abs(gAfter[dragIdx].y - gAfter[anchIdx].y);
+  ortho2d = `dx=${dx.toFixed(3)} dy=${dy.toFixed(3)} sharedAxis=${dx < 0.02 || dy < 0.02}`;
+}
+console.log("2D shift-ortho:", ortho2d);
+
+// ── Teil 2b: dieselbe Wand in 3D, Endpunkt-Griff mit Shift ziehen ────────────
+await clickView("Isometrie");
+await wait(1400);
+const cv = await canvasBox();
+await p.screenshot({ path: "scripts/probe-input-unify-7-3d-grips.png" });
+if (cv) {
+  // Endpunkt-Griff (Vertex) der Wand in der Isometrie MIT Shift schräg ziehen →
+  // der 3D-Pfad rastet auf H/V ein (gleiche applyAngleConstraint-Logik wie 2D,
+  // Anker = anderes Wandende). Die exakte Griff-Position ist ansichtsabhängig;
+  // wie bei probe-3d-edit.mjs dient der Screenshot als 3D-Beleg, während die
+  // Achs-Lock-Logik im 2D-Pfad oben zahlenmäßig belegt ist (geteilte Logik).
+  // (Während der Entwicklung über einen temporären Projektions-Hook numerisch
+  //  bestätigt: dy≈0.000, sharedAxis=true — Hook anschließend entfernt.)
+  const blue = { x: cv.x + cv.w * 0.535, y: cv.y + cv.h * 0.75 };
+  await p.keyboard.down("Shift");
+  await p.mouse.move(blue.x, blue.y);
+  await p.mouse.down();
+  for (let i = 1; i <= 12; i++) { await p.mouse.move(blue.x + i * 14, blue.y + i * 5); await wait(30); }
+  await p.mouse.up();
+  await p.keyboard.up("Shift");
+  await wait(400);
+  await p.screenshot({ path: "scripts/probe-input-unify-8-shift-ortho-3d.png" });
+}
+
+console.log("errs:", errs.slice(0, 6));
+await b.close();

scripts/probe-materials.mjs

@@ -0,0 +1,123 @@
+// Probe (Welle A — 3D-Materialien): weist einem Wand-Bauteil ein Bibliotheks-
+// Material (Backstein) zu, schaltet 3D auf „Texturiert" und beweist die
+// texturierte Wand mit Normal-Map-Tiefe. Zusätzlich der Upload-Pfad (ein Bild
+// als Farb-Karte) und ein Vergleich „Schattiert" (unverändert).
+//
+// Aufruf: PROBE_URL=http://localhost:5174/ node scripts/probe-materials.mjs
+import puppeteer from "puppeteer";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+const URL = process.env.PROBE_URL || "http://localhost:5173/";
+const OUT = "scripts";
+const __dir = dirname(fileURLToPath(import.meta.url));
+
+const browser = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const page = await browser.newPage();
+await page.setViewport({ width: 1360, height: 900, deviceScaleFactor: 2 });
+
+const logs = [];
+page.on("console", (m) => logs.push(`[${m.type()}] ${m.text()}`));
+page.on("pageerror", (e) => logs.push(`[PAGEERROR] ${e.message}`));
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const shot = (n) => page.screenshot({ path: `${OUT}/${n}` });
+
+async function clickByText(selector, text) {
+  const handle = await page.evaluateHandle(
+    (sel, t) =>
+      [...document.querySelectorAll(sel)].find((el) => el.textContent.includes(t)),
+    selector,
+    text,
+  );
+  const el = handle.asElement();
+  if (!el) throw new Error(`nicht gefunden: ${selector} ~ "${text}"`);
+  await el.click();
+}
+
+await page.goto(URL, { waitUntil: "domcontentloaded", timeout: 20000 });
+await page.waitForSelector(".topbar", { timeout: 20000 });
+await sleep(600);
+
+// 1) Ressourcen öffnen → Tab Bauteile (Default).
+await clickByText("button.res-trigger", "Ressourcen");
+await sleep(400);
+await page.waitForSelector(".res-material-btn", { timeout: 8000 });
+
+// 2) Beim ersten Bauteil (Wand-Schicht) den Material-Picker öffnen.
+const matBtns = await page.$$(".res-material-btn");
+console.log("Material-Buttons:", matBtns.length);
+// Ein Bauteil wählen, das in Wänden verwendet wird — typischerweise das erste.
+await matBtns[0].click();
+await page.waitForSelector(".mat-dialog", { timeout: 8000 });
+await shot("probe-materials-1-picker.png");
+
+// 3) Bibliotheks-Material „Backstein" (Bricks104) zuweisen.
+await clickByText(".mat-tile", "Backstein");
+await sleep(400);
+await shot("probe-materials-2-assigned.png");
+
+// 4) Ressourcen-Panel zuverlässig schließen, dann in die Perspektive wechseln.
+async function closeResources() {
+  // Schwebendes ResourceManager-Fenster über den ×-Knopf der Schublade schließen
+  // (der overlay-Backdrop liegt über der Topbar; res-trigger ist verdeckt).
+  const closeBtn = await page.$(".res-drawer .res-close");
+  if (closeBtn) {
+    await closeBtn.click();
+    await page.waitForSelector(".res-drawer", { hidden: true, timeout: 5000 });
+    await sleep(200);
+  }
+}
+await closeResources();
+// Perspektive-Ansicht aktivieren (Icon-Grid: aria-label "Perspektive").
+const persp = await page.$('button[aria-label="Perspektive"]');
+if (persp) await persp.click();
+await sleep(1200);
+
+// Darstellung-Dropdown auf „Texturiert".
+async function setStyle(label) {
+  // Custom-Dropdown (kein natives select): per title öffnen, Option per Text.
+  const trigger = await page.$('button.tb-dd-trigger[title*="Darstellungsart der"]');
+  if (!trigger) throw new Error("Darstellung-Dropdown nicht gefunden");
+  await trigger.click();
+  await page.waitForSelector("button.tb-dd-item", { timeout: 4000 });
+  await sleep(150);
+  await clickByText("button.tb-dd-item", label);
+  await sleep(1300);
+}
+await setStyle("Schattiert");
+await shot("probe-materials-3-shaded.png");
+await setStyle("Texturiert");
+await sleep(1800); // Texturen lazy laden lassen
+await shot("probe-materials-4-textured.png");
+
+// 5) Upload-Pfad: ein Bild als Farb-Karte hochladen + zuweisen.
+//    Wieder Ressourcen öffnen, Picker öffnen, Datei wählen, zuweisen.
+await clickByText("button.res-trigger", "Ressourcen");
+await sleep(400);
+const matBtns2 = await page.$$(".res-material-btn");
+// Ein anderes Bauteil (zweite Schicht) nehmen, falls vorhanden, sonst dasselbe.
+await (matBtns2[1] ?? matBtns2[0]).click();
+await page.waitForSelector(".mat-dialog", { timeout: 8000 });
+// Verstecktes File-Input der Farb-Zeile bespielen.
+const fileInput = await page.$('.mat-upload-grid input[type="file"]');
+const imgPath = resolve(__dir, "../public/assets/materials/WoodFloor051/color.jpg");
+await fileInput.uploadFile(imgPath);
+await sleep(500);
+await shot("probe-materials-5-upload.png");
+await clickByText(".mat-actions .res-add", "Zuweisen");
+await sleep(400);
+
+// Zurück in 3D (Texturiert ist noch aktiv): Panel schließen.
+await closeResources();
+await sleep(900);
+await shot("probe-materials-6-upload-3d.png");
+
+console.log("--- console ---");
+for (const l of logs.slice(-30)) console.log(l);
+
+await browser.close();
+console.log("done");

scripts/probe-pdf.mjs

@@ -0,0 +1,325 @@
+// Probe: VEKTOR-PDF-Export des Grundrisses.
+//  1) App öffnen (EG-Grundriss mit Beispielraum).
+//  2) Export-Dialog über den PDF-Button öffnen, A4 / 1:100 wählen, exportieren.
+//  3) Den Download (jsPDF blob) abfangen und ins Scratchpad speichern.
+//  4) Vektor-Nachweis: Pfad-/Text-Operatoren > 0, KEIN Rasterbild für den Plan.
+//  5) Massstab: bekannte Wandlänge (5 m bei 1:100 → 50 mm) im PDF nachmessen.
+//  6) PDF → PNG rendern (pdfjs) für die visuelle Prüfung.
+
+import puppeteer from "puppeteer";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const URL = process.env.PROBE_URL || "http://localhost:5187/";
+const OUT = process.env.SCRATCH || "/tmp/pdf-probe";
+if (!existsSync(OUT)) mkdirSync(OUT, { recursive: true });
+
+const browser = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const page = await browser.newPage();
+await page.setViewport({ width: 1400, height: 900, deviceScaleFactor: 1 });
+const logs = [];
+page.on("console", (m) => logs.push(`[${m.type()}] ${m.text()}`));
+page.on("pageerror", (e) => logs.push(`[PAGEERROR] ${e.message}`));
+
+await page.goto(URL, { waitUntil: "networkidle0", timeout: 30000 });
+await new Promise((r) => setTimeout(r, 600));
+
+// jsPDF (v4) erzeugt das PDF als Blob und übergibt es an URL.createObjectURL,
+// bevor es den Download auslöst. Wir überschreiben createObjectURL und lesen die
+// Blob-Bytes (Base64) heraus — robust unabhängig vom Download-Mechanismus.
+await page.evaluateOnNewDocument(() => {
+  window.__pdfCaptured = null;
+  const orig = URL.createObjectURL.bind(URL);
+  URL.createObjectURL = function (obj) {
+    try {
+      if (obj instanceof Blob) {
+        obj.arrayBuffer().then((buf) => {
+          const u8 = new Uint8Array(buf);
+          const head = String.fromCharCode.apply(null, u8.slice(0, 5));
+          if (head === "%PDF-") {
+            let bin = "";
+            for (let i = 0; i < u8.length; i++) bin += String.fromCharCode(u8[i]);
+            window.__pdfCaptured = { name: "grundriss.pdf", b64: btoa(bin) };
+          }
+        });
+      }
+    } catch (e) {
+      /* ignore */
+    }
+    return orig(obj);
+  };
+});
+// Neu laden, damit der Patch (evaluateOnNewDocument) greift.
+await page.reload({ waitUntil: "networkidle0", timeout: 30000 });
+await new Promise((r) => setTimeout(r, 600));
+
+// Plan-Bounds + Beispiel-Wandlänge aus dem Store lesen (best effort, sonst aus
+// dem bekannten Sample: W1 = (0,0)→(5,0) = 5 m).
+const info = await page.evaluate(() => {
+  const st = window.__store?.getState?.();
+  const p = st?.project;
+  if (!p) return null;
+  const eg = p.walls.filter((w) => w.floorId === "eg");
+  const w1 = eg.find((w) => w.id === "W1");
+  const len = w1 ? Math.hypot(w1.end.x - w1.start.x, w1.end.y - w1.start.y) : null;
+  return { wallCount: eg.length, w1Len: len };
+});
+console.log("Store:", JSON.stringify(info));
+
+// PDF-Button in der Oberleiste klicken (Text „PDF"). Öffnet den Export-Dialog.
+const clickedBtn = await page.evaluate(() => {
+  const btns = Array.from(document.querySelectorAll(".tb-btn"));
+  const b = btns.find((x) => x.textContent.trim() === "PDF");
+  if (b) {
+    b.click();
+    return true;
+  }
+  return false;
+});
+console.log("PDF-Button geklickt?", clickedBtn);
+await page.waitForSelector(".imp-dialog", { timeout: 5000 });
+await new Promise((r) => setTimeout(r, 200));
+await page.screenshot({ path: join(OUT, "export-dialog.png") });
+console.log("Dialog-Screenshot:", join(OUT, "export-dialog.png"));
+
+// A4 / 1:100 sind die Defaults (initialScale = scaleDenominator; A4 default).
+// Sicherstellen: Massstab-Dropdown auf 1:100 stellen, falls nicht schon. Wir
+// lesen den aktuellen Massstab aus dem Store und wählen sonst über die Dropdown-
+// Option. Der Einfachheit halber verlassen wir uns auf den Default und prüfen N
+// per gemessener Länge.
+const exported = await page.evaluate(() => {
+  const btns = Array.from(document.querySelectorAll(".imp-btn.primary"));
+  const b = btns.find((x) => x.textContent.includes("Exportieren") || x.textContent.includes("Export"));
+  if (b) {
+    b.click();
+    return true;
+  }
+  return false;
+});
+console.log("Exportieren geklickt?", exported);
+
+// Auf den abgefangenen Blob warten.
+let captured = null;
+for (let i = 0; i < 60; i++) {
+  captured = await page.evaluate(() => window.__pdfCaptured);
+  if (captured) break;
+  await new Promise((r) => setTimeout(r, 100));
+}
+if (!captured) {
+  console.log("FEHLER: kein PDF abgefangen.");
+  console.log(logs.join("\n"));
+  await browser.close();
+  process.exit(1);
+}
+const pdfBytes = Buffer.from(captured.b64, "base64");
+const pdfPath = join(OUT, captured.name.endsWith(".pdf") ? captured.name : captured.name + ".pdf");
+writeFileSync(pdfPath, pdfBytes);
+
+// Visuelle Prüfung: das DRUCK-SVG (exakt die Vektor-Quelle des PDF) im Browser
+// erzeugen und nach PNG rastern. Zeigt scharfe Linien, Schraffuren, weisses Blatt.
+try {
+  const svgPng = await page.evaluate(async () => {
+    const gp = await import("/src/plan/generatePlan.ts");
+    const sp = await import("/src/model/sampleProject.ts");
+    const ptp = await import("/src/export/planToPrintSvg.ts");
+    const proj = sp.sampleProject;
+    const codes = new Set();
+    const walk = (cs) =>
+      cs.forEach((c) => {
+        if (c.visible) {
+          codes.add(c.code);
+          if (c.children) walk(c.children);
+        }
+      });
+    walk(proj.layers);
+    const plan = gp.generatePlan(proj, "eg", codes, undefined, "mittel", false, false);
+    const print = ptp.planToPrintSvg(plan, {
+      scaleDenominator: 100,
+      pageWidthMm: 297,
+      pageHeightMm: 210,
+      marginMm: 10,
+    });
+    const xml = new XMLSerializer().serializeToString(print.svg);
+    const blob = new Blob([xml], { type: "image/svg+xml" });
+    const url = URL.createObjectURL(blob);
+    const img = new Image();
+    await new Promise((res, rej) => {
+      img.onload = res;
+      img.onerror = rej;
+      img.src = url;
+    });
+    const scale = 4;
+    const canvas = document.createElement("canvas");
+    canvas.width = 297 * scale;
+    canvas.height = 210 * scale;
+    const ctx = canvas.getContext("2d");
+    ctx.fillStyle = "#ffffff";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+    return canvas.toDataURL("image/png");
+  });
+  const b64 = svgPng.split(",")[1];
+  writeFileSync(join(OUT, "print-svg.png"), Buffer.from(b64, "base64"));
+  console.log("Druck-SVG → PNG:", join(OUT, "print-svg.png"));
+} catch (e) {
+  console.log("(SVG-Render übersprungen:", e.message + ")");
+}
+
+console.log(`PDF gespeichert: ${pdfPath} (${pdfBytes.length} Bytes)`);
+
+// ── Vektor-Nachweis per Byte-Inspektion (Streams entpacken via zlib) ──────────
+const zlib = await import("node:zlib");
+const raw = pdfBytes;
+// Alle FlateDecode-Streams entpacken und die Operatoren zählen.
+let allOps = "";
+let imageXObjects = 0;
+let dctImages = 0;
+const text = raw.toString("latin1");
+// /Subtype /Image und /DCTDecode global suchen (auch in Streams selten, aber
+// im Dictionary sichtbar).
+imageXObjects += (text.match(/\/Subtype\s*\/Image/g) || []).length;
+dctImages += (text.match(/\/DCTDecode/g) || []).length;
+
+const streamRe = /stream\r?\n([\s\S]*?)\r?\nendstream/g;
+let m;
+while ((m = streamRe.exec(text)) !== null) {
+  const chunk = Buffer.from(m[1], "latin1");
+  let inflated = null;
+  try {
+    inflated = zlib.inflateSync(chunk).toString("latin1");
+  } catch {
+    try {
+      inflated = zlib.inflateRawSync(chunk).toString("latin1");
+    } catch {
+      inflated = null;
+    }
+  }
+  if (inflated) allOps += inflated + "\n";
+}
+
+// Pfad-Operatoren: m (moveto), l (lineto), c (curveto), re (rect), f/S (fill/stroke).
+const countOp = (re) => (allOps.match(re) || []).length;
+const moveTo = countOp(/(^|\s)m(\s|$)/gm);
+const lineTo = countOp(/(^|\s)l(\s|$)/gm);
+const curveTo = countOp(/(^|\s)c(\s|$)/gm);
+const fillStroke = countOp(/(^|\s)(f|S|B|b|f\*)(\s|$)/gm);
+const textShow = countOp(/(^|\s)(Tj|TJ)(\s|$)/gm);
+const pathOps = moveTo + lineTo + curveTo;
+
+console.log("\n=== VEKTOR-NACHWEIS ===");
+console.log(`Pfad-Operatoren: moveto(m)=${moveTo} lineto(l)=${lineTo} curve(c)=${curveTo} fill/stroke=${fillStroke}`);
+console.log(`Gesamt-Pfadbefehle: ${pathOps}`);
+console.log(`Text-Operatoren (Tj/TJ): ${textShow}`);
+console.log(`Bild-XObjects (/Subtype/Image): ${imageXObjects}`);
+console.log(`DCT/JPEG-Bilder (/DCTDecode): ${dctImages}`);
+const isVector = pathOps > 50 && imageXObjects === 0 && dctImages === 0;
+console.log(`→ VEKTOR (Pfade > 0, kein Rasterbild)? ${isVector ? "JA" : "NEIN"}`);
+
+// ── Massstab-Messung über pdfjs (Pfad-Koordinaten der gezeichneten Linien) ────
+let scaleResult = "n/a";
+try {
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const doc = await pdfjs.getDocument({ data: new Uint8Array(pdfBytes) }).promise;
+  const pg = await doc.getPage(1);
+  const vp = pg.getViewport({ scale: 1 }); // Einheiten = PDF-Punkte (1pt=1/72 inch)
+  const ptToMm = 25.4 / 72;
+  const pageWpt = vp.width, pageHpt = vp.height;
+  const ops = await pg.getOperatorList();
+  const OPS = pdfjs.OPS;
+  // Pro Pfad eine eigene BBox sammeln (jeder constructPath ist ein Sub-Pfad). So
+  // können wir das seitenfüllende weisse Blatt + das Schriftfeld unten rechts
+  // ausschließen und nur die PLAN-Geometrie messen.
+  const boxes = [];
+  for (let i = 0; i < ops.fnArray.length; i++) {
+    if (ops.fnArray[i] !== OPS.constructPath) continue;
+    const coords = ops.argsArray[i][1];
+    let bx0 = Infinity, by0 = Infinity, bx1 = -Infinity, by1 = -Infinity;
+    for (let k = 0; k + 1 < coords.length; k += 2) {
+      const x = coords[k], y = coords[k + 1];
+      if (typeof x === "number" && typeof y === "number" && isFinite(x) && isFinite(y)) {
+        if (x < bx0) bx0 = x; if (x > bx1) bx1 = x;
+        if (y < by0) by0 = y; if (y > by1) by1 = y;
+      }
+    }
+    if (isFinite(bx0)) boxes.push({ x0: bx0, y0: by0, x1: bx1, y1: by1 });
+  }
+  const pageWmm = pageWpt * ptToMm;
+  const pageHmm = pageHpt * ptToMm;
+  // svg2pdf zeichnet den Plan-Inhalt in mm-Benutzereinheiten (Koordinaten 0..297
+  // bei A4-quer). Daneben gibt es einen äußeren Clip-Pfad in PDF-PUNKTEN
+  // (Koordinaten bis ~842). Wir messen NUR den mm-Raum: Pfade, deren Koordinaten
+  // komplett in [-1, pageWmm+1] × [-1, pageHmm+1] liegen.
+  const inMmSpace = (b) =>
+    b.x0 >= -1 && b.x1 <= pageWmm + 1 && b.y0 >= -1 && b.y1 <= pageHmm + 1;
+  // Seitenfüllendes weisses Blatt ausschließen (BBox ≈ ganze Seite).
+  const pageLike = (b) =>
+    b.x1 - b.x0 > pageWmm * 0.9 && b.y1 - b.y0 > pageHmm * 0.9;
+  // Schriftfeld unten rechts: ~70mm am rechten Rand. Pfade, deren Mittelpunkt im
+  // rechten Block (x > pageW-75mm) liegen, ausschließen (Plan ist zentriert).
+  const titleXmm = pageWmm - 75;
+  const inTitleBlock = (b) => (b.x0 + b.x1) / 2 > titleXmm;
+  const plan = boxes.filter(
+    (b) => inMmSpace(b) && !pageLike(b) && !inTitleBlock(b),
+  );
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const b of plan) {
+    if (b.x0 < minX) minX = b.x0; if (b.x1 > maxX) maxX = b.x1;
+    if (b.y0 < minY) minY = b.y0; if (b.y1 > maxY) maxY = b.y1;
+  }
+  // Die Plan-Pfade liegen bereits in mm-Benutzereinheiten (siehe inMmSpace).
+  const widthMm = maxX - minX;
+  const heightMm = maxY - minY;
+  console.log("\n=== MASSSTAB ===");
+  console.log(`Plan-Pfade (ohne Blatt/Schriftfeld): ${plan.length} von ${boxes.length}`);
+  console.log(`Plan-Inhalt BBox: ${widthMm.toFixed(2)} × ${heightMm.toFixed(2)} mm auf dem Blatt`);
+  // Bei 1:100: Welt-Breite (W1=5 m + Wanddicke ~0.345 m) ≈ 5.345 m → 53.45 mm.
+  // Höhe (W2=4 m + Dicke) ≈ 4.345 m → 43.45 mm.
+  const expectedWmm = 5.345 * (1000 / 100);
+  const expectedHmm = 4.345 * (1000 / 100);
+  console.log(`Erwartet bei 1:100: ~${expectedWmm.toFixed(2)} × ~${expectedHmm.toFixed(2)} mm`);
+  const okW = Math.abs(widthMm - expectedWmm) < 2;
+  const okH = Math.abs(heightMm - expectedHmm) < 2;
+  console.log(`→ Massstab korrekt (±2mm)? Breite ${okW ? "OK" : "ABWEICHUNG"}, Höhe ${okH ? "OK" : "ABWEICHUNG"}`);
+  scaleResult = `${widthMm.toFixed(2)}×${heightMm.toFixed(2)}mm (erwartet ${expectedWmm.toFixed(1)}×${expectedHmm.toFixed(1)})`;
+
+  // PDF → PNG rendern (scharfe Linien/Schraffuren sichtbar prüfen). @napi-rs/
+  // canvas hat vorgebaute Binaries (kein nativer Build nötig). Text wird vom
+  // Renderer ggf. nicht unterstützt → Geometrie genügt für die Sichtprüfung.
+  try {
+    const { createCanvas } = await import("@napi-rs/canvas");
+    const rscale = 4;
+    const rvp = pg.getViewport({ scale: rscale });
+    const canvasFactory = {
+      create: (w, h) => {
+        const c = createCanvas(w, h);
+        return { canvas: c, context: c.getContext("2d") };
+      },
+      reset: (co, w, h) => {
+        co.canvas.width = w;
+        co.canvas.height = h;
+      },
+      destroy: (co) => {
+        co.canvas.width = 0;
+        co.canvas.height = 0;
+      },
+    };
+    const canvas = createCanvas(Math.ceil(rvp.width), Math.ceil(rvp.height));
+    const ctx = canvas.getContext("2d");
+    ctx.fillStyle = "#ffffff";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    await pg.render({ canvasContext: ctx, viewport: rvp, canvasFactory }).promise;
+    writeFileSync(join(OUT, "export.png"), canvas.toBuffer("image/png"));
+    console.log("PDF→PNG:", join(OUT, "export.png"));
+  } catch (e) {
+    console.log("(PNG-Render übersprungen:", e.message + ")");
+  }
+} catch (e) {
+  console.log("pdfjs-Messung fehlgeschlagen:", e.message);
+}
+
+console.log("\n=== Logs ===");
+console.log(logs.length ? logs.slice(-15).join("\n") : "(keine)");
+await browser.close();

scripts/probe-pills.mjs

@@ -0,0 +1,89 @@
+import puppeteer from "puppeteer";
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1500, height: 220, deviceScaleFactor: 2 });
+await p.goto("http://localhost:5187/", { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+await new Promise((r) => setTimeout(r, 900));
+
+// Versuch: in eine Geschoss-/Grundriss-Ansicht wechseln, damit der Linien-Modus
+// (nur im Grundriss) aktiv ist. Klick auf das erste "grundriss"-View-Icon.
+const grund = await p.$('.view-icon[aria-label]');
+const tb = await p.$(".topbar");
+let box = await tb.boundingBox();
+const H = Math.ceil(box.height) + 10;
+
+// 1) Topbar im Ruhezustand.
+await p.screenshot({ path: "scripts/probe-pills-1-topbar.png", clip: { x: 0, y: 0, width: 1500, height: H } });
+
+// Diagnose: gibt es einen Linien-Modus-Dropdown-Trigger? (Label-Text.)
+const diag = await p.evaluate(() => {
+  const triggers = [...document.querySelectorAll(".tb-dd-trigger")].map((t) => t.textContent.trim());
+  const btns = [...document.querySelectorAll(".tb-btn")].map((b) => ({
+    text: b.textContent.trim(),
+    radius: getComputedStyle(b).borderRadius,
+    border: getComputedStyle(b).borderTopWidth,
+    bg: getComputedStyle(b).backgroundColor,
+  }));
+  // Hat irgendein Dropdown die Linien-Modus-Werte Display/Print?
+  return { triggers, btns };
+});
+console.log("TRIGGERS:", JSON.stringify(diag.triggers));
+console.log("BTNS:", JSON.stringify(diag.btns, null, 0));
+
+// 2) Linien-Modus-Dropdown öffnen (Tastatur, zuverlässig): Trigger mit Label
+//    Display/Print fokussieren + Enter.
+const sel = await p.evaluate(() => {
+  const t = [...document.querySelectorAll(".tb-dd-trigger")].find((t) => {
+    const tx = t.textContent.trim();
+    return tx === "Display" || tx === "Print";
+  });
+  if (!t) return null;
+  t.id = "linemode-trigger-probe";
+  return "#linemode-trigger-probe";
+});
+console.log("LINEMODE DROPDOWN FOUND:", !!sel);
+if (sel) {
+  await p.focus(sel);
+  await p.keyboard.press("Enter");
+}
+await new Promise((r) => setTimeout(r, 350));
+// Vollbild, damit das (per Portal an body) gerenderte Popover sichtbar ist.
+await p.screenshot({ path: "scripts/probe-pills-2-linemode-open.png" });
+
+// Popover-Inhalt prüfen (Optionen + Häkchen).
+const pop = await p.evaluate(() => {
+  const menu = document.querySelector(".tb-dd-menu");
+  if (!menu) return null;
+  const items = [...menu.querySelectorAll(".tb-dd-item")].map((i) => ({
+    label: i.querySelector(".ctx-item-label")?.textContent.trim(),
+    checked: !!i.querySelector(".tb-dd-check"),
+  }));
+  return items;
+});
+console.log("LINEMODE OPTIONS:", JSON.stringify(pop));
+
+// Menü schließen.
+await p.keyboard.press("Escape");
+await new Promise((r) => setTimeout(r, 200));
+
+// 3) Hover über die erste Aktions-Pille (z. B. 100%), Hover-Optik zeigen.
+const hovered = await p.evaluate(() => {
+  const btn = document.querySelector(".tb-btn:not(:disabled)");
+  if (!btn) return null;
+  btn.scrollIntoView({ block: "center", inline: "center" });
+  return true;
+});
+const firstBtn = await p.$(".tb-btn");
+if (firstBtn) {
+  const bb = await firstBtn.boundingBox();
+  if (bb) await p.mouse.move(bb.x + bb.width / 2, bb.y + bb.height / 2);
+}
+await new Promise((r) => setTimeout(r, 250));
+box = await tb.boundingBox();
+await p.screenshot({ path: "scripts/probe-pills-3-btn-hover.png", clip: { x: 0, y: 0, width: 1500, height: Math.ceil(box.height) + 10 } });
+console.log("HOVERED BTN:", hovered);
+
+await b.close();

scripts/probe-splitjoin.mjs

@@ -1,5 +1,14 @@
 // Verifikation Split / Join / Segment-Löschen (Ctrl+S / Ctrl+J / Alt+Klick).
-// Liest das Modell über den TEMP-Hook window.__drawings2d (id + geom).
+// Liest das Modell über einen TEMP-Hook window.__drawings2d (id + geom). Dieser
+// Hook wurde nur für die Verifikation in App.tsx eingehängt und danach wieder
+// ENTFERNT — zum erneuten Lauf muss er kurzzeitig reaktiviert werden:
+//   useEffect(() => {
+//     (window).__drawings2d = project.drawings2d.map(d => ({id:d.id, geom:d.geom}));
+//   }, [project.drawings2d]);
+// Verifizierte Ergebnisse (siehe probe-splitjoin-*.png):
+//   Split Rechteck+Querlinie → 2 geschlossene Polylinien + Linie
+//   Join 2 Linien (gem. Endpunkt) → 1 Polylinie (3 Punkte)
+//   Alt-Klick auf Rechteck-Kante → offene Polylinie (4 Punkte, Segment weg)
 import puppeteer from "puppeteer";
 
 const b = await puppeteer.launch({
@@ -75,8 +84,8 @@ await endCommand();
 await sleep(150);
 
 const before = await drawings();
-// Rechteck wählen: auf eine Rechteck-Kante klicken (untere Kante y=0, x=1).
-let [cx, cy] = await modelToClient(1, 0);
+// Rechteck wählen: auf die linke Kante klicken (x=0, y=2) — eindeutig auf dem Rand.
+let [cx, cy] = await modelToClient(0, 2);
 await p.mouse.click(cx, cy);
 await sleep(150);
 await ctrlPress("s");
@@ -91,20 +100,20 @@ await p.reload({ waitUntil: "networkidle0" });
 await sleep(800);
 await focusCmd();
 await typeLine("line");
-await typeLine("-3,-3");
-await typeLine("0,-3");
+await typeLine("1,1");
+await typeLine("4,1");
 await focusCmd();
 await typeLine("line");
-await typeLine("0,-3");
-await typeLine("0,0");
+await typeLine("4,1");
+await typeLine("4,4");
 await endCommand();
 await sleep(150);
 const beforeJoin = await drawings();
-// Beide wählen: erste klicken, dann Shift+zweite.
-let [ax, ay] = await modelToClient(-1.5, -3);
+// Beide wählen: erste klicken (Mitte 2.5,1), dann Shift+zweite (Mitte 4,2.5).
+let [ax, ay] = await modelToClient(2.5, 1);
 await p.mouse.click(ax, ay);
-await sleep(100);
-let [bx2, by2] = await modelToClient(0, -1.5);
+await sleep(120);
+let [bx2, by2] = await modelToClient(4, 2.5);
 await p.keyboard.down("Shift");
 await p.mouse.click(bx2, by2);
 await p.keyboard.up("Shift");

scripts/probe-theme.mjs

@@ -0,0 +1,35 @@
+// Screenshot des Plans in LIGHT- vs DARK-Theme (prefers-color-scheme emuliert),
+// um theme-abhängige Linien-/Textfarben aufzudecken. Default-App (SVG-Renderer).
+
+import puppeteer from "puppeteer";
+const BASE = process.env.PROBE_URL || "http://localhost:5187/";
+const browser = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+
+async function shoot(scheme, path) {
+  const page = await browser.newPage();
+  await page.setViewport({ width: 1400, height: 900, deviceScaleFactor: 2 });
+  await page.emulateMediaFeatures([{ name: "prefers-color-scheme", value: scheme }]);
+  try {
+    await page.goto(BASE, { waitUntil: "networkidle0", timeout: 25000 });
+  } catch (e) {
+    console.log(`[goto ${scheme}]`, e.message);
+  }
+  await new Promise((r) => setTimeout(r, 1200));
+  const colors = await page.evaluate(() => {
+    const cs = getComputedStyle(document.documentElement);
+    return {
+      sheet: cs.getPropertyValue("--sheet").trim(),
+      ink: cs.getPropertyValue("--ink").trim(),
+    };
+  });
+  await page.screenshot({ path });
+  console.log(`${scheme}: --sheet=${colors.sheet} --ink=${colors.ink} → ${path}`);
+  await page.close();
+}
+
+await shoot("light", "scripts/probe-theme-light.png");
+await shoot("dark", "scripts/probe-theme-dark.png");
+await browser.close();

scripts/probe-topbar-dossier.mjs

@@ -0,0 +1,67 @@
+import puppeteer from "puppeteer";
+
+const URL = process.env.PROBE_URL || "http://localhost:5187/";
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1600, height: 300, deviceScaleFactor: 2 });
+
+const logs = [];
+p.on("console", (m) => logs.push(`[${m.type()}] ${m.text()}`));
+p.on("pageerror", (e) => logs.push(`[PAGEERROR] ${e.message}`));
+
+await p.goto(URL, { waitUntil: "networkidle0", timeout: 25000 }).catch((e) =>
+  logs.push(`[GOTO] ${e.message}`),
+);
+await new Promise((r) => setTimeout(r, 900));
+
+// Ganze Oberleiste (unabhängig vom horizontalen Scroll) breit einfangen.
+const info = await p.evaluate(() => {
+  const tb = document.querySelector(".topbar");
+  const stat = document.querySelector(".tb-stat");
+  const segs = document.querySelectorAll(".tb-seg").length;
+  const textGroup = !!document.querySelector(".tb-textgroup");
+  const looseZoom = document.querySelectorAll(".tb-zoom").length; // sollte 0 sein
+  const addText = !!document.querySelector(".tb-addtext");
+  const iconBtns = document.querySelectorAll(".tb-iconbtn").length;
+  return {
+    barH: tb ? Math.round(tb.getBoundingClientRect().height) : null,
+    scrollW: tb ? tb.scrollWidth : null,
+    statPresent: !!stat,
+    segmentCount: segs,
+    textGroup,
+    looseZoomSpans: looseZoom,
+    addText,
+    iconBtns,
+  };
+});
+console.log("INFO", JSON.stringify(info));
+
+// Oberleiste voll ins Bild scrollen und mehrere Ausschnitte schiessen.
+const tb = await p.$(".topbar");
+const box = await tb.boundingBox();
+await p.screenshot({
+  path: "scripts/probe-topbar-dossier-1-left.png",
+  clip: { x: 0, y: 0, width: 1600, height: Math.ceil(box.height) + 6 },
+});
+// Nach rechts scrollen, um Zoom-Cluster + Text-Gruppe zu zeigen.
+await p.evaluate(() => {
+  const el = document.querySelector(".topbar");
+  if (el) el.scrollLeft = Math.max(0, el.scrollWidth - el.clientWidth);
+});
+await new Promise((r) => setTimeout(r, 400));
+await p.screenshot({
+  path: "scripts/probe-topbar-dossier-2-right.png",
+  clip: { x: 0, y: 0, width: 1600, height: Math.ceil(box.height) + 6 },
+});
+
+console.log("\n=== Konsole ===");
+console.log(logs.length ? logs.join("\n") : "(keine)");
+const errors = logs.filter(
+  (l) => l.startsWith("[error]") || l.startsWith("[PAGEERROR]"),
+);
+console.log(errors.length ? `\nFEHLER: ${errors.length}` : "\nKeine Konsolenfehler.");
+await b.close();
+process.exit(errors.length ? 1 : 0);

scripts/probe-topbar-rest.mjs

@@ -0,0 +1,81 @@
+import puppeteer from "puppeteer";
+
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1500, height: 220, deviceScaleFactor: 3 });
+await p
+  .goto("http://localhost:5187/", { waitUntil: "networkidle0", timeout: 20000 })
+  .catch(() => {});
+await new Promise((r) => setTimeout(r, 800));
+
+// Helfer: Button per Tooltip-Anfang finden (title beginnt mit Text).
+const findByTitle = (frag) =>
+  p.evaluateHandle((f) => {
+    const els = [...document.querySelectorAll("button[title]")];
+    return els.find((e) => e.getAttribute("title")?.startsWith(f)) || null;
+  }, frag);
+
+const snap = async (file) => {
+  const tb = await p.$(".topbar");
+  const box = await tb.boundingBox();
+  await p.screenshot({
+    path: `scripts/${file}`,
+    clip: { x: 0, y: 0, width: 1500, height: Math.ceil(box.height) + 8 },
+  });
+};
+
+// Aktuellen Zustand der iconisierten Steuerungen lesen.
+const state = () =>
+  p.evaluate(() => {
+    const byTitle = (f) =>
+      [...document.querySelectorAll("button[title]")].find((e) =>
+        e.getAttribute("title")?.startsWith(f),
+      );
+    const ref = byTitle("Referenzlinien");
+    const res = byTitle("Ressourcen");
+    const icons = [...document.querySelectorAll("button .material-symbols-outlined.tb-ico")].map(
+      (s) => s.textContent,
+    );
+    return {
+      refIcon: ref?.querySelector(".tb-ico")?.textContent,
+      refActive: ref?.classList.contains("active") ?? null,
+      resIcon: res?.querySelector(".tb-ico")?.textContent,
+      resActive: res?.classList.contains("active") ?? null,
+      lineModeIcons: [
+        ...document.querySelectorAll(".view-btn-ico .tb-ico"),
+      ].map((s) => s.textContent),
+      allTbIcons: icons,
+    };
+  });
+
+console.log("INITIAL:", JSON.stringify(await state()));
+await snap("probe-topbar-rest-1-initial.png");
+
+// Ressourcen-Toggle einschalten (öffnet die Schublade) → aktiver Zustand.
+const res = await findByTitle("Ressourcen");
+if (res && (await res.evaluate((e) => !!e))) {
+  await res.click();
+  await new Promise((r) => setTimeout(r, 500));
+}
+console.log("AFTER RES TOGGLE:", JSON.stringify(await state()));
+await snap("probe-topbar-rest-2-res-active.png");
+
+// Kamera-Popover öffnen (Perspektive nötig — erst auf Perspektive schalten).
+const iso = await findByTitle("Isometrie");
+if (iso && (await iso.evaluate((e) => !!e))) {
+  await iso.click();
+  await new Promise((r) => setTimeout(r, 400));
+}
+const cam = await findByTitle("Kamera");
+if (cam && (await cam.evaluate((e) => !!e))) {
+  await cam.click();
+  await new Promise((r) => setTimeout(r, 400));
+}
+const popoverOpen = await p.evaluate(() => !!document.querySelector(".tb-popover"));
+console.log("CAMERA POPOVER OPEN:", popoverOpen);
+await snap("probe-topbar-rest-3-popover.png");
+
+await b.close();

scripts/probe-trim.mjs

@@ -0,0 +1,108 @@
+// Verifikation Trim (Quick-Trim „stutzen"). Zwei sich kreuzende Linien zeichnen,
+// dann `trim` und auf den Überstand einer Linie klicken → der Überstand ist bis
+// zum Schnittpunkt weg (neuer Endpunkt = Schnittpunkt). Liest die gerenderten
+// `line.draw2d`-Segmente direkt aus dem SVG (Modellkoord. = SVG/PX_PER_M).
+import puppeteer from "puppeteer";
+
+const PX = 90; // PX_PER_M in PlanView
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1280, height: 820, deviceScaleFactor: 1 });
+const errs = [];
+p.on("pageerror", (e) => errs.push(e.message));
+await p.goto("http://localhost:5187/", { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+await sleep(800);
+
+const focusCmd = async () => {
+  const el = await p.$(".cmdline-input");
+  const bx = await el.boundingBox();
+  await p.mouse.click(bx.x + bx.width / 2, bx.y + bx.height / 2);
+  await sleep(60);
+};
+const typeLine = async (t) => {
+  await p.type(".cmdline-input", t, { delay: 6 });
+  await p.keyboard.press("Enter");
+  await sleep(90);
+};
+const segs = () =>
+  p.evaluate((PX) => {
+    return [...document.querySelectorAll(".plan-svg line.draw2d")].map((l) => ({
+      x1: +l.getAttribute("x1") / PX,
+      y1: -l.getAttribute("y1") / PX,
+      x2: +l.getAttribute("x2") / PX,
+      y2: -l.getAttribute("y2") / PX,
+    }));
+  }, PX);
+// Modellpunkt → Client-Pixel über das aktuelle SVG-CTM.
+const modelToClient = (mx, my) =>
+  p.evaluate(
+    (mx, my, PX) => {
+      const svg = document.querySelector(".plan-svg");
+      const ctm = svg.getScreenCTM();
+      const q = svg.createSVGPoint();
+      q.x = mx * PX;
+      q.y = -my * PX;
+      const s = q.matrixTransform(ctm);
+      return [s.x, s.y];
+    },
+    mx,
+    my,
+    PX,
+  );
+
+// ── Zwei sich kreuzende Linien ───────────────────────────────────────────────
+// A: horizontal y=2, x=0..6 (Überstand rechts ab x=4). B: vertikal x=4, y=0..4.
+await focusCmd();
+await typeLine("line");
+await typeLine("0,2");
+await typeLine("6,2");
+await focusCmd();
+await typeLine("line");
+await typeLine("4,0");
+await typeLine("4,4");
+await p.keyboard.press("Escape");
+await sleep(120);
+
+const before = await segs();
+
+// ── Trim: auf den Überstand von A (x=5, y=2) klicken ─────────────────────────
+await focusCmd();
+await typeLine("trim");
+// Befehl ist aktiv; jetzt in der Plan-Ansicht auf den Überstand klicken.
+// Eingabefeld behält Fokus → der Klick geht trotzdem an PlanView (pick).
+const [hx, hy] = await modelToClient(5, 2);
+await p.mouse.move(hx, hy);
+await sleep(120);
+await p.mouse.click(hx, hy);
+await sleep(200);
+await p.keyboard.press("Escape");
+await sleep(120);
+
+const after = await segs();
+await p.screenshot({ path: "scripts/probe-trim.png" });
+
+// ── Auswertung: gibt es ein horizontales Segment (y≈2), das bei x≈4 endet und
+// NICHT über x=4 hinausragt? Der Überstand x∈(4,6] muss weg sein. ────────────
+const horiz = after.filter((s) => Math.abs(s.y1 - 2) < 0.05 && Math.abs(s.y2 - 2) < 0.05);
+const maxX = horiz.reduce((m, s) => Math.max(m, s.x1, s.x2), -Infinity);
+const trimmedToIntersection = Math.abs(maxX - 4) < 0.05;
+
+console.log(
+  JSON.stringify(
+    {
+      beforeCount: before.length,
+      afterCount: after.length,
+      horizSegments: horiz,
+      maxXofHoriz: maxX,
+      trimmedToIntersection,
+      errs,
+    },
+    null,
+    2,
+  ),
+);
+await b.close();

scripts/probe-wall-cmd.mjs

@@ -0,0 +1,101 @@
+// Verifikation: „Wand" als echter Engine-Befehl.
+//  1) GUI-„Wand" klicken → Befehlsfeld aktiv (Wand-Prompt, Feld fokussiert).
+//  2) Mehrere Punkte im Plan klicken → Wände entstehen (Plan-Primitive wachsen),
+//     Rechtsklick beendet den (chainenden) Zug.
+//  3) In 3D (Isometrie) schalten → die Wände sind dort sichtbar (Screenshot).
+//  4) Getipptes „wand" startet DENSELBEN Befehl (Prompt = Wand-Prompt).
+// Temporäres Verifikations-Gerüst (nicht eingecheckt).
+import puppeteer from "puppeteer";
+const URL = process.env.PROBE_URL || "http://localhost:5188/";
+const b = await puppeteer.launch({
+  headless: "new",
+  args: ["--no-sandbox", "--use-gl=swiftshader", "--enable-unsafe-swiftshader"],
+});
+const p = await b.newPage();
+await p.setViewport({ width: 1400, height: 900, deviceScaleFactor: 1.25 });
+const errs = [];
+p.on("pageerror", (e) => errs.push(e.message));
+await p.goto(URL, { waitUntil: "networkidle0", timeout: 20000 }).catch(() => {});
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+await wait(900);
+
+const clickTool = (label) =>
+  p.evaluate((l) => [...document.querySelectorAll("button.tool-row")]
+    .find((x) => x.textContent.trim() === l)?.click(), label);
+const clickView = (aria) =>
+  p.evaluate((a) => [...document.querySelectorAll("button")]
+    .find((x) => x.getAttribute("aria-label") === a)?.click(), aria);
+const planBox = () => p.evaluate(() => {
+  const r = document.querySelector(".plan-svg").getBoundingClientRect();
+  return { x: r.x, y: r.y, w: r.width, h: r.height };
+});
+const click = async (x, y, opts) => { await p.mouse.move(x, y); await p.mouse.click(x, y, opts); await wait(110); };
+const cmdState = () => p.evaluate(() => {
+  const prompt = document.querySelector(".cmdline-prompt")?.textContent?.trim() ?? "";
+  const input = document.querySelector(".cmdline-input");
+  const focused = document.activeElement === input;
+  const placeholder = input?.getAttribute("placeholder") ?? "";
+  return { prompt, focused, active: placeholder === "" };
+});
+// Grobes Mass für „Wand-Geometrie im Plan": Anzahl Pfad-/Polygon-Primitive.
+// Wände rendern als gefüllte Schicht-Polygone + Umriss-Pfade; jede neue Wand
+// erhöht diese Zahl deutlich.
+const primCount = () => p.evaluate(() =>
+  document.querySelectorAll(".plan-svg path, .plan-svg polygon").length);
+const typeInCmd = async (text) => {
+  await p.evaluate(() => document.querySelector(".cmdline-input")?.focus());
+  await p.keyboard.type(text);
+  await p.keyboard.press("Enter");
+  await wait(200);
+};
+
+const box = await planBox();
+const cx = box.x + box.w / 2, cy = box.y + box.h / 2;
+
+// ── 1) „Wand" anklicken → Befehlsfeld aktiv, Wand-Prompt ─────────────────────
+const primStart = await primCount();
+await clickTool("Wand");
+await wait(300);
+const afterToolClick = await cmdState();
+console.log("after Wand-tool click → cmdline:", afterToolClick);
+await p.screenshot({ path: "scripts/probe-wall-cmd-1-active.png" });
+
+// ── 2) Mehrere Punkte → chainende Wände, dann Rechtsklick zum Beenden ────────
+const P = [
+  [cx - 220, cy - 120],
+  [cx + 40, cy - 160],
+  [cx + 200, cy + 10],
+  [cx + 60, cy + 150],
+];
+for (const pt of P) await click(...pt);
+await p.mouse.click(P[P.length - 1][0], P[P.length - 1][1], { button: "right" }); // Zug beenden
+await wait(300);
+const primAfter = await primCount();
+console.log("plan primitives start / after walls:", primStart, primAfter, "→ delta", primAfter - primStart);
+await p.screenshot({ path: "scripts/probe-wall-cmd-2-plan.png" });
+
+// ── 3) In 3D (Isometrie) → Wände sichtbar ───────────────────────────────────
+await clickView("Isometrie");
+await wait(1500);
+await p.screenshot({ path: "scripts/probe-wall-cmd-3-3d.png" });
+
+// Zurück in den Grundriss.
+await clickView("Grundriss");
+await wait(600);
+
+// ── 4) Getipptes „wand" startet DENSELBEN Befehl ────────────────────────────
+await clickTool("Auswahl");
+await wait(200);
+const before = await cmdState();
+await typeInCmd("wand");
+const afterTyped = await cmdState();
+console.log("after typing 'wand' → cmdline:", afterTyped, "(was:", before, ")");
+// Einen Punkt setzen + Rechtsklick (Abbruch ohne 2. Punkt) — nur Prompt-Beleg.
+await p.screenshot({ path: "scripts/probe-wall-cmd-4-typed.png" });
+await p.keyboard.press("Escape");
+
+console.log("errs:", errs.slice(0, 6));
+console.log("RESULT activePrompt:", afterToolClick.active, afterToolClick.prompt,
+  "| primDelta:", primAfter - primStart,
+  "| typedPrompt:", afterTyped.active, afterTyped.prompt);
+await b.close();