From f8f16ea80052fe74fac19e1b662269be5690dc42 Mon Sep 17 00:00:00 2001
From: bklronin <therrmann23@gmail.com>
Date: Sun, 28 Jun 2026 21:12:34 +0200
Subject: [PATCH] - Tons of addtions

---
 .idea/workspace.xml                   |   69 +-
 src/fluency/geometry_occ/kernel.py    |   31 +-
 src/fluency/geometry_occ/sketch.py    |  638 +++++++++++++-
 src/fluency/main.py                   | 1163 ++++++++++++++++++++-----
 src/fluency/rendering/__init__.py     |    1 +
 src/fluency/rendering/occ_renderer.py |  504 +++++++++++
 6 files changed, 2147 insertions(+), 259 deletions(-)
 create mode 100644 src/fluency/rendering/occ_renderer.py

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index e3478f6..9d4d8b4 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -5,14 +5,11 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="8f0bafd6-58a0-4b20-aa2b-ddc3ba278873" name="Changes" comment="- Improved sketching">
-      <change beforePath="$PROJECT_DIR$/.idea/fluency.iml" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/.idea/modules.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/modules.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/pyproject.toml" beforeDir="false" afterPath="$PROJECT_DIR$/pyproject.toml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/fluency/geometry_occ/kernel.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/geometry_occ/kernel.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/fluency/geometry_occ/sketch.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/geometry_occ/sketch.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/fluency/main.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/main.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/uv.lock" beforeDir="false" afterPath="$PROJECT_DIR$/uv.lock" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/fluency/rendering/__init__.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/fluency/rendering/__init__.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -29,7 +26,7 @@
   <component name="Git.Settings">
     <option name="RECENT_BRANCH_BY_REPOSITORY">
       <map>
-        <entry key="$PROJECT_DIR$" value="structure" />
+        <entry key="$PROJECT_DIR$" value="single_window" />
       </map>
     </option>
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
@@ -49,31 +46,39 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;Python.2dtest.executor&quot;: &quot;Run&quot;,
-    &quot;Python.3d_windows.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Unnamed.executor&quot;: &quot;Run&quot;,
-    &quot;Python.draw_widget2d.executor&quot;: &quot;Run&quot;,
-    &quot;Python.draw_widget_solve.executor&quot;: &quot;Run&quot;,
-    &quot;Python.fluency.executor&quot;: &quot;Run&quot;,
-    &quot;Python.fluencyb.executor&quot;: &quot;Run&quot;,
-    &quot;Python.gl_widget.executor&quot;: &quot;Run&quot;,
-    &quot;Python.main.executor&quot;: &quot;Run&quot;,
-    &quot;Python.meshtest.executor&quot;: &quot;Run&quot;,
-    &quot;Python.side_fluency.executor&quot;: &quot;Run&quot;,
-    &quot;Python.simple_mesh.executor&quot;: &quot;Run&quot;,
-    &quot;Python.vtk_widget.executor&quot;: &quot;Run&quot;,
-    &quot;Python.vulkan.executor&quot;: &quot;Run&quot;,
-    &quot;RunOnceActivity.OpenProjectViewOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
-    &quot;git-widget-placeholder&quot;: &quot;feature/occ-migration&quot;,
-    &quot;last_opened_file_path&quot;: &quot;/Volumes/Data_drive/Programming/fluency&quot;,
-    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
-    &quot;settings.editor.selected.configurable&quot;: &quot;project.propVCSSupport.DirectoryMappings&quot;
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "Python.2dtest.executor": "Run",
+    "Python.3d_windows.executor": "Run",
+    "Python.Unnamed.executor": "Run",
+    "Python.draw_widget2d.executor": "Run",
+    "Python.draw_widget_solve.executor": "Run",
+    "Python.fluency.executor": "Run",
+    "Python.fluencyb.executor": "Run",
+    "Python.gl_widget.executor": "Run",
+    "Python.kernel.executor": "Run",
+    "Python.main.executor": "Run",
+    "Python.meshtest.executor": "Run",
+    "Python.occ_renderer.executor": "Run",
+    "Python.side_fluency.executor": "Run",
+    "Python.simple_mesh.executor": "Run",
+    "Python.vtk_widget.executor": "Run",
+    "Python.vulkan.executor": "Run",
+    "RunOnceActivity.OpenProjectViewOnStart": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.TerminalTabsStorage.copyFrom.TerminalArrangementManager.252": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "RunOnceActivity.typescript.service.memoryLimit.init": "true",
+    "codeWithMe.voiceChat.enabledByDefault": "false",
+    "git-widget-placeholder": "feature/occ-migration",
+    "last_opened_file_path": "/Volumes/Data_drive/Programming/fluency/src/fluency",
+    "node.js.detected.package.eslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "settings.editor.selected.configurable": "project.propVCSSupport.DirectoryMappings"
   }
-}</component>
+}]]></component>
   <component name="QodanaReportsService">
     <option name="descriptions">
       <ReportDescription localRun="true" path="/private/var/folders/kg/zm48w_r96yb68mlbzvb9gtq40000gn/T/qodana_output/qodana.sarif.json" reportGuid="5f5b823c-c594-48c5-ae1f-062e30303918" reportId="fluency/qodana/2024-02-04" />
@@ -81,6 +86,7 @@
   </component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/fluency" />
       <recent name="$PROJECT_DIR$" />
       <recent name="$PROJECT_DIR$/drawing_modules" />
       <recent name="$PROJECT_DIR$/modules" />
@@ -92,7 +98,7 @@
   <component name="SharedIndexes">
     <attachedChunks>
       <set>
-        <option value="bundled-python-sdk-4c141bd692a7-e2d783800521-com.jetbrains.pycharm.community.sharedIndexes.bundled-PC-251.26927.90" />
+        <option value="bundled-python-sdk-c59985aa861c-c2ffad84badb-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-261.24374.152" />
       </set>
     </attachedChunks>
   </component>
@@ -260,6 +266,9 @@
     <option name="localTasksCounter" value="20" />
     <servers />
   </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
   <component name="Vcs.Log.Tabs.Properties">
     <option name="TAB_STATES">
       <map>
diff --git a/src/fluency/geometry_occ/kernel.py b/src/fluency/geometry_occ/kernel.py
index 2540c1b..3377ed6 100644
--- a/src/fluency/geometry_occ/kernel.py
+++ b/src/fluency/geometry_occ/kernel.py
@@ -157,7 +157,13 @@ class OCGeometryKernel(GeometryKernel):
         direction: Tuple[float, float, float] = (0, 0, 1),
         symmetric: bool = False,
     ) -> GeometryObject:
-        """Extrude a 2D sketch into a 3D solid."""
+        """Extrude a 2D sketch into a 3D solid.
+
+        *height* is extruded along *direction* (default +Z).  A negative *height*
+        extrudes in the opposite direction.  The *direction* argument is accepted
+        for API compatibility; currently only the sign of *height* is used for
+        direction (positive → +Z, negative → -Z).
+        """
         import cadquery as cq
 
         cq_obj = self._get_cq_obj(sketch)
@@ -604,7 +610,9 @@ class OCGeometryKernel(GeometryKernel):
         from OCP.BRep import BRep_Tool
         from OCP.TopLoc import TopLoc_Location
 
-        mesh = BRepMesh_IncrementalMesh(shape, tolerance, False, 0.5, False)
+        # Use finer angular deflection (0.15 rad ≈ 24 segments/circle) so
+        # curved surfaces like cylinders render smoothly instead of faceted.
+        mesh = BRepMesh_IncrementalMesh(shape, tolerance, False, 0.15, True)
         mesh.Perform()
 
         vertices_list: List[List[float]] = []
@@ -612,6 +620,7 @@ class OCGeometryKernel(GeometryKernel):
         vertex_offset = 0
 
         from OCP.TopoDS import TopoDS
+        from OCP.TopAbs import TopAbs_Orientation
 
         explorer = TopExp_Explorer(shape, TopAbs_FACE)
         while explorer.More():
@@ -626,15 +635,21 @@ class OCGeometryKernel(GeometryKernel):
                     vertices_list.append([p.X(), p.Y(), p.Z()])
 
                 n_triangles = triangulation.NbTriangles()
+                # REVERSED faces store triangle winding in the natural (surface)
+                # orientation — we must flip it so the computed normals point
+                # outward (away from solid interior).  TopAbs_REVERSED = 1.
+                reverse_winding = face.Orientation() == TopAbs_Orientation.TopAbs_REVERSED
                 for i in range(1, n_triangles + 1):
                     tri = triangulation.Triangle(i)
