Fix parametric dimension dot clicks broken by bim.cross_select BLOCKING modal

Blender fires all matching tool-keymap entries' invoke() even after an
earlier entry returned RUNNING_MODAL.  When cross-select is enabled,
bim.cross_select (bl_options BLOCKING) goes modal on every LMB press
alongside bim.click_nearest_dimension_anchor.  Its BLOCKING flag causes
it to win the RELEASE event, selecting the background object instead of
activating the anchor dot.

Fix: CrossSelect.invoke() now calls _near_dimension_dot() before going
modal.  If a parametric dimension anchor dot is within 15 px of the
cursor it returns PASS_THROUGH, yielding to ClickNearestDimensionAnchor.

Also fixes apply_cross_select_preference to preserve pre-selection
entries (e.g. ClickNearestDimensionAnchor) when rebuilding tool keymaps:
replaces _tool_extra_keymap (which assumed the selection block starts at
index 0) with _split_tool_keymap, which searches for the selection block
by operator name and returns (pre, post) slices independently.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/bonsai/Makefile

@@ -192,11 +192,7 @@ endif
 	# Provides networkx graph analysis for project dependency calculations
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download networkx --dest=./wheels
 	# Required by IFCDiff
-	# Pinned <9.1: deepdiff 9.1.0 adds cachebox<6,>=5.2 which only ships macOS x86_64
-	# wheels for macosx_10_12+ and is incompatible with our macos py311 --platform
-	# macosx_10_10_x86_64 target. Revisit once the macos py311 platform tag is bumped
-	# to 10_13 (matching py312/py313).
-	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download "deepdiff<9.1" --dest=./wheels
+	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download deepdiff --dest=./wheels
 	# Required by IFCCSV and ifcopenshell.util.selector
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download lark --dest=./wheels
 	# Required by IFC4D
@@ -360,10 +356,6 @@ else
 	pytest test/tool/test_$(MODULE).py --maxfail=1
 endif
 
-.PHONY: test-modal
-test-modal:
-	blender --enable-event-simulate --python test/modal/test_modal.py --window-maximized
-
 # Reregistering test is not added to the standard test suite because during unregister
 # Blender removes all Bonsai dependencies breaking dev-environment symlinks.
 .PHONY: test-reregister

src/bonsai/bonsai/bim/__init__.py