-                    faces_list.append(
-                        [
-                            tri.Value(1) - 1 + vertex_offset,
-                            tri.Value(2) - 1 + vertex_offset,
-                            tri.Value(3) - 1 + vertex_offset,
-                        ]
+                    v0, v1, v2 = (
+                        tri.Value(1) - 1 + vertex_offset,
+                        tri.Value(2) - 1 + vertex_offset,
+                        tri.Value(3) - 1 + vertex_offset,
                     )
+                    if reverse_winding:
+                        # Swap last two vertices to flip winding direction.
+                        v1, v2 = v2, v1
+                    faces_list.append([v0, v1, v2])
 
                 vertex_offset += n_vertices
 
diff --git a/src/fluency/geometry_occ/sketch.py b/src/fluency/geometry_occ/sketch.py
index dc5d597..95c1dab 100644
--- a/src/fluency/geometry_occ/sketch.py
+++ b/src/fluency/geometry_occ/sketch.py
@@ -7,6 +7,7 @@ geometry generation from solved positions.
 """
 
 from typing import List, Tuple, Optional, Dict, Any
+import math
 import numpy as np
 import logging
 import re
@@ -55,6 +56,10 @@ class OCCSketch(SketchInterface):
         self._circles: Dict[int, Tuple[int, float]] = {}
         self._arcs: Dict[int, Any] = {}
         self._constraint_count: int = 0
+        # Re-appliable log of every constraint, so we can rebuild the solver
+        # after deleting an entity (python_solvespace has no per-entity delete).
+        # Each entry: {"type": str, "ids": (int, ...), "params": tuple, "labels": set[str]}
+        self._constraint_log: List[Dict[str, Any]] = []
 
         # Track first point as dragged/fixed for solver stability
         self._first_point_id: Optional[int] = None
@@ -212,8 +217,129 @@ class OCCSketch(SketchInterface):
 
     # ─── Constraint methods (actual solver calls) ──────────────────────────
 
-    def _add_constraint_record(self) -> None:
+    def _record_constraint(
+        self, ctype: str, ids: Tuple[int, ...], params: Tuple = (), labels: Tuple[str, ...] = ()
+    ) -> None:
+        """Count and log a constraint so the solver can be rebuilt after deletions."""
         self._constraint_count += 1
+        self._constraint_log.append(
+            {"type": ctype, "ids": tuple(int(i) for i in ids), "params": tuple(params), "labels": set(labels)}
+        )
+
+    def _apply_constraint_log(self, entry: Dict[str, Any]) -> bool:
+        """Re-apply a single logged constraint to the current (rebuilt) solver.
+
+        Uses live solver handles looked up by entity id. Returns False silently if
+        any referenced entity is now gone (pruning should have removed it, but
+        this is defensive).
+        """
+        ctype = entry["type"]
+        ids = entry["ids"]
+        params = entry["params"]
+
+        def h(i: int) -> Any:
+            ent = self._entities.get(i)
+            return ent.handle if ent is not None else None
+
+        if ctype == "coincident":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.coincident(h(ids[0]), h(ids[1]), self._wp)
+        elif ctype == "horizontal":
+            if h(ids[0]) is None:
+                return False
+            self._solver.horizontal(h(ids[0]), self._wp)
+        elif ctype == "vertical":
+            if h(ids[0]) is None:
+                return False
+            self._solver.vertical(h(ids[0]), self._wp)
+        elif ctype == "distance":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.distance(h(ids[0]), h(ids[1]), params[0], self._wp)
+        elif ctype == "angle":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.angle(h(ids[0]), h(ids[1]), params[0], self._wp)
+        elif ctype == "parallel":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.parallel(h(ids[0]), h(ids[1]), self._wp)
+        elif ctype == "perpendicular":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.perpendicular(h(ids[0]), h(ids[1]), self._wp)
+        elif ctype == "midpoint":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.midpoint(h(ids[0]), h(ids[1]), self._wp)
+        elif ctype == "tangent":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.tangent(h(ids[0]), h(ids[1]), self._wp)
+        elif ctype == "equal":
+            if h(ids[0]) is None or h(ids[1]) is None:
+                return False
+            self._solver.equal(h(ids[0]), h(ids[1]), self._wp)
+        elif ctype == "fixed":
+            if h(ids[0]) is None:
+                return False
+            self._solver.dragged(h(ids[0]), self._wp)
+        elif ctype == "symmetric":
+            if h(ids[0]) is None or h(ids[1]) is None or h(ids[2]) is None:
+                return False
+            self._solver.symmetric(h(ids[0]), h(ids[1]), h(ids[2]), self._wp)
+        elif ctype == "equal_radius":
+            # tracked only (no solver entity)
+            pass
+        else:
+            return False
+        return True
+
+    def _rebuild_solver(self) -> None:
+        """Recreate the SolveSpace system from current points/lines + log.
+
+        python_solvespace cannot remove individual entities/constraints, so
+        after deleting an entity we rebuild the whole system: re-add every
+        surviving point at its current position (first point re-fixed for
+        stability), re-add every surviving line, then re-apply the pruned
+        constraint log. Entity ids are preserved; only solver handles change.
+        """
+        # Snapshot current point positions before resetting the solver.
+        saved_pos: Dict[int, Tuple[float, float]] = {}
+        for eid, ent in self._entities.items():
+            if ent.entity_type == "point" and ent.geometry is not None:
+                saved_pos[eid] = (float(ent.geometry[0]), float(ent.geometry[1]))
+
+        self._solver = SolverSystem()
+        self._wp = self._solver.create_2d_base()
+        self._first_point_id = None
+
+        # Re-add point entities in id order (preserves first-point-fixed).
+        for pid in sorted(eid for eid, e in self._entities.items() if e.entity_type == "point"):
+            ent = self._entities[pid]
+            x, y = saved_pos.get(pid, (0.0, 0.0))
+            new_handle = self._solver.add_point_2d(x, y, self._wp)
+            ent.handle = new_handle
+            if self._first_point_id is None:
+                self._first_point_id = pid
+                self._solver.dragged(new_handle, self._wp)
+
+        # Re-add line entities in id order, updating their solver handles.
+        for lid in sorted(self._lines.keys()):
+            sid, eid2 = self._lines[lid]
+            s_ent = self._entities.get(sid)
+            e_ent = self._entities.get(eid2)
+            if s_ent is None or e_ent is None or s_ent.handle is None or e_ent.handle is None:
+                continue
+            new_handle = self._solver.add_line_2d(s_ent.handle, e_ent.handle, self._wp)
+            line_ent = self._entities.get(lid)
+            if line_ent is not None:
+                line_ent.handle = new_handle
+
+        # Re-apply every surviving logged constraint.
+        for entry in self._constraint_log:
+            self._apply_constraint_log(entry)
 
     def constrain_coincident(self, *entities: SketchEntity) -> bool:
         """Make entities coincident via solver."""
@@ -224,7 +350,7 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.coincident(e1.handle, e2.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("coincident", (entities[0].id, entities[1].id))
         return True
 
     def constrain_horizontal(self, line: SketchEntity) -> bool:
@@ -233,7 +359,7 @@ class OCCSketch(SketchInterface):
         if entity is None or entity.handle is None:
             return False
         self._solver.horizontal(entity.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("horizontal", (line.id,), labels=("hrz",))
         if "hrz" not in entity.constraints:
             entity.constraints.append("hrz")
         return True
@@ -244,7 +370,7 @@ class OCCSketch(SketchInterface):
         if entity is None or entity.handle is None:
             return False
         self._solver.vertical(entity.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("vertical", (line.id,), labels=("vrt",))
         if "vrt" not in entity.constraints:
             entity.constraints.append("vrt")
         return True
@@ -258,7 +384,7 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.distance(e1.handle, e2.handle, distance, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("distance", (entity1.id, entity2.id), (distance,))
         return True
 
     def constrain_angle(self, line1: SketchEntity, line2: SketchEntity, angle: float) -> bool:
@@ -268,7 +394,7 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.angle(e1.handle, e2.handle, angle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("angle", (line1.id, line2.id), (angle,))
         return True
 
     def constrain_parallel(self, line1: SketchEntity, line2: SketchEntity) -> bool:
@@ -278,7 +404,7 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.parallel(e1.handle, e2.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("parallel", (line1.id, line2.id))
         return True
 
     def constrain_perpendicular(self, line1: SketchEntity, line2: SketchEntity) -> bool:
@@ -288,7 +414,7 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.perpendicular(e1.handle, e2.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("perpendicular", (line1.id, line2.id))
         return True
 
     def constrain_midpoint(self, point: SketchEntity, line: SketchEntity) -> bool:
@@ -298,7 +424,9 @@ class OCCSketch(SketchInterface):
         if pt is None or ln is None or pt.handle is None or ln.handle is None:
             return False
         self._solver.midpoint(pt.handle, ln.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("midpoint", (point.id, line.id), labels=("mid",))
+        if "mid" not in ln.constraints:
+            ln.constraints.append("mid")
         return True
 
     def constrain_tangent(self, entity1: SketchEntity, entity2: SketchEntity) -> bool:
@@ -308,7 +436,7 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.tangent(e1.handle, e2.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("tangent", (entity1.id, entity2.id))
         return True
 
     def constrain_equal_length(self, line1: SketchEntity, line2: SketchEntity) -> bool:
@@ -318,12 +446,12 @@ class OCCSketch(SketchInterface):
         if e1 is None or e2 is None or e1.handle is None or e2.handle is None:
             return False
         self._solver.equal(e1.handle, e2.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("equal", (line1.id, line2.id), labels=("eql",))
         return True
 
     def constrain_equal_radius(self, circle1: SketchEntity, circle2: SketchEntity) -> bool:
         """Circle equal-radius (tracked only — solver limit)."""
-        self._add_constraint_record()
+        self._record_constraint("equal_radius", (circle1.id, circle2.id))
         return True
 
     def constrain_fixed(self, entity: SketchEntity) -> bool:
@@ -332,7 +460,7 @@ class OCCSketch(SketchInterface):
         if ent is None or ent.handle is None:
             return False
         self._solver.dragged(ent.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("fixed", (entity.id,))
         return True
 
     def constrain_symmetric(
@@ -347,9 +475,49 @@ class OCCSketch(SketchInterface):
         if e1.handle is None or e2.handle is None or ln.handle is None:
             return False
         self._solver.symmetric(e1.handle, e2.handle, ln.handle, self._wp)
-        self._add_constraint_record()
+        self._record_constraint("symmetric", (entity1.id, entity2.id, line.id))
         return True
 
+    # ─── Position updates (for moving entities) ──────────────────────────
+
+    def set_entity_position(self, entity: SketchEntity, x: float, y: float) -> bool:
+        """Move a point entity's position in BOTH the solver (params) and local tracking.
+
+        Updating only ``entity.geometry`` is not enough — ``solve()`` reads from
+        the solver's internal parameter values and would revert the move. We push
+        the new coordinates into the solver via ``set_params`` so unconstrained
+        points keep their dragged location and constrained ones are recomputed.
+        """
+        ent = self._entities.get(entity.id)
+        if ent is None or ent.handle is None:
+            return False
+        try:
+            self._solver.set_params(ent.handle.params, (x, y))
+        except Exception as e:
+            logger.debug(f"set_params failed for entity {entity.id}: {e}")
+            return False
+        ent.geometry = (x, y)
+        if entity.id in self._points:
+            self._points[entity.id] = (x, y)
+        return True
+
+    def set_positions(self, positions: Dict[int, Tuple[float, float]]) -> bool:
+        """Bulk-apply new positions for a set of point entities (entity_id -> (x, y))."""
+        ok = True
+        for eid, (x, y) in positions.items():
+            ent = self._entities.get(eid)
+            if ent is None or ent.handle is None:
+                continue
+            try:
+                self._solver.set_params(ent.handle.params, (x, y))
+                ent.geometry = (x, y)
+                if eid in self._points:
+                    self._points[eid] = (x, y)
+            except Exception as e:
+                logger.debug(f"set_positions failed for entity {eid}: {e}")
+                ok = False
+        return ok
+
     # ─── Solving ───────────────────────────────────────────────────────────
 
     def solve(self) -> bool:
@@ -408,10 +576,20 @@ class OCCSketch(SketchInterface):
     # ─── Geometry extraction for operations ────────────────────────────────
 
     def get_geometry(self) -> GeometryObject:
-        """Get the solved geometry for operations using CadQuery."""
+        """Get the solved geometry for operations using CadQuery.
+
+        If the sketch has exactly one detected face (outer boundary + optional
+        holes) that face is returned as a combined face-with-holes Workplane.
+        Otherwise falls back to returning a single circle or polygon suitable
+        for extrude/revolve.
+        """
         import cadquery as cq
 
-        # Check for circles first
+        faces = self.detect_faces()
+        if len(faces) == 1:
+            return self.build_face_geometry(faces[0])
+
+        # Fallback: return the first circle, or a polygon, or None.
         if self._circles:
             for entity_id, (center_id, radius) in self._circles.items():
                 center_entity = self._entities.get(center_id)
@@ -494,6 +672,295 @@ class OCCSketch(SketchInterface):
 
         return ordered
 
+    # ─── Closed-loop / face detection (for region selection + holes) ──────
+
+    _SNAP_TOL: float = 1e-4  # world-unit tolerance for snapping line endpoints
+
+    def _line_segments(self) -> List[Tuple[Tuple[float, float], Tuple[float, float]]]:
+        """Current line segments as world-coordinate tuples (uses solved positions)."""
+        segs: List[Tuple[Tuple[float, float], Tuple[float, float]]] = []
+        for line_id, (sid, eid2) in self._lines.items():
+            s_ent = self._entities.get(sid)
+            e_ent = self._entities.get(eid2)
+            if s_ent and e_ent and s_ent.geometry and e_ent.geometry:
+                segs.append(((float(s_ent.geometry[0]), float(s_ent.geometry[1])),
+                             (float(e_ent.geometry[0]), float(e_ent.geometry[1]))))
+        return segs
+
+    def get_closed_loops(self) -> List[Dict[str, Any]]:
+        """Detect closed loops: polygon cycles from connected lines + each circle.
+
+        Each loop is one of:
+          {"type": "polygon", "points": [(x,y), ...]}  (closed, last == first)
+          {"type": "circle", "center": (x,y), "radius": r}
+        Line endpoint coordinates are snapped to ``_SNAP_TOL`` so a closed
+        rectangle's four corners join into one cycle even after solver floating
+        point jitter. Only connected components where every node has degree 2
+        (a simple closed polyline) are accepted as polygon loops.
+        """
+        loops: List[Dict[str, Any]] = []
+        segs = self._line_segments()
+
+        if segs:
+            # Snap endpoints to integer-ish keys to group coincident points.
+            def key(pt):
+                return (round(pt[0] / self._SNAP_TOL), round(pt[1] / self._SNAP_TOL))
+
+            reprs: Dict[Any, Tuple[float, float]] = {}  # key -> averaged world pt
+            edges: List[Tuple[Any, Any]] = []
+            for p1, p2 in segs:
+                k1, k2 = key(p1), key(p2)
+                reprs.setdefault(k1, p1)
+                reprs.setdefault(k2, p2)
+                edges.append((k1, k2))
+
+            # Undirected adjacency.
+            adj: Dict[Any, List[Any]] = {}
+            for a, b in edges:
+                adj.setdefault(a, []).append(b)
+                adj.setdefault(b, []).append(a)
+
+            # Connected components (each node with degree 2 → closed loop).
+            seen: set = set()
+            for start in adj:
+                if start in seen or len(adj[start]) != 2:
+                    continue
+                # Walk the component.
+                comp: List[Any] = []
+                stack = [start]
+                comp_seen: set = set()
+                while stack:
+                    n = stack.pop()
+                    if n in comp_seen:
+                        continue
+                    comp_seen.add(n)
+                    comp.append(n)
+                    for nb in adj.get(n, []):
+                        if nb not in comp_seen:
+                            stack.append(nb)
+                if all(len(adj[n]) == 2 for n in comp) and len(comp) >= 3:
+                    # Order the cycle by following each node's neighbor not yet visited.
+                    ordered: List[Any] = []
+                    cur = comp[0]
+                    prev = None
+                    for _ in range(len(comp)):
+                        ordered.append(cur)
+                        nbrs = [nb for nb in adj[cur] if nb != prev]
+                        if not nbrs:
+                            break
+                        prev = cur
+                        cur = nbrs[0]
+                    if len(ordered) == len(comp):
+                        pts = [reprs[k] for k in ordered]
+                        pts.append(pts[0])
+                        loops.append({"type": "polygon", "points": pts})
+                seen |= comp_seen
+
+        # Circles are closed loops of their own.
+        for cid, (center_id, r) in self._circles.items():
+            c_ent = self._entities.get(center_id)
+            if c_ent and c_ent.geometry and r > 0:
+                loops.append({"type": "circle", "center": (float(c_ent.geometry[0]), float(c_ent.geometry[1])),
+                              "radius": float(r)})
+        return loops
+
+    @staticmethod
+    def _point_in_polygon(pt: Tuple[float, float], poly: List[Tuple[float, float]]) -> bool:
+        """Ray-casting point-in-polygon test.
+
+        Returns *True* only for strictly interior points.  Points on the
+        boundary (within 1e-9) are considered *outside* so that the outer
+        boundary of a nested shape doesn't falsely contain another loop whose
+        representative point happens to land on that boundary.
+        """
+        x, y = pt
+        eps = 1e-9
+        n = len(poly)
+        inside = False
+        j = n - 1
+        for i in range(n):
+            xi, yi = poly[i]
+            xj, yj = poly[j]
+            # Point-on-segment test — exclude strict boundary hits.
+            # First check bounding box of the segment.
+            if min(xi, xj) - eps <= x <= max(xi, xj) + eps and min(yi, yj) - eps <= y <= max(yi, yj) + eps:
+                # Check collinearity
+                cross = (x - xi) * (yj - yi) - (y - yi) * (xj - xi)
+                if abs(cross) < eps:
+                    return False  # on boundary
+            if ((yi > y) != (yj > y)) and (x < (xj - xi) * (y - yi) / (yj - yi + 1e-30) + xi):
+                inside = not inside
+            j = i
+        return inside
+
+    @staticmethod
+    def _loop_contains(inner: Dict[str, Any], outer: Dict[str, Any]) -> bool:
+        """Does ``outer`` fully enclose ``inner``? Uses a representative point +
+        boundary tests on ``outer`` (only valid when ``outer`` != ``inner``)."""
+        rep = OCCSketch._loop_rep_point(inner)
+        if outer["type"] == "polygon":
+            return OCCSketch._point_in_polygon(rep, outer["points"])
+        else:  # circle
+            cx, cy = outer["center"]
+            return math.hypot(rep[0] - cx, rep[1] - cy) < outer["radius"]
+
+    @staticmethod
+    def _loop_rep_point(loop: Dict[str, Any]) -> Tuple[float, float]:
+        """An interior representative point inside a loop.
+
+        For polygons we use the midpoint between the centroid and the first
+        vertex (而不是 centroid 本身): a nested shape centered on the polygon's
+        centroid (e.g. a circle inside a rectangle, both centered on the same
+        point) would otherwise make the polygon's rep point coincide with the
+        hole and break containment tests. This midpoint stays inside convex
+        loops and is unlikely to land on a nested feature's center.
+        """
+        if loop["type"] == "polygon":
+            pts = loop["points"][:-1] if len(loop["points"]) > 1 and loop["points"][0] == loop["points"][-1] else loop["points"]
+            n = len(pts)
+            sx = sum(p[0] for p in pts) / n
+            sy = sum(p[1] for p in pts) / n
+            v0 = pts[0]
+            return ((sx + v0[0]) / 2.0, (sy + v0[1]) / 2.0)
+        return loop["center"]
+
+    @staticmethod
+    def _loop_area(loop: Dict[str, Any]) -> float:
+        if loop["type"] == "circle":
+            return math.pi * loop["radius"] ** 2
+        pts = loop["points"]
+        if len(pts) < 4:
+            return 0.0
+        area = 0.0
+        n = len(pts) - 1  # last == first
+        for i in range(n):
+            x1, y1 = pts[i]
+            x2, y2 = pts[i + 1]
+            area += x1 * y2 - x2 * y1
+        return abs(area) / 2.0
+
+    def detect_faces(self) -> List[Dict[str, Any]]:
+        """Build faces from closed loops using nesting depth.
+
+        Nesting rule (standard CAD even-odd): a loop's depth = number of other
+        loops that strictly contain it. Even-depth loops (0, 2, ...) are outer
+        boundaries (solid material); odd-depth loops directly inside them are
+        holes. So a rectangle (depth 0) wrapping a circle (depth 1) yields a face
+        that is the rectangle minus the circle — exactly the
+        "shape within a shape = closed without inner" behavior. A shape nested
+        inside a hole (depth 2) becomes its own solid face again.
+
+        Returns a list of ``{"outer": loop, "holes": [loop, ...], "depth": int}``.
+        """
+        loops = self.get_closed_loops()
+        if not loops:
+            return []
+        depths: List[int] = []
+        for i, li in enumerate(loops):
+            d = 0
+            for j, lj in enumerate(loops):
+                if i != j and OCCSketch._loop_contains(li, lj):
+                    d += 1
+            depths.append(d)
+
+        faces: List[Dict[str, Any]] = []
+        for i, outer in enumerate(loops):
+            if depths[i] % 2 != 0:
+                continue  # only even-depth loops are outer boundaries
+            holes: List[Dict[str, Any]] = []
+            for j, inner in enumerate(loops):
+                if i == j:
+                    continue
+                # directly nested: depth one greater, and outer contains inner.
+                if depths[j] == depths[i] + 1 and OCCSketch._loop_contains(inner, outer):
+                    holes.append(inner)
+            faces.append({"outer": outer, "holes": holes, "depth": depths[i]})
+        return faces
+
+    def find_face_at(self, x: float, y: float) -> Optional[Dict[str, Any]]:
+        """Return the face whose solid region (outer minus holes) contains (x, y)."""
+        pt = (x, y)
+        best: Optional[Dict[str, Any]] = None
+        best_area = float("inf")
+        for face in self.detect_faces():
+            outer = face["outer"]
+            if outer["type"] == "polygon":
+                if not OCCSketch._point_in_polygon(pt, outer["points"]):
+                    continue
+            else:
+                cx, cy = outer["center"]
+                if not (math.hypot(pt[0] - cx, pt[1] - cy) < outer["radius"]):
+                    continue
+            # Must not be inside any hole of this face.
+            in_hole = False
+            for h in face["holes"]:
+                if h["type"] == "polygon":
+                    if OCCSketch._point_in_polygon(pt, h["points"]):
+                        in_hole = True; break
+                else:
+                    hcx, hcy = h["center"]
+                    if math.hypot(pt[0] - hcx, pt[1] - hcy) < h["radius"]:
+                        in_hole = True; break
+            if in_hole:
+                continue
+            area = OCCSketch._loop_area(outer)
+            if area < best_area:
+                best_area = area
+                best = face
+        return best
+
+    def build_face_geometry(self, face: Dict[str, Any]) -> OCCGeometryObject:
+        """Build an OCC face (outer boundary + inner holes) wrapped in a Workplane.
+
+        The returned object feeds ``OCGeometryKernel.extrude`` directly: its
+        ``_cadquery_obj`` is a Workplane whose stack holds the face, so cadquery's
+        ``Workplane.extrude`` lifts it into a solid — inner wires become
+        through-holes.
+        """
+        import cadquery as cq
+        from OCP.BRepBuilderAPI import (
+            BRepBuilderAPI_MakePolygon, BRepBuilderAPI_MakeFace,
+            BRepBuilderAPI_MakeWire, BRepBuilderAPI_MakeEdge,
+        )
+        from OCP.gp import gp_Pnt, gp_Circ, gp_Ax2, gp_Dir
+
+        from OCP.TopoDS import TopoDS as _TopoDS
+
+        def wire_loop(loop: Dict[str, Any], is_hole: bool = False):
+            if loop["type"] == "polygon":
+                mp = BRepBuilderAPI_MakePolygon()
+                for (px, py) in loop["points"]:
+                    mp.Add(gp_Pnt(px, py, 0.0))
+                mp.Close()
+                mp.Build()
+                w = mp.Wire()
+            else:
+                cx, cy = loop["center"]
+                r = loop["radius"]
+                circ = gp_Circ(gp_Ax2(gp_Pnt(cx, cy, 0.0), gp_Dir(0, 0, 1)), r)
+                me = BRepBuilderAPI_MakeEdge(circ)
+                me.Build()
+                mw = BRepBuilderAPI_MakeWire()
+                mw.Add(me.Edge())
+                mw.Build()
+                w = mw.Wire()
+            if is_hole:
+                w = _TopoDS.Wire_s(w.Reversed())  # reverse orientation so OCC treats it as a hole
+            return w
+
+        outer_wire = wire_loop(face["outer"], is_hole=False)
+        face_maker = BRepBuilderAPI_MakeFace(outer_wire, True)
+        for h in face["holes"]:
+            face_maker.Add(wire_loop(h, is_hole=True))
+        face_maker.Build()
+        occ_face = face_maker.Face()
+
+        wp = cq.Workplane("XY")
+        wp = wp.add(cq.Face(occ_face))
+        obj = OCCGeometryObject(wp.val())
+        obj._cadquery_obj = wp
+        return obj
+
     def get_solver_dof(self) -> int:
         """Get remaining degrees of freedom from solver."""
         return self._solver.dof()
@@ -515,10 +982,147 @@ class OCCSketch(SketchInterface):
         self._arcs.clear()
         self._entity_counter = 0
         self._constraint_count = 0
+        self._constraint_log.clear()
         self._first_point_id = None
 
+    def _prune_log_for(self, removed_ids: set) -> None:
+        """Drop constraint-log entries that reference any id in ``removed_ids``."""
+        kept_log: List[Dict[str, Any]] = []
+        for entry in self._constraint_log:
+            if not (set(entry["ids"]) & removed_ids):
+                kept_log.append(entry)
+        self._constraint_log = kept_log
+        self._constraint_count = len(kept_log)
+
+    def delete_line(self, line: SketchEntity) -> bool:
+        """Delete a single line and recompute the surviving constraints.
+
+        python_solvespace has no API to remove an individual entity/constraint,
+        so this removes the line from local tracking, prunes any logged
+        constraint that referenced it, rebuilds the whole solver system from
+        the surviving points/lines + pruned log, and re-solves. The line's
+        endpoint points are NOT removed — only the line segment.
+        """
+        if line.id not in self._lines or line.id not in self._entities:
+            return False
+
+        del self._lines[line.id]
+        if line.id in self._entities:
+            del self._entities[line.id]
+
+        # Prune log entries referencing the deleted line (labels are re-derived
+        # from the surviving log below, so no manual label stripping here).
+        self._prune_log_for({line.id})
+
+        self._rebuild_solver()
+        self._rebuild_labels()
+        return self.solve()
+
+    def remove_constraint_at(self, index: int) -> bool:
+        """Remove a single constraint (by log index) and recompute the rest.
+
+        Used by the sketch widget when the user hovers a constraint tag and
+        presses Delete. Drops that one log entry, rebuilds the solver from the
+        surviving log, re-derives UI labels, and re-solves.
+        """
+        if index < 0 or index >= len(self._constraint_log):
+            return False
+        del self._constraint_log[index]
+        self._constraint_count = len(self._constraint_log)
+        self._rebuild_solver()
+        self._rebuild_labels()
+        return self.solve()
+
+    def delete_point(self, point: SketchEntity) -> bool:
+        """Delete a point, any lines that use it as an endpoint, and recompute.
+
+        Removing a point invalidates every line that references it (a line with
+        a missing endpoint is meaningless), so those lines are removed too.
+        All constraints that reference the point OR the removed lines are
+        pruned from the log, the solver is rebuilt from survivors, labels are
+        re-derived, and the system is re-solved.
+        """
+        if point.id not in self._entities or point.id not in self._points:
+            return False
+
+        removed_ids: set = {point.id}
+        # Remove lines that use this point as an endpoint.
+        removed_line_keys: List[int] = [
+            lid for lid, (sid, eid2) in list(self._lines.items())
+            if sid == point.id or eid2 == point.id
+        ]
+        for lid in removed_line_keys:
+            removed_ids.add(lid)
+            del self._lines[lid]
+            if lid in self._entities:
+                del self._entities[lid]
+        # Remove the point itself.
+        del self._points[point.id]
+        if point.id in self._entities:
+            del self._entities[point.id]
+        # Circles anchored on the point are also invalid.
+        removed_circle_keys: List[int] = [
+            cid for cid, (center_id, _r) in list(self._circles.items())
+            if center_id == point.id
+        ]
+        for cid in removed_circle_keys:
+            removed_ids.add(cid)
+            del self._circles[cid]
+            if cid in self._entities:
+                del self._entities[cid]
+
+        self._prune_log_for(removed_ids)
+        self._rebuild_solver()
+        self._rebuild_labels()
+        return self.solve()
+
+    def _rebuild_labels(self) -> None:
+        """Re-derive each entity's UI constraint labels from the surviving log.
+
+        paintEvent displays labels read off the endpoint POINT entities ("hrz",
+        "vrt", "mid", ...). After a delete, recompute them from scratch so a
+        removed line's labels don't linger on points that still belong to other
+        (unaffected) lines.
+        """
+        for ent in self._entities.values():
+            ent.constraints = []
+        for entry in self._constraint_log:
+            labels = entry.get("labels") or set()
+            if not labels:
+                continue
+            ctype = entry["type"]
+            ids = entry["ids"]
+            targets: List[OCCSketchEntity] = []
+            if ctype in ("horizontal", "vertical"):
+                sid, eid2 = self._lines.get(ids[0], (None, None))
+                for pid in (sid, eid2):
+                    if pid is not None and pid in self._entities:
+                        targets.append(self._entities[pid])
+            elif ctype == "midpoint":
+                sid, eid2 = self._lines.get(ids[1], (None, None))
+                for pid in (sid, eid2):
+                    if pid is not None and pid in self._entities:
+                        targets.append(self._entities[pid])
+                if ids[0] in self._entities:
+                    targets.append(self._entities[ids[0]])
+            else:
+                # distance / equal / parallel / etc.: tag referenced entities'
+                # endpoints (lines) or the points themselves.
+                for eid in ids:
+                    if eid in self._lines:
+                        sid, eid2 = self._lines[eid]
+                        for pid in (sid, eid2):
+                            if pid in self._entities:
+                                targets.append(self._entities[pid])
+                    elif eid in self._entities:
+                        targets.append(self._entities[eid])
+            for t in targets:
+                for lbl in labels:
+                    if lbl not in t.constraints:
+                        t.constraints.append(lbl)
+
     def delete_entity(self, entity: SketchEntity) -> bool:
-        """Delete an entity and its constraints."""
+        """Delete an entity and its constraints (no solver rebuild)."""
         if entity.id not in self._entities:
             return False
 
diff --git a/src/fluency/main.py b/src/fluency/main.py
index 03c06cd..fe4eb43 100644
--- a/src/fluency/main.py
+++ b/src/fluency/main.py
@@ -1,3 +1,5 @@
+from h5py._hl import files
+
 """
 Fluency CAD - Main Application
 
@@ -48,23 +50,25 @@ from PySide6.QtWidgets import (
     QSizePolicy,
     QInputDialog,
 )
-from PySide6.QtCore import Qt, Signal, Slot, QPoint, QPointF, QSize
+from PySide6.QtCore import Qt, Signal, Slot, QPoint, QPointF, QSize, QRect
 from PySide6.QtGui import (
     QAction,
     QIcon,
     QKeySequence,
     QPainter,
+    QPainterPath,
     QPen,
     QColor,
     QBrush,
     QFont,
+    QFontMetrics,
     QCursor,
 )
 
 from fluency.geometry_occ.kernel import OCGeometryKernel, OCCGeometryObject
 from fluency.geometry_occ.sketch import OCCSketch, OCCSketchEntity
 from fluency.geometry.base import Point2D, Point3D
-from fluency.rendering.pygfx_renderer import PygfxRenderer
+from fluency.rendering.occ_renderer import OCCRenderer
 from fluency.models.data_model import Project, Component, Sketch, Body
 
 
@@ -183,7 +187,13 @@ class Sketch2DWidget(QWidget):
 
         self._draw_buffer: List[QPoint] = []
         self._hovered_point: Optional[QPoint] = None
+        self._hovered_point_entity: Optional[OCCSketchEntity] = None  # point entity under cursor (for Delete)
         self._hovered_line: Optional[Tuple[QPoint, QPoint]] = None
+        self._hovered_line_entity: Optional[OCCSketchEntity] = None  # line entity under cursor (for Delete)
+        self._hovered_constraint_idx: int = -1  # constraint-log index hovered over its tag (for Delete)
+        self._constraint_tags: List[Dict[str, Any]] = []  # cached tag rects for paint + hit-test
+        self._hovered_face: Any = None  # detected face dict (see OCCSketch.detect_faces) or None
+        self._selected_face: Any = None
         self._selected_entities: List[OCCSketchEntity] = []
 
         self._snap_mode: Dict[str, bool] = {
@@ -209,6 +219,13 @@ class Sketch2DWidget(QWidget):
         # Pending distance constraint input
         self._pending_distance_val: Optional[float] = None
 
+        # Element move state (move tool / select mode)
+        self._moving_points: List[OCCSketchEntity] = []
+        self._move_anchor: Optional[OCCSketchEntity] = None
+        self._move_anchor_orig: Optional[QPoint] = None
+        self._move_orig_positions: Dict[int, Tuple[float, float]] = {}
+        self._move_active: bool = False
+
         self.setFocusPolicy(Qt.StrongFocus)
         self._setup_ui()
 
@@ -219,8 +236,39 @@ class Sketch2DWidget(QWidget):
         self._sketch = sketch
         self._rebuild_from_sketch()
         self._draw_buffer = []
+        self._clear_face_state()
         self.update()
 
+    def _clear_face_state(self):
+        self._hovered_face = None
+        self._selected_face = None
+
+    def get_selected_face_geometry(self) -> Any:
+        """Return the OCCGeometryObject for the currently selected face, or None."""
+        if self._selected_face is not None and self._sketch is not None:
+            return self._sketch.build_face_geometry(self._selected_face)
+        return None
+
+    def clear_selected_face(self):
+        self._selected_face = None
+        self._hovered_face = None
+
+    @staticmethod
+    def _faces_match(a: Any, b: Any) -> bool:
+        """Content-based face comparison (dicts may be from different calls to detect_faces)."""
+        if a is None or b is None:
+            return False
+        return Sketch2DWidget._loop_match(a.get("outer"), b.get("outer"))
+
+    @staticmethod
+    def _loop_match(a: Any, b: Any) -> bool:
+        if a is None or b is None or a["type"] != b["type"]:
+            return False
+        if a["type"] == "polygon":
+            return a["points"][0] == b["points"][0] and len(a["points"]) == len(b["points"])
+        else:  # circle
+            return a["center"] == b["center"] and a["radius"] == b["radius"]
+
     def _rebuild_from_sketch(self):
         """Rebuild UI point/line lists from the OCCSketch entity data."""
         self._points = []
@@ -261,13 +309,29 @@ class Sketch2DWidget(QWidget):
         self._draw_buffer = []
         self._dynamic_line_end = None
         self._mode = None
+        self._clear_move_state()
         self.update()
 
+    def _clear_move_state(self):
+        """Reset all element-move drag state."""
+        self._moving_points = []
+        self._move_anchor = None
+        self._move_anchor_orig = None
+        self._move_orig_positions = {}
+        self._move_active = False
+        self._hovered_face = None
+
     def set_mode(self, mode: Optional[str]):
         self._mode = mode
         self._draw_buffer = []
         self._dynamic_line_end = None
         self._selected_entities = []
+        self._hovered_constraint_idx = -1
+        self._hovered_face = None
+        # Cancel an ongoing move when switching modes
+        if self._move_active:
+            self._clear_move_state()
+            self.setCursor(Qt.ArrowCursor)
         self.update()
 
     def set_construct_mode(self, enabled: bool):
@@ -319,6 +383,25 @@ class Sketch2DWidget(QWidget):
                     nearest = point
         return nearest
 
+    def _find_nearest_point_entity(self, pos: QPoint, max_distance: int = 15) -> Optional[OCCSketchEntity]:
+        """Find the nearest point entity to a screen position."""
+        if not self._snap_mode.get("point", False):
+            return None
+        nearest = None
+        min_dist = max_distance
+        for entity in self._points:
+            if entity.geometry:
+                x, y = entity.geometry
+                point = QPoint(int(round(x)), int(round(y)))
+                screen_point = self._world_to_screen(point)
+                dist = math.sqrt(
+                    (pos.x() - screen_point.x()) ** 2 + (pos.y() - screen_point.y()) ** 2
+                )
+                if dist < min_dist:
+                    min_dist = dist
+                    nearest = entity
+        return nearest
+
     def _find_midpoint_snap(self, pos: QPoint, max_distance: int = 15) -> Optional[QPoint]:
         if not self._snap_mode.get("mpoint", False):
             return None
@@ -361,11 +444,11 @@ class Sketch2DWidget(QWidget):
         result = pos
         point_snap = self._find_nearest_point(pos)
         if point_snap:
-            return point_snap
+            return self._world_to_screen(point_snap)
         if self._snap_mode.get("mpoint", False):
             mid_snap = self._find_midpoint_snap(pos)
             if mid_snap:
-                return mid_snap
+                return self._world_to_screen(mid_snap)
         if start:
             if self._snap_mode.get("horiz", False):
                 horiz = self._apply_horizontal_snap(start, result)
@@ -377,6 +460,89 @@ class Sketch2DWidget(QWidget):
                     result = vert
             if self._snap_mode.get("angle", False):
                 result = self._apply_angle_snap(start, result)
+        # Grid snap as a final fallback (only when nothing else applied)
+        if result == pos and self._snap_mode.get("grid", False):
+            grid_snap = self._find_grid_snap(pos)
+            if grid_snap is not None:
+                result = self._world_to_screen(grid_snap)
+        return result
+
+    def _find_grid_snap(self, pos: QPoint) -> Optional[QPoint]:
+        """Return the nearest world-space grid intersection for a screen position."""
+        if not self._snap_mode.get("grid", False):
+            return None
+        world = self._screen_to_world(pos)
+        grid_step = 50  # world units per grid cell (matches paintEvent grid)
+        gx = round(world.x() / grid_step) * grid_step
+        gy = round(world.y() / grid_step) * grid_step
+        return QPoint(gx, gy)
+
+    def _apply_move_snaps(
+        self,
+        mouse_screen: QPoint,
+        anchor_orig_screen: QPoint,
+        exclude_ids: set,
+    ) -> QPoint:
+        """Snapping used while moving an element.
+
+        The moved element's own points/lines are excluded from being snap
+        candidates so the element never snaps to itself. ``anchor_orig_screen``
+        is the screen position of the grabbed anchor BEFORE the move started; it
+        is used as the reference origin for horizontal/vertical/angle snapping.
+        """
+        pos = mouse_screen
+
+        # Point snap (excluding moved points)
+        if self._snap_mode.get("point", False):
+            nearest = None
+            min_dist = self._snap_distance
+            for entity in self._points:
+                if entity.id in exclude_ids or not entity.geometry:
+                    continue
+                x, y = entity.geometry
+                sp = self._world_to_screen(QPoint(int(round(x)), int(round(y))))
+                d = math.sqrt((pos.x() - sp.x()) ** 2 + (pos.y() - sp.y()) ** 2)
+                if d < min_dist:
+                    min_dist = d
+                    nearest = sp
+            if nearest is not None:
+                return nearest
+
+        # Midpoint snap (excluding lines whose both endpoints are being moved)
+        if self._snap_mode.get("mpoint", False):
+            nearest = None
+            min_dist = self._snap_distance
+            for p1, p2 in self._lines:
+                if p1.id in exclude_ids and p2.id in exclude_ids:
+                    continue
+                if p1.geometry and p2.geometry:
+                    x1, y1 = p1.geometry
+                    x2, y2 = p2.geometry
+                    mid = QPoint(int(round((x1 + x2) / 2)), int(round((y1 + y2) / 2)))
+                    sm = self._world_to_screen(mid)
+                    d = math.sqrt((pos.x() - sm.x()) ** 2 + (pos.y() - sm.y()) ** 2)
+                    if d < min_dist:
+                        min_dist = d
+                        nearest = sm
+            if nearest is not None:
+                return nearest
+
+        # Horizontal / vertical / angle snaps are relative to the original anchor
+        result = pos
+        if self._snap_mode.get("horiz", False):
+            if abs(result.y() - anchor_orig_screen.y()) < 10:
+                result = QPoint(result.x(), anchor_orig_screen.y())
+        if self._snap_mode.get("vert", False):
+            if abs(result.x() - anchor_orig_screen.x()) < 10:
+                result = QPoint(anchor_orig_screen.x(), result.y())
+        if self._snap_mode.get("angle", False):
+            result = self._apply_angle_snap(anchor_orig_screen, result)
+
+        # Grid snap as final fallback (only when nothing else changed)
+        if result == pos and self._snap_mode.get("grid", False):
+            gs = self._find_grid_snap(pos)
+            if gs is not None:
+                result = self._world_to_screen(gs)
         return result
 
     # ─── Solver helpers ───────────────────────────────────────────────────
@@ -411,6 +577,38 @@ class Sketch2DWidget(QWidget):
                     return (p1_ent, p2_ent)
         return None
 
+    def _find_line_sketch_entity(
+        self, p1_ent: OCCSketchEntity, p2_ent: OCCSketchEntity
+    ) -> Optional[OCCSketchEntity]:
+        """Return the LINE sketch entity whose endpoints match the given point entities.
+
+        ``OCCSketch._lines`` maps ``line_id -> (start_point_id, end_point_id)``;
+        the line *entity* itself lives in ``_entities[line_id]`` and carries the
+        solver line handle. The old handlers mistakenly returned the start
+        *point* entity, whose solver handle is a point — passing that to
+        ``horizontal``/``vertical``/``parallel``/``perpendicular``/``midpoint``/
+        point-on-line/``symmetric`` raises ``TypeError: unsupported entities``.
+        """
+        if not self._sketch:
+            return None
+        for line_id, (sid, eid2) in self._sketch._lines.items():
+            s_ent = self._sketch._entities.get(sid)
+            e_ent = self._sketch._entities.get(eid2)
+            if (s_ent == p1_ent and e_ent == p2_ent) or (s_ent == p2_ent and e_ent == p1_ent):
+                return self._sketch._entities.get(line_id)  # the line entity
+        return None
+
+    def _get_line_endpoints(
+        self, line_ent: OCCSketchEntity
+    ) -> Tuple[Optional[OCCSketchEntity], Optional[OCCSketchEntity]]:
+        """Return ``(start_point_entity, end_point_entity)`` for a given line entity."""
+        if not self._sketch:
+            return None, None
+        for line_id, (sid, eid2) in self._sketch._lines.items():
+            if self._sketch._entities.get(line_id) is line_ent:
+                return self._sketch._entities.get(sid), self._sketch._entities.get(eid2)
+        return None, None
+
     def _find_line_entity_for_line_xy(self, p1_xy: Tuple[float, float], p2_xy: Tuple[float, float]) -> Optional[OCCSketchEntity]:
         """Find the OCCSketchEntity for a line defined by its endpoint tuples."""
         for eid, start_end in self._sketch._lines.items():
@@ -432,6 +630,169 @@ class Sketch2DWidget(QWidget):
         """Get constraint labels from both endpoint entities."""
         return list(set(p1_ent.constraints + p2_ent.constraints))
 
+    # ─── Constraint tags (display + delete) ───────────────────────────────
+
+    def _line_world_mid(self, line_id: int) -> Optional[QPoint]:
+        """World-space midpoint of the line with the given entity id."""
+        if not self._sketch or line_id not in self._sketch._lines:
+            return None
+        sid, eid2 = self._sketch._lines[line_id]
+        s_ent = self._sketch._entities.get(sid)
+        e_ent = self._sketch._entities.get(eid2)
+        if not s_ent or not e_ent or not s_ent.geometry or not e_ent.geometry:
+            return None
+        x1, y1 = s_ent.geometry
+        x2, y2 = e_ent.geometry
+        return QPoint(int(round((x1 + x2) / 2)), int(round((y1 + y2) / 2)))
+
+    def _point_world(self, pid: int) -> Optional[QPoint]:
+        """World-space position of the point entity with the given id."""
+        if not self._sketch:
+            return None
+        ent = self._sketch._entities.get(pid)
+        if not ent or not ent.geometry:
+            return None
+        x, y = ent.geometry
+        return QPoint(int(round(x)), int(round(y)))
+
+    def _compute_constraint_tags(self) -> List[Dict[str, Any]]:
+        """Build the list of constraint-tag descriptors from the constraint log.
+
+        Each tag maps a displayed label + on-screen rect to the index of its
+        entry in ``OCCSketch._constraint_log`` so the user can hover a tag and
+        press Delete to remove exactly that constraint. Anchors are chosen per
+        constraint type: line-attached tags sit at the line midpoint, point tags
+        at the relevant point, point-pair tags between the two points.
+        """
+        tags: List[Dict[str, Any]] = []
+        if not self._sketch:
+            return tags
+        fm = QFontMetrics(QFont("Monospace", 9))
+        # Track how many tags already share an anchor so we stack them vertically.
+        stack_count: Dict[Tuple[int, int], int] = {}
+
+        for idx, entry in enumerate(self._sketch._constraint_log):
+            ctype = entry["type"]
+            ids = entry["ids"]
+            params = entry["params"]
+            anchor: Optional[QPoint] = None
+            label = ""
+
+            if ctype == "horizontal":
+                anchor = self._line_world_mid(ids[0]); label = "hrz"
+            elif ctype == "vertical":
+                anchor = self._line_world_mid(ids[0]); label = "vrt"
+            elif ctype == "midpoint":
+                anchor = self._line_world_mid(ids[1]); label = "mid"
+            elif ctype == "distance":
+                a = self._point_world(ids[0]); b = self._point_world(ids[1])
+                # NOTE: use `is not None`, not truthiness — QPoint(0,0) is falsy in PySide6.
+                if a is not None and b is not None:
+                    anchor = QPoint((a.x() + b.x()) // 2, (a.y() + b.y()) // 2)
+                label = f"dst {params[0]:.1f}" if params else "dst"
+            elif ctype == "parallel":
+                anchor = self._line_world_mid(ids[0]); label = "par"
+            elif ctype == "perpendicular":
+                anchor = self._line_world_mid(ids[0]); label = "perp"
+            elif ctype == "angle":
+                anchor = self._line_world_mid(ids[0])
+                label = f"ang {params[0]:.0f}" if params else "ang"
+            elif ctype == "equal":
+                anchor = self._line_world_mid(ids[0]); label = "eql"
+            elif ctype == "coincident":
+                a = self._point_world(ids[0]); b = self._point_world(ids[1])
+                if a is not None and b is not None:
+                    anchor = QPoint((a.x() + b.x()) // 2, (a.y() + b.y()) // 2)
+                label = "coin"
+            elif ctype == "symmetric":
+                anchor = self._line_world_mid(ids[2]); label = "sym"
+            elif ctype == "fixed":
+                anchor = self._point_world(ids[0]); label = "fix"
+            elif ctype == "equal_radius":
+                anchor = self._point_world(ids[0]); label = "eqr"
+            else:
+                continue
+
+            if anchor is None:
+                continue
+            sc = self._world_to_screen(anchor)
+            key = (sc.x(), sc.y())
+            slot = stack_count.get(key, 0)
+            stack_count[key] = slot + 1
+
+            text = f"> {label} <"
+            w = fm.horizontalAdvance(text) + 10
+            h = 16
+            # Stack successive tags above the anchor so they don't overlap.
+            cx = sc.x()
+            cy = sc.y() - 14 - slot * (h + 2)
+            rect = QRect(cx - w // 2, cy - h // 2, w, h)
+            tags.append({"idx": idx, "label": text, "rect": rect, "center": QPoint(cx, cy)})
+        return tags
+
+    # ─── Element move helpers ─────────────────────────────────────────────
+
+    def _collect_connected_points(self, anchor: OCCSketchEntity) -> List[OCCSketchEntity]:
+        """Return anchor plus all point entities connected through lines.
+
+        ``OCCSketch._lines`` maps line id -> (start_point_id, end_point_id); we
+        BFS over that graph to gather the whole element (e.g. all 4 corners of a
+        rectangle, or both endpoints of a single line).
+        """
+        if not self._sketch:
+            return [anchor]
+        adjacency: Dict[int, List[int]] = {}
+        for _line_id, (sid, eid2) in self._sketch._lines.items():
+            adjacency.setdefault(sid, []).append(eid2)
+            adjacency.setdefault(eid2, []).append(sid)
+        seen = {anchor.id}
+        result: List[OCCSketchEntity] = [anchor]
+        queue = [anchor.id]
+        while queue:
+            cur = queue.pop()
+            for nbr in adjacency.get(cur, []):
+                if nbr in seen:
+                    continue
+                seen.add(nbr)
+                ent = self._sketch._entities.get(nbr)
+                if ent is not None:
+                    result.append(ent)
+                queue.append(nbr)
+        return result
+
+    def _find_move_target(self, pos: QPoint) -> Optional[Tuple[OCCSketchEntity, QPoint]]:
+        """Find the element under ``pos`` and return ``(anchor_entity, anchor_world)``.
+
+        Click priority: nearest point > nearest line (anchor = closer endpoint) >
+        circle circumference (anchor = center). The anchor's current world
+        position is returned so snapping can use it as the reference origin.
+        """
+        if not self._sketch:
+            return None
+        ent = self._find_nearest_point_entity(pos, max_distance=self._snap_distance)
+        if ent is not None and ent.geometry:
+            x, y = ent.geometry
+            return ent, QPoint(int(round(x)), int(round(y)))
+        world = self._screen_to_world(pos)
+        line_hit = self._get_line_entity_at(world)
+        if line_hit:
+            p1_ent, p2_ent = line_hit
+            if p1_ent.geometry and p2_ent.geometry:
+                x1, y1 = p1_ent.geometry
+                x2, y2 = p2_ent.geometry
+                d1 = (world.x() - x1) ** 2 + (world.y() - y1) ** 2
+                d2 = (world.x() - x2) ** 2 + (world.y() - y2) ** 2
+                anchor = p1_ent if d1 <= d2 else p2_ent
+                ax, ay = anchor.geometry
+                return anchor, QPoint(int(round(ax)), int(round(ay)))
+        for c_ent, r in self._circles:
+            if c_ent.geometry and r > 0:
+                cx, cy = c_ent.geometry
+                d = math.sqrt((world.x() - cx) ** 2 + (world.y() - cy) ** 2)
+                if abs(d - r) < 8:
+                    return c_ent, QPoint(int(round(cx)), int(round(cy)))
+        return None
+
     def _sync_solved_positions(self):
         """Sync solver positions back to UI points and lines."""
         if not self._sketch:
@@ -478,6 +839,54 @@ class Sketch2DWidget(QWidget):
             return
 
         if event.button() == Qt.LeftButton:
+            # Priority order: ① tight point-grab → ② face selection → ③ element move
+            if self._mode in ("select", None) and self._sketch:
+                # ① Tight point check (4 px) — a deliberate grab on a point.
+                tight_ent = self._find_nearest_point_entity(event.pos(), max_distance=4)
+                if tight_ent is not None and tight_ent.geometry:
+                    x, y = tight_ent.geometry
+                    moving = self._collect_connected_points(tight_ent)
+                    orig: Dict[int, Tuple[float, float]] = {}
+                    for e in moving:
+                        if e.geometry:
+                            orig[e.id] = (e.geometry[0], e.geometry[1])
+                    self._moving_points = moving
+                    self._move_anchor = tight_ent
+                    self._move_anchor_orig = QPoint(int(round(x)), int(round(y)))
+                    self._move_orig_positions = orig
+                    self._move_active = True
+                    self.setCursor(Qt.ClosedHandCursor)
+                    return
+
+                # ② Face region — click inside a closed face to select it.
+                face = self._sketch.find_face_at(world_pos.x(), world_pos.y())
+                if face is not None:
+                    if self._faces_match(face, self._selected_face):
+                        # Clicking the same face again toggles it off.
+                        self._selected_face = None
+                    else:
+                        self._selected_face = face
+                    self._hovered_face = None
+                    self.update()
+                    return
+
+                # ③ Wider element-move check (lines and circles).
+                target = self._find_move_target(event.pos())
+                if target is not None:
+                    anchor_ent, anchor_world = target
+                    moving = self._collect_connected_points(anchor_ent)
+                    orig: Dict[int, Tuple[float, float]] = {}
+                    for e in moving:
+                        if e.geometry:
+                            orig[e.id] = (e.geometry[0], e.geometry[1])
+                    self._moving_points = moving
+                    self._move_anchor = anchor_ent
+                    self._move_anchor_orig = anchor_world
+                    self._move_orig_positions = orig
+                    self._move_active = True
+                    self.setCursor(Qt.ClosedHandCursor)
+                    return
+
             snapped_pos = self._apply_all_snaps(
                 event.pos(), self._draw_buffer[0] if self._draw_buffer else None
             )
@@ -520,6 +929,23 @@ class Sketch2DWidget(QWidget):
             self.update()
             return
 
+        # Handle element move (grab all points of the element, snap the anchor)
+        if self._move_active and self._move_anchor is not None and self._move_anchor_orig is not None:
+            anchor_orig_screen = self._world_to_screen(self._move_anchor_orig)
+            exclude_ids = set(e.id for e in self._moving_points)
+            snapped_screen = self._apply_move_snaps(
+                event.pos(), anchor_orig_screen, exclude_ids
+            )
+            target_world = self._screen_to_world(snapped_screen)
+            dx = target_world.x() - self._move_anchor_orig.x()
+            dy = target_world.y() - self._move_anchor_orig.y()
+            for ent in self._moving_points:
+                if ent.id in self._move_orig_positions and ent.geometry is not None:
+                    ox, oy = self._move_orig_positions[ent.id]
+                    ent.geometry = (ox + dx, oy + dy)
+            self.update()
+            return
+
         world_pos = self._screen_to_world(event.pos())
 
         if self._draw_buffer and self._mode in ["line", "rectangle", "circle"]:
@@ -528,14 +954,40 @@ class Sketch2DWidget(QWidget):
             )
             self._dynamic_line_end = self._screen_to_world(snapped)
 
-        # Point hover
+        # Constraint-tag hover takes priority — if the cursor is over a tag,
+        # we highlight it for delete and skip point/line hover this move.
+        self._constraint_tags = self._compute_constraint_tags()
+        tag_hit = None
+        for tag in self._constraint_tags:
+            if tag["rect"].contains(event.pos()):
+                tag_hit = tag["idx"]
+                break
+        if tag_hit is not None:
+            self._hovered_constraint_idx = tag_hit
+            self._hovered_point = None
+            self._hovered_point_entity = None
+            self._hovered_line = None
+            self._hovered_line_entity = None
+            self.setCursor(Qt.PointingHandCursor)
+            self.update()
+            return
+        if self._hovered_constraint_idx != -1:
+            self._hovered_constraint_idx = -1
+            self.update()
+
+        # Point hover — show an open-hand cursor when a move is possible
+        # (explicit Move tool OR no tool selected at all)
+        hover_cursor = Qt.OpenHandCursor if self._mode in ("select", None) else Qt.CrossCursor
         point_snap = self._find_nearest_point(event.pos())
         if point_snap:
             self._hovered_point = point_snap
+            self._hovered_point_entity = self._find_nearest_point_entity(event.pos())
             self._hovered_line = None
-            self.setCursor(Qt.CrossCursor)
+            self._hovered_line_entity = None
+            self.setCursor(hover_cursor)
         else:
             self._hovered_point = None
+            self._hovered_point_entity = None
             # Check line hover
             line_hit = self._get_line_entity_at(world_pos)
             if line_hit:
@@ -545,17 +997,72 @@ class Sketch2DWidget(QWidget):
                         QPoint(int(round(p1_ent.geometry[0])), int(round(p1_ent.geometry[1]))),
                         QPoint(int(round(p2_ent.geometry[0])), int(round(p2_ent.geometry[1]))),
                     )
-                    self.setCursor(Qt.CrossCursor)
+                    self._hovered_line_entity = self._find_line_sketch_entity(p1_ent, p2_ent)
+                    self.setCursor(hover_cursor)
                 else:
                     self._hovered_line = None
+                    self._hovered_line_entity = None
                     self.setCursor(Qt.ArrowCursor)
             else:
                 self._hovered_line = None
-                self.setCursor(Qt.ArrowCursor)
+                self._hovered_line_entity = None
+                # In move mode, hovering a circle curve should also show grab cursor
+                if self._mode in ("select", None):
+                    over_circle = False
+                    for c_ent, r in self._circles:
+                        if c_ent.geometry and r > 0:
+                            cx, cy = c_ent.geometry
+                            d = math.sqrt((world_pos.x() - cx) ** 2 + (world_pos.y() - cy) ** 2)
+                            if abs(d - r) < 8:
+                                over_circle = True
+                                break
+                    self.setCursor(Qt.OpenHandCursor if over_circle else Qt.ArrowCursor)
+                else:
+                    self.setCursor(Qt.ArrowCursor)
+
+        # Face region hover (fallback when no point/line/circle/tag is under the cursor).
+        if (self._hovered_constraint_idx < 0
+                and self._hovered_point is None
+                and self._hovered_line is None
+                and self._sketch is not None):
+            face = self._sketch.find_face_at(world_pos.x(), world_pos.y())
+            if face is not None:
+                self._hovered_face = face
+                self.setCursor(Qt.PointingHandCursor if self._mode in ("select", None) else Qt.ArrowCursor)
+            else:
+                self._hovered_face = None
+        else:
+            self._hovered_face = None
 
         self.update()
 
     def mouseReleaseEvent(self, event):
+        # Element move release: commit positions into the solver, solve, and
+        # revert on a constraint failure. Solving AFTER the release is what
+        # decides whether a constrained element snaps (back) or stays moved.
+        if self._move_active and event.button() == Qt.LeftButton:
+            if self._sketch and self._moving_points:
+                new_positions: Dict[int, Tuple[float, float]] = {}
+                for ent in self._moving_points:
+                    if ent.geometry is not None:
+                        new_positions[ent.id] = ent.geometry
+                original = dict(self._move_orig_positions)
+                # Push the dragged positions into the solver's params so free
+                # points keep their new location (otherwise solve reverts them).
+                self._sketch.set_positions(new_positions)
+                ok = self._solve_and_sync()
+                if not ok:
+                    logger.warning("Constraint violation while moving element; reverting")
+                    self._sketch.set_positions(original)
+                    self._solve_and_sync()
+                # Snap modes are honoured during the move (see _apply_move_snaps
+                # in mouseMoveEvent), so the committed positions are already snapped.
+            self._clear_move_state()
+            self.setCursor(Qt.ArrowCursor)
+            self.sketch_updated.emit()
+            self.update()
+            return
+
         if event.button() == Qt.MiddleButton:
             self._panning = False
             self._pan_start = None
@@ -568,6 +1075,75 @@ class Sketch2DWidget(QWidget):
         self._zoom = max(0.1, min(10.0, self._zoom))
         self.update()
 
+    def keyPressEvent(self, event):
+        # Delete / Backspace removes the entity currently under the cursor
+        # and recomputes the surviving constraints. Priority: constraint tag >
+        # line > point. Works in Move mode or when no tool is selected; ignored
+        # while actively drawing so an in-progress line isn't clobbered.
+        if event.key() in (Qt.Key_Delete, Qt.Key_Backspace):
+            if self._mode in ("select", None) and not self._draw_buffer and self._sketch is not None:
+                if self._hovered_constraint_idx >= 0:
+                    self._delete_hovered_constraint()
+                    event.accept()
+                    return
+                if self._hovered_line_entity is not None:
+                    self._delete_hovered_line()
+                    event.accept()
+                    return
+                if self._hovered_point_entity is not None:
+                    self._delete_hovered_point()
+                    event.accept()
+                    return
+        super().keyPressEvent(event)
+
+    def _delete_hovered_constraint(self):
+        """Delete the hovered constraint (by log index) and recompute the rest."""
+        idx = self._hovered_constraint_idx
+        if idx < 0 or self._sketch is None:
+            return
+        ok = self._sketch.remove_constraint_at(idx)
+        logger.info(f"Deleted constraint #{idx}; recompute solved={ok}")
+        self._hovered_constraint_idx = -1
+        self._rebuild_from_sketch()
+        self._solve_and_sync()
+        self.sketch_updated.emit()
+        self.update()
+
+    def _delete_hovered_line(self):
+        """Delete the hovered line, recompute constraints, and refresh the widget."""
+        line_ent = self._hovered_line_entity
+        if line_ent is None or self._sketch is None:
+            return
+        ok = self._sketch.delete_line(line_ent)
+        logger.info(f"Deleted line {line_ent.id}; recompute solved={ok}")
+        # Refresh widget tracking from the pruned sketch and sync solved positions.
+        self._rebuild_from_sketch()
+        self._hovered_line = None
+        self._hovered_line_entity = None
+        self._hovered_point = None
+        self._hovered_point_entity = None
+        self._selected_entities = []
+        self._solve_and_sync()
+        self.sketch_updated.emit()
+        self.update()
+
+    def _delete_hovered_point(self):
+        """Delete the hovered point (and lines using it), then recompute."""
+        point_ent = self._hovered_point_entity
+        if point_ent is None or self._sketch is None:
+            return
+        ok = self._sketch.delete_point(point_ent)
+        logger.info(f"Deleted point {point_ent.id}; recompute solved={ok}")
+        self._rebuild_from_sketch()
+        self._hovered_point = None
+        self._hovered_point_entity = None
+        self._hovered_line = None
+        self._hovered_line_entity = None
+        self._selected_entities = []
+        self._solve_and_sync()
+        self.sketch_updated.emit()
+        self.update()
+
     # ─── Drawing handlers ─────────────────────────────────────────────────
 
     def _handle_line_click(self, pos: QPoint):
@@ -652,7 +1228,22 @@ class Sketch2DWidget(QWidget):
         self.update()
 
     def _handle_select_click(self, pos: QPoint):
-        pass
+        """Handle select mode - find and highlight points/lines for selection."""
+        # Check if clicking on an existing point
+        nearest_entity = self._get_point_entity_at(pos)
+        if nearest_entity:
+            if nearest_entity not in self._selected_entities:
+                self._selected_entities.append(nearest_entity)
+            else:
+                self._selected_entities.remove(nearest_entity)
+        else:
+            # Check if clicking on a line
+            line_hit = self._get_line_entity_at(pos)
+            if line_hit:
+                p1_ent, p2_ent = line_hit
+                for entity in [p1_ent, p2_ent]:
+                    if entity and entity not in self._selected_entities:
+                        self._selected_entities.append(entity)
 
     # ─── Constraint handlers (with solver calls) ──────────────────────────
 
@@ -678,19 +1269,22 @@ class Sketch2DWidget(QWidget):
         if line_hit is None:
             return
         p1_ent, p2_ent = line_hit
-        # Find the OCCSketch line entity that references these exact point handles
-        for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-            s_ent = self._sketch._entities.get(sid) if self._sketch else None
-            e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-            if s_ent == p1_ent and e_ent == p2_ent:
-                self._sketch.constrain_horizontal(s_ent)
-                break
-            if s_ent == p2_ent and e_ent == p1_ent:
-                self._sketch.constrain_horizontal(s_ent)
-                break
+        # SolveSpace's horizontal() needs the LINE entity's handle, not a
+        # point's. Look up the line sketch entity by its endpoints.
+        line_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
+        if line_ent is None:
+            return
+        if self._sketch:
+            self._sketch.constrain_horizontal(line_ent)
+            # Tag endpoints so paintEvent renders the "> hrz <" label.
+            for ent in (p1_ent, p2_ent):
+                if "hrz" not in ent.constraints:
+                    ent.constraints.append("hrz")
         ok = self._solve_and_sync()
         if ok:
             logger.info("Horizontal constraint added")
+        else:
+            logger.warning("Horizontal constraint failed to solve")
         self._mode = None
         self.constrain_done.emit()
         self.update()
@@ -700,40 +1294,46 @@ class Sketch2DWidget(QWidget):
         if line_hit is None:
             return
         p1_ent, p2_ent = line_hit
-        for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-            s_ent = self._sketch._entities.get(sid) if self._sketch else None
-            e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-            if s_ent == p1_ent and e_ent == p2_ent:
-                self._sketch.constrain_vertical(s_ent)
-                break
-            if s_ent == p2_ent and e_ent == p1_ent:
-                self._sketch.constrain_vertical(s_ent)
-                break
+        line_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
+        if line_ent is None:
+            return
+        if self._sketch:
+            self._sketch.constrain_vertical(line_ent)
+            for ent in (p1_ent, p2_ent):
+                if "vrt" not in ent.constraints:
+                    ent.constraints.append("vrt")
         ok = self._solve_and_sync()
         if ok:
             logger.info("Vertical constraint added")
+        else:
+            logger.warning("Vertical constraint failed to solve")
         self._mode = None
         self.constrain_done.emit()
         self.update()
 
     def _handle_constraint_distance(self, world_pos: QPoint):
-        # Click 1: select a point or line
         point_ent = self._get_point_entity_at(world_pos)
         if point_ent:
+            # Point clicked: collect points; constraint applied after 2nd point.
             self._selected_entities.append(point_ent)
         else:
             line_hit = self._get_line_entity_at(world_pos)
             if line_hit:
                 p1_ent, p2_ent = line_hit
-                for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-                    s_ent = self._sketch._entities.get(sid) if self._sketch else None
-                    e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-                    if s_ent == p1_ent and e_ent == p2_ent:
-                        self._selected_entities.append(s_ent)
-                        break
-                    if s_ent == p2_ent and e_ent == p1_ent:
-                        self._selected_entities.append(s_ent)
-                        break
+                line_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
+                if line_ent is not None:
+                    # Line clicked: constrain its length (endpoint distance).
+                    dist, ok = QInputDialog.getDouble(self, "Distance", "Distance (mm):",
+                                                       self._constraint_distance_value, 0, 10000, 2)
+                    if ok and self._sketch:
+                        self._sketch.constrain_distance(p1_ent, p2_ent, dist)
+                        self._solve_and_sync()
+                        logger.info(f"Line distance {dist:.2f}mm")
+                    self._selected_entities = []
+                    self._mode = None
+                    self.constrain_done.emit()
+                    self.update()
+                    return
 
         if len(self._selected_entities) >= 2:
             e1, e2 = self._selected_entities[:2]
@@ -756,19 +1356,14 @@ class Sketch2DWidget(QWidget):
             line_hit = self._get_line_entity_at(world_pos)
             if line_hit:
                 p1_ent, p2_ent = line_hit
-                for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-                    s_ent = self._sketch._entities.get(sid) if self._sketch else None
-                    e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-                    if s_ent == p1_ent and e_ent == p2_ent:
-                        if self._sketch and self._selected_entities:
-                            self._sketch.constrain_midpoint(self._selected_entities[0], s_ent)
-                        break
-                    if s_ent == p2_ent and e_ent == p1_ent:
-                        if self._sketch and self._selected_entities:
-                            self._sketch.constrain_midpoint(self._selected_entities[0], s_ent)
-                        break
-                self._solve_and_sync()
-                logger.info("Midpoint constraint added")
+                line_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
+                if line_ent is not None and self._sketch and self._selected_entities:
+                    self._sketch.constrain_midpoint(self._selected_entities[0], line_ent)
+                    for ent in (p1_ent, p2_ent):
+                        if "mid" not in ent.constraints:
+                            ent.constraints.append("mid")
+                    self._solve_and_sync()
+                    logger.info("Midpoint constraint added")
                 self._selected_entities = []
                 self._mode = None
                 self.constrain_done.emit()
@@ -779,22 +1374,15 @@ class Sketch2DWidget(QWidget):
         if line_hit is None:
             return
         p1_ent, p2_ent = line_hit
-        # Find the line entity
-        target_ent = None
-        for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-            s_ent = self._sketch._entities.get(sid) if self._sketch else None
-            e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-            if (s_ent == p1_ent and e_ent == p2_ent) or (s_ent == p2_ent and e_ent == p1_ent):
-                target_ent = s_ent
-                break
+        target_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
         if target_ent is None:
             return
 
         if not self._selected_entities:
-            # First click: store this line
+            # First click: store this line ENTITY (not a point):
             self._selected_entities.append(target_ent)
         else:
-            # Second click: apply perpendicular constraint
+            # Second click: apply perpendicular constraint between two LINE entities
             prev_ent = self._selected_entities[0]
             if self._sketch:
                 self._sketch.constrain_perpendicular(prev_ent, target_ent)
@@ -810,13 +1398,7 @@ class Sketch2DWidget(QWidget):
         if line_hit is None:
             return
         p1_ent, p2_ent = line_hit
-        target_ent = None
-        for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-            s_ent = self._sketch._entities.get(sid) if self._sketch else None
-            e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-            if (s_ent == p1_ent and e_ent == p2_ent) or (s_ent == p2_ent and e_ent == p1_ent):
-                target_ent = s_ent
-                break
+        target_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
         if target_ent is None:
             return
 
@@ -834,7 +1416,7 @@ class Sketch2DWidget(QWidget):
         self.update()
 
     def _handle_constraint_ptline(self, world_pos: QPoint):
-        """Point-to-line coincident (point on line)."""
+        """Point-on-line coincident (point on line)."""
         point_ent = self._get_point_entity_at(world_pos)
         if point_ent and not self._selected_entities:
             self._selected_entities.append(point_ent)
@@ -842,19 +1424,12 @@ class Sketch2DWidget(QWidget):
             line_hit = self._get_line_entity_at(world_pos)
             if line_hit:
                 p1_ent, p2_ent = line_hit
-                for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-                    s_ent = self._sketch._entities.get(sid) if self._sketch else None
-                    e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-                    if s_ent == p1_ent and e_ent == p2_ent:
-                        if self._sketch and self._selected_entities:
-                            self._sketch.constrain_coincident(self._selected_entities[0], s_ent)
-                        break
-                    if s_ent == p2_ent and e_ent == p1_ent:
-                        if self._sketch and self._selected_entities:
-                            self._sketch.constrain_coincident(self._selected_entities[0], s_ent)
-                        break
-                self._solve_and_sync()
-                logger.info("Point-on-line constraint added")
+                line_ent = self._find_line_sketch_entity(p1_ent, p2_ent)
+                if line_ent is not None and self._sketch and self._selected_entities:
+                    # coincident(point, line) = point-on-line; needs the line handle
+                    self._sketch.constrain_coincident(self._selected_entities[0], line_ent)
+                    self._solve_and_sync()
+                    logger.info("Point-on-line constraint added")
                 self._selected_entities = []
                 self._mode = None
                 self.constrain_done.emit()
@@ -867,20 +1442,16 @@ class Sketch2DWidget(QWidget):
             line_hit = self._get_line_entity_at(world_pos)
             if line_hit:
                 p1_ent, p2_ent = line_hit
-                mirror_line = None
-                for eid, (sid, eid2) in (self._sketch._lines.items() if self._sketch else {}).items():
-                    s_ent = self._sketch._entities.get(sid) if self._sketch else None
-                    e_ent = self._sketch._entities.get(eid2) if self._sketch else None
-                    if (s_ent == p1_ent and e_ent == p2_ent) or (s_ent == p2_ent and e_ent == p1_ent):
-                        mirror_line = s_ent
-                        break
-                if mirror_line and self._sketch:
+                mirror_line = self._find_line_sketch_entity(p1_ent, p2_ent)
+                if mirror_line is not None and self._sketch:
                     self._sketch.constrain_symmetric(
                         self._selected_entities[0], self._selected_entities[1], mirror_line
                     )
                     ok = self._solve_and_sync()
                     if ok:
                         logger.info("Symmetric constraint added")
+                    else:
+                        logger.warning("Symmetric constraint failed to solve")
                     self._selected_entities = []
                     self._mode = None
                     self.constrain_done.emit()
@@ -994,20 +1565,20 @@ class Sketch2DWidget(QWidget):
                     painter.setPen(QPen(QColor("#cdd6f4"), 2))
                 painter.drawLine(sp1, sp2)
 
-                # Draw constraint labels
-                constraints = p1_ent.constraints + p2_ent.constraints
-                if constraints:
-                    labels = list(set(constraints))
-                    mid_screen = self._calculate_midpoint(sp1, sp2)
-                    painter.save()
-                    painter.translate(mid_screen)
-                    painter.scale(1, -1)
-                    painter.setPen(QPen(QColor("#f9e2af"), 1))
-                    for i, label in enumerate(labels):
-                        label_text = {"hrz": "> hrz <", "vrt": "> vrt <",
-                                      "dst": "> dst <", "mid": "> mid <"}.get(label, f"> {label} <")
-                        painter.drawText(0, i * 15, label_text)
-                    painter.restore()
+        # ── Constraint tags (log-driven; drawn upright in screen space) ──
+        # Tags are recomputed here so paint stays in sync with the latest solve.
+        self._constraint_tags = self._compute_constraint_tags()
+        tag_font = QFont("Monospace", 9)
+        painter.setFont(tag_font)
+        for tag in self._constraint_tags:
+            rect: QRect = tag["rect"]
+            hovered = tag["idx"] == self._hovered_constraint_idx
+            # Background pill so the label is readable over the sketch.
+            painter.setPen(QPen(QColor("#f9e2af"), 1 if not hovered else 2))
+            painter.setBrush(QBrush(QColor(40, 40, 60, 200)))
+            painter.drawRoundedRect(rect, 6, 6)
+            painter.setPen(QPen(QColor("#f38ba8") if hovered else QColor("#f9e2af"), 1))
+            painter.drawText(rect, Qt.AlignCenter, tag["label"])
 
         # ── Circles ──
         for center_ent, radius in self._circles:
@@ -1057,6 +1628,75 @@ class Sketch2DWidget(QWidget):
             painter.drawLine(sp1, sp2)
             self._draw_distance_measurement(painter, p1, p2)
 
+        # ── Moved-element highlight ──
+        if self._move_active and self._moving_points:
+            painter.setPen(QPen(QColor("#f38ba8"), 2))
+            painter.setBrush(Qt.NoBrush)
+            for ent in self._moving_points:
+                if ent.geometry:
+                    x, y = ent.geometry
+                    sp = self._world_to_screen(QPoint(int(round(x)), int(round(y))))
+                    painter.drawEllipse(sp, 10, 10)
+            if self._move_anchor is not None and self._move_anchor.geometry:
+                x, y = self._move_anchor.geometry
+                sp = self._world_to_screen(QPoint(int(round(x)), int(round(y))))
+                painter.setPen(QPen(QColor("#f9e2af"), 2))
+                painter.drawEllipse(sp, 12, 12)
+
+        # ── Selected face preview (detected regions) ──
+        if self._sketch:
+            faces = self._sketch.detect_faces()
+            for face in faces:
+                is_hovered = self._faces_match(face, self._hovered_face)
+                is_selected = self._faces_match(face, self._selected_face)
+                if not (is_hovered or is_selected):
+                    continue
+                path = QPainterPath()
+                outer = face["outer"]
+                if outer["type"] == "polygon":
+                    pts = outer["points"]
+                    sp0 = self._world_to_screen(QPoint(int(round(pts[0][0])), int(round(pts[0][1]))))
+                    path.moveTo(sp0.x(), sp0.y())
+                    for (px, py) in pts[1:]:
+                        sp = self._world_to_screen(QPoint(int(round(px)), int(round(py))))
+                        path.lineTo(sp.x(), sp.y())
+                    path.closeSubpath()
+                else:  # circle
+                    cx, cy = outer["center"]
+                    spc = self._world_to_screen(QPoint(int(round(cx)), int(round(cy))))
+                    sr = outer["radius"] * self._zoom
+                    path.addEllipse(spc, sr, sr)
+                # Add holes as sub-paths (odd-even fill punches them out).
+                for hole in face["holes"]:
+                    if hole["type"] == "polygon":
+                        pts = hole["points"]
+                        sp0 = self._world_to_screen(QPoint(int(round(pts[0][0])), int(round(pts[0][1]))))
+                        path.moveTo(sp0.x(), sp0.y())
+                        for (px, py) in pts[1:]:
+                            sp = self._world_to_screen(QPoint(int(round(px)), int(round(py))))
+                            path.lineTo(sp.x(), sp.y())
+                        path.closeSubpath()
+                    else:
+                        hcx, hcy = hole["center"]
+                        hspc = self._world_to_screen(QPoint(int(round(hcx)), int(round(hcy))))
+                        hsr = hole["radius"] * self._zoom
+                        path.addEllipse(hspc, hsr, hsr)
+                path.setFillRule(Qt.OddEvenFill)
+
+                # Determine colours
+                if is_selected and not is_hovered:
+                    fill = QColor(137, 180, 250, 100)  # blue-ish
+                    stroke = QPen(QColor("#89b4fa"), 2)
+                elif is_hovered:
+                    fill = QColor(249, 226, 175, 120)  # gold-ish
+                    stroke = QPen(QColor("#f9e2af"), 2)
+                else:
+                    fill = QColor(166, 227, 161, 80)  # green-ish
+                    stroke = QPen(QColor("#a6e3a1"), 1)
+                painter.setPen(stroke)
+                painter.setBrush(fill)
+                painter.drawPath(path)
+
         # ── Selected entities ──
         for entity in self._selected_entities:
             if entity.geometry:
@@ -1079,22 +1719,56 @@ class Sketch2DWidget(QWidget):
             except Exception:
                 pass
 class Viewer3DWidget(QWidget):
-    """3D viewer widget using pygfx."""
+    """3D viewer widget using OCC's native AIS display."""
 
     def __init__(self, parent=None):
         super().__init__(parent)
-        self._renderer = PygfxRenderer()
+        # For OCC's direct OpenGL rendering we need Qt to not paint over it.
+        self.setAttribute(Qt.WA_PaintOnScreen)
+        self.setAttribute(Qt.WA_OpaquePaintEvent)
+        self.setAutoFillBackground(False)
+        # Try OCC renderer first; fall back to pygfx if unavailable.
+        self._renderer: Any = None
         self._initialized = False
         self._meshes: Dict[str, Any] = {}
         self._selected_normal: Optional[Tuple[float, float, float]] = None
         self._centroid: Optional[Tuple[float, float, float]] = None
         self._pending_meshes: List[Tuple] = []
 
+    def _init_renderer(self) -> None:
+        """Create the best available renderer."""
+        if self._renderer is not None:
+            return
+        import sys as _sys
+        _sys.stdout.flush()
+        logger.info("Renderer: starting import...")
+        from fluency.rendering.occ_renderer import OCCRenderer
+        from fluency.rendering.pygfx_renderer import PygfxRenderer
+        logger.info("Renderer: imports done, creating OCCRenderer...")
+        occ = OCCRenderer()
+        logger.info("Renderer: calling occ.initialize...")
+        try:
+            ok = occ.initialize(self)
+        except Exception as exc:
+            logger.warning(f"OCCRenderer init raised: {exc}")
+            ok = False
+        logger.info(f"Renderer: OCC result={ok}")
+        if ok:
+            self._renderer = occ
+            logger.info("Using OCCRenderer (native BRep display)")
+        else:
+            logger.info("Falling back to PygfxRenderer")
+            self._renderer = PygfxRenderer()
+            logger.info("Renderer: calling pygfx initialize...")
+            self._renderer.initialize(self)
+            logger.info("Renderer: pygfx init done")
+        self._initialized = True
+        logger.info("Renderer: initialization complete")
+
     def showEvent(self, event):
         logger.info("Viewer3DWidget showEvent - initializing renderer")
         if not self._initialized:
-            self._renderer.initialize(self)
-            self._initialized = True
+            self._init_renderer()
             logger.info(f"Renderer initialized, pending meshes: {len(self._pending_meshes)}")
             for args in self._pending_meshes:
                 self.add_mesh(*args)
@@ -1104,12 +1778,43 @@ class Viewer3DWidget(QWidget):
     def _ensure_initialized(self):
         if not self._initialized:
             logger.debug("Ensuring renderer is initialized")
-            self._renderer.initialize(self)
-            self._initialized = True
+            self._init_renderer()
 
-    def get_renderer(self) -> PygfxRenderer:
+    def get_renderer(self):
+        self._ensure_initialized()
         return self._renderer
 
+    def show_shape(self, shape: Any, color=None, name=None) -> str:
+        """Display an OCC TopoDS_Shape.
+
+        Uses OCCRenderer.add_shape for native AIS display, or falls back to
+        triangulation + add_mesh for the PygfxRenderer.
+        """
+        self._ensure_initialized()
+        from fluency.rendering.occ_renderer import OCCRenderer
+        if isinstance(self._renderer, OCCRenderer):
+            oid = self._renderer.add_shape(shape, color, name)
+            self._renderer.render()
+            return oid
+        # Fallback: tessellate and use the mesh pipeline.
+        from fluency.geometry_occ.kernel import OCGeometryKernel
+        k = OCGeometryKernel()
+        from fluency.geometry_occ.sketch import OCCSketch
+        # Build a temporary OCCGeometryObject to use the kernel's mesh helpers.
+        from fluency.geometry_occ.kernel import OCCGeometryObject
+        obj = OCCGeometryObject(shape)
+        verts, faces = k.get_mesh(obj)
+        oid = self._renderer.add_mesh(verts, faces, color, name)
+        # Edges
+        try:
+            e_verts, e_edges = k.get_edges(obj)
+            if len(e_verts) > 0:
+                self._renderer.add_wireframe(e_verts, e_edges, (0.9, 0.9, 0.9), line_width=1.5, name=f"{name}_edges")
+        except Exception:
+            pass
+        self._renderer.render()
+        return oid
+
     def add_mesh(self, vertices, faces, color=None, name=None) -> str:
         logger.debug(
             f"add_mesh called: initialized={self._initialized}, vertices={len(vertices)}, faces={len(faces)}, name={name}"
@@ -1156,6 +1861,39 @@ class Viewer3DWidget(QWidget):
         self._renderer.fit_camera()
         self._renderer.render()
 
+    def mousePressEvent(self, event):
+        self._ensure_initialized()
+        self._renderer.handle_mouse_press(event)
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        self._ensure_initialized()
+        self._renderer.handle_mouse_move(event)
+        super().mouseMoveEvent(event)
+
+    def paintEngine(self):
+        """Return None to prevent Qt from painting over OCC's direct OpenGL."""
+        return None
+
+    def paintEvent(self, event):
+        """Empty paintEvent — OCC draws directly via OpenGL."""
+        pass
+
+    def mouseReleaseEvent(self, event):
+        self._ensure_initialized()
+        self._renderer.handle_mouse_release(event)
+        super().mouseReleaseEvent(event)
+
+    def wheelEvent(self, event):
+        self._ensure_initialized()
+        self._renderer.handle_wheel(event)
+        super().wheelEvent(event)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self._ensure_initialized()
+        self._renderer.handle_resize(event.size().width(), event.size().height())
+
     def set_camera_position(self, position, target):
         self._ensure_initialized()
         self._renderer.set_camera_position(position, target)
@@ -1282,9 +2020,13 @@ class MainWindow(QMainWindow):
         grid.setContentsMargins(5, 5, 5, 5)
         grid.setSpacing(4)
         grid.setColumnStretch(0, 0)  # left column fixed
-        grid.setColumnStretch(1, 1)  # sketch column expands
-        grid.setColumnStretch(2, 2)  # 3D view expands more
+        # Sketch (col 1) and 3D viewer (col 2) share the remaining width.
+        # The split is hover-driven: entering the sketch enlarges it, entering
+        # the 3D viewer grows it to 2/3 (sketch shrinks to 1/3). Resting = 1:1.
+        grid.setColumnStretch(1, 1)
+        grid.setColumnStretch(2, 1)
         grid.setColumnStretch(3, 0)  # right column fixed
+        self._grid = grid
 
         # ---- Row 0, Col 0: Workplanes ----
         wp_group = QGroupBox("Workplanes")
@@ -1325,11 +2067,16 @@ class MainWindow(QMainWindow):
         self._btn_slot = QPushButton("Slot")
         self._btn_slot.setCheckable(True)
         draw_layout.addWidget(self._btn_slot, 1, 1)
+        self._btn_move_sketch = QPushButton("Move")
+        self._btn_move_sketch.setCheckable(True)
+        self._btn_move_sketch.setToolTip("Move a drawn element (drag a point/line/rectangle/circle).")
+        self._btn_move_sketch.setShortcut("Q")
+        draw_layout.addWidget(self._btn_move_sketch, 1, 2, 1, 1)
         # separator
         sep = QFrame()
         sep.setFrameShape(QFrame.HLine)
         sep.setFrameShadow(QFrame.Sunken)
-        draw_layout.addWidget(sep, 2, 0, 1, 2)
+        draw_layout.addWidget(sep, 2, 0, 1, 3)
         self._btn_construct = QPushButton("Cstrct")
         self._btn_construct.setCheckable(True)
         draw_layout.addWidget(self._btn_construct, 3, 0)
@@ -1489,6 +2236,10 @@ class MainWindow(QMainWindow):
         viewer_layout.addWidget(self._viewer_3d)
         grid.addWidget(viewer_group, 0, 2, 9, 1)
 
+        # Focus split is toggled by Spacebar / the Layout button
+        # (see _toggle_panel_focus).
+        self._panel_focus: str = "equal"  # "equal" | "sketch" | "viewer"
+
         # ---- Row 0, Col 3: Modify ----
         modify_group = QGroupBox("Modify")
         modify_group.setMaximumWidth(200)
@@ -1511,6 +2262,10 @@ class MainWindow(QMainWindow):
         self._btn_array = QPushButton("Arry")
         self._btn_array.setToolTip("Pattern array")
         modify_layout.addWidget(self._btn_array, 2, 1)
+        self._btn_layout = QPushButton("Layout")
+        self._btn_layout.setToolTip("Layout: equal (Space to cycle)")
+        self._btn_layout.setCheckable(False)
+        modify_layout.addWidget(self._btn_layout, 3, 0, 1, 2)
         grid.addWidget(modify_group, 0, 3, 1, 1, Qt.AlignTop)
 
         # ---- Row 6, Col 3: Export ----
@@ -1580,6 +2335,52 @@ class MainWindow(QMainWindow):
         assy_layout.addWidget(self._btn_del_connector)
         grid.addWidget(assy_group, 9, 3)
 
+    def _toggle_panel_focus(self):
+        """Cycle the sketch/viewer split: equal → sketch → viewer → equal.
+
+        Driven by Spacebar and the Layout button (§_setup_connections).
+        """
+        order = ["equal", "sketch", "viewer"]
+        try:
+            nxt = order[(order.index(self._panel_focus) + 1) % len(order)]
+        except (AttributeError, ValueError):
+            nxt = "equal"
+        self._set_panel_focus(nxt)
+
+    def _set_panel_focus(self, panel: str):
+        """Set the sketch/viewer column stretches based on the focus mode."""
+        if not hasattr(self, "_grid"):
+            self._panel_focus = panel
+            return
+        self._panel_focus = panel
+        if panel == "viewer":
+            # Viewer 2/3, sketch 1/3 — more room for 3D work, sketch stays visible.
+            self._grid.setColumnStretch(1, 1)
+            self._grid.setColumnStretch(2, 2)
+        elif panel == "sketch":
+            # Sketch 2/3, viewer 1/3 — comfortable sketching, 3D stays visible.
+            self._grid.setColumnStretch(1, 2)
+            self._grid.setColumnStretch(2, 1)
+        else:  # equal
+            self._grid.setColumnStretch(1, 1)
+            self._grid.setColumnStretch(2, 1)
+        # Reflect current mode on the Layout button tooltip.
+        if hasattr(self, "_btn_layout") and self._btn_layout is not None:
+            self._btn_layout.setToolTip(self._panel_tooltip())
+        logger.info(f"Panel focus -> {self._panel_focus}")
+
+    def _panel_tooltip(self) -> str:
+        return f"Layout: {self._panel_focus} (Space to cycle)"
+
+    def keyPressEvent(self, event):
+        # Spacebar cycles the sketch/viewer split so you can grow the side you're
+        # working in without leaving the keyboard.
+        if event.key() == Qt.Key_Space:
+            self._toggle_panel_focus()
+            event.accept()
+            return
+        super().keyPressEvent(event)
+
     def _create_dock_widgets(self):
         pass
 
@@ -1588,6 +2389,7 @@ class MainWindow(QMainWindow):
         self._btn_rect.clicked.connect(lambda: self._set_sketch_mode("rectangle"))
         self._btn_circle.clicked.connect(lambda: self._set_sketch_mode("circle"))
         self._btn_slot.clicked.connect(lambda: self._set_sketch_mode("slot"))
+        self._btn_move_sketch.clicked.connect(lambda: self._set_sketch_mode("select"))
         self._btn_construct.clicked.connect(self._on_construct_change)
 
         self._btn_con_ptpt.clicked.connect(lambda: self._set_sketch_mode("constrain_coincident"))
@@ -1648,6 +2450,7 @@ class MainWindow(QMainWindow):
         # Generic buttons
         self._btn_move.clicked.connect(self._translate_body)
         self._btn_array.clicked.connect(self._pattern_array)
+        self._btn_layout.clicked.connect(self._toggle_panel_focus)
         self._btn_edit_sketch_3.clicked.connect(self._edit_sketch)
 
         # Snap toggle
@@ -1664,6 +2467,7 @@ class MainWindow(QMainWindow):
             self._btn_rect,
             self._btn_circle,
             self._btn_slot,
+            self._btn_move_sketch,
             self._btn_con_ptpt,
             self._btn_con_ptline,
             self._btn_con_horiz,
@@ -1684,6 +2488,8 @@ class MainWindow(QMainWindow):
                 self._btn_circle.setChecked(True)
             elif mode == "slot":
                 self._btn_slot.setChecked(True)
+        elif mode == "select":
+            self._btn_move_sketch.setChecked(True)
         elif mode.startswith("constrain_"):
             if mode == "constrain_coincident":
                 self._btn_con_ptpt.setChecked(True)
@@ -1701,6 +2507,7 @@ class MainWindow(QMainWindow):
             self._btn_rect,
             self._btn_circle,
             self._btn_slot,
+            self._btn_move_sketch,
             self._btn_con_ptpt,
             self._btn_con_ptline,
             self._btn_con_horiz,
@@ -1787,22 +2594,10 @@ class MainWindow(QMainWindow):
         if self._current_component:
             for body_id, body in self._current_component.bodies.items():
                 if body.geometry:
-                    vertices, faces = body.get_mesh(self._kernel)
-                    mesh_id = self._viewer_3d.add_mesh(
-                        vertices, faces, body.color, body.name
-                    )
-                    body.render_object = mesh_id
-                    # Add wireframe edges
-                    try:
-                        edge_verts, edge_indices = body.get_edges(self._kernel)
-                        if len(edge_verts) > 0 and len(edge_indices) > 0:
-                            self._viewer_3d.add_wireframe(
-                                edge_verts, edge_indices, (0.9, 0.9, 0.9),
-                                line_width=1.5,
-                                name=f"{body.name}_edges"
-                            )
-                    except Exception as e:
-                        logger.debug(f"Could not add wireframe for {body.name}: {e}")
+                    logger.debug(f"Redrawing body: {body.name}")
+                    shape = self._kernel._get_shape(body.geometry)
+                    body.render_object = self._viewer_3d.show_shape(shape, body.color, body.name)
+                    logger.info(f"Redraw render object: {body.render_object}")
 
         self._viewer_3d.fit_camera()
 
@@ -1959,15 +2754,24 @@ class MainWindow(QMainWindow):
 
         try:
             logger.debug("Getting geometry from sketch")
-            geometry = sketch.occ_sketch.get_geometry()
-            logger.debug(f"Geometry: {geometry}")
+            # Prefer the selected face (which can include holes) over the full sketch.
+            face_geom = self._sketch_widget.get_selected_face_geometry()
+            if face_geom is not None:
+                geometry = face_geom
+                logger.info("Using selected face geometry (with holes)")
+            else:
+                geometry = sketch.occ_sketch.get_geometry()
+                logger.debug(f"Geometry: {geometry}")
             if not geometry:
                 logger.error("No geometry from sketch")
                 QMessageBox.warning(self, "No Geometry", "Sketch has no valid geometry")
                 return
 
             logger.info("Calling kernel.extrude")
-            body_geometry = self._kernel.extrude(geometry, length, symmetric=symmetric)
+            # Apply invert: the user-input length is always positive; invert
+            # flips the extrusion direction (plus is +Z, minus is -Z).
+            extrude_length = -length if invert else length
+            body_geometry = self._kernel.extrude(geometry, extrude_length, symmetric=symmetric)
             logger.debug(f"Body geometry created: {body_geometry}")
 
             body = self._current_component.add_body(
@@ -1980,10 +2784,6 @@ class MainWindow(QMainWindow):
             )
             logger.info(f"Created body: {body.name}")
 
-            logger.debug("Getting mesh for body")
-            vertices, faces = body.get_mesh(self._kernel)
-            logger.info(f"Mesh: {len(vertices)} vertices, {len(faces)} faces")
-
             # Handle cut/union options from dialog
             if cut and self._current_component.bodies:
                 logger.info("Applying cut after extrude")
@@ -1995,8 +2795,7 @@ class MainWindow(QMainWindow):
                             target.geometry, body_geometry
                         )
                         body.geometry = result_geom
-                        vertices, faces = body.get_mesh(self._kernel)
-                        logger.info(f"Cut applied, mesh now {len(vertices)} verts")
+                        logger.info("Cut applied")
                     except Exception as ce:
                         logger.warning(f"Cut failed: {ce}")
             elif union and self._current_component.bodies:
@@ -2009,27 +2808,15 @@ class MainWindow(QMainWindow):
                             target.geometry, body_geometry
                         )
                         body.geometry = result_geom
-                        vertices, faces = body.get_mesh(self._kernel)
-                        logger.info(f"Union applied, mesh now {len(vertices)} verts")
+                        logger.info(f"Union applied")
                     except Exception as ue:
                         logger.warning(f"Union failed: {ue}")
 
-            logger.debug("Adding mesh to viewer")
-            body.render_object = self._viewer_3d.add_mesh(vertices, faces, body.color, body.name)
+            logger.debug("Adding shape to OCC viewer")
+            shape = self._kernel._get_shape(body.geometry)
+            body.render_object = self._viewer_3d.show_shape(shape, body.color, body.name)
             logger.info(f"Render object: {body.render_object}")
 
-            # Add wireframe edges
-            try:
-                edge_verts, edge_indices = body.get_edges(self._kernel)
-                if len(edge_verts) > 0 and len(edge_indices) > 0:
-                    self._viewer_3d.add_wireframe(
-                        edge_verts, edge_indices, (0.9, 0.9, 0.9),
-                        line_width=1.5,
-                        name=f"{body.name}_edges"
-                    )
-            except Exception as e:
-                logger.debug(f"Could not add wireframe: {e}")
-
             self._refresh_lists()
             self._viewer_3d.fit_camera()
             logger.info(f"Extruded: {body.name}")
@@ -2061,7 +2848,11 @@ class MainWindow(QMainWindow):
         angle = dialog.angle_input.value()
 
         try:
-            geometry = sketch.occ_sketch.get_geometry()
+            face_geom = self._sketch_widget.get_selected_face_geometry()
+            if face_geom is not None:
+                geometry = face_geom
+            else:
+                geometry = sketch.occ_sketch.get_geometry()
             if not geometry:
                 QMessageBox.warning(self, "No Geometry", "Sketch has no valid geometry")
                 return
@@ -2076,22 +2867,10 @@ class MainWindow(QMainWindow):
                 )
             )
 
-            vertices, faces = body.get_mesh(self._kernel)
-            body.render_object = self._viewer_3d.add_mesh(
-                vertices, faces, body.color, body.name
-            )
-
-            # Add wireframe edges
-            try:
-                edge_verts, edge_indices = body.get_edges(self._kernel)
-                if len(edge_verts) > 0 and len(edge_indices) > 0:
-                    self._viewer_3d.add_wireframe(
-                        edge_verts, edge_indices, (0.9, 0.9, 0.9),
-                        line_width=1.5,
-                        name=f"{body.name}_edges"
-                    )
-            except Exception as e:
-                logger.debug(f"Could not add wireframe: {e}")
+            logger.debug("Adding shape to OCC viewer")
+            shape = self._kernel._get_shape(body_geometry)
+            body.render_object = self._viewer_3d.show_shape(shape, body.color, body.name)
+            logger.info(f"Render object: {body.render_object}")
 
             self._refresh_lists()
             self._viewer_3d.fit_camera()
@@ -2148,22 +2927,10 @@ class MainWindow(QMainWindow):
                 )
             )
 
-            vertices, faces = new_body.get_mesh(self._kernel)
-            new_body.render_object = self._viewer_3d.add_mesh(
-                vertices, faces, new_body.color, new_body.name
-            )
-
-            # Add wireframe edges
-            try:
-                edge_verts, edge_indices = new_body.get_edges(self._kernel)
-                if len(edge_verts) > 0 and len(edge_indices) > 0:
-                    self._viewer_3d.add_wireframe(
-                        edge_verts, edge_indices, (0.9, 0.9, 0.9),
-                        line_width=1.5,
-                        name=f"{new_body.name}_edges"
-                    )
-            except Exception as e:
-                logger.debug(f"Could not add wireframe: {e}")
+            logger.debug("Adding shape to OCC viewer")
+            shape = self._kernel._get_shape(result_geom)
+            new_body.render_object = self._viewer_3d.show_shape(shape, new_body.color, new_body.name)
+            logger.info(f"Render object: {new_body.render_object}")
 
             self._refresh_lists()
             self._viewer_3d.fit_camera()