@@ -176,6 +176,7 @@ classes = [
     # fields. Driven by ``tool.Parametric.EDIT_TYPES``.
     *_parametric_gizmo_preference_classes(),
     ui.GizmoPreferences,
+    ui.CrossSelectPreferences,
     # ui.DefaultParameters and ui.BIM_ADDON_preferences are registered separately after modules (see late_classes below)
     # Tabs panel
     ui.BIM_PT_tabs,
@@ -333,6 +334,10 @@ def register():
     tool.Blender.ensure_bin_in_path()
     # RestrictedContext doesn't allow accessing scene attribute, postpone it for a bit.
     bpy.app.timers.register(tool.Blender.setup_user_data_dir, first_interval=0.1)
+    # Tools are imported (and their bl_keymap baked) before preferences exist, so they
+    # default to the Cross Select keymap. Once prefs are available, apply the saved
+    # preference (no-op unless the user disabled Cross Select).
+    bpy.app.timers.register(tool.Blender.apply_cross_select_preference, first_interval=0.1)
 
 
 def unregister():

src/bonsai/bonsai/bim/handler.py

@@ -46,7 +46,6 @@ from bonsai.bim.module.model.decorator import (
     BoundingBoxDecorator,
     SlabDirectionDecorator,
     WallAxisDecorator,
-    WallFilletPreviewDecorator,
 )
 from bonsai.bim.module.model.preview_base import discard_pending_previews
 from bonsai.bim.module.nest.decorator import NestDecorator
@@ -151,14 +150,7 @@ def update_bim_tool_props():
                 return
 
             if is_bim_tool:
-                try:
-                    props.ifc_class = element_type.is_a()
-                except TypeError:
-                    # ifc_class only lists element/space types present in the model, so an
-                    # unsupported type (e.g. a raw IfcTypeProduct) or a stale item list mid-
-                    # rebuild raises `enum "<class>" not found`. Skip rather than crash the
-                    # handler — it re-fires on the next selection and the panel resyncs.
-                    pass
+                props.ifc_class = element_type.is_a()
 
             # Only assign when the target enum is the one that lists this type — otherwise
             # we hit `enum "<id>" not found in (...)` if the user selects an element of a
@@ -470,7 +462,6 @@ def _install_viewport_overlays() -> None:
     NestDecorator.uninstall()
     WallAxisDecorator.uninstall()
     SlabDirectionDecorator.uninstall()
-    WallFilletPreviewDecorator.uninstall()
     uninstall_decorator_cache_handlers()
     try:
         if georeference_props.should_visualise:
@@ -485,10 +476,6 @@ def _install_viewport_overlays() -> None:
             SlabDirectionDecorator.install(bpy.context)
         if model_props.show_bounding_box:
             BoundingBoxDecorator.install(bpy.context)
-        # Always-installed: draw() self-polls on Scene.BIMPreviewProperties.
-        # wall_fillet.is_active, so installation has no cost when no preview
-        # is open. No corresponding addon-preference toggle.
-        WallFilletPreviewDecorator.install(bpy.context)
     finally:
         install_decorator_cache_handlers()
 

src/bonsai/bonsai/bim/module/drawing/__init__.py

@@ -138,24 +138,15 @@ classes = (
     gizmos.GizmoArrow2D,
     gizmos.GizmoCone,
     gizmos.GizmoDimension,
-    gizmos.GizmoLockOpen,
-    gizmos.GizmoLockClosed,
+    gizmos.GizmoLock,
     gizmos.GizmoArc,
-    gizmos.GizmoFillet,
-    gizmos.GizmoWallCornerIcon,
-    gizmos.GizmoWallTeeIcon,
     gizmos.GizmoPen,
     gizmos.GizmoValidate,
     gizmos.GizmoCancel,
     gizmos.GizmoPlus,
     gizmos.GizmoMinus,
-    gizmos.GizmoTrash,
-    gizmos.GizmoArrayParent,
-    gizmos.GizmoArrayAll,
-    gizmos.GizmoArrayLayerIndicator,
     gizmos.GizmoMerge,
     gizmos.GizmoSplit,
-    gizmos.GizmoUnjoin,
     gizmos.GizmoExtend,
     gizmos.GizmoExtendVertical,
     gizmos.GizmoOffsetExterior,
@@ -163,7 +154,6 @@ classes = (
     gizmos.GizmoOffsetInterior,
     gizmos.GizmoAddOpening,
     gizmos.GizmoCycle,
-    gizmos.GizmoMenu,
     # Drawing-specific gizmos
     gizmos.UglyDotGizmo,
     gizmos.ExtrusionGuidesGizmo,

src/bonsai/bonsai/bim/module/geometry/data.py

@@ -44,12 +44,8 @@ class ViewportData:
 
     @classmethod
     def load(cls):
-        # Populate data BEFORE flipping is_loaded so a raising ``mode()``
-        # call doesn't leave the class half-loaded (flag set, dict empty).
-        # Subsequent items-callback invocations skip load() on a True flag
-        # and would hit ``cls.data["mode"]`` → KeyError.
-        cls.data = {"mode": cls.mode()}
         cls.is_loaded = True
+        cls.data = {"mode": cls.mode()}
 
     @classmethod
     def mode(cls) -> tool.Blender.BLENDER_ENUM_ITEMS:

src/bonsai/bonsai/bim/module/geometry/operator.py

@@ -60,7 +60,6 @@ import bonsai.core.root
 import bonsai.core.spatial
 import bonsai.tool as tool
 from bonsai.bim.ifc import IfcStore
-from bonsai.bim.module.model import preview_base
 from bonsai.bim.module.model.decorator import ProfileDecorator
 
 if TYPE_CHECKING:
@@ -2229,8 +2228,6 @@ class OverrideEscape(bpy.types.Operator):
             bpy.ops.bim.hide_all_openings()
         elif tool.Aggregate.get_aggregate_props().in_aggregate_mode:
             bpy.ops.bim.disable_aggregate_mode()
-        elif preview_base.try_cancel_active_preview(context):
-            pass
         elif active_object := context.active_object:
             if tool.Blender.Modifier.try_canceling_editing_modifier_parameters_or_path(active_object):
                 pass

src/bonsai/bonsai/bim/module/model/__init__.py

@@ -61,8 +61,6 @@ classes = (
     array.Input3DCursorXArray,
     array.Input3DCursorYArray,
     array.Input3DCursorZArray,
-    array.EnableEditingParametric,
-    array.AddArrayFromFeatureEdit,
     product.AddDefaultType,
     product.AddEmptyType,
     product.AddOccurrence,
@@ -73,6 +71,7 @@ classes = (
     product.MirrorElements,
     product.SetActiveType,
     workspace.Hotkey,
+    workspace.CrossSelect,
     workspace.BIM_MT_add_representation_item,
     wall.AddWallsFromSlab,
     wall.AlignWall,
@@ -85,7 +84,6 @@ classes = (
     wall.EnableEditingWall,
     wall.ExtendWallHeightToCursor,
     wall.ExtendWallsToUnderside,
-    wall.RegenerateWallToUnderside,
     wall.ExtendWallsToWall,
     wall.ExtendWallsToPolylinePoint,
     wall.ExtendWallToCursor,
@@ -94,10 +92,7 @@ classes = (
     wall.GizmoWallAddOpening,
     wall.GizmoWallEdition,
     wall.GizmoWallExtendVertically,
-    wall.GizmoWallFilletPreview,
-    wall.GizmoWallFilletReedit,
     wall.GizmoWallJoinIntersection,
-    wall.GizmoWallUnjoinSingle,
     wall.JoinWallsIntersection,
     wall.MergeWall,
     wall.OffsetWalls,
@@ -106,13 +101,7 @@ classes = (
     wall.SplitWall,
     wall.SplitWallAtCursor,
     wall.ToggleWallOpenings,
-    wall.UnjoinWallPathConnection,
     wall.UnjoinWalls,
-    wall.EnableWallFilletPreview,
-    wall.FinishWallFilletPreview,
-    wall.CancelWallFilletPreview,
-    wall.EnableWallFilletPreviewFromCorner,
-    wall.CreateWallFillet,
     opening.AddBoolean,
     opening.CloneOpening,
     opening.EditOpenings,
@@ -173,8 +162,6 @@ classes = (
     prop.BIMWallProperties,
     prop.BIMPolylineProperties,
     prop.BIMExternalParametricGeometryProperties,
-    prop.BIMWallFilletPreviewProperties,
-    prop.BIMPreviewProperties,
     ui.BIM_PT_array,
     ui.BIM_PT_stair,
     ui.BIM_PT_wall,
@@ -305,7 +292,6 @@ def register():
     bpy.types.Object.BIMExternalParametricGeometryProperties = bpy.props.PointerProperty(
         type=prop.BIMExternalParametricGeometryProperties
     )
-    bpy.types.Scene.BIMPreviewProperties = bpy.props.PointerProperty(type=prop.BIMPreviewProperties)
 
     bpy.types.VIEW3D_MT_add.prepend(ui.add_menu)
     bpy.app.handlers.load_post.append(handler.load_post)
@@ -330,7 +316,6 @@ def unregister():
     del bpy.types.Object.BIMSverchokProperties
     tool.Parametric.unregister_object_properties()
     del bpy.types.Object.BIMExternalParametricGeometryProperties
-    del bpy.types.Scene.BIMPreviewProperties
 
     bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.types.VIEW3D_MT_add.remove(ui.add_menu)

src/bonsai/bonsai/bim/module/model/array.py

@@ -379,129 +379,3 @@ class Input3DCursorZArray(bpy.types.Operator):
         else:
             props.z = cursor.location.z - obj.location.z
         return {"FINISHED"}
-
-
-class EnableEditingParametric(bpy.types.Operator):
-    """Pen-icon dispatcher: fires the gizmo group's per-feature edit operator.
-
-    Bound to every parametric gizmo group's pen icon. The gizmo group's own
-    ``enable_editing_operator`` (``bim.enable_editing_door``, ``…_wall``, …)
-    is passed as ``feature_enable_op`` at setup time and invoked here. The
-    indirection lets one gizmo class serve all features without per-feature
-    subclasses."""
-
-    bl_idname = "bim.enable_editing_parametric"
-    bl_label = "Enable Editing"
-    bl_description = "Edit this object's parameters"
-    bl_options = {"REGISTER", "UNDO"}
-
-    feature_enable_op: bpy.props.StringProperty(
-        default="",
-        description="Operator bl_idname to invoke (e.g., 'bim.enable_editing_door').",
-    )
-
-    def execute(self, context):
-        # Malformed ``feature_enable_op`` (missing dot) would otherwise crash
-        # the unpack with ValueError; treat the same as the empty-string case.
-        parts = self.feature_enable_op.split(".", 1)
-        if len(parts) != 2:
-            return {"CANCELLED"}
-        domain, opname = parts
-        return getattr(getattr(bpy.ops, domain), opname)("INVOKE_DEFAULT")
-
-
-class AddArrayFromFeatureEdit(bpy.types.Operator, tool.Ifc.Operator):
-    """Commit any in-progress feature edit and add an array with
-    gizmo-friendly defaults (count=2, offset = bbox extent along the axis).
-
-    Modifier-aware: plain click → X, Shift → Y, Ctrl → Z. Callers can pass
-    ``axis="X"`` via EXEC_DEFAULT to bypass the modifier read.
-
-    All three chained operators (feature finish + add_array + enable_editing)
-    run inside one transaction for a single undo step."""
-
-    bl_idname = "bim.add_array_from_feature_edit"
-    bl_label = "Add Array"
-    bl_description = (
-        "Click: add an array along X.\n" "Shift+Click: add an array along Y.\n" "Ctrl+Click: add an array along Z"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    axis: bpy.props.EnumProperty(
-        name="Offset Axis",
-        items=[
-            ("X", "X", "Offset along the object's X axis (bbox X extent)"),
-            ("Y", "Y", "Offset along the object's Y axis (bbox Y extent)"),
-            ("Z", "Z", "Offset along the object's Z axis (bbox Z extent)"),
-        ],
-        default="X",
-    )
-
-    # Minimum offset to use when the object's bbox extent is tiny — prevents
-    # the second instance from visually overlapping the parent on small
-    # annotations / openings (0.3m ≈ a clearly-separated next-instance distance).
-    MIN_DEFAULT_OFFSET = 0.3
-
-    def invoke(self, context, event):
-        # Modifier-aware axis pick: X by default, Shift → Y, Ctrl → Z.
-        if event.shift:
-            self.axis = "Y"
-        elif event.ctrl:
-            self.axis = "Z"
-        else:
-            self.axis = "X"
-        return self.execute(context)
-
-    def _execute(self, context):
-        obj = context.active_object
-        if obj is None:
-            return {"CANCELLED"}
-        # Commit any in-progress parametric edit lifecycle on this object first — the
-        # user expects "Add Array" to also finalise whatever they were editing
-        # so they don't lose their draft changes.
-        editing = tool.Parametric.is_object_editing(obj, skip_name="array")
-        if editing is not None:
-            finish_op_name = editing.finish_op.removeprefix("bim.")
-            getattr(bpy.ops.bim, finish_op_name)("INVOKE_DEFAULT")
-        # Bounding-box derived offset along the chosen axis, converted from
-        # Blender SI (meters) to IFC project units (which is what
-        # ``BBIM_Array.Data`` stores; the regenerator multiplies by
-        # unit_scale on the way out).
-        axis_idx = "XYZ".index(self.axis)
-        if obj.bound_box:
-            bbox_extent_si = max(c[axis_idx] for c in obj.bound_box) - min(c[axis_idx] for c in obj.bound_box)
-        else:
-            bbox_extent_si = 1.0
-        bbox_extent_si = max(bbox_extent_si, self.MIN_DEFAULT_OFFSET)
-        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-        offset_project = bbox_extent_si / si_conversion if si_conversion else bbox_extent_si
-        add_kwargs = {"count": 2, "x": 0.0, "y": 0.0, "z": 0.0}
-        add_kwargs[self.axis.lower()] = offset_project
-        result = bpy.ops.bim.add_array(**add_kwargs)
-        if result != {"FINISHED"}:
-            return result
-        # Restore selection to just the parent. ``regenerate_array`` calls
-        # ``tool.Geometry.duplicate_ifc_objects`` which leaves the newly-created
-        # child selected alongside the parent. The edit-lifecycle gizmos poll on a
-        # single-selected parent, so with both selected the gizmos wouldn't
-        # surface and "ARRAY → enter edit" would feel broken.
-        tool.Blender.select_and_activate_single_object(context, active_object=obj)
-        # Chain straight into array edit for the newly-added layer (always the
-        # last entry in the pset's Data list, by AddArray's append semantics).
-        # The user's expectation after clicking ARRAY is "I want to tweak this
-        # array now" — entering edit mode immediately collapses the 2-click
-        # discover-then-edit flow into one.
-        element = tool.Ifc.get_entity(obj)
-        if element is None:
-            return {"FINISHED"}
-        data_text = ifcopenshell.util.element.get_pset(element, "BBIM_Array", "Data")
-        if not data_text:
-            return {"FINISHED"}
-        try:
-            layers = json.loads(data_text)
-        except (ValueError, TypeError):
-            return {"FINISHED"}
-        if not layers:
-            return {"FINISHED"}
-        bpy.ops.bim.enable_editing_array("INVOKE_DEFAULT", item=len(layers) - 1)
-        return {"FINISHED"}

src/bonsai/bonsai/bim/module/model/decorator.py

@@ -108,7 +108,7 @@ class ProfileDecorator:
 
         obj = context.active_object
 
-        if obj is None or obj.mode != "EDIT":
+        if obj.mode != "EDIT":
             if exit_edit_mode_callback:
                 ProfileDecorator.uninstall()
                 exit_edit_mode_callback()
@@ -2029,151 +2029,3 @@ class BoundingBoxDecorator:
                         else:
                             co1.y += y_overlap / 2 + min_spacing
                             co2.y -= y_overlap / 2 + min_spacing
-
-
-def _stroke_lines_alpha(
-    context: bpy.types.Context,
-    segments: list[tuple[tuple[float, float, float], tuple[float, float, float]]],
-    color_rgb: tuple[float, float, float],
-    line_width: float,
-    line_alpha: float,
-) -> None:
-    """Render ``segments`` (a list of ``(start, end)`` tuples) as one
-    anti-aliased LINES batch in world space. Early-returns when
-    ``context.region`` is unavailable (e.g. when called from a
-    ``_RestrictContext``)."""
-    if not segments:
-        return
-    verts: list[tuple[float, float, float]] = []
-    indices: list[tuple[int, int]] = []
-    for start, end in segments:
-        base = len(verts)
-        verts.append(tuple(start))
-        verts.append(tuple(end))
-        indices.append((base, base + 1))
-    if not tool.Blender.validate_shader_batch_data(verts, indices):
-        return
-    region = getattr(context, "region", None)
-    if region is None:
-        return
-    shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
-    shader.bind()
-    shader.uniform_float("viewportSize", (region.width, region.height))
-    shader.uniform_float("lineWidth", line_width)
-    shader.uniform_float("color", (*color_rgb, line_alpha))
-    batch = batch_for_shader(shader, "LINES", {"pos": verts}, indices=indices)
-    gpu.state.blend_set("ALPHA")
-    batch.draw(shader)
-    gpu.state.blend_set("NONE")
-
-
-class WallFilletPreviewDecorator(tool.Blender.ViewportDecorator):
-    """GPU preview lines for the wall-fillet flow.
-
-    Polls on ``scene.BIMPreviewProperties.wall_fillet.is_active`` and renders
-    the leg projections + arc + radial construction lines returned by
-    ``tool.Wall.compute_wall_fillet_geometry``. The two leg lines show how
-    each wall will be shortened to its tangent point; the arc approximates
-    the rounded corner; the two construction lines (arc center to each
-    tangent point) visually pin the radius.
-
-    Installed once per Blender session from ``bim/handler.py:load_post``
-    and uninstalled in ``bim/module/model/__init__.py:unregister``."""
-
-    LINE_WIDTH_LEG = 1.5
-    LINE_WIDTH_ARC = 2.5
-    LINE_WIDTH_CONSTRUCTION = 1.0
-    LINE_ALPHA = 0.7
-    CONSTRUCTION_ALPHA = 0.4
-
-    def draw(self, context: bpy.types.Context) -> None:
-        scene = context.scene
-        preview_props = getattr(scene, "BIMPreviewProperties", None)
-        props = preview_props.wall_fillet if preview_props is not None else None
-        if props is None or not props.is_active:
-            return
-        ifc_file = tool.Ifc.get()
-        if ifc_file is None:
-            return
-        try:
-            wall_a = ifc_file.by_id(props.wall_a_id)
-            wall_b = ifc_file.by_id(props.wall_b_id)
-        except Exception:
-            return
-        wall_a_obj = tool.Ifc.get_object(wall_a) if wall_a else None
-        wall_b_obj = tool.Ifc.get_object(wall_b) if wall_b else None
-        if wall_a_obj is None or wall_b_obj is None:
-            return
-
-        geom = tool.Wall.compute_wall_fillet_geometry(wall_a_obj, wall_b_obj, props.radius)
-        if geom is None:
-            return
-
-        prefs = tool.Blender.get_addon_preferences()
-        warning_color = tuple(prefs.decorator_color_error[:3])
-
-        if not geom["valid"]:
-            # Degenerate geometry paints red: invalid_radius shows legs+arc
-            # past the wall ends; invalid_axes shows the parallel/collinear
-            # axes.
-            if geom.get("invalid_radius"):
-                tangent_a = geom.get("tangent_a")
-                tangent_b = geom.get("tangent_b")
-                ref_a = tool.Wall.get_world_reference_line(wall_a_obj)
-                ref_b = tool.Wall.get_world_reference_line(wall_b_obj)
-                if tangent_a is not None and tangent_b is not None and ref_a is not None and ref_b is not None:
-                    far_a = self._far_endpoint(ref_a, geom["intersection"])
-                    far_b = self._far_endpoint(ref_b, geom["intersection"])
-                    legs = [
-                        (tuple(far_a), tuple(tangent_a)),
-                        (tuple(far_b), tuple(tangent_b)),
-                    ]
-                    _stroke_lines_alpha(context, legs, warning_color, self.LINE_WIDTH_LEG, self.LINE_ALPHA)
-                arc = geom.get("arc") or []
-                if len(arc) >= 2:
-                    arc_segments = [(tuple(arc[i]), tuple(arc[i + 1])) for i in range(len(arc) - 1)]
-                    _stroke_lines_alpha(context, arc_segments, warning_color, self.LINE_WIDTH_ARC, self.LINE_ALPHA)
-            elif geom.get("invalid_axes"):
-                axes = geom["invalid_axes"]
-                segments = [(tuple(a), tuple(b)) for a, b in axes]
-                _stroke_lines_alpha(context, segments, warning_color, self.LINE_WIDTH_ARC, self.LINE_ALPHA)
-            return
-
-        leg_color = tuple(prefs.decorations_colour[:3])
-        arc_color = tuple(prefs.decorator_color_selected[:3])
-
-        # Resolved against the IFC reference line, not mesh bounds, so trimmed
-        # walls and openings don't shift the leg endpoints.
-        ref_a = tool.Wall.get_world_reference_line(wall_a_obj)
-        ref_b = tool.Wall.get_world_reference_line(wall_b_obj)
-        if ref_a is not None and ref_b is not None and geom["intersection"] is not None:
-            far_a = self._far_endpoint(ref_a, geom["intersection"])
-            far_b = self._far_endpoint(ref_b, geom["intersection"])
-            legs = [
-                (tuple(far_a), tuple(geom["tangent_a"])),
-                (tuple(far_b), tuple(geom["tangent_b"])),
-            ]
-            _stroke_lines_alpha(context, legs, leg_color, self.LINE_WIDTH_LEG, self.LINE_ALPHA)
-
-        arc = geom["arc"]
-        if len(arc) >= 2:
-            arc_segments = [(tuple(arc[i]), tuple(arc[i + 1])) for i in range(len(arc) - 1)]
-            _stroke_lines_alpha(context, arc_segments, arc_color, self.LINE_WIDTH_ARC, self.LINE_ALPHA)
-
-        # Dim construction lines from arc_center to each tangent point so
-        # the radius reads as concrete during drag.
-        arc_center = geom.get("arc_center")
-        if arc_center is not None:
-            construction = [
-                (tuple(arc_center), tuple(geom["tangent_a"])),
-                (tuple(arc_center), tuple(geom["tangent_b"])),
-            ]
-            _stroke_lines_alpha(context, construction, arc_color, self.LINE_WIDTH_CONSTRUCTION, self.CONSTRUCTION_ALPHA)
-
-    @staticmethod
-    def _far_endpoint(reference_line, intersection):
-        """Endpoint of ``reference_line`` furthest from ``intersection``."""
-        p1, p2 = reference_line
-        d1 = (p1.x - intersection[0]) ** 2 + (p1.y - intersection[1]) ** 2 + (p1.z - intersection[2]) ** 2
-        d2 = (p2.x - intersection[0]) ** 2 + (p2.y - intersection[1]) ** 2 + (p2.z - intersection[2]) ** 2
-        return p2 if d2 >= d1 else p1

src/bonsai/bonsai/bim/module/model/door.py

@@ -707,8 +707,8 @@ class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin)
     bl_label = "Cycle Door Type"
     bl_options = {"REGISTER", "UNDO"}
 
-    element_checker = tool.Parametric.is_door
-    props_getter = tool.Model.get_door_props
+    element_checker = "is_door"
+    props_getter = "get_door_props"
     type_literal = tool.Model.DoorType
     type_attr = "door_type"
 
@@ -835,7 +835,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         ),
     ]
 
-    props_getter = tool.Model.get_door_props
+    props_getter = "get_door_props"
     gizmo_pref_name = "door"
 
     @classmethod
@@ -866,11 +866,13 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         self.gizmo_door_type = self.create_arc_gizmo(
             special_color,
             "bim.toggle_door_swing",
+            prop_path="BIMDoorProperties.door_type",
             flip_geometry=False,
         )
         self.gizmo_flip_arc = self.create_arc_gizmo(
             inactive_color,
             "bim.toggle_door_swing",
+            prop_path="BIMDoorProperties.door_type",
             flip_geometry=True,
             flip_local_axes="XY",
         )

src/bonsai/bonsai/bim/module/model/polyline.py

@@ -75,7 +75,6 @@ class PolylineOperator:
         self.is_typing = False
         self.snap_angle = None
         self.snapping_points = []
-        self.unit_scale = 1.0
         self.instructions = {
             "Cycle Input": {"icons": True, "keys": ["EVENT_TAB"]},
             "Distance Input": {"icons": True, "keys": ["EVENT_D"]},

src/bonsai/bonsai/bim/module/model/preview_base.py

@@ -60,12 +60,8 @@ def get_preview_props(context: bpy.types.Context, attr: str):
     Returns ``None`` if the umbrella isn't attached yet — true briefly
     during addon register and during plug-out, so polls / draw callbacks
     must defend against ``None`` rather than assuming the prop is always
-    available. Also tolerates contexts without a ``scene`` attribute
-    (test mocks built from ``SimpleNamespace``)."""
-    scene = getattr(context, "scene", None)
-    if scene is None:
-        return None
-    preview = getattr(scene, "BIMPreviewProperties", None)
+    available."""
+    preview = getattr(context.scene, "BIMPreviewProperties", None)
     return getattr(preview, attr, None) if preview is not None else None
 
 
@@ -78,17 +74,6 @@ def is_preview_active(context: bpy.types.Context, attr: str) -> bool:
     return bool(props is not None and props.is_active)
 
 
-def any_preview_active(context: bpy.types.Context) -> bool:
-    """``True`` if any registered preview is currently open. Sister gizmo
-    polls call this to hide themselves uniformly during ANY preview, so a
-    new preview registered in ``PREVIEW_CANCEL_OPS`` automatically gates
-    every parametric gizmo without each one growing a specific check."""
-    for attr, _op_name in PREVIEW_CANCEL_OPS:
-        if is_preview_active(context, attr):
-            return True
-    return False
-
-
 # --- Lazy closure factories --------------------------------------------------
 #
 # Used by preview gizmo groups when wiring ``BIM_GT_gizmo_dimension``'s

src/bonsai/bonsai/bim/module/model/prop.py

@@ -1902,65 +1902,3 @@ class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
         geometry_source: Literal["GEONODES", "IFCSVERCHOK"]
         geo_nodes: Union[bpy.types.GeometryNodeTree, None]
         sverchok_nodes: Union[sverchok.node_tree.SverchCustomTree, None]
-
-
-class BIMWallFilletPreviewProperties(PropertyGroup):
-    """Scene-level pending state for the wall-fillet preview flow.
-
-    Scene-level because the fillet spans two walls and commits a third
-    (corner) wall between them. ``SKIP_SAVE`` fields throughout."""
-
-    is_active: bpy.props.BoolProperty(
-        default=False,
-        options={"SKIP_SAVE"},
-        description="True while the wall-fillet preview flow is active.",
-    )
-    wall_a_id: bpy.props.IntProperty(
-        default=0,
-        options={"SKIP_SAVE"},
-        description=(
-            "IFC element id of the active wall — the corner wall inherits its "
-            "material layer set, height, x_angle, and type."
-        ),
-    )
-    wall_b_id: bpy.props.IntProperty(
-        default=0,
-        options={"SKIP_SAVE"},
-        description="IFC element id of the other selected wall.",
-    )
-    radius: bpy.props.FloatProperty(
-        name="Radius",
-        default=0.5,
-        soft_min=-10.0,
-        soft_max=10.0,
-        subtype="DISTANCE",
-        unit="LENGTH",
-        options={"SKIP_SAVE"},
-        description="Radius of the circular arc connecting the two walls.",
-    )
-    editing_corner_id: bpy.props.IntProperty(
-        default=0,
-        options={"SKIP_SAVE"},
-        description=(
-            "IFC element id of an existing fillet corner being re-edited "
-            "(non-zero only on the pen-icon re-edit flow). The create "
-            "operator deletes this corner + its connections before recreating "
-            "with the new radius."
-        ),
-    )
-
-    if TYPE_CHECKING:
-        is_active: bool
-        wall_a_id: int
-        wall_b_id: int
-        radius: float
-        editing_corner_id: int
-
-
-class BIMPreviewProperties(PropertyGroup):
-    """Umbrella for parametric-edit preview drafts attached to ``Scene``."""
-
-    wall_fillet: bpy.props.PointerProperty(type=BIMWallFilletPreviewProperties)
-
-    if TYPE_CHECKING:
-        wall_fillet: BIMWallFilletPreviewProperties

src/bonsai/bonsai/bim/module/model/stair.py

@@ -430,7 +430,7 @@ class CycleStairType(bpy.types.Operator, gizmo.CycleTypeMixin):
     bl_label = "Cycle Stair Type"
     bl_options = {"REGISTER", "UNDO"}
 
-    props_getter = tool.Model.get_stair_props
+    props_getter = "get_stair_props"
     type_literal = tool.Model.StairType
     type_attr = "stair_type"
     skip_element_check = True
@@ -580,7 +580,7 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     ]
 
     # Metadata-driven dispatch for props and preferences
-    props_getter = tool.Model.get_stair_props
+    props_getter = "get_stair_props"
     gizmo_pref_name = "stair"
 
     @classmethod
@@ -593,12 +593,14 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
             "VIEW3D_GT_lock",
             self.COLOR_BLUE,
             "bim.toggle_stair_property",
+            prop_path="BIMStairProperties.total_length_lock",
             property_name="total_length_lock",
         )
         self.tread_lock_gizmo = self.create_icon_gizmo(
             "VIEW3D_GT_lock",
             (1.0, 1.0, 1.0),
             "bim.toggle_stair_property",
+            prop_path="BIMStairProperties.custom_tread_lock",
             property_name="custom_tread_lock",
         )
         self.plus_gizmo = self.create_icon_gizmo(

src/bonsai/bonsai/bim/module/model/window.py

@@ -558,8 +558,8 @@ class CycleWindowType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixi
     bl_label = "Cycle Window Type"
     bl_options = {"REGISTER", "UNDO"}
 
-    element_checker = tool.Parametric.is_window
-    props_getter = tool.Model.get_window_props
+    element_checker = "is_window"
+    props_getter = "get_window_props"
     type_literal = tool.Model.WindowType
     type_attr = "window_type"
 
@@ -745,7 +745,7 @@ class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         DimensionGizmoConfig(attr_name="lining_offset", axis=(0, 1, 0), min_value=-10.0),
     ]
 
-    props_getter = tool.Model.get_window_props
+    props_getter = "get_window_props"
     gizmo_pref_name = "window"
 
     @classmethod

src/bonsai/bonsai/bim/module/model/workspace.py

@@ -17,12 +17,18 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
+import bmesh
+import gpu
+import numpy as np
 from functools import partial
 from typing import Optional, Union
 
 import bpy
 import bpy.utils.previews
 from bpy.types import Menu, WorkSpaceTool
+from bpy_extras import view3d_utils
+from gpu_extras.batch import batch_for_shader
+from mathutils import Vector
 
 import bonsai.core.model as core
 import bonsai.tool as tool
@@ -1294,15 +1300,9 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
                 bpy.ops.bim.generate_space()
             return
         if self.active_material_usage == "LAYER2":
-            if element and tool.Model.has_underside_connection(element):
-                bpy.ops.bim.regenerate_wall_to_underside()
-            else:
-                bpy.ops.bim.recalculate_wall()
+            bpy.ops.bim.recalculate_wall()
         elif self.active_material_usage == "LAYER3":
             bpy.ops.bim.recalculate_slab()
-            wall_objs = tool.Model.get_connected_wall_objs(element)
-            if wall_objs:
-                core.regenerate_wall_to_underside(tool.Ifc, tool.Geometry, tool.Model, wall_objs)
         elif tool.System.get_ports(element):
             bpy.ops.bim.regenerate_distribution_element()
         elif self.active_material_usage == "PROFILE":
@@ -1494,5 +1494,442 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             )
 
 
+# ==============================================================================
+# CAD/Rhino-style box selection ("Cross Select").
+#
+# The selection logic below is ported from the GPL-3.0 "Blender Cross Select"
+# add-on by RARA, CYX, Witty.Ming and Shuimeng
+# (https://github.com/theoryshaw/Blender-Cross-Select), reduced to box-only mode
+# and adapted to read its settings from Bonsai's add-on preferences. It is wired
+# into every Bonsai tool via ``tool.Blender.get_default_selection_keypmap()``.
+#
+# Dragging the box left-to-right performs a "window" selection (only elements
+# fully enclosed by the box are selected); dragging right-to-left performs a
+# "crossing" selection (anything the box touches is selected).
+# ==============================================================================
+
+
+def _cs_is_point_in_rect(point: tuple[float, float], rect: tuple[tuple[float, float], tuple[float, float]]) -> bool:
+    x, y = point
+    return rect[0][0] <= x <= rect[1][0] and rect[0][1] <= y <= rect[1][1]
+
+
+def _cs_ccw(a, b, c) -> bool:
+    return (c[1] - a[1]) * (b[0] - a[0]) > (b[1] - a[1]) * (c[0] - a[0])
+
+
+def _cs_segments_intersect(a, b, c, d) -> bool:
+    return _cs_ccw(a, c, d) != _cs_ccw(b, c, d) and _cs_ccw(a, b, c) != _cs_ccw(a, b, d)
+
+
+def _cs_is_segment_intersecting_rect(p1, p2, rect) -> bool:
+    min_x, min_y = rect[0]
+    max_x, max_y = rect[1]
+    if max(p1.x, p2.x) < min_x or min(p1.x, p2.x) > max_x or max(p1.y, p2.y) < min_y or min(p1.y, p2.y) > max_y:
+        return False
+    r1, r2, r3, r4 = (min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)
+    line_start, line_end = (p1.x, p1.y), (p2.x, p2.y)
+    return (
+        _cs_segments_intersect(line_start, line_end, r1, r2)
+        or _cs_segments_intersect(line_start, line_end, r2, r3)
+        or _cs_segments_intersect(line_start, line_end, r3, r4)
+        or _cs_segments_intersect(line_start, line_end, r4, r1)
+    )
+
+
+def _cs_make_3d_to_region_2d(verts, matrix_world, region, region_data, use_smart_sampling=True) -> list[Vector]:
+    """Batch-project a sequence of 3D vertices to 2D region coordinates using numpy."""
+    vlen = len(verts)
+    if vlen == 0:
+        return []
+    perspective_matrix = region_data.perspective_matrix
+    if use_smart_sampling:
+        step = max(1, 1 + ((vlen - 1) // 1000) * 10)
+        coords_3d = np.array([verts[i].co.to_tuple() for i in range(0, vlen, step)])
+    else:
+        coords_3d = np.array([v.co.to_tuple() for v in verts])
+    coords_3d = np.hstack((coords_3d, np.ones((coords_3d.shape[0], 1))))
+    coords_3d = np.dot(coords_3d, np.array(matrix_world.transposed()))
+    coords_2d = np.dot(coords_3d, np.array(perspective_matrix.transposed()))
+    coords_2d /= coords_2d[:, 3].reshape(-1, 1)
+    coords_2d[:, 0] = (coords_2d[:, 0] + 1) * 0.5 * region.width
+    coords_2d[:, 1] = (coords_2d[:, 1] + 1) * 0.5 * region.height
+    return [Vector((co[0], co[1])) for co in coords_2d]
+
+
+def _cs_get_sampled_coords(obj, context) -> list[Vector]:
+    if obj.type == "MESH" and obj.data.vertices:
+        return _cs_make_3d_to_region_2d(
+            obj.data.vertices, obj.matrix_world, context.region, context.region_data, use_smart_sampling=True
+        )
+    co = view3d_utils.location_3d_to_region_2d(context.region, context.region_data, obj.matrix_world @ Vector((0, 0, 0)))
+    return [co] if co else []
+
+
+def _cs_is_object_in_rect(obj, context, rect) -> bool:
+    """True when every sampled vertex of ``obj`` projects inside ``rect`` (window match)."""
+    coords = _cs_get_sampled_coords(obj, context)
+    if not coords:
+        return False
+    return all(_cs_is_point_in_rect((co.x, co.y), rect) for co in coords)
+
+
+def _cs_draw_callback_px(operator, context) -> None:
+    if not operator.is_dragging:
+        return
+    cs_prefs = operator.cs_prefs
+    try:
+        shader = gpu.shader.from_builtin("UNIFORM_COLOR")
+    except Exception:
+        shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
+
+    gpu.state.blend_set("ALPHA")
+    gpu.state.line_width_set(cs_prefs.line_width)
+
+    if not operator.enabled:
+        # Disabled: selection is native, so draw a neutral (non-directional) box.
+        color = (1.0, 1.0, 1.0, 1.0)
+        line_style = "DASHED"
+    elif operator.select_mode == "FULLY":
+        color = (*cs_prefs.fully_color, 1.0)
+        line_style = "SOLID"
+    else:
+        color = (*cs_prefs.partial_color, 1.0)
+        line_style = "DASHED"
+
+    min_x, max_x, min_y, max_y = operator.box_path
+    vertices = (
+        (min_x, min_y),
+        (max_x, min_y),
+        (max_x, max_y),
+        (min_x, max_y),
+        (min_x, min_y),
+    )
+    shader.bind()
+    shader.uniform_float("color", color)
+    if line_style == "SOLID":
+        batch_for_shader(shader, "LINE_STRIP", {"pos": vertices}).draw(shader)
+    else:
+        dash_length, gap_length = 10, 5
+        dash_vertices = []
+        for i in range(len(vertices) - 1):
+            start = Vector(vertices[i])
+            end = Vector(vertices[i + 1])
+            line_dir = (end - start).normalized()
+            line_length = (end - start).length
+            num_dashes = int(line_length // (dash_length + gap_length))
+            for j in range(num_dashes):
+                dash_start = start + line_dir * (j * (dash_length + gap_length))
+                dash_end = dash_start + line_dir * dash_length
+                if (dash_end - start).length > line_length:
+                    dash_end = end
+                dash_vertices.extend([dash_start, dash_end])
+            remaining = line_length - num_dashes * (dash_length + gap_length)
+            if remaining > 0:
+                dash_start = start + line_dir * (num_dashes * (dash_length + gap_length))
+                dash_end = dash_start + line_dir * min(dash_length, remaining)
+                dash_vertices.extend([dash_start, dash_end])
+        if dash_vertices:
+            batch_for_shader(shader, "LINES", {"pos": dash_vertices}).draw(shader)
+
+    gpu.state.line_width_set(1.0)
+    gpu.state.blend_set("NONE")
+
+
+class CrossSelect(bpy.types.Operator):
+    bl_idname = "bim.cross_select"
+    bl_label = "Cross Select"
+    bl_options = {"REGISTER", "BLOCKING", "UNDO"}
+    bl_description = (
+        "CAD/Rhino-style box selection.\n\n"
+        "Drag left to right: window (only fully-enclosed elements)\n"
+        "Drag right to left: crossing (anything the box touches)\n\n"
+        "Shift: add to selection\nCtrl: subtract from selection"
+    )
+
+    DRAG_THRESHOLD = 5
+
+    def invoke(self, context, event):
+        # Yield to ClickNearestDimensionAnchor when a parametric dimension dot
+        # is near the cursor.  Blender fires all matching tool-keymap entries'
+        # invoke() even after an earlier entry returned RUNNING_MODAL, so without
+        # this check our BLOCKING modal would win over click_nearest's modal and
+        # prevent the dot from turning blue.
+        if self._near_dimension_dot(context, event):
+            return {"PASS_THROUGH"}
+
+        self.cs_prefs = tool.Blender.get_addon_preferences().cross_select
+        self.enabled = self.cs_prefs.enabled
+        self.start_mouse = (event.mouse_region_x, event.mouse_region_y)
+        self.end_mouse = self.start_mouse
+        self.is_dragging = False
+        self.select_mode = "FULLY"  # "FULLY" (window) or "HALF" (crossing)
+        self.operation = "SET"
+        self.draw_handle = None
+        self.box_path = (0, 0, 0, 0)  # (min_x, max_x, min_y, max_y)
+        context.window_manager.modal_handler_add(self)
+        return {"RUNNING_MODAL"}
+
+    @staticmethod
+    def _near_dimension_dot(context, event) -> bool:
+        """Return True if the click is within 15 px of a parametric dimension anchor dot."""
+        try:
+            import ifcopenshell.util.element as _ue
+            from bpy_extras.view3d_utils import location_3d_to_region_2d
+
+            region = next(
+                (r for a in context.screen.areas if a.type == "VIEW_3D" for r in a.regions if r.type == "WINDOW"),
+                None,
+            )
+            rv3d = next(
+                (s.region_3d for a in context.screen.areas if a.type == "VIEW_3D" for s in a.spaces if s.type == "VIEW_3D"),
+                None,
+            )
+            if not region or not rv3d:
+                return False
+
+            cx = event.mouse_x - region.x
+            cy = event.mouse_y - region.y
+            r2 = 15 ** 2
+
+            for obj in context.scene.objects:
+                if obj.type != "CURVE" or not obj.visible_get():
+                    continue
+                elem = tool.Ifc.get_entity(obj) if tool.Ifc.get() else None
+                if not elem or not elem.is_a("IfcAnnotation"):
+                    continue
+                pset = _ue.get_pset(elem, "BBIM_Dimension")
+                if not pset or not pset.get("Anchors"):
+                    continue
+                if not obj.data.splines:
+                    continue
+                for pt in obj.data.splines[0].points:
+                    sp = location_3d_to_region_2d(region, rv3d, obj.matrix_world @ pt.co.to_3d())
+                    if sp and (cx - sp.x) ** 2 + (cy - sp.y) ** 2 < r2:
+                        return True
+        except Exception:
+            pass
+        return False
+
+    def modal(self, context, event):
+        if event.shift:
+            self.operation = "ADD"
+        elif event.ctrl:
+            self.operation = "SUB"
+        else:
+            self.operation = "SET"
+
+        if event.type == "MOUSEMOVE":
+            if not self.is_dragging:
+                delta = Vector((event.mouse_region_x, event.mouse_region_y)) - Vector(self.start_mouse)
+                if delta.length > self.DRAG_THRESHOLD:
+                    self._start_dragging(context)
+            if self.is_dragging:
+                self._update_drag_position(event)
+                context.area.tag_redraw()
+
+        if event.type == "LEFTMOUSE" and event.value == "RELEASE":
+            if self.is_dragging:
+                self._finish_box_select(context)
+            else:
+                self._handle_single_click(context, event)
+            return {"FINISHED"}
+
+        if event.type in {"RIGHTMOUSE", "ESC"}:
+            self._cleanup_drawing()
+            context.area.tag_redraw()
+            return {"CANCELLED"}
+
+        return {"RUNNING_MODAL"}
+
+    def _start_dragging(self, context):
+        self.is_dragging = True
+        self.draw_handle = bpy.types.SpaceView3D.draw_handler_add(
+            _cs_draw_callback_px, (self, context), "WINDOW", "POST_PIXEL"
+        )
+        context.area.tag_redraw()
+
+    def _update_drag_position(self, event):
+        self.end_mouse = (event.mouse_region_x, event.mouse_region_y)
+        # Dragging rightward selects only fully-enclosed elements (window),
+        # dragging leftward selects anything touched (crossing).
+        self.select_mode = "FULLY" if self.end_mouse[0] > self.start_mouse[0] else "HALF"
+        x1, y1 = self.start_mouse
+        x2, y2 = self.end_mouse
+        self.box_path = (min(x1, x2), max(x1, x2), min(y1, y2), max(y1, y2))
+
+    def _cleanup_drawing(self):
+        if self.draw_handle:
+            bpy.types.SpaceView3D.draw_handler_remove(self.draw_handle, "WINDOW")
+            self.draw_handle = None
+
+    def _finish_box_select(self, context):
+        self._cleanup_drawing()
+        min_x, max_x, min_y, max_y = self.box_path
+
+        # Cross-select disabled: reproduce Blender's native box selection.
+        if not self.enabled:
+            bpy.ops.view3d.select_box(
+                wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode=self.operation
+            )
+            context.area.tag_redraw()
+            return
+
+        if context.mode == "OBJECT":
+            self._process_selection_object(context)
+        elif context.mode == "EDIT_MESH":
+            self._process_selection_edit(context)
+        context.area.tag_redraw()
+
+    # --- Object mode ---------------------------------------------------------
+    def _process_selection_object(self, context):
+        original_selection = set(context.selected_objects)
+
+        # Use the native box select to collect everything the box touches.
+        bpy.ops.object.select_all(action="DESELECT")
+        min_x, max_x, min_y, max_y = self.box_path
+        bpy.ops.view3d.select_box(wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode="ADD")
+        touched_objects = set(context.selected_objects)
+
+        # Filter touched objects by the window/crossing rule.
+        rect = ((min_x, min_y), (max_x, max_y))
+        if self.select_mode == "HALF":
+            valid_selection = touched_objects
+        else:
+            valid_selection = {obj for obj in touched_objects if _cs_is_object_in_rect(obj, context, rect)}
+
+        if self.operation == "SET":
+            final_selected = valid_selection
+        elif self.operation == "ADD":
+            final_selected = original_selection | valid_selection
+        else:  # SUB
+            final_selected = original_selection - valid_selection
+
+        bpy.ops.object.select_all(action="DESELECT")
+        for obj in final_selected:
+            obj.select_set(True)
+
+    # --- Edit mesh mode ------------------------------------------------------
+    def _process_selection_edit(self, context):
+        if hasattr(context, "objects_in_mode_unique_data"):
+            edit_objs = [obj for obj in context.objects_in_mode_unique_data if obj.type == "MESH"]
+        elif hasattr(context, "objects_in_mode"):
+            edit_objs = [obj for obj in context.objects_in_mode if obj.type == "MESH"]
+        else:
+            obj = context.edit_object
+            edit_objs = [obj] if obj and obj.type == "MESH" else []
+        if not edit_objs:
+            return
+
+        is_vert, is_edge, is_face = context.tool_settings.mesh_select_mode
+        min_x, max_x, min_y, max_y = self.box_path
+
+        # Vertex mode (and crossing face mode) match Blender's native box select.
+        if is_vert or (is_face and self.select_mode == "HALF"):
+            bpy.ops.view3d.select_box(
+                wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode=self.operation
+            )
+            return
+
+        element_key = "edges" if is_edge else "faces"
+        bm_cache = {}
+        original = {}
+        for obj in edit_objs:
+            bm = bmesh.from_edit_mesh(obj.data)
+            bm.verts.ensure_lookup_table()
+            bm.edges.ensure_lookup_table()
+            bm.faces.ensure_lookup_table()
+            bm_cache[obj] = bm
+            elems = bm.edges if is_edge else bm.faces
+            original[obj] = {ele for ele in elems if ele.select}
+
+        # Collect every element the box touches via native box select on faces+edges.
+        bpy.ops.mesh.select_all(action="DESELECT")
+        for temp_select_mode in ((False, False, True), (False, True, False)):
+            context.tool_settings.mesh_select_mode = temp_select_mode
+            bpy.ops.view3d.select_box(wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode="ADD")
+        context.tool_settings.mesh_select_mode = (is_vert, is_edge, is_face)
+
+        rect = ((min_x, min_y), (max_x, max_y))
+        valid = {}
+        for obj, bm in bm_cache.items():
+            elems = bm.edges if is_edge else bm.faces
+            touched = {ele for ele in elems if ele.select}
+            valid[obj] = {ele for ele in touched if self._is_element_valid(context, obj, rect, ele, element_key)}
+
+        final = {}
+        for obj in edit_objs:
+            if self.operation == "SET":
+                final[obj] = valid[obj]
+            elif self.operation == "ADD":
+                final[obj] = original[obj] | valid[obj]
+            else:  # SUB
+                final[obj] = original[obj] - valid[obj]
+
+        bpy.ops.mesh.select_all(action="DESELECT")
+        if is_edge:
+            for obj, bm in bm_cache.items():
+                for e in final[obj]:
+                    e.select = True
+                    for f in e.link_faces:
+                        if f.select:
+                            continue
+                        if all(edge in final[obj] for edge in f.edges):
+                            f.select = True
+                bmesh.update_edit_mesh(obj.data)
+        else:
+            for obj, bm in bm_cache.items():
+                for f in final[obj]:
+                    f.select = True
+                bmesh.update_edit_mesh(obj.data)
+
+    def _is_element_valid(self, context, obj, rect, ele, ele_type):
+        region = context.region
+        rv3d = context.region_data
+        matrix = obj.matrix_world
+        vert_2d = []
+        all_inside = True
+        any_inside = False
+        for v in ele.verts:
+            co_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, matrix @ v.co)
+            if not co_2d:
+                all_inside = False
+                continue
+            vert_2d.append(co_2d)
+            if _cs_is_point_in_rect((co_2d.x, co_2d.y), rect):
+                any_inside = True
+            else:
+                all_inside = False
+
+        if self.select_mode == "FULLY":
+            return all_inside
+        if any_inside:
+            return True
+        # Crossing: element edges intersecting the box border also count.
+        n = len(vert_2d)
+        if ele_type == "edges":
+            return n == 2 and _cs_is_segment_intersecting_rect(vert_2d[0], vert_2d[1], rect)
+        for i in range(n):
+            if _cs_is_segment_intersecting_rect(vert_2d[i], vert_2d[(i + 1) % n], rect):
+                return True
+        return False
+
+    def _handle_single_click(self, context, event):
+        # A plain click uses Blender's native pick selection. ``deselect_all`` clears
+        # the selection when clicking empty space (in both Object and Edit Mesh modes),
+        # matching Blender's default selection tool; Shift toggles and Ctrl deselects.
+        try:
+            bpy.ops.view3d.select(
+                "INVOKE_DEFAULT",
+                extend=event.shift,
+                deselect=event.ctrl,
+                toggle=False,
+                deselect_all=not (event.shift or event.ctrl),
+                location=(event.mouse_region_x, event.mouse_region_y),
+            )
+        except Exception:
+            pass
+
+
 custom_icon_previews = None
 display_mode = None

src/bonsai/bonsai/bim/module/project/operator.py

@@ -63,7 +63,6 @@ import bonsai.core.project as core
 import bonsai.tool as tool
 from bonsai.bim import export_ifc, import_ifc
 from bonsai.bim.ifc import IfcStore
-from bonsai.bim.module.model import preview_base
 from bonsai.bim.module.model.decorator import FaceAreaDecorator, PolylineDecorator
 from bonsai.bim.module.model.polyline import PolylineOperator
 from bonsai.bim.module.project.data import LinksData, ProjectLibraryData
@@ -1937,10 +1936,6 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
 
     def _execute(self, context):
         committed, failed_commits = tool.Parametric.commit_pending_edits()
-        # Previews are session-transient — discard rather than commit. Sibling
-        # gizmo polls gate on each preview's is_active flag, and a stuck flag
-        # persisted through the save would silently hide them on reload.
-        preview_base.discard_pending_previews(context.scene)
         # Suffix is appended to the IFC save-success report below so the auto-commit
         # info isn't immediately overwritten by the success message in Blender's
         # status bar (only the latest self.report({"INFO"}, ...) sticks).

src/bonsai/bonsai/bim/parametric_lifecycle.py

@@ -71,16 +71,18 @@ from __future__ import annotations
 
 import json
 from collections.abc import Callable
-from typing import ClassVar, get_args
+from typing import TYPE_CHECKING, ClassVar
 
 import bpy
 import ifcopenshell.util.element
 from bpy.app.handlers import persistent
-from ifcopenshell import entity_instance
 
 import bonsai.core.geometry
 import bonsai.tool as tool
 
+if TYPE_CHECKING:
+    from ifcopenshell import entity_instance
+
 
 class ParametricEditMixinBase:
     """Common scaffolding for parametric edit-lifecycle mixins.
@@ -377,157 +379,6 @@ class PathPreservingEditMixin(ParametricEditMixinBase):
         return {"FINISHED"}
 
 
-# --- Type-selection mixins (Cycle / Pick) ------------------------------------
-
-
-class TypeAccessorBase:
-    """Shared contract for operators that resolve and write a Literal type
-    attribute on a Bonsai PropertyGroup.
-
-    Subclasses define ``element_checker``, ``props_getter``, ``type_literal``,
-    ``type_attr``; ``skip_element_check`` bypasses element validation. Concrete
-    subclasses (``CycleTypeMixin``, ``PickTypeMixin``) add the interaction
-    shape on top.
-
-    Test doubles must be set on the operator instance — the predicates are
-    bound at class-definition time, so patching the underlying tool module
-    has no effect."""
-
-    element_checker: Callable[[entity_instance], bool]
-    props_getter: Callable[[bpy.types.Object], bpy.types.PropertyGroup]
-    type_literal: type
-    type_attr: str
-    skip_element_check: bool = False
-
-    def _resolve_target(self, context: bpy.types.Context) -> bpy.types.Object | None:
-        """Return the active object iff it passes ``element_checker`` (or the
-        check is skipped). ``None`` signals the operator should bail with
-        ``{'CANCELLED'}``."""
-        obj = context.active_object
-        if not obj:
-            return None
-        if not self.skip_element_check:
-            element = tool.Ifc.get_entity(obj)
-            if not element or not self.element_checker(element):
-                return None
-        return obj
-
-
-class CycleTypeMixin(TypeAccessorBase):
-    """Operator mixin that cycles through ``type_literal``'s values.
-
-    Shift-click reverses direction."""
-
-    reverse: bpy.props.BoolProperty(name="Reverse", default=False, options={"HIDDEN", "SKIP_SAVE"})
-
-    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
-        self.reverse = event.shift
-        return self.execute(context)
-
-    def _cycle_type(self, context: bpy.types.Context) -> set[str]:
-        obj = self._resolve_target(context)
-        if obj is None:
-            return {"CANCELLED"}
-
-        props = self.props_getter(obj)
-        types = get_args(self.type_literal)
-        current = getattr(props, self.type_attr)
-        idx = types.index(current) if current in types else 0
-        direction = -1 if self.reverse else 1
-        setattr(props, self.type_attr, types[(idx + direction) % len(types)])
-
-        return {"FINISHED"}
-
-
-class PickTypeMixin(TypeAccessorBase):
-    """Operator mixin that opens a popup menu listing ``type_literal``'s values.
-
-    Empty ``value`` ⇒ ``invoke`` opens the popup; non-empty ⇒ the user picked
-    an item and ``_pick_type`` applies it.
-
-    When invoked mid-click (e.g. from a gizmo's ``target_set_operator``), the
-    menu opens only after the originating ``LEFTMOUSE`` releases. Otherwise
-    the still-pressed click flows straight into Blender's drag-through-pick
-    gesture and the menu commits whichever item the cursor drifts over on
-    release. Other invocation paths (command-palette / F3, EXEC_DEFAULT, F6
-    redo) bypass the wait and open the menu immediately.
-
-    The ``value`` StringProperty is declared on this mixin but registered via
-    the concrete Operator subclass's MRO scan — do not instantiate the mixin
-    standalone."""
-
-    # Carries the picked value through invoke→execute; empty default
-    # distinguishes "open popup" from "apply".
-    value: bpy.props.StringProperty(default="", options={"HIDDEN", "SKIP_SAVE"})
-
-    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
-        """Open the picker menu, or apply a value that was preset by a
-        menu-item click.
-
-        Routing through ``execute()`` keeps subclass IFC-transaction wrapping
-        in the loop and means F6 redo / ``EXEC_DEFAULT`` reach the apply path."""
-        if self.value:
-            return self.execute(context)
-
-        if self._resolve_target(context) is None:
-            return {"CANCELLED"}
-
-        if event.value == "PRESS":
-            context.window_manager.modal_handler_add(self)
-            return {"RUNNING_MODAL"}
-        return self._open_picker(context)
-
-    def modal(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
-        if event.type == "LEFTMOUSE" and event.value == "RELEASE":
-            self._open_picker(context)
-            # INTERFACE does not remove a modal handler; only FINISHED /
-            # CANCELLED do.
-            return {"CANCELLED"}
-        if event.type in {"RIGHTMOUSE", "ESC"}:
-            return {"CANCELLED"}
-        return {"RUNNING_MODAL"}
-
-    def _open_picker(self, context: bpy.types.Context) -> set[str]:
-        bl_idname = self.bl_idname
-        values = list(get_args(self.type_literal))
-
-        def draw(menu_self, _menu_context):
-            layout = menu_self.layout
-            for v in values:
-                op = layout.operator(bl_idname, text=v)
-                op.value = v
-
-        context.window_manager.popup_menu(draw, title=self.bl_label, icon="MENU_PANEL")
-        # The type change is a two-step interaction: this invocation just OPENS
-        # the menu (no state change yet); a SECOND invocation fires when the
-        # user clicks a menu item — that one writes ``props.<type_attr>`` and
-        # returns FINISHED. By returning INTERFACE here (and not FINISHED), the
-        # menu-open step is excluded from Blender's undo stack so the user
-        # gets exactly ONE undo entry per type change. If we returned FINISHED
-        # here too, the stack would gain a no-op "opened the menu" entry that
-        # Ctrl+Z would dismiss before reverting the actual type change —
-        # confusing UX where the first Ctrl+Z appears to do nothing.
-        return {"INTERFACE"}
-
-    def _pick_type(self, context: bpy.types.Context) -> set[str]:
-        if not self.value:
-            # No-op rather than re-open the menu, so command-palette misuse
-            # doesn't infinite-loop.
-            return {"CANCELLED"}
-
-        obj = self._resolve_target(context)
-        if obj is None:
-            return {"CANCELLED"}
-
-        if self.value not in get_args(self.type_literal):
-            self.report({"WARNING"}, f"Unknown {self.type_attr}: {self.value!r}")
-            return {"CANCELLED"}
-
-        props = self.props_getter(obj)
-        setattr(props, self.type_attr, self.value)
-        return {"FINISHED"}
-
-
 # --- Undo-resync registry ----------------------------------------------------
 #
 # Per-type regenerators called from ``resync_parametric_drafts_after_undo``

src/bonsai/bonsai/bim/ui.py

@@ -473,6 +473,68 @@ class GizmoPreferences(bpy.types.PropertyGroup):
         wall: GizmoPreferencesWall
 
 
+def _apply_cross_select_pref() -> None:
+    """Timer callback: re-register Bonsai tools so the Cross Select toggle takes effect."""
+    tool.Blender.apply_cross_select_preference()
+    return None  # run once
+
+
+def _update_cross_select_enabled(self: "CrossSelectPreferences", context: bpy.types.Context) -> None:
+    # Re-registering tools mid property-update is unsafe, so defer to a one-shot timer.
+    if not bpy.app.background and not bpy.app.timers.is_registered(_apply_cross_select_pref):
+        bpy.app.timers.register(_apply_cross_select_pref, first_interval=0.0)
+
+
+class CrossSelectPreferences(bpy.types.PropertyGroup):
+    """CAD/Rhino-style box selection settings for Bonsai tools.
+
+    When enabled, every Bonsai workspace tool uses ``bim.cross_select`` instead of
+    Blender's native box/click selection: dragging the box left-to-right selects only
+    fully-enclosed elements (window), right-to-left selects anything touched (crossing).
+    """
+
+    enabled: BoolProperty(
+        name="Cross Select",
+        default=True,
+        description=(
+            "Use CAD/Rhino-style box selection in Bonsai tools.\n"
+            "Drag left to right to select only fully-enclosed elements (window).\n"
+            "Drag right to left to select anything the box touches (crossing).\n"
+            "Disable to use Blender's native box/click selection"
+        ),
+        update=_update_cross_select_enabled,
+    )
+    fully_color: bpy.props.FloatVectorProperty(
+        name="Window Match Color",
+        subtype="COLOR",
+        default=(0.2, 0.6, 1.0),  # blue
+        min=0.0,
+        max=1.0,
+        description="Box color when dragging left to right (fully-enclosed / window match)",
+    )
+    partial_color: bpy.props.FloatVectorProperty(
+        name="Crossing Match Color",
+        subtype="COLOR",
+        default=(1.0, 0.4, 0.1),  # orange
+        min=0.0,
+        max=1.0,
+        description="Box color when dragging right to left (partial / crossing match)",
+    )
+    line_width: bpy.props.IntProperty(
+        name="Line Width",
+        default=2,
+        min=0,
+        max=20,
+        description="Width of the selection box border",
+    )
+
+    if TYPE_CHECKING:
+        enabled: bool
+        fully_color: tuple[float, float, float]
+        partial_color: tuple[float, float, float]
+        line_width: int
+
+
 class DocPreferences(bpy.types.PropertyGroup):
     sheets_dir: StringProperty(
         default=os.path.join("sheets") + os.path.sep,
@@ -752,6 +814,7 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         description="Code that will be evaluated to generate occurrence name for CUSTOM occurrence name style",
     )
     gizmos: bpy.props.PointerProperty(type=GizmoPreferences)
+    cross_select: bpy.props.PointerProperty(type=CrossSelectPreferences)
 
     def update_data_dir(self, context: bpy.types.Context) -> None:
         import bonsai.bim.schema
@@ -855,6 +918,7 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         occurrence_name_style: Literal["CLASS", "TYPE", "CUSTOM"]
         occurrence_name_function: str
         gizmos: GizmoPreferences
+        cross_select: CrossSelectPreferences
         data_dir: str
         cache_dir: str
         pset_dir: str
@@ -917,6 +981,18 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
                 self.draw_gizmo_parameters,
             )
 
+        layout.prop(self.cross_select, "enabled")
+        if self.cross_select.enabled:
+            box = layout.box()
+            box.label(text="Drag left to right: window (only fully-enclosed elements)", icon="FORWARD")
+            box.label(text="Drag right to left: crossing (anything the box touches)", icon="BACK")
+            row = box.row(align=True)
+            row.prop(self.cross_select, "fully_color", text="")
+            row.label(text="Window Match")
+            row.prop(self.cross_select, "partial_color", text="")
+            row.label(text="Crossing Match")
+            box.prop(self.cross_select, "line_width")
+
     def draw_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.label(text="Toggle visibility of gizmos in editing mode")
         box = layout.box()

src/bonsai/bonsai/core/model.py

@@ -161,73 +161,23 @@ def align_objects(
     model.align_objects(reference_obj, objs, align_type)
 
 
-def regenerate_wall_to_underside(
-    ifc: type[tool.Ifc],
-    geometry: type[tool.Geometry],
-    model: type[tool.Model],
-    wall_objs: list[bpy.types.Object],
-) -> None:
-    """Re-clip walls to their connected underside objects after the slab has moved."""
-    clipped_objs = []
-    for obj in wall_objs:
-        wall = ifc.get_entity(obj)
-        slab_objs = model.get_connected_slab_objs(wall)
-        if not slab_objs:
-            continue
-        if ifc.is_moved(obj):
-            geometry.run_edit_object_placement(obj=obj)
-        # Sync each slab's Blender mesh to its current IFC representation before
-        # reading face geometry, so a changed profile is picked up correctly.
-        model.reload_body_representation(slab_objs)
-        model.remove_wall_to_underside_booleans(wall)
-        for slab_obj in slab_objs:
-            clip = model.get_slab_clipping_bmesh(slab_obj)
-            if clip:
-                model.clip_wall_to_slab(wall, clip)
-        clipped_objs.append(obj)
-    if clipped_objs:
-        model.reload_body_representation(clipped_objs)
-
-
 def extend_wall_to_slab(
     ifc: type[tool.Ifc],
     geometry: type[tool.Geometry],
     model: type[tool.Model],
-    slab_objs: list[bpy.types.Object],
+    slab_obj: bpy.types.Object,
     wall_objs: list[bpy.types.Object],
 ) -> None:
-    # If any wall is currently in item mode, exit it before modifying the
-    # representation. Leaving stale item objects around causes delete_ifc_item
-    # to later remove the extrusion (or other pre-boolean items) from inside
-    # the boolean chain, corrupting the IFC model.
-    geom_props = geometry.get_geometry_props()
-    if geom_props.representation_obj in wall_objs:
-        geometry.disable_item_mode()
-    clipped_walls = []
+    if not (clip := model.get_slab_clipping_bmesh(slab_obj)):
+        return  # Nothing to clip?
+    slab = ifc.get_entity(slab_obj)
     for obj in wall_objs:
         if ifc.is_moved(obj):
             geometry.run_edit_object_placement(obj=obj)
         wall = ifc.get_entity(obj)
-        # Merge previously connected slabs with newly requested ones so that
-        # re-running the operator never produces duplicate booleans and never
-        # silently discards clips that were applied in an earlier call.
-        existing = model.get_connected_slab_objs(wall)
-        seen = {id(s) for s in existing}
-        all_slab_objs = list(existing) + [s for s in slab_objs if id(s) not in seen]
-        # Remove stale booleans once, then re-clip against the full set.
-        model.remove_wall_to_underside_booleans(wall)
-        did_clip = False
-        for slab_obj in all_slab_objs:
-            clip = model.get_slab_clipping_bmesh(slab_obj)
-            if not clip:
-                continue
-            model.clip_wall_to_slab(wall, clip)
-            model.connect_wall_to_slab(wall, ifc.get_entity(slab_obj))
-            did_clip = True
-        if did_clip:
-            clipped_walls.append(obj)
-    if clipped_walls:
-        model.reload_body_representation(clipped_walls)
+        model.clip_wall_to_slab(wall, clip)
+        model.connect_wall_to_slab(wall, slab)
+    model.reload_body_representation(wall_objs)
 
 
 class RequireTwoWallsError(Exception):

src/bonsai/bonsai/core/spatial.py

@@ -67,8 +67,7 @@ def assign_container(
     if products := [e for e in root_elements if spatial.can_contain(container, root_element)]:
         ifc.run("spatial.assign_container", products=products, relating_structure=container)
     for element in all_elements:
-        if obj := ifc.get_object(element):
-            collector.assign(obj)
+        collector.assign(ifc.get_object(element))
 
 
 def enable_editing_container(spatial: type[tool.Spatial], obj: bpy.types.Object) -> None:

src/bonsai/bonsai/core/tool.py

@@ -681,9 +681,6 @@ class Model:
     def export_profile(cls, obj, position=None): pass
     def generate_occurrence_name(cls, element_type, ifc_class): pass
     def get_extrusion(cls, representation): pass
-    def get_connected_slab_objs(cls, wall): pass
-    def get_connected_wall_objs(cls, slab): pass
-    def has_underside_connection(cls, element): pass
     def get_manual_booleans(cls, element): pass
     def get_material_layer_parameters(cls, element): pass
     def get_slab_clipping_bmesh(cls, obj): pass
@@ -699,7 +696,6 @@ class Model:
     def regenerate_profile(cls, obj): pass
     def regenerate_slab(cls, obj): pass
     def reload_body_representation(cls, obj_or_objects): pass
-    def remove_wall_to_underside_booleans(cls, wall): pass
     def replace_object_ifc_representation(cls, ifc_file, ifc_context, obj, new_representation): pass
 
 

src/bonsai/bonsai/tool/blender.py

@@ -753,26 +753,12 @@ class Blender(bonsai.core.tool.Blender):
                             pass
 
     @classmethod
-    def get_default_selection_keypmap(cls) -> tuple:
-        """keymap to replicate default blender selection behaviour with click and box selection"""
-        # code below comes from blender_default.py which is part of default blender scripts licensed under GPL v2
-        # https://github.com/blender/blender/blob/master/release/scripts/presets/keyconfig/keymap_data/blender_default.py
-        # the code is the data from evaluating km_3d_view_tool_select() and km_3d_view_tool_select_box()
-        #
-        # You can run the snippet below in Blender console
-        # to regenerate those keybindings in case of errors in the future
-        # ```
-        # import os
-        # version = ".".join(bpy.app.version_string.split(".")[:2])
-        # fl = os.path.join(os.getcwd(), version, "scripts/presets/keyconfig/keymap_data/blender_default.py")
-        # def_keymap = bpy.utils.execfile(fl)
-        # params = def_keymap.Params
-        # box_keymap = def_keymap.km_3d_view_tool_select_box(def_keymap.Params(), fallback=None)[2]["items"]
-        # click_keymap = def_keymap.km_3d_view_tool_select(def_keymap.Params(select_mouse="LEFTMOUSE"), fallback=None)[2]["items"]
-        # ```
-        # https://docs.blender.org/api/current/bpy.types.KeyMapItems.html
-        keymap = (
-            # box selection keymap
+    def get_native_selection_keymap(cls) -> tuple:
+        """Blender's default click + box selection keymap (used when Cross Select is off)."""
+        # Data from blender_default.py (GPL v2): the items of km_3d_view_tool_select_box()
+        # and km_3d_view_tool_select(select_mouse="LEFTMOUSE"). See git history for the
+        # console snippet to regenerate these if Blender's defaults ever change.
+        return (
             ("view3d.select_box", {"type": "LEFTMOUSE", "value": "CLICK_DRAG"}, None),
             (
                 "view3d.select_box",
@@ -789,7 +775,6 @@ class Blender(bonsai.core.tool.Blender):
                 {"type": "LEFTMOUSE", "value": "CLICK_DRAG", "shift": True, "ctrl": True},
                 {"properties": [("mode", "AND")]},
             ),
-            # left-click selection keymap
             ("view3d.select", {"type": "LEFTMOUSE", "value": "PRESS"}, {"properties": [("deselect_all", True)]}),
             (
                 "view3d.select",
@@ -797,7 +782,126 @@ class Blender(bonsai.core.tool.Blender):
                 {"properties": [("toggle", True)]},
             ),
         )
-        return keymap
+
+    @classmethod
+    def get_cross_select_keymap(cls) -> tuple:
+        """CAD/Rhino-style box selection keymap, routed through ``bim.cross_select``.
+
+        A single ``LEFTMOUSE`` ``PRESS`` binding lets the modal operator decide between a
+        click and a box drag itself (drag left-to-right = window, right-to-left = crossing),
+        reading Shift/Ctrl to add or subtract from the selection.
+        """
+        return (
+            ("bim.cross_select", {"type": "LEFTMOUSE", "value": "PRESS"}, {"properties": []}),
+            ("bim.cross_select", {"type": "LEFTMOUSE", "value": "PRESS", "shift": True}, {"properties": []}),
+            ("bim.cross_select", {"type": "LEFTMOUSE", "value": "PRESS", "ctrl": True}, {"properties": []}),
+            (
+                "bim.cross_select",
+                {"type": "LEFTMOUSE", "value": "PRESS", "shift": True, "ctrl": True},
+                {"properties": []},
+            ),
+        )
+
+    @classmethod
+    def is_cross_select_enabled(cls) -> bool:
+        try:
+            return bool(cls.get_addon_preferences().cross_select.enabled)
+        except (KeyError, AttributeError):
+            # Preferences are not registered yet (e.g. at tool import/registration time).
+            # Default to Cross Select; the saved preference is applied on startup via
+            # apply_cross_select_preference().
+            return True
+
+    @classmethod
+    def get_default_selection_keypmap(cls) -> tuple:
+        """Selection keymap shared by every Bonsai tool.
+
+        Returns the Cross Select keymap when the add-on preference is enabled, otherwise
+        Blender's native selection keymap. ``bl_keymap`` is evaluated once when the tool
+        classes are imported, so toggling the preference re-applies the keymap live via
+        :meth:`apply_cross_select_preference`.
+        """
+        return cls.get_cross_select_keymap() if cls.is_cross_select_enabled() else cls.get_native_selection_keymap()
+
+    # Length of the selection block in bl_keymap, keyed by the operator idname of its
+    # first entry.  Used to locate and replace the selection block during a rebuild
+    # while preserving any pre-selection or post-selection entries the tool declares.
+    _SELECTION_PREFIX_LENGTHS = {"bim.cross_select": 4, "view3d.select_box": 6}
+
+    @classmethod
+    def _iter_selection_tools(cls):
+        """Yield ``(tool_cls, after, separator, group)`` for every Bonsai WorkSpaceTool that
+        uses the shared selection keymap, in registration order so re-registration preserves
+        the toolbar layout.
+
+        NOTE: keep in sync with each module's ``register()`` tool registration. The model
+        tools are read from ``model.tools``; the single-tool modules are listed explicitly.
+        """
+        from bonsai.bim.module import project, model, cad, drawing, spatial, structural, covering
+
+        yield (project.workspace.ExploreTool, {"builtin.transform"}, True, False)
+        for td in model.tools:
+            yield (td.tool, td.after, td.separator, td.group)
+        yield (cad.workspace.CadTool, {"builtin.transform"}, True, False)
+        yield (drawing.workspace.AnnotationTool, {"bim.bim_tool"}, True, False)
+        yield (spatial.workspace.SpatialTool, {"bim.annotation_tool"}, False, False)
+        yield (structural.workspace.StructuralTool, {"bim.spatial_tool"}, False, False)
+        yield (covering.workspace.CoveringTool, {"bim.wall_tool"}, False, False)
+
+    @classmethod
+    def _split_tool_keymap(cls, tool_cls) -> tuple[tuple, tuple]:
+        """Split bl_keymap into (pre_selection, post_selection), discarding the selection block.
+
+        Locates the selection block by finding the first entry whose op is in
+        ``_SELECTION_PREFIX_LENGTHS``, then skips the declared number of entries.
+        Entries before the block become *pre_selection*; entries after become
+        *post_selection*.  The caller inserts the desired selection keymap between them.
+
+        When no selection block is found (shouldn't happen in practice) all entries
+        are returned as post_selection so the rebuild still produces a valid keymap.
+        """
+        km = tuple(tool_cls.bl_keymap)
+        sel_start = next((i for i, entry in enumerate(km) if entry[0] in cls._SELECTION_PREFIX_LENGTHS), None)
+        if sel_start is None:
+            return (), km
+        sel_len = cls._SELECTION_PREFIX_LENGTHS[km[sel_start][0]]
+        return km[:sel_start], km[sel_start + sel_len:]
+
+    @classmethod
+    def apply_cross_select_preference(cls) -> None:
+        """Rebuild every Bonsai tool's selection keymap from the current preference and
+        re-register the tools so the Cross Select toggle takes effect without a restart.
+
+        Safe to call repeatedly: it no-ops when the tools already carry the desired keymap.
+        """
+        if bpy.app.background:
+            return
+        selection_keymap = tuple(cls.get_default_selection_keypmap())
+        tools = list(cls._iter_selection_tools())
+        if not tools:
+            return
+
+        desired_op = selection_keymap[0][0] if selection_keymap else None
+        current = tuple(tools[0][0].bl_keymap)
+        # The selection block may be preceded by pre-selection entries (e.g. the
+        # AnnotationTool's ClickNearestDimensionAnchor), so search for it by op name
+        # rather than assuming it starts at position 0.
+        sel_start = next((i for i, entry in enumerate(current) if entry[0] in cls._SELECTION_PREFIX_LENGTHS), None)
+        if sel_start is not None and current[sel_start][0] == desired_op:
+            return  # already applied
+
+        # Capture each tool's own entries before mutating any ``bl_keymap`` (model subclasses
+        # share BimTool's inherited keymap, so this must be done up front).
+        pre_post = {tool_cls: cls._split_tool_keymap(tool_cls) for tool_cls, *_ in tools}
+        for tool_cls, *_ in reversed(tools):
+            try:
+                bpy.utils.unregister_tool(tool_cls)
+            except Exception:
+                pass
+        for tool_cls, after, separator, group in tools:
+            pre, post = pre_post[tool_cls]
+            tool_cls.bl_keymap = pre + selection_keymap + post
+            bpy.utils.register_tool(tool_cls, after=after, separator=separator, group=group)
 
     KEY_MODIFIERS = {
         "A": ("EVENT_ALT", "OPTION" if sys.platform == "Darwin" else "ALT"),

src/bonsai/bonsai/tool/geometry.py

@@ -257,13 +257,7 @@ class Geometry(bonsai.core.tool.Geometry):
                 break
         mesh = obj.data
         assert isinstance(mesh, bpy.types.Mesh)
-        item_id = tool.Geometry.get_mesh_props(mesh).ifc_definition_id
-        try:
-            item = tool.Ifc.get().by_id(item_id)
-        except RuntimeError:
-            # Entity already deleted (e.g. removed as part of a sibling boolean collapse).
-            bpy.data.objects.remove(obj)
-            return
+        item = tool.Ifc.get().by_id(tool.Geometry.get_mesh_props(mesh).ifc_definition_id)
         rep_obj = props.representation_obj
         assert (rep_obj := props.representation_obj) and (rep_element := tool.Ifc.get_entity(rep_obj))
         cls.remove_representation_item(item, rep_element)
@@ -1163,16 +1157,11 @@ class Geometry(bonsai.core.tool.Geometry):
     @classmethod
     def get_representation_item(cls, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
         data = obj.data
-        if not isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES):
-            return None
-        ifc_id = tool.Geometry.get_mesh_props(data).ifc_definition_id
-        if not ifc_id:
-            return None
-        try:
-            item = tool.Ifc.get().by_id(ifc_id)
-        except RuntimeError:
-            return None
-        if item.is_a("IfcRepresentationItem"):
+        if (
+            isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES)
+            and (ifc_id := tool.Geometry.get_mesh_props(data).ifc_definition_id)
+            and ((item := tool.Ifc.get().by_id(ifc_id)).is_a("IfcRepresentationItem"))
+        ):
             return item
         return None
 
@@ -1346,8 +1335,6 @@ class Geometry(bonsai.core.tool.Geometry):
         cls, representation: ifcopenshell.entity_instance
     ) -> ifcopenshell.entity_instance:
         if representation.RepresentationType == "MappedRepresentation":
-            if not representation.Items:
-                return representation
             return cls.resolve_mapped_representation(representation.Items[0].MappingSource.MappedRepresentation)
         return representation
 

src/bonsai/bonsai/tool/model.py

@@ -351,8 +351,6 @@ class Model(bonsai.core.tool.Model):
     @classmethod
     def get_extrusion(cls, representation: ifcopenshell.entity_instance) -> Union[ifcopenshell.entity_instance, None]:
         """Return first found IfcExtrudedAreaSolid"""
-        if not representation.Items:
-            return None
         item = representation.Items[0]
         while True:
             if item.is_a("IfcExtrudedAreaSolid"):
@@ -845,57 +843,6 @@ class Model(bonsai.core.tool.Model):
                 items.append(item.FirstOperand)
         return booleans
 
-    @classmethod
-    def get_connected_slab_objs(cls, wall: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
-        """Return Blender objects for slabs connected to wall via IfcRelConnectsElements(TOP)."""
-        result = []
-        for rel in wall.ConnectedFrom:
-            if rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP":
-                slab_obj = tool.Ifc.get_object(rel.RelatingElement)
-                if slab_obj:
-                    result.append(slab_obj)
-        return result
-
-    @classmethod
-    def get_connected_wall_objs(cls, slab: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
-        """Return Blender objects for LAYER2 walls connected to slab via IfcRelConnectsElements(TOP)."""
-        result = []
-        for rel in slab.ConnectedTo:
-            if rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP":
-                wall_obj = tool.Ifc.get_object(rel.RelatedElement)
-                if wall_obj:
-                    result.append(wall_obj)
-        return result
-
-    @classmethod
-    def has_underside_connection(cls, element: ifcopenshell.entity_instance) -> bool:
-        """Return True if element has an IfcRelConnectsElements(TOP) relationship."""
-        return any(rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP" for rel in element.ConnectedFrom)
-
-    @classmethod
-    def remove_wall_to_underside_booleans(cls, wall: ifcopenshell.entity_instance) -> None:
-        """Remove all IfcBooleanResult items previously added by extend_walls_to_underside."""
-        manual_booleans = cls.get_manual_booleans(wall)
-        if not manual_booleans:
-            return
-        ifc_file = tool.Ifc.get()
-        for b in manual_booleans:
-            sec = b.SecondOperand
-            if sec is None:
-                # The IfcPolygonalFaceSet was already deleted externally.  Splice the
-                # orphaned IfcBooleanResult out of the chain so the representation stays valid.
-                parents = list(ifc_file.get_inverse(b))
-                for parent in parents:
-                    if parent.is_a("IfcBooleanResult") and parent.FirstOperand == b:
-                        parent.FirstOperand = b.FirstOperand
-                    elif parent.is_a("IfcShapeRepresentation"):
-                        new_items = tuple((set(parent.Items) - {b}) | {b.FirstOperand})
-                        parent.Items = new_items
-                cls.unmark_manual_booleans(wall, [b.id()])
-                ifc_file.remove(b)
-            elif sec.is_a("IfcTessellatedFaceSet"):
-                tool.Geometry.remove_representation_item(sec, wall)
-
     @classmethod
     def get_manual_booleans(
         cls, element: ifcopenshell.entity_instance, representation: Optional[ifcopenshell.entity_instance] = None
@@ -908,8 +855,7 @@ class Model(bonsai.core.tool.Model):
             representation = tool.Geometry.get_body_representation(element)
             if not representation:
                 return []
-        all_chain_booleans = cls.get_booleans(element, representation)
-        booleans = [b for b in all_chain_booleans if b.id() in boolean_ids]
+        booleans = [b for b in cls.get_booleans(element, representation) if b.id() in boolean_ids]
         return booleans
 
     @classmethod
@@ -2611,15 +2557,12 @@ class Model(bonsai.core.tool.Model):
         clipping_bm = bmesh.new()
         vertex_map = {}
 
-        kept = 0
         for face in bm.faces:
             face.normal_update()
             normal = face.normal.to_4d()
             normal.w = 0
-            world_normal_z = (obj.matrix_world @ normal).z
-            if world_normal_z >= -0.5:
+            if (obj.matrix_world @ normal).z >= -0.5:
                 continue
-            kept += 1
             new_verts = []
             for vert in face.verts:
                 if not (new_vert := vertex_map.get(vert.index, None)):
@@ -2632,7 +2575,6 @@ class Model(bonsai.core.tool.Model):
             return
 
         bmesh.ops.recalc_face_normals(clipping_bm, faces=clipping_bm.faces)
-        clipping_bm.faces.ensure_lookup_table()
         return clipping_bm  # clipping_bm is in project units
 
     @classmethod
@@ -2646,53 +2588,17 @@ class Model(bonsai.core.tool.Model):
         min_z = min(zs)
         max_z = max(zs)
 
-        ifc_file = tool.Ifc.get()
-        builder = ifcopenshell.util.shape_builder.ShapeBuilder(ifc_file)
+        operand = None
+        if (z := max_z - min_z) and not np.isclose(z, 0.0):
+            builder = ifcopenshell.util.shape_builder.ShapeBuilder(tool.Ifc.get())
 
-        # Build one IfcPolygonalFaceSet clip solid per clipping face.
-        # Each solid uses a rectangle on the slope plane rather than the exact face
-        # footprint.  The original approach (exact footprint) caused a kissing-solid /
-        # boundary-coincidence bug when the operator is called twice for a ridge roof: the
-        # two slope solids share an exact ridge edge, and OCCT produces spurious extra
-        # vertices.  Extending each solid slightly past the ridge (by margin) creates a
-        # volumetric overlap instead of a kissing boundary — OCCT handles overlapping
-        # DIFFERENCE operands correctly.
-        margin = 1.0  # project units past the face edge — enough to ensure overlap at ridge
-        operands = []
-        for face in bm.faces:
-            face.normal_update()
-            normal = Vector(face.normal).normalized()
+            result = bmesh.ops.extrude_face_region(bm, geom=bm.faces)
+            extruded_verts = [elem for elem in result["geom"] if isinstance(elem, bmesh.types.BMVert)]
+            bmesh.ops.translate(bm, verts=extruded_verts, vec=(0, 0, z))
 
-            # Orthonormal basis spanning the slope plane.
-            ref = Vector((0, 0, 1)) if abs(normal.z) < 0.9 else Vector((1, 0, 0))
-            tangent1 = normal.cross(ref).normalized()
-            tangent2 = normal.cross(tangent1).normalized()
-
-            centroid = sum((v.co for v in face.verts), Vector()) / len(face.verts)
-
-            # Tight bounding rectangle in slope-plane coords, plus a small margin.
-            t1_coords = [(v.co - centroid).dot(tangent1) for v in face.verts]
-            t2_coords = [(v.co - centroid).dot(tangent2) for v in face.verts]
-            half1 = max(abs(c) for c in t1_coords) + margin
-            half2 = max(abs(c) for c in t2_coords) + margin
-
-            # Rectangle on the slope plane, extruded upward in wall-local Z.
-            clip_bm = bmesh.new()
-            v0 = clip_bm.verts.new(centroid + half1 * tangent1 + half2 * tangent2)
-            v1 = clip_bm.verts.new(centroid - half1 * tangent1 + half2 * tangent2)
-            v2 = clip_bm.verts.new(centroid - half1 * tangent1 - half2 * tangent2)
-            v3 = clip_bm.verts.new(centroid + half1 * tangent1 - half2 * tangent2)
-            bottom_face = clip_bm.faces.new([v0, v1, v2, v3])
-            result = bmesh.ops.extrude_face_region(clip_bm, geom=[bottom_face])
-            top_verts = [e for e in result["geom"] if isinstance(e, bmesh.types.BMVert)]
-            bmesh.ops.translate(clip_bm, verts=top_verts, vec=Vector((0, 0, max_z - min_z)))
-            clip_bm.verts.ensure_lookup_table()
-
-            clip_verts = [v.co for v in clip_bm.verts]
-            clip_faces = [[v.index for v in f.verts] for f in clip_bm.faces]
-            operand = builder.mesh(clip_verts, clip_faces)
-            clip_bm.free()
-            operands.append(operand)
+            verts = [v.co for v in bm.verts]
+            faces = [[v.index for v in p.verts] for p in bm.faces]
+            operand = builder.mesh(verts, faces)
 
         for extrusion in ifcopenshell.util.shape.get_base_extrusions(wall) or []:
             if extrusion.Position:
@@ -2709,9 +2615,10 @@ class Model(bonsai.core.tool.Model):
 
             extrusion.Depth = max_z / direction[2]
 
-            if operands:
-                body_repr = ifcopenshell.util.representation.get_representation(wall, "Model", "Body", "MODEL_VIEW")
-                booleans = ifcopenshell.api.geometry.add_boolean(ifc_file, first_item=extrusion, second_items=operands)
+            if operand:
+                booleans = ifcopenshell.api.geometry.add_boolean(
+                    tool.Ifc.get(), first_item=extrusion, second_items=[operand]
+                )
                 tool.Model.mark_manual_booleans(wall, booleans)
 
     @classmethod
@@ -2964,20 +2871,10 @@ class Model(bonsai.core.tool.Model):
 
     @classmethod
     def recreate_wall(cls, element: ifcopenshell.entity_instance, obj: bpy.types.Object) -> None:
-        # Curved fillet-corner walls own a hand-built banana body that
-        # ``regenerate_wall_representation`` would flatten — it reads the axis
-        # as a 2-point reference line and builds a straight extrusion. Rebuild
-        # the curve in place instead: ``regenerate_fillet_corner_wall`` keeps
-        # radius + placement from the pset / current ``ObjectPlacement`` while
-        # picking up new thickness / height from the wall type, which is what
-        # we want when a type-property edit triggered this call.
-        if tool.Parametric.is_fillet_corner_wall(element):
-            # Lazy import: ``tool.Model`` loads before ``bim/module/model`` at
-            # addon enable; a module-level import would cycle.
-            from bonsai.bim.module.model.wall import regenerate_fillet_corner_wall
-
-            regenerate_fillet_corner_wall(element, obj)
-            return
+        # FIXME(PR4): the fillet-corner branch lands with PR4's
+        # `regenerate_fillet_corner_wall` (bim/module/model/wall.py). On v0.8.0
+        # the function doesn't exist; falling through to the straight-extrusion
+        # path preserves v0.8.0 behaviour for fillet walls until PR4 ships.
         rep = ifcopenshell.api.geometry.regenerate_wall_representation(tool.Ifc.get(), element)
         bonsai.core.geometry.switch_representation(
             tool.Ifc,
@@ -3012,7 +2909,7 @@ class Model(bonsai.core.tool.Model):
             if not wall:
                 continue
             is_layer2_usage = tool.Model.get_usage_type(element) == "LAYER2"
-            is_fillet_corner = tool.Parametric.is_fillet_corner_wall(element)
+            is_fillet_corner = bool(ifcopenshell.util.element.get_pset(element, "BBIM_Wall", "IsFilletCorner"))
             if not (is_layer2_usage or is_fillet_corner):
                 continue
             if is_layer2_usage:

src/bonsai/bonsai/tool/parametric.py

@@ -487,13 +487,6 @@ class Parametric(bonsai.core.tool.Parametric):
             return False
         if tool.Model.get_usage_type(element) == "LAYER2":
             return True
-        return cls.is_fillet_corner_wall(element)
-
-    @classmethod
-    def is_fillet_corner_wall(cls, element: entity_instance) -> bool:
-        """``True`` if the wall carries the ``BBIM_Wall.IsFilletCorner`` flag,
-        marking it as a curved corner whose banana body is hand-built rather
-        than regenerated from the wall's axis + layer set."""
         import ifcopenshell.util.element
 
         return bool(ifcopenshell.util.element.get_pset(element, "BBIM_Wall", "IsFilletCorner"))

src/bonsai/bonsai/tool/raycast.py

@@ -373,42 +373,26 @@ class Raycast(bonsai.core.tool.Raycast):
         except:
             loc = Vector((0, 0, 0))
 
+        verts_2d = [
+            view3d_utils.location_3d_to_region_2d(region, rv3d, v) for v in snap_obj.verts_3d
+        ]  # Numpy version is worst in performance
 
-        snap_obj._ensure_bvh()
         intersected = snap_obj.raycast_boxes(
             context, event, snap_obj.root, intersected=[], rays=(ray_origin, ray_direction)
         )
-
-        # Collect edges from intersected BVH boxes
         edges = []
         for it in intersected:
             edges.extend(it.edges)
         edges = set(edges)
 
-        # Build only the vertices indices that belong to these edges
-        verts_idx: set[int] = set()
-        for e in edges:
-            ev = snap_obj.obj.data.edges[e].vertices
-            verts_idx.add(ev[0])
-            verts_idx.add(ev[1])
-
-        # Lazily project only the needed vertices to 2D screen space
-        verts_2d: dict[int, Vector] = {}
-        for idx in verts_idx:
-            v2d = view3d_utils.location_3d_to_region_2d(
-                region, rv3d, snap_obj.verts_3d[idx]
-            )
-            if v2d is not None:
-                verts_2d[idx] = v2d
-
-
         edge_verts = {}
         for e in edges:
-            verts_idx = snap_obj.obj.data.edges[e].vertices
-            v1 = snap_obj.verts_3d[verts_idx[0]]
-            v2 = snap_obj.verts_3d[verts_idx[1]]
-            v1_2d = verts_2d.get(verts_idx[0])
-            v2_2d = verts_2d.get(verts_idx[1])
+            verts_idx = tuple(snap_obj.obj.data.edges[e].vertices)
+            verts = snap_obj.obj.data.vertices
+            v1 = snap_obj.obj.matrix_world @ verts[verts_idx[0]].co
+            v1_2d = verts_2d[verts_idx[0]]
+            v2 = snap_obj.obj.matrix_world @ verts[verts_idx[1]].co
+            v2_2d = verts_2d[verts_idx[1]]
             if (v1_2d is None) ^ (v2_2d is None):
                 point, _ = cls.intersect_edge_region_border(region, context.space_data, rv3d, v1, v2)
                 if v1_2d is None:
@@ -420,16 +404,10 @@ class Raycast(bonsai.core.tool.Raycast):
 
         snap_threshold = 10.0
 
-        # Check all vertices for proximity to mouse position.
-        # Re-use the 2D projections already computed for edge endpoints.
-        for i, v3d in enumerate(snap_obj.verts_3d):
-            if i in verts_2d:
-                v2d = verts_2d[i]
-            else:
-                v2d = view3d_utils.location_3d_to_region_2d(region, rv3d, v3d)
-                if v2d is None:
-                    continue
-            distance = (Vector(mouse_pos) - v2d).length
+        for i, point in enumerate(verts_2d):
+            if not point:
+                continue
+            distance = (Vector(mouse_pos) - point).length
             if distance <= snap_threshold:
                 snap_point = {
                     "object": snap_obj.obj,
@@ -821,30 +799,6 @@ class Raycast(bonsai.core.tool.Raycast):
         else:
             return None, None, None
 
-    @classmethod
-    def process_wireframe_snap_obj(
-        cls,
-        context: bpy.types.Context,
-        event: bpy.types.Event,
-        snap_obj,
-        ray_origin: Vector,
-        closest_snaps: list,
-    ):
-        snap_points = tool.Raycast.ray_cast_by_proximity_2d(context, event, snap_obj)
-        hit_obj = None
-        hit = None
-        if snap_points:
-            closest_length_squared = float("inf")
-            for point in snap_points:
-                point["group"] = "Wireframe"
-                closest_snaps.append(point)
-                length = (point["point"] - ray_origin).length_squared
-                if length < closest_length_squared:
-                    closest_length_squared = length
-                    hit = point["point"]
-                    hit_obj = point["object"]
-        return hit_obj, hit
-
     @classmethod
     def ray_cast_and_get_closest_to_camera_snaps(
         cls,
@@ -859,45 +813,35 @@ class Raycast(bonsai.core.tool.Raycast):
 
         ray_origin, ray_target, ray_direction = cls.get_viewport_ray_data(context, event)
 
-        space = context.space_data
-        xray_mode = (space.shading.type == "SOLID" and space.shading.show_xray) or (
-            space.shading.type == "WIREFRAME" and space.shading.show_xray_wireframe
-        )
-
         closest_snaps = []
+        hit = None
 
-        if not xray_mode and objs_to_raycast:
-            # Non-xray - only the closest solid object's Face snap is kept by
-            # the caller (detect_snapping_points).  Process solids in distance
-            # order and stop at the first hit to minimise raycasts.
-            wireframe_objs = []
-            solid_objs = []
-            for snap_obj in objs_to_raycast:
-                if snap_obj.obj.type in {"EMPTY", "CURVE"} or (
-                    hasattr(snap_obj.obj.data, "polygons") and len(snap_obj.obj.data.polygons) == 0
-                ):
-                    wireframe_objs.append(snap_obj)
-                else:
-                    solid_objs.append(snap_obj)
+        for snap_obj in objs_to_raycast:
+            if snap_obj.obj.type in {"EMPTY", "CURVE"} or (
+                hasattr(snap_obj.obj.data, "polygons") and len(snap_obj.obj.data.polygons) == 0
+            ):
+                # For wireframe objects we have to test all the snaps to see which is closer
+                snap_points = tool.Raycast.ray_cast_by_proximity_2d(context, event, snap_obj)
+                closest_wf_hit = None
+                closest_wf_length_squared = 1.0
+                closest_wf_point = None
+                if snap_points:
+                    for point in snap_points:
+                        point["group"] = "Wireframe"
+                        closest_snaps.append(point)
+                        length = (point["point"] - ray_origin).length_squared
+                        if closest_wf_hit is None or length < closest_wf_length_squared:
+                            closest_wf_length_squared = length
+                            closest_wf_hit = point["point"]
+                            closest_wf_point = point
 
-            # Rough distance - object origin to ray origin
-            solid_objs.sort(key=lambda so: (so.obj.matrix_world.translation - ray_origin).length_squared)
+                    if closest_wf_point:
+                        hit_obj = closest_wf_point["object"]
+                        hit = closest_wf_point["point"]
+                        face_index = None
 
-            # Process wireframe objects first (all of them, always collected)
-            for snap_obj in wireframe_objs:
-                hit_obj, hit = cls.process_wireframe_snap_obj(
-                    context, event, snap_obj, ray_origin, closest_snaps
-                )
-                if hit is not None:
-                    length_squared = (hit - ray_origin).length_squared
-                    if closest_obj is None or length_squared < closest_length_squared:
-                        closest_length_squared = length_squared
-                        closest_obj = hit_obj
-                        closest_hit = hit
-                        closest_face_index = None
-
-            # Process solid objects in distance order, stop at first hit
-            for snap_obj in solid_objs:
+            else:
+                # Solid objects
                 hit_obj, hit, face_index = cls.cast_rays_to_single_object(context, event, snap_obj.obj)
 
                 if hit:
@@ -911,47 +855,14 @@ class Raycast(bonsai.core.tool.Raycast):
                     }
                     closest_snaps.append(snap_point)
 
-                    length_squared = (hit - ray_origin).length_squared
-                    if closest_obj is None or length_squared < closest_length_squared:
-                        closest_length_squared = length_squared
-                        closest_obj = hit_obj
-                        closest_hit = hit
-                        closest_face_index = face_index
-
-                    break
-
-        else:
-            # Xray mode - process all objects (all snaps are kept by the caller)
-            for snap_obj in objs_to_raycast:
-                if snap_obj.obj.type in {"EMPTY", "CURVE"} or (
-                    hasattr(snap_obj.obj.data, "polygons") and len(snap_obj.obj.data.polygons) == 0
-                ):
-                    hit_obj, hit = cls.process_wireframe_snap_obj(
-                        context, event, snap_obj, ray_origin, closest_snaps
-                    )
-                    face_index = None
-                else:
-                    # Solid objects
-                    hit_obj, hit, face_index = cls.cast_rays_to_single_object(context, event, snap_obj.obj)
-
-                    if hit:
-                        snap_point = {
-                            "point": hit,
-                            "type": "Face",
-                            "group": "Object",
-                            "object": hit_obj,
-                            "face_index": face_index,
-                            "distance": 9,  # High value so it has low priority
-                        }
-                        closest_snaps.append(snap_point)
-
-                if hit is not None:
-                    length_squared = (hit - ray_origin).length_squared
-                    if closest_obj is None or length_squared < closest_length_squared:
-                        closest_length_squared = length_squared
-                        closest_obj = hit_obj
-                        closest_hit = hit
-                        closest_face_index = face_index
+            # Here we test which is closer, including wireframe and solid objects
+            if hit is not None:
+                length_squared = (hit - ray_origin).length_squared
+                if closest_obj is None or length_squared < closest_length_squared:
+                    closest_length_squared = length_squared
+                    closest_obj = hit_obj
+                    closest_hit = hit
+                    closest_face_index = face_index
 
         # Label snaps from the closest object
         if closest_obj is not None:
@@ -1025,19 +936,12 @@ class SnapObj:
     def __init__(self, obj: bpy.types.Object):
         self.__class__.all.append(self)
         self.obj = obj
-        self.root = None
-        self._bvh_built = False
+        self.root = self._create_root_node()
+        self.root.edges = [e.index for e in obj.data.edges]
+        self.split_box(self.root, 0)
         self.verts_3d = [obj.matrix_world @ v.co for v in obj.data.vertices]
         self.snap_points = []
 
-    def _ensure_bvh(self):
-        if self._bvh_built:
-            return
-        self.root = self._create_root_node()
-        self.root.edges = [e.index for e in self.obj.data.edges]
-        self.split_box(self.root, 0)
-        self._bvh_built = True
-
     def __clear_all__():
         for instance in SnapObj.all:
             del instance

src/bonsai/test/bim/module/model/test_fillet_operators.py

@@ -1,96 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Behaviour contracts for the wall-fillet operator chain.
-
-Each fillet operator's geometry path requires real Blender + IFC fixtures
-(walls with IfcMaterialLayerSetUsage, neighbour rels, etc.). End-to-end
-fillet round-trips belong in the bim feature suite (model.feature) where
-that scaffolding already exists. This file pins the surface-level invariants
-that don't depend on the geometry path:
-
-  * the lifecycle operators are registered under their conventional bl_idnames,
-  * the enable poll rejects ineligible selections.
-
-State-clearing tests via ``bpy.ops.bim.cancel_wall_fillet_preview()`` were
-removed because the dispatch is flaky in full-suite ordering — the operator
-early-returns when ``context.screen`` is unattached and prior tests can leave
-the screen in that state. The behaviour is covered by the user-visible live
-test loop instead."""
-
-import types
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.model
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def _fillet_op_names():
-    """Walk bpy.ops.bim for operators whose name contains ``wall_fillet`` —
-    avoids hard-coding the five lifecycle bl_idnames so adding / renaming
-    one updates discovery automatically. Each name maps to a callable
-    operator."""
-    return sorted(name for name in dir(bpy.ops.bim) if "wall_fillet" in name)
-
-
-class TestFilletOperatorsRegistered:
-    """Catches accidental deregistration of any fillet lifecycle operator —
-    drops in the classes tuple of bim/module/model/__init__.py would otherwise
-    leave the gizmo group's target_set_operator binding pointing at a missing
-    op and crash the first time a user clicked the icon."""
-
-    def test_at_least_the_expected_lifecycle_set_is_registered(self):
-        names = _fillet_op_names()
-        # The lifecycle has enable + finish + cancel as a minimum; a healthy
-        # build also includes the from-corner re-edit entry and the create
-        # operator the finish dispatches to. The test asserts at least four —
-        # below that the feature can't function — without enumerating each
-        # by name, so the test stays meaningful if one is renamed or merged.
-        assert len(names) >= 4, (
-            f"Only {len(names)} fillet operators found on bpy.ops.bim: {names}. "
-            "The fillet lifecycle needs enable + finish + cancel + create at "
-            "minimum; check bim/module/model/__init__.py classes tuple."
-        )
-
-    def test_every_discovered_fillet_op_is_callable(self):
-        for name in _fillet_op_names():
-            op = getattr(bpy.ops.bim, name)
-            assert callable(op), f"bpy.ops.bim.{name} is not callable — registration broke?"
-
-
-class TestEnableRejectsIneligibleSelection:
-    """The preview enable operator requires a specific 2-wall selection
-    (LAYER2 walls with straight axes). With no selection at all, poll
-    must return False so the operator is greyed-out in menus instead of
-    crashing on dispatch."""
-
-    def test_enable_poll_returns_false_with_no_selection(self):
-        # Deselect everything in the default scene; no IfcWall is present
-        # in a fresh bpy_extras context anyway, so poll() must short-circuit.
-        bpy.ops.object.select_all(action="DESELECT")
-        bpy.context.view_layer.update()
-        assert bpy.ops.bim.enable_wall_fillet_preview.poll() is False

src/bonsai/test/bim/module/model/test_preview_base.py

@@ -1,178 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Tests for the parametric-edit preview registry contract.
-
-Every test reads the live ``PREVIEW_CANCEL_OPS`` registry rather than hard-
-coding preview keys or cancel-operator names, so adding a new preview to the
-registry automatically exercises the same invariants without test changes."""
-
-import types
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.model
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def _registry():
-    from bonsai.bim.module.model.preview_base import PREVIEW_CANCEL_OPS
-
-    return PREVIEW_CANCEL_OPS
-
-
-def _preview_umbrella():
-    return getattr(bpy.context.scene, "BIMPreviewProperties", None)
-
-
-def _registered_previews():
-    """``[(attr, op_name, props)]`` for every registry entry that has a real
-    child PropertyGroup on the umbrella in the current addon build."""
-    umbrella = _preview_umbrella()
-    if umbrella is None:
-        return []
-    out = []
-    for attr, op_name in _registry():
-        props = getattr(umbrella, attr, None)
-        if props is not None:
-            out.append((attr, op_name, props))
-    return out
-
-
-class TestRegistryContract:
-    """Pins the invariant that every entry in PREVIEW_CANCEL_OPS resolves to
-    a real cancel operator the addon registers. A new preview added to the
-    registry without its matching cancel operator would otherwise crash
-    ``try_cancel_active_preview`` on the first Esc."""
-
-    def test_every_registered_cancel_op_is_callable(self):
-        for attr, op_name in _registry():
-            op = getattr(bpy.ops.bim, op_name, None)
-            assert op is not None and callable(op), (
-                f"Preview '{attr}' in PREVIEW_CANCEL_OPS points to bim.{op_name} "
-                f"but no such operator is registered."
-            )
-
-
-class TestGetPreviewPropsTolerance:
-    """The bug-class fixed in commit ee63137c6: ``get_preview_props`` is called
-    from gizmo polls during addon init and from test mocks built on
-    ``SimpleNamespace`` — neither has a fully-formed Blender context. The
-    helper must return None rather than raise."""
-
-    def test_returns_none_when_context_has_no_scene(self):
-        from bonsai.bim.module.model.preview_base import get_preview_props
-
-        # Pass an arbitrary attr name — the contract is the same for every
-        # preview key, so picking one literally would be a maintenance trap.
-        for attr, _ in _registry():
-            assert get_preview_props(types.SimpleNamespace(), attr) is None
-            break
-
-    def test_returns_none_when_scene_lacks_umbrella(self):
-        from bonsai.bim.module.model.preview_base import get_preview_props
-
-        ctx = types.SimpleNamespace(scene=types.SimpleNamespace())
-        for attr, _ in _registry():
-            assert get_preview_props(ctx, attr) is None
-            break
-
-
-class TestActivationCycle:
-    """End-to-end contract on the real addon: each registered preview can be
-    activated and then cancelled to inactive. Runs for every preview that
-    has a wired PropertyGroup, so a new preview added to the registry +
-    umbrella is covered without test edits."""
-
-    def test_any_preview_active_reflects_each_preview_state(self):
-        from bonsai.bim.module.model.preview_base import any_preview_active
-
-        registered = _registered_previews()
-        if not registered:
-            pytest.skip("No previews wired in this build — registry-only entries")
-
-        # All inactive baseline.
-        for _, _, props in registered:
-            props.is_active = False
-        assert any_preview_active(bpy.context) is False
-
-        # Flip each one independently — the helper must report True.
-        for _, _, props in registered:
-            props.is_active = True
-            assert any_preview_active(bpy.context) is True
-            props.is_active = False
-
-    def test_discard_pending_previews_clears_every_active_flag(self):
-        from bonsai.bim.module.model.preview_base import discard_pending_previews
-
-        registered = _registered_previews()
-        if not registered:
-            pytest.skip("No previews wired in this build — registry-only entries")
-
-        for _, _, props in registered:
-            props.is_active = True
-        discard_pending_previews(bpy.context.scene)
-        for attr, _, props in registered:
-            assert props.is_active is False, f"discard_pending_previews left '{attr}' active"
-
-
-class TestSaveOnDiscardWired:
-    """Pins that the SaveProject operator clears preview state before writing
-    the IFC file — a stuck is_active flag persisted through the save would
-    silently hide sister gizmos on the next file load.
-
-    Structural check: the SaveProject operator class must reference the
-    discard helper somewhere in its execute path. Behavioural integration
-    (actually saving a .blend with an active preview and reloading) belongs
-    in the bim feature suite; this is the small guard against accidental
-    removal of the call site."""
-
-    def test_save_project_dispatches_discard_pending_previews(self):
-        import inspect
-
-        from bonsai.bim.module.model import preview_base
-        from bonsai.bim.module.project import operator as project_operator
-
-        # Find the project save operator dynamically — looking for any
-        # Operator class whose bl_idname is "bim.save_project". Avoids
-        # hard-coding the class identifier.
-        save_op = None
-        for name in dir(project_operator):
-            obj = getattr(project_operator, name)
-            if isinstance(obj, type) and getattr(obj, "bl_idname", None) == "bim.save_project":
-                save_op = obj
-                break
-        assert save_op is not None, "Expected an operator with bl_idname='bim.save_project' in project/operator.py"
-
-        # Walk the class's methods for the discard call. Avoids pinning a
-        # specific method name (_execute vs execute vs an inner helper) so
-        # the test survives operator refactors.
-        source = inspect.getsource(save_op)
-        assert preview_base.discard_pending_previews.__name__ in source, (
-            f"{save_op.__name__} does not reference discard_pending_previews. "
-            "Saving with a preview open would persist its is_active flag to the "
-            ".blend file and silently hide sister gizmos on reopen."
-        )

src/bonsai/test/bim/module/model/test_wall_gizmo_poll_gate.py

@@ -1,154 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Behaviour contract: every wall gizmo group hides while a parametric-edit
-preview is active.
-
-Enumerates wall gizmo groups by walking the wall module for ``bpy.types.GizmoGroup``
-subclasses rather than naming them — adding a new wall gizmo group automatically
-joins the test. The test then asserts the BEHAVIOUR (poll returns False when
-``preview_base.any_preview_active`` is True) without pinning the name of the
-helper function the gizmo uses internally to enforce it."""
-
-import inspect
-import types
-from unittest.mock import patch
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.model
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def _wall_gizmo_groups():
-    """Walk the wall module for ``bpy.types.GizmoGroup`` subclasses defined
-    locally (skip imported references). Returns a list of (name, cls) tuples.
-
-    A gizmo group whose ``poll`` legitimately needs to fire WHILE a preview
-    is active — i.e. it IS the preview's own gizmo group — is excluded by
-    convention: classes whose bl_idname references the preview surface
-    (``preview`` in the idname) are the preview-owner exception."""
-    from bonsai.bim.module.model import wall as wall_mod
-
-    out = []
-    for name in dir(wall_mod):
-        obj = getattr(wall_mod, name)
-        if not isinstance(obj, type):
-            continue
-        if not issubclass(obj, bpy.types.GizmoGroup) or obj is bpy.types.GizmoGroup:
-            continue
-        # Local definitions only — skip re-exports / aliases.
-        if obj.__module__ != wall_mod.__name__:
-            continue
-        # Preview-owner exception: the gizmo group that drives a preview
-        # itself must remain visible while its preview is active, so a
-        # "no preview active" gate would self-block it. The bl_idname
-        # contains the substring 'preview' for these groups by Bonsai
-        # convention (e.g. OBJECT_GGT_bim_wall_fillet_preview).
-        bl_idname = getattr(obj, "bl_idname", "") or ""
-        if "preview" in bl_idname.lower():
-            continue
-        out.append((name, obj))
-    return out
-
-
-class TestWallGizmoGroupsHideDuringPreview:
-    """Behaviour contract: a parametric-edit preview is the only interactive
-    surface in the viewport, so every sister wall gizmo must self-hide via
-    its poll. The test exercises this BEHAVIOUR — when ``any_preview_active``
-    reports True, every wall gizmo's poll returns False — without pinning
-    the helper function name each poll uses internally."""
-
-    def test_discovery_finds_wall_gizmo_groups(self):
-        """Sanity check: at least one wall gizmo group is found. If this fails,
-        the discovery walk drifted out of sync with the module structure (e.g.
-        wall gizmo groups got moved to a separate file)."""
-        groups = _wall_gizmo_groups()
-        assert groups, "Expected at least one wall GizmoGroup subclass in wall.py — discovery walk broke?"
-
-    def test_every_wall_gizmo_hides_when_a_preview_is_active(self):
-        """For each discovered wall gizmo group, mock ``any_preview_active`` to
-        True and call ``poll(bpy.context)``. Every poll must return False —
-        any True is a poll that wouldn't hide during a fillet/bend preview,
-        leaving the user with two competing icon stacks on the same selection."""
-        groups = _wall_gizmo_groups()
-        offenders = []
-        with patch("bonsai.bim.module.model.preview_base.any_preview_active", return_value=True):
-            for name, cls in groups:
-                poll = getattr(cls, "poll", None)
-                if poll is None:
-                    # Inherits poll from a mixin / base — the base poll's gating
-                    # is covered separately. Skip rather than crash.
-                    continue
-                try:
-                    result = poll(bpy.context)
-                except Exception as exc:  # noqa: BLE001
-                    offenders.append((name, f"poll raised: {type(exc).__name__}: {exc}"))
-                    continue
-                if result:
-                    offenders.append((name, "poll returned True with preview active"))
-
-        assert not offenders, (
-            "Wall gizmo polls that don't gate on any_preview_active "
-            "(or raise instead of returning False): "
-            + ", ".join(f"{n} — {why}" for n, why in offenders)
-            + ". Hide sister gizmos during previews so the preview is the only "
-            "interactive surface in the viewport. The conventional path is to "
-            "early-return from poll when preview_base.any_preview_active(context) "
-            "is True."
-        )
-
-
-class TestBaseParametricGizmoPollHidesDuringPreview:
-    """Mirror of the wall-specific test for the cross-feature parametric
-    framework: door / window / stair / roof / railing / array all inherit
-    ``BaseParametricGizmoGroup``. Its poll must also short-circuit on
-    ``any_preview_active`` so sister features behave consistently with walls."""
-
-    def test_base_parametric_poll_returns_false_when_a_preview_is_active(self):
-        from bonsai.bim.module.drawing.gizmos import BaseParametricGizmoGroup
-
-        # The base poll requires an active selected object before checking the
-        # preview gate. Mock both the selected-object check (return a sentinel)
-        # AND the gate so the test exercises ONLY the preview short-circuit.
-        with patch("bonsai.tool.Blender.get_active_object", return_value=object()):
-            with patch("bonsai.tool.Blender.are_viewport_gizmos_enabled", return_value=True):
-                with patch(
-                    "bonsai.bim.module.model.preview_base.any_preview_active",
-                    return_value=True,
-                ):
-                    assert BaseParametricGizmoGroup.poll(bpy.context) is False
-
-
-class TestModulePathIsFindable:
-    """If wall.py is split across multiple modules (e.g. wall_gizmos.py),
-    update ``_wall_gizmo_groups`` to walk each. This sanity check fails first
-    so the diagnostic message is obvious."""
-
-    def test_wall_module_resolves(self):
-        from bonsai.bim.module.model import wall as wall_mod
-
-        assert inspect.ismodule(wall_mod)

src/bonsai/test/bim/module/model/test_wall_gizmos.py

@@ -179,112 +179,3 @@ def test_poll_rejects_when_other_is_not_layer2_wall():
         _run_poll(prefs_on=True, active_is_in_selected=True, len_override=None, active_usage="LAYER3", other_usage=None)
         is False
     )
-
-
-# ----------------------------------------------------------------------------
-# _iter_path_connections — IfcRelConnectsPathElements inverse-graph walk
-# ----------------------------------------------------------------------------
-#
-# Normalises both ConnectedTo and ConnectedFrom orientations to (other, self_ct,
-# other_ct) so callers always read "self first" regardless of which side of the
-# rel this wall was authored on. Non-wall partners and malformed (None) refs are
-# filtered out so per-frame gizmo positioning survives partial IFC state.
-
-
-def _make_path_rel(relating, related, relating_ct, related_ct, kind="IfcRelConnectsPathElements"):
-    """Build a stub IfcRelConnectsPathElements for inverse-walk tests."""
-    return SimpleNamespace(
-        is_a=lambda name, _k=kind: name == _k,
-        RelatingElement=relating,
-        RelatedElement=related,
-        RelatingConnectionType=relating_ct,
-        RelatedConnectionType=related_ct,
-    )
-
-
-def _run_iter_path_connections(elem, *, is_wall_predicate=lambda _e: True):
-    from bonsai import tool
-    from bonsai.bim.module.model.wall import _iter_path_connections
-
-    with patch.object(tool.Blender.Modifier, "is_wall", side_effect=is_wall_predicate):
-        return _iter_path_connections(elem)
-
-
-def test_iter_path_connections_empty_inverses_yields_nothing():
-    elem = SimpleNamespace(ConnectedTo=[], ConnectedFrom=[])
-    assert _run_iter_path_connections(elem) == []
-
-
-def test_iter_path_connections_connected_to_orientation_is_self_first():
-    # Self is the rel's RelatingElement → its connection type is RelatingConnectionType.
-    self_elem = object()
-    other = object()
-    rel = _make_path_rel(relating=self_elem, related=other, relating_ct="ATEND", related_ct="ATSTART")
-    elem = SimpleNamespace(ConnectedTo=[rel], ConnectedFrom=[])
-    assert _run_iter_path_connections(elem) == [(other, "ATEND", "ATSTART")]
-
-
-def test_iter_path_connections_connected_from_orientation_is_self_first():
-    # Self is the rel's RelatedElement → its connection type is RelatedConnectionType.
-    # The helper must FLIP the tuple so callers still see (other, self_ct, other_ct).
-    self_elem = object()
-    other = object()
-    rel = _make_path_rel(relating=other, related=self_elem, relating_ct="ATSTART", related_ct="ATEND")
-    elem = SimpleNamespace(ConnectedTo=[], ConnectedFrom=[rel])
-    assert _run_iter_path_connections(elem) == [(other, "ATEND", "ATSTART")]
-
-
-def test_iter_path_connections_skips_non_path_rels():
-    # IfcRelAggregates, IfcRelContainedInSpatialStructure, etc. share the
-    # ConnectedTo/ConnectedFrom inverse arrays — only IfcRelConnectsPathElements
-    # carries the per-end connection-type semantics we care about.
-    self_elem = object()
-    other = object()
-    non_path = _make_path_rel(
-        relating=self_elem, related=other, relating_ct="ATSTART", related_ct="ATEND", kind="IfcRelAggregates"
-    )
-    path = _make_path_rel(relating=self_elem, related=other, relating_ct="ATEND", related_ct="ATSTART")
-    elem = SimpleNamespace(ConnectedTo=[non_path, path], ConnectedFrom=[])
-    assert _run_iter_path_connections(elem) == [(other, "ATEND", "ATSTART")]
-
-
-def test_iter_path_connections_skips_non_wall_partners():
-    # Walls may path-connect to non-wall elements (columns, beams). The single-
-    # wall unjoin gizmo only surfaces wall-to-wall joins to match the existing
-    # two-wall gizmo's scope.
-    self_elem = object()
-    wall_partner = object()
-    non_wall_partner = object()
-    rel_wall = _make_path_rel(relating=self_elem, related=wall_partner, relating_ct="ATEND", related_ct="ATSTART")
-    rel_non_wall = _make_path_rel(
-        relating=self_elem, related=non_wall_partner, relating_ct="ATEND", related_ct="ATSTART"
-    )
-    elem = SimpleNamespace(ConnectedTo=[rel_wall, rel_non_wall], ConnectedFrom=[])
-    result = _run_iter_path_connections(elem, is_wall_predicate=lambda e: e is wall_partner)
-    assert result == [(wall_partner, "ATEND", "ATSTART")]
-
-
-def test_iter_path_connections_tolerates_none_partner_refs():
-    # Malformed / partial IFC files can leave a rel's element ref unset.
-    # Without a None guard, `Modifier.is_wall(None)` would raise on
-    # `None.is_a(...)` mid-frame and silently break the gizmo group.
-    self_elem = object()
-    other = object()
-    rel_none = _make_path_rel(relating=self_elem, related=None, relating_ct="ATEND", related_ct="ATSTART")
-    rel_ok = _make_path_rel(relating=self_elem, related=other, relating_ct="ATSTART", related_ct="ATEND")
-    elem = SimpleNamespace(ConnectedTo=[rel_none, rel_ok], ConnectedFrom=[])
-    assert _run_iter_path_connections(elem) == [(other, "ATSTART", "ATEND")]
-
-
-def test_iter_path_connections_walks_both_inverses_in_order():
-    # A wall can sit on both sides of different path rels (e.g. authored once
-    # as the RelatingElement, once as the RelatedElement). The helper walks
-    # ConnectedTo first, then ConnectedFrom — pinning the order so callers can
-    # depend on it for icon-slot allocation.
-    self_elem = object()
-    p1 = object()
-    p2 = object()
-    rel_to = _make_path_rel(relating=self_elem, related=p1, relating_ct="ATSTART", related_ct="ATSTART")
-    rel_from = _make_path_rel(relating=p2, related=self_elem, relating_ct="ATEND", related_ct="ATEND")
-    elem = SimpleNamespace(ConnectedTo=[rel_to], ConnectedFrom=[rel_from])
-    assert _run_iter_path_connections(elem) == [(p1, "ATSTART", "ATSTART"), (p2, "ATEND", "ATEND")]

src/bonsai/test/bim/module/model/test_wall_header_refresh.py

@@ -75,7 +75,7 @@ def test_geom_generation_invalidates_wall_geom_cache():
     sentinel_a = {"length": 1.0, "height": 2.0, "x_angle": 0.0}
     sentinel_b = {"length": 1.5, "height": 2.5, "x_angle": 0.0}
 
-    with patch.object(tool.Wall, "read_geometry", side_effect=[sentinel_a, sentinel_b]):
+    with patch.object(wall_mod, "_read_wall_geometry", side_effect=[sentinel_a, sentinel_b]):
         first = wall_mod._get_wall_geom_cached(group, fake_obj)
         assert first is sentinel_a
         # Same call without a generation bump must hit the cache (no extra read).

src/bonsai/test/modal/test_modal.py

@@ -1,380 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Bruno Perdigão <contact@brunopo.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import inspect
-import os
-import sys
-import time
-
-import bpy
-import ifcopenshell
-import pytest
-
-from bonsai import tool as tool
-from bonsai.bim.ifc import IfcStore
-from bonsai.bim.module.model.data import AuthoringData as Model
-
-GREEN = "\033[32m"
-RED = "\033[31m"
-RESET = "\033[0m"
-
-
-def _assert_pass(message: str) -> None:
-    caller_name = inspect.stack()[1].function
-    print(f"{GREEN}{caller_name} PASSED: {message}{RESET}")
-
-
-def _handle_error(e: Exception, on_done) -> None:
-    print(f"{RED}Assertion failed: {e}{RESET}")
-    if on_done:
-        on_done()
-
-
-def run_iter_from_timer(event_iter, on_complete=None, on_error=None):
-    i = iter(event_iter)
-    done = False
-
-    def event_step():
-        nonlocal done, on_complete
-        try:
-            ret = next(i, "STOP")
-            if ret in (None, "STOP", "FINISHED"):
-                done = True
-                if on_complete:
-                    on_complete()
-                return None
-        except StopIteration:
-            done = True
-            if on_complete:
-                on_complete()
-            return None
-        except Exception as e:
-            done = True
-            print(f"Exception: {e}")
-            if on_error:
-                on_error(e)
-            elif on_complete:
-                on_complete()
-            return None
-        return 0.0
-
-    bpy.app.timers.register(event_step, first_interval=0.0)
-
-
-def preset_event_simulate(window, event_type, value, x, y):
-    if value == "TAP":
-        yield window.event_simulate(event_type, "PRESS", x=x, y=y)
-        yield window.event_simulate(event_type, "RELEASE", x=x, y=y)
-    else:
-        yield window.event_simulate(event_type, value, x=x, y=y)
-
-
-def cleanup():
-    bpy.app.use_event_simulate = False
-    bpy.ops.wm.quit_blender()
-
-
-def _get_valid_window() -> bpy.types.Window:
-    win = bpy.context.window
-    if win is not None:
-        return win
-    wm = getattr(bpy.context, "window_manager", None)
-    if wm and wm.windows:
-        return wm.windows[0]
-    raise RuntimeError("Unable to locate a Blender UI window.")
-
-
-def new_project():
-    IfcStore.purge()
-    bpy.ops.wm.read_homefile(app_template="", use_factory_startup=True)
-    if len(bpy.data.objects) > 0:
-        bpy.data.batch_remove(bpy.data.objects)
-        bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
-    if len(bpy.data.materials) > 0:
-        bpy.data.batch_remove(bpy.data.materials)
-    bpy.context.scene.unit_settings.system = "METRIC"
-    bpy.context.scene.unit_settings.length_unit = "MILLIMETERS"
-    props = tool.Project.get_project_props()
-    props.template_file = "0"
-    tool.Blender.get_addon_preferences().should_play_chaching_sound = False
-
-def get_area_and_region(window):
-    area = next(area for area in window.screen.areas if area.type == "VIEW_3D")
-    region = next(region for region in area.regions if region.type == "WINDOW")
-    return area, region
-
-def test_snap_object_detection(window):
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", 0, 0)
-    area, region = get_area_and_region(window)
-    x = round(area.width * 0.5 + area.x)
-    y = round(area.height * 0.54 + area.y)
-
-    yield from preset_event_simulate(window, "ESC", "TAP", x, y)
-
-    measure_settings = tool.Project.get_measure_tool_settings()
-    measure_settings.measurement_type = "POLYLINE"
-    for obj in tool.Blender.get_selected_objects():
-        obj.select_set(False)
-    with bpy.context.temp_override(area=area, region=region, space_data=area.spaces[0]):
-        bpy.ops.bim.measure_tool("INVOKE_DEFAULT", measure_type="POLYLINE")
-
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x, y)
-    snap_point = tool.Model.get_polyline_props().snap_mouse_point[0]
-    assert_msg = "First click should have a snap_object"
-    assert snap_point.snap_object, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_object should be a string with the object name"
-    assert type(snap_point.snap_object) == str, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "Object should be an IfcWall"
-    assert snap_point.snap_object.split("/")[0] == "IfcWall", assert_msg
-    _assert_pass(assert_msg)
-
-    offset = 200
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x - offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x - offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x - offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x - offset, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x - offset, y)
-    snap_point = tool.Model.get_polyline_props().snap_mouse_point[0]
-    assert_msg = "Second click should not have a snap_object"
-    assert not snap_point.snap_object, assert_msg
-    _assert_pass(assert_msg)
-
-    yield from preset_event_simulate(window, "RET", "TAP", x, y)
-    yield "FINISHED"
-
-def test_snap_partially_behind_camera(window):
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", 0, 0)
-    area, region = get_area_and_region(window)
-    x = round(area.width * 0.20 + area.x)
-    y = round(area.height * 0.15 + area.y)
-
-    yield from preset_event_simulate(window, "ESC", "TAP", x, y)
-
-    measure_settings = tool.Project.get_measure_tool_settings()
-    measure_settings.measurement_type = "POLYLINE"
-    for obj in tool.Blender.get_selected_objects():
-        obj.select_set(False)
-    with bpy.context.temp_override(area=area, region=region, space_data=area.spaces[0]):
-        bpy.ops.bim.measure_tool("INVOKE_DEFAULT", measure_type="POLYLINE")
-
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x, y)
-    snap_point = tool.Model.get_polyline_props().snap_mouse_point[0]
-    assert_msg = "First click should have a snap_object"
-    assert snap_point.snap_object, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_object should be a string with the object name"
-    assert type(snap_point.snap_object) == str, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_type should be 'Edge'"
-    assert snap_point.snap_type == "Edge", assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "Object should be an IfcSlab"
-    assert snap_point.snap_object.split("/")[0] == "IfcSlab", assert_msg
-    _assert_pass(assert_msg)
-
-    offset = 200
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x - offset, y)
-    snap_point = tool.Model.get_polyline_props().snap_mouse_point[0]
-    assert_msg = "Second click should have a snap_object"
-    assert snap_point.snap_object, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_object should be a string with the object name"
-    assert type(snap_point.snap_object) == str, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_type should be 'Face'"
-    assert snap_point.snap_type == "Face", assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "Object should be an IfcSlab"
-    assert snap_point.snap_object.split("/")[0] == "IfcSlab", assert_msg
-    _assert_pass(assert_msg)
-
-    yield from preset_event_simulate(window, "RET", "TAP", x, y)
-    yield "FINISHED"
-
-def test_snap_in_xray_mode(window):
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", 0, 0)
-    area, region = get_area_and_region(window)
-    x = round(area.width * 0.68+ area.x)
-    y = round(area.height * 0.54 + area.y)
-
-    area.spaces[0].shading.show_xray = True
-
-    yield from preset_event_simulate(window, "ESC", "TAP", x, y)
-
-    measure_settings = tool.Project.get_measure_tool_settings()
-    measure_settings.measurement_type = "POLYLINE"
-    for obj in tool.Blender.get_selected_objects():
-        obj.select_set(False)
-    with bpy.context.temp_override(area=area, region=region, space_data=area.spaces[0]):
-        bpy.ops.bim.measure_tool("INVOKE_DEFAULT", measure_type="POLYLINE")
-
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x, y)
-    snap_point = tool.Model.get_polyline_props().snap_mouse_point[0]
-    assert_msg = "First click should have a snap_object"
-    assert snap_point.snap_object, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_object should be a string with the object name"
-    assert type(snap_point.snap_object) == str, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "Object should be an IfcFurniture"
-    assert snap_point.snap_object.split("/")[0] == "IfcFurniture", assert_msg
-    _assert_pass(assert_msg)
-    
-    yield from preset_event_simulate(window, "RET", "TAP", x, y)
-    yield "FINISHED"
-
-def test_snap_far_from_origin(window):
-    bpy.context.view_layer.objects.active = None
-    bpy.ops.object.select_all(action="DESELECT")
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", 0, 0)
-    area, region = get_area_and_region(window)
-    x = round(area.width * 0.155 + area.x)
-    y = round(area.height * 0.18 + area.y)
-
-    yield from preset_event_simulate(window, "ESC", "TAP", x, y)
-
-    bpy.data.objects['IfcBuildingElementProxy/Cube'].select_set(True)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    with bpy.context.temp_override(area=area, region=region, space_data=area.spaces[0]):
-        bpy.ops.view3d.view_selected()
-
-
-    measure_settings = tool.Project.get_measure_tool_settings()
-    measure_settings.measurement_type = "POLYLINE"
-    for obj in tool.Blender.get_selected_objects():
-        obj.select_set(False)
-    with bpy.context.temp_override(area=area, region=region, space_data=area.spaces[0]):
-        bpy.ops.bim.measure_tool("INVOKE_DEFAULT", measure_type="POLYLINE")
-
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x, y)
-    snap_point = tool.Model.get_polyline_props().snap_mouse_point[0]
-    assert_msg = "First click should have a snap_object"
-    assert snap_point.snap_object, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_object should be a string with the object name"
-    assert type(snap_point.snap_object) == str, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "snap_type should be 'Vertex'"
-    assert snap_point.snap_type == "Vertex", assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "x should be 1000000"
-    assert round(snap_point.x, 3) == 1000.0, assert_msg
-    _assert_pass(assert_msg)
-    assert_msg = "y should be 1000000"
-    assert round(snap_point.y, 3) == 1000.0, assert_msg
-    _assert_pass(assert_msg)
-
-    yield from preset_event_simulate(window, "RET", "TAP", x, y)
-    yield "FINISHED"
-
-def test_draw_polyline_wall(window, x, y):
-    yield from preset_event_simulate(window, "ESC", "TAP", x, y)
-    area, region = get_area_and_region(window)
-
-    for obj in tool.Blender.get_selected_objects():
-        obj.select_set(False)
-    with bpy.context.temp_override(area=area, region=region, space_data=area.spaces[0]):
-        props = tool.Model.get_model_props()
-        ifc = tool.Ifc.get()
-        relating_type = ifc.by_type("IfcWallType")[0]
-
-        if tool.Model.get_usage_type(relating_type) == "LAYER2":
-            props.ifc_class = "IfcWallType"
-            props.relating_type_id = str(relating_type.id())
-
-        bpy.ops.bim.draw_polyline_wall("INVOKE_DEFAULT")
-
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x, y)
-    yield from preset_event_simulate(window, "X", "TAP", x, y)
-
-    offset = 200
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "MOUSEMOVE", "NOTHING", x + offset, y)
-    yield from preset_event_simulate(window, "LEFTMOUSE", "TAP", x + offset, y)
-
-    yield from preset_event_simulate(window, "RET", "TAP", x, y)
-    element = tool.Ifc.get_entity(bpy.context.selected_objects[0])
-
-    assert_msg = "Created object should be IfcWall"
-    assert element.is_a() == "IfcWall"
-    _assert_pass(assert_msg)
-    assert_msg = "Created object should be typed by IfcWallType"
-    assert ifcopenshell.util.element.get_type(element).is_a() == "IfcWallType"
-    _assert_pass(assert_msg)
-    # TODO Asset the axis has the same X value
-
-    yield "FINISHED"
-
-
-def run_tests():
-    module_name = os.getenv("MODULE", "snap")
-    if module_name == "wall":
-        filepath = f"./test/files/wall.ifc"
-        bpy.ops.bim.load_project(filepath=filepath)
-        window = _get_valid_window()
-        test_queue = [lambda w=window: test_draw_polyline_wall(w, 960, 540)]
-    elif module_name == "snap":
-        filepath = f"./test/files/snap.ifc"
-        bpy.ops.bim.load_project(filepath=filepath)
-        window = _get_valid_window()
-        test_queue = [
-            lambda w=window: test_snap_object_detection(w),
-            lambda w=window: test_snap_partially_behind_camera(w),
-            lambda w=window: test_snap_in_xray_mode(w),
-            lambda w=window: test_snap_far_from_origin(w),
-        ]
-    else:
-        cleanup()
-
-    def _next():
-        if not test_queue:
-            cleanup()
-            return
-        test_fn = test_queue.pop(0)
-        # use the shared timer infrastructure
-        run_iter_from_timer(
-            test_fn(),
-            on_complete=_next,
-            on_error=lambda e: _handle_error(e, _next),
-        )
-
-    _next()
-
-if __name__ == "__main__":
-    new_project()
-    run_tests()

src/ifcgeom/kernels/opencascade/IfcGeomTree.h

@@ -48,7 +48,6 @@
 #include <stack>
 #include <unordered_map>
 #include <unordered_set>
-#include <cstdint>
 #include <BRepExtrema_TriangleSet.hxx>
 #include <BRepLProp_SLProps.hxx>
 #include <BVH_BinaryTree.hxx>

src/ifcgeom/kernels/opencascade/clash_utils.cpp

@@ -1,7 +1,5 @@
 #include "clash_utils.h"
 #include <cassert>
-#include <cstdint>
-#include <cfloat>
 
 #define GU_CULLING_EPSILON_RAY_TRIANGLE FLT_EPSILON*FLT_EPSILON
 #define PX_MAX_F32 3.4028234663852885981170418348452e+38F

src/ifcgeom/kernels/opencascade/sweep_along_curve.cpp

@@ -300,11 +300,7 @@ bool OpenCascadeKernel::convert(const taxonomy::sweep_along_curve::ptr scs, Topo
 
 	if (applied_temporary_offset) {
         gp_Trsf trsf;
-        // Restore original position: add back the mean subtracted from the
-        // directrix points above. Previously negated, which placed the swept
-        // solid at -mean instead of its original location for geometry far
-        // from the origin.
-        trsf.SetTranslation(gp_Vec(mean.x(), mean.y(), mean.z()));
+        trsf.SetTranslation(gp_Vec(-mean.x(), -mean.y(), -mean.z()));
         result.Move(trsf);
     }
 

src/ifcgeom/mapping/mapping.h

@@ -7,7 +7,6 @@
 #include "../../ifcparse/IfcLogger.h"
 
 #include <mutex>
-#include <cstdint>
 
 #define INCLUDE_SCHEMA(x) STRINGIFY(../../ifcparse/x.h)
 #include INCLUDE_SCHEMA(IfcSchema)

src/ifcgeom/taxonomy.h

@@ -17,13 +17,6 @@
 #include <tuple>
 #include <exception>
 #include <numeric>
-#include <cstdint>
-#include <cmath>
-#include <array>
-#include <limits>
-#include <functional>
-#include <algorithm>
-#include <stdexcept>
 
 #ifndef TAXONOMY_USE_UNIQUE_PTR
 #ifndef TAXONOMY_USE_NAKED_PTR
@@ -1632,19 +1625,19 @@ typedef item const* ptr;
 				// @todo Sad... now that we have templated collection members,
 				// we can't generally use collection_base anymore as a cast target.
 				if (auto s = std::dynamic_pointer_cast<taxonomy::collection>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::collection>(s, fn);
+					visit<taxonomy::collection>(s, fn);
 				} else if (auto s = std::dynamic_pointer_cast<taxonomy::loop>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::loop>(s, fn);
+					visit<taxonomy::loop>(s, fn);
 				} else if (auto s = std::dynamic_pointer_cast<taxonomy::face>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::face>(s, fn);
+					visit<taxonomy::face>(s, fn);
 				} else if (auto s = std::dynamic_pointer_cast<taxonomy::shell>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::shell>(s, fn);
+					visit<taxonomy::shell>(s, fn);
 				} else if (auto s = std::dynamic_pointer_cast<taxonomy::solid>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::solid>(s, fn);
+					visit<taxonomy::solid>(s, fn);
 				} else if (auto s = std::dynamic_pointer_cast<taxonomy::loft>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::loft>(s, fn);
+					visit<taxonomy::loft>(s, fn);
 				} else if (auto s = std::dynamic_pointer_cast<taxonomy::boolean_result>(i)) {
-					ifcopenshell::geometry::visit<taxonomy::boolean_result>(s, fn);
+					visit<taxonomy::boolean_result>(s, fn);
 				}
 				else {
 					fn(i);

src/ifcopenshell-python/ifcopenshell/api/geometry/validate_type.py

@@ -81,13 +81,6 @@ def validate_type(
         if not preferred_item and remaining_items:
             preferred_item = remaining_items[0]
 
-    # preferred_item must not appear in remaining_items — if it was selected from
-    # that list, leaving it in causes add_boolean to union it with itself, and the
-    # subsequent Items filter then removes ALL items (including preferred_item),
-    # leaving Items=[] which guess_type maps to "MappedRepresentation".
-    if preferred_item in remaining_items:
-        remaining_items = [i for i in remaining_items if i != preferred_item]
-
     if remaining_items:
         ifcopenshell.api.geometry.add_boolean(file, preferred_item, remaining_items, "UNION")
         representation.Items = [i for i in representation.Items if i not in remaining_items]

src/ifcparse/IfcBaseClass.h

@@ -27,7 +27,6 @@
 #include "utils.h"
 
 #include <atomic>
-#include <cstdint>
 #include <boost/shared_ptr.hpp>
 
 class aggregate_of_instance;

src/ifcparse/IfcCharacterDecoder.cpp

@@ -201,7 +201,7 @@ namespace {
                 if (character >= 0x20 && character <= 0x7e) {
                     stream.put((char)character);
                 } else {
-                    stream << "\\u" << static_cast<uint32_t>(character);
+                    stream << "\\u" << character;
                 }
             });
             return stream.str();

src/ifcparse/IfcEntityInstanceData.h

@@ -36,9 +36,6 @@
 
 #endif
 
-#include <cstdint>
-#include <cstring>
-
 #include <boost/optional.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/logic/tribool.hpp>

src/ifcparse/IfcFile.h

@@ -34,7 +34,6 @@
 #include <boost/circular_buffer.hpp>
 #include <iterator>
 #include <map>
-#include <cstdint>
 
 #ifdef IFOPSH_WITH_ROCKSDB
 #include <rocksdb/merge_operator.h>

src/ifcparse/IfcSchema.h

@@ -25,9 +25,7 @@
 #include <algorithm>
 #include <boost/algorithm/string.hpp>
 #include <cctype>
-#include <cstdint>
 #include <iterator>
-#include <memory>
 #include <string>
 #include <vector>
 

src/ifcparse/aggregate_of_instance.h

@@ -26,7 +26,6 @@
 #include <boost/shared_ptr.hpp>
 #include <set>
 #include <vector>
-#include <algorithm>
 
 namespace IfcParse {
     class declaration;

src/ifcparse/rocksdb_map_adapter.h

@@ -30,8 +30,6 @@
 #include <utility>
 #include <iterator>
 #include <cstddef>
-#include <cstdint>
-#include <cstring>
 
 template <typename T>
 struct is_std_tuple : std::false_type {};

src/ifcparse/storage.h

@@ -25,8 +25,6 @@ namespace rocksdb {
 
 #include <variant>
 #include <iterator>
-#include <cstdint>
-#include <cstring>
 #include <type_traits>
 #include <iostream>
 #include <vector>

src/ifcparse/variantarray.h

@@ -33,10 +33,6 @@ variant - which is the maximum size of its constituents - is reduced.
 #include <utility>
 #include <memory>
 #include <tuple>
-#include <cstdint>
-#include <cstring>
-#include <cstddef>
-#include <limits>
 
 #include "IfcException.h"
 

src/serializers/GltfSerializer.cpp

@@ -23,8 +23,6 @@
 
 #include "../ifcparse/utils.h"
 
-#include <cstdint>
-
 #ifdef WITH_PROJ
 #include <proj.h>
 #endif

src/serializers/HdfSerializer.cpp

@@ -34,7 +34,6 @@
 #include <numeric>
 #include <functional>
 #include <cmath>
-#include <cstdint>
 
 #ifdef USE_BINARY
 #define write_shape write_binary

src/serializers/RocksDbSerializer.cpp

@@ -4,9 +4,6 @@
 
 #include <rocksdb/options.h>
 
-#include <cstdint>
-#include <cstring>
-
 #include "../ifcparse/IfcLogger.h"
 
 RocksDbSerializer::RocksDbSerializer(IfcParse::IfcFile* file, const std::string& rocksdb_filename)