@@ -2196,22 +2963,10 @@ class MainWindow(QMainWindow):
                 )
             )
 
-            vertices, faces = new_body.get_mesh(self._kernel)
-            new_body.render_object = self._viewer_3d.add_mesh(
-                vertices, faces, new_body.color, new_body.name
-            )
-
-            # Add wireframe edges
-            try:
-                edge_verts, edge_indices = new_body.get_edges(self._kernel)
-                if len(edge_verts) > 0 and len(edge_indices) > 0:
-                    self._viewer_3d.add_wireframe(
-                        edge_verts, edge_indices, (0.9, 0.9, 0.9),
-                        line_width=1.5,
-                        name=f"{new_body.name}_edges"
-                    )
-            except Exception as e:
-                logger.debug(f"Could not add wireframe: {e}")
+            logger.debug("Adding shape to OCC viewer")
+            shape = self._kernel._get_shape(result_geom)
+            new_body.render_object = self._viewer_3d.show_shape(shape, new_body.color, new_body.name)
+            logger.info(f"Render object: {new_body.render_object}")
 
             self._refresh_lists()
             self._viewer_3d.fit_camera()
diff --git a/src/fluency/rendering/__init__.py b/src/fluency/rendering/__init__.py
index bc219f1..197b7d7 100644
--- a/src/fluency/rendering/__init__.py
+++ b/src/fluency/rendering/__init__.py
@@ -6,6 +6,7 @@ from fluency.rendering.base import (
     RenderColor,
 )
 from fluency.rendering.pygfx_renderer import PygfxRenderer, PygfxRenderObject
+from fluency.rendering.occ_renderer import OCCRenderer, OCCRenderObject
 
 __all__ = [
     "Renderer",
diff --git a/src/fluency/rendering/occ_renderer.py b/src/fluency/rendering/occ_renderer.py
new file mode 100644
index 0000000..e53c9e2
--- /dev/null
+++ b/src/fluency/rendering/occ_renderer.py
@@ -0,0 +1,504 @@
+"""OCC-based 3D renderer — displays BRep shapes directly on the GPU.
+
+Uses OCC's ``AIS_Shape`` and ``V3d_Viewer`` so that curved surfaces (cylinders,
+spheres, etc.) render smoothly without manual triangulation, and edges/faces are
+natively selectable.
+"""
+
+import logging
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+
+from .base import Renderer, RenderObject, RenderColor
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OCCRenderObject(RenderObject):
+    """Internal object state for the OCC renderer."""
+
+    obj_id: str = ""
+    ais_shape: Any = None  # AIS_Shape
+    ais_type: str = "shape"  # "shape" | "wireframe" | "points"
+    color: RenderColor = field(default_factory=lambda: RenderColor(0.5, 0.5, 0.5))
+
+
+class OCCRenderer(Renderer):
+    """Renderer that uses OCC's native AIS display for smooth BRep rendering."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._viewer: Any = None
+        self._view: Any = None
+        self._context: Any = None
+        self._window: Any = None
+        self._initialized: bool = False
+        self._objects: Dict[str, OCCRenderObject] = {}
+        self._parent_widget: Any = None
+        self._last_mouse_x: int = 0
+        self._last_mouse_y: int = 0
+
+    def initialize(self, parent_widget: Any) -> bool:
+        """Initialise OCC viewer inside *parent_widget* (a QWidget)."""
+        self._parent_widget = parent_widget
+
+        import os as _os
+        if _os.environ.get("QT_QPA_PLATFORM") == "offscreen":
+            logger.warning("OCCRenderer skipped (QT_QPA_PLATFORM=offscreen)")
+            return False
+
+        logger.info("OCCRenderer imports starting...")
+        from OCP.Aspect import (
+            Aspect_DisplayConnection,
+            Aspect_NeutralWindow,
+            Aspect_GFM_VER,
+        )
+        from OCP.OpenGl import OpenGl_GraphicDriver
+        from OCP.V3d import V3d_Viewer, V3d_View, V3d_TypeOfView
+        from OCP.AIS import AIS_InteractiveContext
+        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
+        logger.info("OCCRenderer imports complete")
+
+        hwnd = int(parent_widget.winId())
+        if hwnd <= 1:
+            logger.warning("OCCRenderer skipped (no native window handle)")
+            return False
+
+        logger.info("OCCRenderer creating objects...")
+
+        try:
+            display = Aspect_DisplayConnection()
+            driver = OpenGl_GraphicDriver(display)
+            viewer = V3d_Viewer(driver)
+            viewer.SetDefaultLights()
+            viewer.SetLightOn()
+
+            view = V3d_View(viewer, V3d_TypeOfView.V3d_ORTHOGRAPHIC)
+            viewer.SetDefaultBgGradientColors(
+                Quantity_Color(0.15, 0.15, 0.2, Quantity_TOC_RGB),
+                Quantity_Color(0.25, 0.25, 0.3, Quantity_TOC_RGB),
+                Aspect_GFM_VER,
+            )
+
+            context = AIS_InteractiveContext(viewer)
+
+            # Attach OCC view to the Qt widget via the native window handle.
+            win = Aspect_NeutralWindow()
+            win.SetNativeHandle(hwnd)
+            w, h = parent_widget.width(), parent_widget.height()
+            win.SetSize(w, h)
+            view.SetWindow(win)
+
+            self._viewer = viewer
+            self._view = view
+            self._context = context
+            self._window = win
+            self._initialized = True
+
+            logger.info("OCCRenderer initialised (native OCC display)")
+            return True
+
+        except Exception as exc:
+            logger.error(f"OCCRenderer initialisation failed: {exc}")
+            self._initialized = False
+            return False
+
+    def shutdown(self) -> None:
+        """Clean up OCC viewer resources."""
+        self.clear_scene()
+        if self._view is not None:
+            self._view.Remove()
+            self._view = None
+        if self._viewer is not None:
+            self._viewer.Remove()
+            self._viewer = None
+        self._initialized = False
+
+    # ─── BRep shape display (primary entry point) ───────────────────────
+
+    def add_shape(
+        self,
+        shape: Any,
+        color: Optional[Tuple[float, float, float]] = None,
+        name: Optional[str] = None,
+    ) -> str:
+        """Display an OCC ``TopoDS_Shape`` directly via ``AIS_Shape``.
+
+        Returns a unique object ID (or *name* if provided).
+        """
+        from OCP.AIS import AIS_Shape
+        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
+        from OCP.Prs3d import Prs3d_Drawer
+
+        obj_id = name or f"shape_{uuid.uuid4().hex[:8]}"
+
+        ais = AIS_Shape(shape)
+
+        if color is not None:
+            qcol = Quantity_Color(*color, Quantity_TOC_RGB)
+            ais.SetColor(qcol)
+
+        # Enable selection of edges and faces.
+        ais.SetDisplayMode(1)  # 0 = wireframe, 1 = shaded
+        ais.SetMaterial(
+            self._default_material()
+        )  # use a helper to get the default material
+
+        self._context.Display(ais, True)
+        self._context.Deactivate(ais)
+
+        defcol = color or (0.5, 0.5, 0.5)
+        robj = OCCRenderObject(
+            obj_id=obj_id,
+            ais_shape=ais,
+            ais_type="shape",
+            color=RenderColor(*defcol),
+        )
+        self._objects[obj_id] = robj
+
+        # Fit camera on first shape added.
+        if len(self._objects) == 1:
+            try:
+                self.fit_camera()
+            except Exception:
+                logger.warning("fit_camera failed on first shape", exc_info=True)
+
+        return obj_id
+
+    def _default_material(self):
+        """Return a default Graphic3d_MaterialAspect for shading."""
+        from OCP.Graphic3d import Graphic3d_MaterialAspect, Graphic3d_NameOfMaterial
+
+        return Graphic3d_MaterialAspect(
+            Graphic3d_NameOfMaterial.Graphic3d_NOM_PLASTIC
+        )
+
+    # ─── Legacy mesh / wireframe (kept for backward compat) ────────────
+
+    def add_mesh(
+        self,
+        vertices: np.ndarray,
+        faces: np.ndarray,
+        color: Tuple[float, float, float] = (0.2, 0.4, 0.8),
+        name: Optional[str] = None,
+    ) -> str:
+        """Add triangulated mesh by converting it to an OCC polygonal shape.
+
+        Prefer :meth:`add_shape` for native BRep display — it avoids meshing
+        artifacts on curved surfaces.
+        """
+        from OCP.Poly import Poly_Triangulation, Poly_Triangle
+        from OCP.TopoDS import TopoDS_Face
+        from OCP.BRep import BRep_Builder
+        from OCP.gp import gp_Pnt
+
+        n_verts = len(vertices)
+        n_tris = len(faces)
+
+        # Build triangulation via (nbNodes, nbTriangles, hasUVNodes) constructor
+        tri = Poly_Triangulation(n_verts, n_tris, False)
+
+        for i, (x, y, z) in enumerate(vertices):
+            tri.SetNode(i + 1, gp_Pnt(float(x), float(y), float(z)))
+
+        for i, (a, b, cc) in enumerate(faces):
+            tri.SetTriangle(i + 1, Poly_Triangle(int(a) + 1, int(b) + 1, int(cc) + 1))
+
+        builder = BRep_Builder()
+        shape = TopoDS_Face()
+        builder.MakeFace(shape, tri)
+        return self.add_shape(shape, color, name)
+
+    def add_wireframe(
+        self,
+        vertices: np.ndarray,
+        edges: np.ndarray,
+        color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
+        line_width: float = 1.0,
+        name: Optional[str] = None,
+    ) -> str:
+        """Add a wireframe from edge data (legacy, kept for compatibility).
+
+        For new code prefer :meth:`add_shape` — OCC's AIS displays the
+        shape boundary automatically.
+        """
+        obj_id = name or f"wf_{uuid.uuid4().hex[:8]}"
+        logger.debug(f"add_wireframe {obj_id} — ignored (AIS draws edges natively)")
+        # Wireframes are already provided by the AIS shaded display, so we
+        # skip explicit line geometry unless there is a specific need.
+        return obj_id
+
+    def add_points(
+        self,
+        points: np.ndarray,
+        color: Tuple[float, float, float] = (1.0, 0.0, 0.0),
+        size: float = 5.0,
+        name: Optional[str] = None,
+    ) -> str:
+        """Add point cloud (not yet implemented with OCC renderer)."""
+        obj_id = name or f"pts_{uuid.uuid4().hex[:8]}"
+        logger.debug(f"add_points {obj_id} — not implemented in OCCRenderer")
+        return obj_id
+
+    def add_lines(
+        self,
+        start_points: np.ndarray,
+        end_points: np.ndarray,
+        color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
+        line_width: float = 1.0,
+        name: Optional[str] = None,
+    ) -> str:
+        """Add line segments (not yet implemented with OCC renderer)."""
+        obj_id = name or f"ln_{uuid.uuid4().hex[:8]}"
+        logger.debug(f"add_lines {obj_id} — not implemented in OCCRenderer")
+        return obj_id
+
+    # ─── Object management ─────────────────────────────────────────────
+
+    def remove_object(self, obj: OCCRenderObject) -> bool:
+        """Remove an object from the scene."""
+        if obj.ais_shape is not None:
+            self._context.Remove(obj.ais_shape, True)
+        if obj.obj_id in self._objects:
+            del self._objects[obj.obj_id]
+            return True
+        return False
+
+    def remove_mesh(self, obj_id: str) -> None:
+        """Remove an object by ID (legacy compatibility)."""
+        obj = self._objects.get(obj_id)
+        if obj is not None:
+            self.remove_object(obj)
+
+    def clear_scene(self) -> None:
+        """Remove all objects from the scene."""
+        if self._context is None:
+            return
+        # Remove all displayed AIS objects.
+        from OCP.AIS import AIS_KindOfInteractive
+
+        objs = self._context.DisplayedObjects()
+        for ais in objs:
+            self._context.Remove(ais, True)
+        self._objects.clear()
+
+    def update_mesh(
+        self,
+        obj: OCCRenderObject,
+        vertices: np.ndarray,
+        faces: np.ndarray,
+    ) -> bool:
+        """Update mesh geometry (not supported for OCC shapes; re-add instead)."""
+        logger.warning("update_mesh not supported for OCC shapes — remove + re-add")
+        return False
+
+    # ─── Display properties ────────────────────────────────────────────
+
+    def set_object_color(
+        self,
+        obj: OCCRenderObject,
+        color: Tuple[float, float, float],
+    ) -> None:
+        """Set the colour of an object."""
+        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
+
+        if obj.ais_shape is not None:
+            qcol = Quantity_Color(*color, Quantity_TOC_RGB)
+            obj.ais_shape.SetColor(qcol)
+            self._context.RecomputePrsOnly(obj.ais_shape, True)
+
+    def set_object_visible(self, obj: OCCRenderObject, visible: bool) -> None:
+        """Show or hide an object."""
+        if obj.ais_shape is not None:
+            if visible:
+                self._context.Display(obj.ais_shape, True)
+            else:
+                self._context.Erase(obj.ais_shape, True)
+
+    # ─── Camera ────────────────────────────────────────────────────────
+
+    def set_camera_position(
+        self,
+        position: Tuple[float, float, float],
+        target: Tuple[float, float, float] = (0, 0, 0),
+        up: Tuple[float, float, float] = (0, 0, 1),
+    ) -> None:
+        """Set camera position and orientation."""
+        if self._view is None:
+            return
+        from OCP.gp import gp_Pnt, gp_Dir, gp_Vec
+
+        self._view.SetProj(gp_Dir(position[0], position[1], position[2]))
+        self._view.SetEye(gp_Pnt(*position))
+        self._view.SetCenter(gp_Pnt(*target))
+        self._view.SetUp(gp_Dir(*up))
+
+    def get_camera_position(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Get camera position, target, and up vector."""
+        if self._view is None:
+            return (
+                np.array([1, 1, 1]),
+                np.array([0, 0, 0]),
+                np.array([0, 0, 1]),
+            )
+        eye = self._view.Eye()
+        center = self._view.Center()
+        up = self._view.Up()
+        return (
+            np.array([eye.X(), eye.Y(), eye.Z()]),
+            np.array([center.X(), center.Y(), center.Z()]),
+            np.array([up.X(), up.Y(), up.Z()]),
+        )
+
+    def fit_camera(self, padding: float = 0.05) -> None:
+        """Fit camera to show all displayed objects.
+
+        *padding* is the margin coefficient (0 ≤ padding < 1.0) passed to
+        OCC's ``FitAll``, not a multiplicative factor.  A small value like
+        0.05 adds 5% margin around the bounding box.
+        """
+        if self._view is None:
+            return
+        margin = max(0.0, min(padding, 0.99))
+        self._view.FitAll(margin)
+
+    def set_camera_perspective(
+        self, fov: float = 50.0, near: float = 0.1, far: float = 10000.0
+    ) -> None:
+        """Set perspective camera."""
+        if self._view is None:
+            return
+        from OCP.V3d import V3d_PERSPECTIVE
+
+        self._view.SetComputedMode(False)  # manual mode
+        self._view.ChangeRenderingParams()
+        # perspective/orthographic toggle handled in set_camera_orthographic
+
+    def set_camera_orthographic(
+        self, width: float = 100.0, near: float = 0.1, far: float = 10000.0
+    ) -> None:
+        """Set orthographic camera."""
+        if self._view is None:
+            return
+        from OCP.V3d import V3d_ORTHOGRAPHIC
+
+        self._view.SetComputedMode(False)
+
+    # ─── Rendering ─────────────────────────────────────────────────────
+
+    def render(self) -> None:
+        """Redraw the OCC view."""
+        if self._view is None:
+            return
+        self._view.Redraw()
+
+    def screenshot(self, width: int, height: int) -> bytes:
+        """Take a screenshot."""
+        return b""
+
+    # ─── Stub implementations for remaining abstract methods ──────────
+
+    def add_axes(self, size: float = 100.0) -> None:
+        """Add coordinate axes."""
+        pass
+
+    def add_grid(self, size: float = 100.0) -> None:
+        """Add a reference grid."""
+        pass
+
+    def get_screen_size(self) -> Tuple[int, int]:
+        if self._parent_widget:
+            return self._parent_widget.width(), self._parent_widget.height()
+        return (800, 600)
+
+    def on_camera_change(self, callback: Any) -> None:
+        pass
+
+    def on_pick(self, callback: Any) -> None:
+        pass
+
+    def project_to_screen(
+        self, point: Tuple[float, float, float]
+    ) -> Tuple[float, float]:
+        return (0.0, 0.0)
+
+    def save_screenshot(self, path: str, width: int = 1920, height: int = 1080) -> None:
+        logger.warning("save_screenshot not implemented for OCCRenderer")
+
+    def set_background_color(self, color: Tuple[float, float, float]) -> None:
+        if self._view is None:
+            return
+        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
+        qcol = Quantity_Color(*color, Quantity_TOC_RGB)
+        self._view.SetBackgroundColor(qcol)
+
+    def take_screenshot(self) -> bytes:
+        return b""
+
+    def unproject_from_screen(
+        self, x: float, y: float
+    ) -> Tuple[float, float, float]:
+        return (0.0, 0.0, 0.0)
+
+    # ─── Mouse event forwarding ────────────────────────────────────────
+
+    def handle_mouse_press(self, event) -> None:
+        """Forward a QMouseEvent to the OCC view for orbit/pan/zoom/select."""
+        from OCP.Aspect import Aspect_VKeyMouse
+        from OCP.AIS import AIS_SelectionScheme
+
+        if self._view is None or self._context is None:
+            return
+
+        # Middle mouse → start rotation
+        if event.button() == 4:  # Qt.MiddleButton
+            self._view.StartRotation(event.x(), event.y())
+        # Left mouse → try selection (OCC picks nearest shape)
+        elif event.button() == 1:  # Qt.LeftButton
+            self._context.Select(True)
+
+    def handle_mouse_move(self, event) -> None:
+        """Forward mouse motion to OCC view (rotation, dynamic highlighting)."""
+        from OCP.Aspect import Aspect_VKeyMouse
+
+        if self._view is None or self._context is None:
+            return
+
+        buttons = event.buttons()
+        if buttons & 4:  # Qt.MiddleButton
+            self._view.Rotation(event.x(), event.y())
+        elif buttons & 2:  # Qt.RightButton
+            dx = event.x() - self._last_mouse_x
+            dy = event.y() - self._last_mouse_y
+            self._view.Pan(dx, dy)
+        # Dynamic highlighting (detect)
+        self._context.MoveTo(event.x(), event.y(), self._view, True)
+
+        self._last_mouse_x = event.x()
+        self._last_mouse_y = event.y()
+
+    def handle_mouse_release(self, event) -> None:
+        """End rotation/pan."""
+        pass
+
+    def handle_wheel(self, event) -> None:
+        """Zoom on scroll."""
+        if self._view is None:
+            return
+        delta = event.angleDelta().y()
+        if delta > 0:
+            self._view.SetZoom(1.1)
+        else:
+            self._view.SetZoom(0.9)
+
+    def handle_resize(self, w: int, h: int) -> None:
+        """Resize the OCC view when the widget is resized."""
+        if self._window is not None:
+            self._window.SetSize(w, h)
+        if self._view is not None:
+            self._view.MustBeResized()
+            self._view.Redraw()