Decouple should_start_fresh_session from use_relative_path

so IFC files always open in a clean session

.github/workflows/ci-ifcwrap-standalone.yml

@@ -1,155 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-name: ci-ifcwrap-standalone
-
-on:
-  workflow_dispatch:
-  pull_request:
-    paths:
-      - ".github/workflows/ci-ifcwrap-standalone.yml"
-      - "cmake/**"
-      - "src/ifcwrap/**"
-      - "src/ifcparse/**"
-      - "src/ifcgeom/**"
-      - "src/serializers/**"
-      - "src/ifcconvert/**"
-      - "src/ifcopenshell-python/**"
-      - "src/svgfill/**"
-  push:
-    paths:
-      - ".github/workflows/ci-ifcwrap-standalone.yml"
-      - "cmake/**"
-      - "src/ifcwrap/**"
-      - "src/ifcparse/**"
-      - "src/ifcgeom/**"
-      - "src/serializers/**"
-      - "src/ifcconvert/**"
-      - "src/ifcopenshell-python/**"
-      - "src/svgfill/**"
-
-env:
-  IFCOPENSHELL_PREFIX: ${{ github.workspace }}/ifcopenshell-install
-
-jobs:
-  build-ifcopenshell:
-    runs-on: ubuntu-22.04
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Install C++ dependencies
-        run: |
-          sudo apt update
-          sudo apt-get install --no-install-recommends -y \
-            cmake \
-            gcc \
-            g++ \
-            libboost-date-time-dev \
-            libboost-filesystem-dev \
-            libboost-iostreams-dev \
-            libboost-program-options-dev \
-            libboost-regex-dev \
-            libboost-system-dev \
-            libboost-thread-dev \
-            libeigen3-dev \
-            libocct-data-exchange-dev \
-            libocct-draw-dev \
-            libocct-foundation-dev \
-            libocct-modeling-algorithms-dev \
-            libocct-modeling-data-dev \
-            libocct-ocaf-dev \
-            libocct-visualization-dev \
-            libpcre3-dev \
-            libtbb-dev \
-            libxml2-dev \
-            libxi-dev \
-            occt-misc \
-            tcl-dev \
-            tk-dev \
-            swig
-
-      - name: Configure minimal IfcOpenShell
-        run: |
-          cmake -S cmake -B build-ifcopenshell \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_INSTALL_PREFIX="${IFCOPENSHELL_PREFIX}" \
-            -DCMAKE_PREFIX_PATH=/usr \
-            -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
-            -DMINIMAL_BUILD=ON \
-            -DBUILD_IFCPYTHON=OFF \
-            "-DSCHEMA_VERSIONS=4x3_add2"
-
-      - name: Build and install minimal IfcOpenShell
-        run: |
-          cmake --build build-ifcopenshell --target install -j "$(nproc)"
-
-      - name: Set up Python 3.11
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.11
-
-      - name: Install Python import dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install numpy typing_extensions
-
-      - name: Configure standalone IfcPython
-        run: |
-          PYTHON_EXECUTABLE="$(python -c 'import sys; print(sys.executable)')"
-          PYTHON_INCLUDE_DIR="$(python -c 'import sysconfig; print(sysconfig.get_path("include"))')"
-
-          cmake -S src/ifcwrap -B "build-ifcwrap-311" \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_PREFIX_PATH="${IFCOPENSHELL_PREFIX};/usr" \
-            -DPython_EXECUTABLE:FILEPATH="${PYTHON_EXECUTABLE}" \
-            -DPython_INCLUDE_DIR:PATH="${PYTHON_INCLUDE_DIR}" \
-            -DPYTHON_EXECUTABLE:FILEPATH="${PYTHON_EXECUTABLE}" \
-            -DPYTHON_INCLUDE_DIR:PATH="${PYTHON_INCLUDE_DIR}"
-
-      - name: Build and install standalone IfcPython
-        run: |
-          cmake --build "build-ifcwrap-311" --target install -j "$(nproc)"
-
-      - name: Import installed IfcPython
-        run: |
-          PYTHONPATH="${RUNNER_TEMP}/ifcopenshell-python" python - <<'PY'
-          import ifcopenshell
-
-          print("IfcOpenShell import ok:", ifcopenshell.version)
-          PY
-
-      - name: Set up Python 3.12
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.12
-
-      - name: Install Python import dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install numpy typing_extensions
-
-      - name: Configure standalone IfcPython
-        run: |
-          PYTHON_EXECUTABLE="$(python -c 'import sys; print(sys.executable)')"
-          PYTHON_INCLUDE_DIR="$(python -c 'import sysconfig; print(sysconfig.get_path("include"))')"
-
-          cmake -S src/ifcwrap -B "build-ifcwrap-312" \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_PREFIX_PATH="${IFCOPENSHELL_PREFIX};/usr" \
-            -DPython_EXECUTABLE:FILEPATH="${PYTHON_EXECUTABLE}" \
-            -DPython_INCLUDE_DIR:PATH="${PYTHON_INCLUDE_DIR}" \
-            -DPYTHON_EXECUTABLE:FILEPATH="${PYTHON_EXECUTABLE}" \
-            -DPYTHON_INCLUDE_DIR:PATH="${PYTHON_INCLUDE_DIR}"
-
-      - name: Build and install standalone IfcPython
-        run: |
-          cmake --build "build-ifcwrap-312" --target install -j "$(nproc)"
-
-      - name: Import installed IfcPython
-        run: |
-          PYTHONPATH="${RUNNER_TEMP}/ifcopenshell-python" python - <<'PY'
-          import ifcopenshell
-
-          print("IfcOpenShell import ok:", ifcopenshell.version)
-          PY

.github/workflows/ci.yml

@@ -10,13 +10,9 @@ on:
       - 'src/ifcgeomserver/**'
       - 'src/ifcjni/**'
       - 'src/ifcmax/**'
-      - 'src/ifc5d/**'
-      - 'src/ifcedit/**'
-      - 'src/ifcmcp/**'
       - 'src/ifcopenshell-python/**'
       - '!src/ifcopenshell-python/docs/**'
       - 'src/ifcparse/**'
-      - 'src/ifcquery/**'
       - 'src/ifcwrap/**'
       - 'src/qtviewer/**'
       - 'src/svgfill/**'
@@ -55,7 +51,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing psutil
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing
           pip install src/bcf --no-deps
           pip install pytest-xdist==3.8.0
 
@@ -256,26 +252,13 @@ jobs:
           pip install deepdiff
           cd ../ifcdiff && make test || ERROR=1
           cd ../ifcpatch && make test || ERROR=1
-          pip install -e ../ifc5d --no-deps
-          pip install odfpy xlsxwriter
-          cd ../ifc5d && make test || ERROR=1
-          pip install -e ../ifcquery --no-deps
-          cd ../ifcquery && make test || ERROR=1
-          pip install -e ../ifcedit --no-deps
-          cd ../ifcedit && make test || ERROR=1
-          pip install mcp
-          pip install -e ../ifcmcp --no-deps
-          cd ../ifcmcp && make test || ERROR=1
           pip install -e ../ifctester --no-deps
           cd ../ifctester && make test || ERROR=1
           make build-ids-docs || ERROR=1
           # Run mathutils related tests at the end to ensure no other code is relying on mathutils.
-          # mathutils only has pre-built wheels for Python 3.13+; skip on older versions.
           cd ../ifcopenshell-python
-          if python -c "import sys; sys.exit(0 if sys.version_info >= (3, 13) else 1)"; then
-            pip install mathutils
-            make test-mathutils || ERROR=1
-          fi
+          pip install mathutils
+          make test-mathutils || ERROR=1
           if [ $ERROR -ne 0 ]; then
             echo "One or more tests failed";
             exit 1;

.gitignore

@@ -28,7 +28,6 @@ venv
 !.vscode/launch.json
 !.vscode/tasks.json
 .vs
-/*.code-workspace
 
 # PyCharm files
 .idea
@@ -129,4 +128,3 @@ src/ifcopenshell-python/ifcopenshell/express/*.exp.cache.dat
 *.claude
 *.py.tmp*
 *.json.tmp*
-

cmake/CMakeLists.txt

@@ -27,14 +27,13 @@ endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON) # not necessary, but encouraged
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-# The VERSION file in the repository root is the single source of truth for the
-# release version. Read it unconditionally so a plain source build reports the
-# real version through buildinfo.cpp instead of the stale hardcoded 0.8.0
-# fallback (see #8164). VERSION_OVERRIDE still controls the branch name used
-# when ADD_COMMIT_SHA embeds a commit sha.
-file(READ "../VERSION" "RELEASE_VERSION_")
-string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
-message(STATUS "Detected version '${RELEASE_VERSION}'")
+if(VERSION_OVERRIDE)
+    file(READ "../VERSION" "RELEASE_VERSION_")
+    string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
+    message(STATUS "Detected version '${RELEASE_VERSION}'")
+else()
+    set(RELEASE_VERSION "0.8.0")
+endif()
 
 add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
 
@@ -661,11 +660,6 @@ if(ADD_COMMIT_SHA)
     endif()
 endif(ADD_COMMIT_SHA)
 
-# Always expose the release version (from the VERSION file) to buildinfo.cpp so
-# that a build without commit-sha info reports the correct version instead of a
-# stale hardcoded fallback. See #8164.
-target_compile_definitions(IfcParse PRIVATE IFCOPENSHELL_VERSION_STRING=${RELEASE_VERSION})
-
 if(MSVC)
     # @todo still needs to be understood better, but the cgal and cgal-simple kernel cause multiply defined boost lambda placeholders _1 ... _3
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /FORCE:MULTIPLE")

cmake/FindIfcOpenShell.cmake

@@ -1,131 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-################################################################################
-#                                                                              #
-# This file is part of IfcOpenShell.                                           #
-#                                                                              #
-# IfcOpenShell is free software: you can redistribute it and/or modify         #
-# it under the terms of the Lesser GNU General Public License as published by  #
-# the Free Software Foundation, either version 3.0 of the License, or          #
-# (at your option) any later version.                                          #
-#                                                                              #
-# IfcOpenShell 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                 #
-# Lesser GNU General Public License for more details.                          #
-#                                                                              #
-# You should have received a copy of the Lesser GNU General Public License     #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.         #
-#                                                                              #
-################################################################################
-
-include("${CMAKE_CURRENT_LIST_DIR}/utilities.cmake" OPTIONAL)
-
-set(_IfcOpenShell_find_args)
-if(IfcOpenShell_FIND_VERSION)
-    list(APPEND _IfcOpenShell_find_args "${IfcOpenShell_FIND_VERSION}")
-    if(IfcOpenShell_FIND_VERSION_EXACT)
-        list(APPEND _IfcOpenShell_find_args EXACT)
-    endif()
-endif()
-list(APPEND _IfcOpenShell_find_args CONFIG QUIET)
-if(IfcOpenShell_FIND_COMPONENTS)
-    list(APPEND _IfcOpenShell_find_args COMPONENTS ${IfcOpenShell_FIND_COMPONENTS})
-endif()
-
-set(_IfcOpenShell_saved_module_path "${CMAKE_MODULE_PATH}")
-list(REMOVE_ITEM CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
-find_package(IfcOpenShell ${_IfcOpenShell_find_args})
-set(CMAKE_MODULE_PATH "${_IfcOpenShell_saved_module_path}")
-
-if(NOT IfcOpenShell_FOUND)
-    set(_IfcOpenShell_error "Could not find an IfcOpenShell CMake config package. Set IfcOpenShell_DIR or CMAKE_PREFIX_PATH.")
-    if(IfcOpenShell_FIND_REQUIRED)
-        message(FATAL_ERROR "${_IfcOpenShell_error}")
-    elseif(NOT IfcOpenShell_FIND_QUIETLY)
-        message(STATUS "${_IfcOpenShell_error}")
-    endif()
-    return()
-endif()
-
-set(_IfcOpenShell_required_targets IfcOpenShell::IfcParse IfcOpenShell::IfcGeom)
-set(_IfcOpenShell_missing_targets "")
-foreach(_IfcOpenShell_target IN LISTS _IfcOpenShell_required_targets)
-    if(NOT TARGET ${_IfcOpenShell_target})
-        list(APPEND _IfcOpenShell_missing_targets ${_IfcOpenShell_target})
-    endif()
-endforeach()
-
-if(_IfcOpenShell_missing_targets)
-    set(IfcOpenShell_FOUND FALSE)
-    string(REPLACE ";" ", " _IfcOpenShell_missing_targets_text "${_IfcOpenShell_missing_targets}")
-    set(_IfcOpenShell_error "IfcOpenShell config was found, but required targets are missing: ${_IfcOpenShell_missing_targets_text}.")
-    if(IfcOpenShell_FIND_REQUIRED)
-        message(FATAL_ERROR "${_IfcOpenShell_error}")
-    elseif(NOT IfcOpenShell_FIND_QUIETLY)
-        message(STATUS "${_IfcOpenShell_error}")
-    endif()
-    return()
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_WITH_OPENCASCADE)
-    set(IFCOPENSHELL_WITH_OPENCASCADE OFF)
-    if(TARGET IfcOpenShell::geometry_kernel_opencascade)
-        set(IFCOPENSHELL_WITH_OPENCASCADE ON)
-    endif()
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_WITH_CGAL)
-    set(IFCOPENSHELL_WITH_CGAL OFF)
-    if(TARGET IfcOpenShell::IFCOPENSHELL_CGAL)
-        set(IFCOPENSHELL_WITH_CGAL ON)
-    endif()
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_IFCXML)
-    set(IFCOPENSHELL_IFCXML OFF)
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_WITH_ROCKSDB)
-    set(IFCOPENSHELL_WITH_ROCKSDB OFF)
-endif()
-
-set(IFCOPENSHELL_LIBRARIES IfcOpenShell::IfcParse)
-foreach(_IfcOpenShell_target IN ITEMS IfcOpenShell::geometry_serializer IfcOpenShell::Serializers)
-    if(TARGET ${_IfcOpenShell_target})
-        list(APPEND IFCOPENSHELL_LIBRARIES ${_IfcOpenShell_target})
-    endif()
-endforeach()
-
-set(IFCOPENSHELL_KERNEL_LIBRARIES "")
-foreach(_IfcOpenShell_target IN ITEMS
-    IfcOpenShell::geometry_kernel_opencascade
-    IfcOpenShell::geometry_kernel_cgal
-    IfcOpenShell::geometry_kernel_cgal_simple
-)
-    if(TARGET ${_IfcOpenShell_target})
-        list(APPEND IFCOPENSHELL_KERNEL_LIBRARIES ${_IfcOpenShell_target})
-    endif()
-endforeach()
-
-set(IFCOPENSHELL_GEOMETRY_LIBRARIES IfcOpenShell::IfcGeom ${IFCOPENSHELL_KERNEL_LIBRARIES})
-
-if(TARGET IfcOpenShell::OpenCASCADE_INTERFACE)
-    set(OpenCASCADE_LIBRARIES IfcOpenShell::OpenCASCADE_INTERFACE)
-endif()
-
-if(TARGET IfcOpenShell::IFCOPENSHELL_CGAL)
-    set(CGAL_LIBRARIES IfcOpenShell::IFCOPENSHELL_CGAL)
-endif()
-
-if(TARGET IfcOpenShell::svgfill)
-    set(IFCOPENSHELL_SVGFILL_LIBRARY IfcOpenShell::svgfill)
-endif()
-
-mark_as_advanced(IfcOpenShell_DIR)
-
-unset(_IfcOpenShell_error)
-unset(_IfcOpenShell_find_args)
-unset(_IfcOpenShell_missing_targets)
-unset(_IfcOpenShell_missing_targets_text)
-unset(_IfcOpenShell_required_targets)
-unset(_IfcOpenShell_target)

cmake/IfcOpenShellConfig.cmake.in

@@ -7,26 +7,12 @@ set(IFCOPENSHELL_WITH_OPENCASCADE @WITH_OPENCASCADE@)
 set(IFCOPENSHELL_WITH_CGAL @WITH_CGAL@)
 set(IFCOPENSHELL_IFCXML @IFCXML_SUPPORT@)
 set(IFCOPENSHELL_WITH_ROCKSDB @WITH_ROCKSDB@)
-set(IFCOPENSHELL_COLLADA_SUPPORT @COLLADA_SUPPORT@)
-set(IFCOPENSHELL_GLTF_SUPPORT @GLTF_SUPPORT@)
-set(IFCOPENSHELL_HDF5_SUPPORT @HDF5_SUPPORT@)
-set(IFCOPENSHELL_WITH_PROJ @WITH_PROJ@)
-set(IFCOPENSHELL_USD_SUPPORT @USD_SUPPORT@)
 
 include(CMakeFindDependencyMacro)
 
-set(IFCOPENSHELL_BOOST_USE_STATIC_LIBS "@Boost_USE_STATIC_LIBS@")
-set(IFCOPENSHELL_BOOST_USE_STATIC_RUNTIME "@Boost_USE_STATIC_RUNTIME@")
-set(IFCOPENSHELL_BOOST_USE_MULTITHREADED "@Boost_USE_MULTITHREADED@")
-if(NOT "${IFCOPENSHELL_BOOST_USE_STATIC_LIBS}" STREQUAL "")
-    set(Boost_USE_STATIC_LIBS ${IFCOPENSHELL_BOOST_USE_STATIC_LIBS})
-endif()
-if(NOT "${IFCOPENSHELL_BOOST_USE_STATIC_RUNTIME}" STREQUAL "")
-    set(Boost_USE_STATIC_RUNTIME ${IFCOPENSHELL_BOOST_USE_STATIC_RUNTIME})
-endif()
-if(NOT "${IFCOPENSHELL_BOOST_USE_MULTITHREADED}" STREQUAL "")
-    set(Boost_USE_MULTITHREADED ${IFCOPENSHELL_BOOST_USE_MULTITHREADED})
-endif()
+set(Boost_USE_STATIC_LIBS ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+set(Boost_USE_MULTITHREADED ON)
 set(Boost_COMPONENTS
     system
     program_options
@@ -57,33 +43,13 @@ if(IFCOPENSHELL_WITH_ROCKSDB)
 endif()
 
 if(IFCOPENSHELL_IFCXML)
-    find_dependency(LibXml2)
+    find_dependency(LibXml2 CONFIG)
 endif()
 
 if(IFCOPENSHELL_WITH_CGAL)
     find_dependency(CGAL CONFIG)
 endif()
 
-if(IFCOPENSHELL_COLLADA_SUPPORT)
-    find_dependency(OpenCOLLADA)
-endif()
-
-if(IFCOPENSHELL_GLTF_SUPPORT)
-    find_dependency(nlohmann_json CONFIG)
-endif()
-
-if(IFCOPENSHELL_HDF5_SUPPORT)
-    find_dependency(HDF5 COMPONENTS C CXX)
-endif()
-
-if(IFCOPENSHELL_WITH_PROJ)
-    find_dependency(PROJ)
-endif()
-
-if(IFCOPENSHELL_USD_SUPPORT)
-    find_dependency(USD)
-endif()
-
 if(IFCOPENSHELL_WITH_OPENCASCADE)
     find_dependency(OpenCASCADE CONFIG)
     if(OpenCASCADE_VERSION VERSION_LESS "7.7.0")

src/bonsai/Makefile

@@ -106,7 +106,7 @@ endif
 endif # def PLATFORM
 
 # Current build commit hash.
-OLD:=3e7b739
+OLD:=1c5b825
 .PHONY: bump
 bump:
 ifndef NEW

src/bonsai/bonsai/bim/__init__.py

@@ -90,7 +90,6 @@ modules = {
     "web": None,
     "light": None,
     "alignment": None,
-    "clip_box": None,
     # Uncomment this line to enable loading of the demo module. Happy hacking!
     # The name "demo" must correlate to a folder name in `bim/module/`.
     # "demo": None,
@@ -272,6 +271,7 @@ def register():
     parametric_lifecycle.install_parametric_lifecycle_handlers()
     bpy.app.handlers.load_post.append(handler.load_post)
     bpy.app.handlers.load_post.append(handler.loadIfcStore)
+    bpy.app.handlers.save_post.append(handler.save_post)
     bpy.types.Scene.BIMProperties = bpy.props.PointerProperty(type=prop.BIMProperties)
     bpy.types.Scene.BIMSnapProperties = bpy.props.PointerProperty(type=prop.BIMSnapProperties)
     bpy.types.Scene.BIMSnapGroups = bpy.props.PointerProperty(type=prop.BIMSnapGroups)
@@ -330,6 +330,7 @@ def unregister():
     parametric_lifecycle.uninstall_parametric_lifecycle_handlers()
     bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.app.handlers.load_post.remove(handler.loadIfcStore)
+    bpy.app.handlers.save_post.remove(handler.save_post)
     del bpy.types.Scene.BIMProperties
     del bpy.types.Collection.BIMCollectionProperties
     del bpy.types.Object.BIMObjectProperties

src/bonsai/bonsai/bim/data/pset/EPset_Drawing.ifc

@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',$,$,'EPset_Drawing','EPset_D
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#23,#22,#27,#24,#29,#30,#19,#12,#26,#9,#8,#7,#6,#4,#18,#11,#5,#20,#25,#14,#10,#17,#28,#16,#3,#21,#13,#15,#2));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#23,#22,#27,#24,#19,#12,#26,#9,#8,#7,#6,#4,#18,#11,#5,#20,#25,#14,#10,#17,#28,#16,#3,#21,#13,#15,#2));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','The scale of this drawing represented as a numerator and denominator, such as 1/100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','The scale of this drawing in human readable format, such as 1:100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -33,7 +33,5 @@ DATA;
 #26=IFCSIMPLEPROPERTYTEMPLATE('2iwERDOW55Pf4hCbuFRe1Q',$,'FillMode','Method to fill areas seen in projection',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #27=IFCSIMPLEPROPERTYTEMPLATE('1YF$qLzBzF19Io8aB2N8cE',$,'CutMode','Method for cutting geometry',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #28=IFCSIMPLEPROPERTYTEMPLATE('1YSnFzurrEyRNtoLdmmddP',$,'BringToFront','The objects with these SVG classes will render in front of all other objects.Ex: IfcBeam, IfcColumn',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
-#29=IFCSIMPLEPROPERTYTEMPLATE('0lP6Y8q9v2QhDnR4sT7uVx',$,'PerspectiveShiftX','Horizontal perspective camera shift stored as drawing metadata using Blender camera shift units.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
-#30=IFCSIMPLEPROPERTYTEMPLATE('2mR8b1NcW5EoFyG7hJ9kLp',$,'PerspectiveShiftY','Vertical perspective camera shift stored as drawing metadata using Blender camera shift units.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;

src/bonsai/bonsai/bim/handler.py

@@ -47,15 +47,10 @@ from bonsai.bim.module.model.array import (
 )
 from bonsai.bim.module.model.data import AuthoringData
 from bonsai.bim.module.model.decorator import (
-    BendPreviewDecorator,
     BoundingBoxDecorator,
-    DoorSwingReadonlyDecorator,
-    MEPSegmentExtendPreviewDecorator,
-    MEPSystemPathDecorator,
     SlabDirectionDecorator,
     WallAxisDecorator,
     WallFilletPreviewDecorator,
-    WallSystemPathDecorator,
 )
 from bonsai.bim.module.model.wall import WallGizmoPreviewDecorator
 from bonsai.bim.module.nest.decorator import NestDecorator
@@ -437,6 +432,29 @@ def subscribe_to_viewport_shading_changes():
             )
 
 
+@persistent
+def save_post(scene) -> None:
+    """After saving the .blend file, convert the stored IFC path to relative if enabled."""
+    pprops = tool.Project.get_project_props()
+    if not pprops.use_relative_project_path:
+        return
+    bim_props = tool.Blender.get_bim_props()
+    ifc_path = bim_props.ifc_file
+    if not ifc_path or not os.path.isabs(ifc_path):
+        return
+    blend_dir = bpy.path.abspath("//")
+    if not blend_dir:
+        return
+    from pathlib import Path
+    from bonsai.bim.ifc import IfcStore
+    try:
+        rel_path = str(Path(ifc_path).relative_to(blend_dir))
+    except ValueError:
+        return  # IFC file is not under the blend directory; keep absolute path
+    bim_props.ifc_file = rel_path
+    IfcStore.set_path(ifc_path)  # keep IfcStore.path absolute for loading
+
+
 def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
     """Invariants enforced on every load_post: msgbus subscription, IFC owner
     settings, scene-bound caches, load-transient parametric state, and the
@@ -515,13 +533,8 @@ def _install_viewport_overlays() -> None:
     NestDecorator.uninstall()
     WallAxisDecorator.uninstall()
     SlabDirectionDecorator.uninstall()
-    MEPSystemPathDecorator.uninstall()
-    WallSystemPathDecorator.uninstall()
     WallFilletPreviewDecorator.uninstall()
-    BendPreviewDecorator.uninstall()
-    MEPSegmentExtendPreviewDecorator.uninstall()
     WallGizmoPreviewDecorator.uninstall()
-    DoorSwingReadonlyDecorator.uninstall()
     ArrayPreviewDecorator.uninstall()
     ArraySelectionHighlightDecorator.uninstall()
     uninstall_decorator_cache_handlers()
@@ -536,28 +549,16 @@ def _install_viewport_overlays() -> None:
             WallAxisDecorator.install(bpy.context)
         if model_props.show_slab_direction:
             SlabDirectionDecorator.install(bpy.context)
-        if model_props.show_paths:
-            MEPSystemPathDecorator.install(bpy.context)
-            WallSystemPathDecorator.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)
-        # Always-installed siblings of WallFilletPreviewDecorator: each
-        # self-polls on its own scene.BIMPreviewProperties subgroup or on
-        # selection + hover gizmo state — zero cost when nothing is active.
-        BendPreviewDecorator.install(bpy.context)
-        MEPSegmentExtendPreviewDecorator.install(bpy.context)
         # Always-installed: draw_lines() self-polls on selection + hover state
         # for join / extend-to-wall / cursor-extend / cursor-split previews.
         # Free when no preview-eligible state is active.
         WallGizmoPreviewDecorator.install(bpy.context)
-        # Always-installed: draw() self-polls on active object + IfcDoor +
-        # parametric pset, so the cost is one bpy/IFC lookup per redraw when
-        # nothing eligible is selected.
-        DoorSwingReadonlyDecorator.install(bpy.context)
         # Always-installed: draw() self-polls on the active object's array
         # family membership, so installation has no cost when no array
         # element is selected.

src/bonsai/bonsai/bim/ifc.py

@@ -566,19 +566,6 @@ class IfcStore:
                 result = getattr(operator, "_modal")(context, event)
         except:
             bonsai.last_error = traceback.format_exc()
-            # An operator that mutated IFC then raised leaves the IFC graph captured
-            # by the transaction but the Blender side stale. Blender does not push an
-            # undo step for a raised operator (mirror of the CANCELLED-modal gap
-            # handled below), so we push one here so Ctrl+Z actually rewinds the
-            # partial mutation, then surface the recovery path to the user.
-            ifc_file = tool.Ifc.get()
-            if ifc_file and ifc_file.transaction and ifc_file.transaction.operations:
-                bpy.ops.ed.undo_push(message=f"Recover {operator.bl_idname}")
-                operator.report(
-                    {"WARNING"},
-                    "Operation partially completed (IFC changed, Blender state may be stale). "
-                    "Press Ctrl+Z to restore the previous state.",
-                )
             # Try to ensure undo will work since Blender undo does work in case of errors.
             # As error come unexpectedly, it's important that user might have a chance to save the file
             # before they got the error and not to lose the work they've done.

src/bonsai/bonsai/bim/import_ifc.py

@@ -223,7 +223,6 @@ class IfcImporter:
         self.elements: set[ifcopenshell.entity_instance] = set()
         self.annotations: set[ifcopenshell.entity_instance] = set()
         self.gross_elements: set[ifcopenshell.entity_instance] = set()
-        self.broken_arrays: set[ifcopenshell.entity_instance] = set()
         self.element_types: set[ifcopenshell.entity_instance] = set()
         self.spatial_elements: set[ifcopenshell.entity_instance] = set()
         self.meshes: dict[str, OBJECT_DATA_TYPE] = {}
@@ -1221,17 +1220,7 @@ class IfcImporter:
                             continue
                     for i in range(len(data)):
                         tool.Array.set_children_lock_state(element, i, True)
-                    tool.Array.constrain_children_to_parent(element)
-                    for layer in data:
-                        for child_guid in layer.get("children", ()):
-                            try:
-                                self.file.by_guid(child_guid)
-                            except RuntimeError:
-                                print(
-                                    f"setup_arrays: array parent {element.GlobalId} references missing "
-                                    f"child GUID {child_guid!r}."
-                                )
-                                self.broken_arrays.add(element)
+                        tool.Array.constrain_children_to_parent(element)
 
     def update_linked_aggregates(self):
         # TODO Remove this after a while. See commit 17d6b8a

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

@@ -20,6 +20,7 @@ import blf
 import bpy
 import gpu
 import ifcopenshell.util.element
+from bpy.types import SpaceView3D
 from bpy_extras import view3d_utils
 from gpu_extras.batch import batch_for_shader
 from mathutils import Vector
@@ -27,6 +28,12 @@ from mathutils import Vector
 import bonsai.tool as tool
 
 
+def transparent_color(color, alpha=0.1):
+    color = [i for i in color]
+    color[3] = alpha
+    return color
+
+
 def create_bounding_box(objs):
     # Initialize the bounding box coordinates
     min_x, min_y, min_z = float("inf"), float("inf"), float("inf")
@@ -72,8 +79,26 @@ def create_bounding_box(objs):
     return indices, edges
 
 
-class AggregateDecorator(tool.Blender.ViewportDecorator):
-    draw_method = "draw_aggregate"
+class AggregateDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_aggregate, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
 
     def dotted_line_shader(self):
         vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
@@ -128,6 +153,14 @@ class AggregateDecorator(tool.Blender.ViewportDecorator):
         shader.uniform_float("u_Scale", 25)
         batch.draw(shader)
 
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
     def draw_aggregate(self, context):
         props = tool.Aggregate.get_aggregate_props()
         self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -158,13 +191,12 @@ class AggregateDecorator(tool.Blender.ViewportDecorator):
                 aggregates.append(obj)
                 continue
 
-            aggregate = None
             aggregates_list = tool.Aggregate.get_aggregates_recursively(element)
             if props.in_aggregate_mode and props.editing_aggregate:
                 index = aggregates_list.index(tool.Ifc.get_entity(props.editing_aggregate))
                 if index > 0:
                     aggregate = aggregates_list[index - 1]
-            elif aggregates_list:
+            else:
                 aggregate = aggregates_list[-1]
             if aggregate:
                 aggregates.append(tool.Ifc.get_object(aggregate))
@@ -193,11 +225,39 @@ class AggregateDecorator(tool.Blender.ViewportDecorator):
             self.draw_custom_batch(line, decorator_color_unselected)
 
 
-class AggregateModeDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_aggregate_name", "POST_PIXEL"),
-        ("draw_aggregate_empty", "POST_VIEW"),
-    )
+class AggregateModeDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(
+            SpaceView3D.draw_handler_add(handler.draw_aggregate_name, (context,), "WINDOW", "POST_PIXEL")
+        )
+        cls.handlers.append(
+            SpaceView3D.draw_handler_add(handler.draw_aggregate_empty, (context,), "WINDOW", "POST_VIEW")
+        )
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
 
     def draw_aggregate_name(self, context):
         if context.mode == "EDIT_MESH":

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

@@ -56,6 +56,11 @@ class BoundaryDecorator:
         unselected_elements_color = self.addon_prefs.decorator_color_unselected
         special_elements_color = self.addon_prefs.decorator_color_special
 
+        def transparent_color(color, alpha=0.1):
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
         gpu.state.point_size_set(6)
         gpu.state.blend_set("ALPHA")
 
@@ -104,11 +109,7 @@ class BoundaryDecorator:
 
         if unselected_edges:
             self.draw_batch("LINES", unselected_vertices, special_elements_color, unselected_edges)
-            self.draw_batch(
-                "TRIS", unselected_vertices, tool.Blender.transparent_color(special_elements_color), unselected_tris
-            )
+            self.draw_batch("TRIS", unselected_vertices, transparent_color(special_elements_color), unselected_tris)
         if selected_edges:
             self.draw_batch("LINES", selected_vertices, selected_elements_color, selected_edges)
-            self.draw_batch(
-                "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), selected_tris
-            )
+            self.draw_batch("TRIS", selected_vertices, transparent_color(selected_elements_color), selected_tris)

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

@@ -345,17 +345,9 @@ class CadArcFrom3Points(bpy.types.Operator):
 class CadOffset(bpy.types.Operator):
     bl_idname = "bim.cad_offset"
     bl_label = "CAD Offset"
-    bl_description = (
-        "Offset selected mesh geometry at provided distance, based on the current viewport angle. "
-        "Creates a copy by default, or moves the existing edges if Copy is disabled."
-    )
+    bl_description = "Copy selected mesh geometry at provided offset. Mesh copied based on the current viewport angle."
     bl_options = {"REGISTER", "UNDO"}
     distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
-    copy: bpy.props.BoolProperty(
-        name="Copy",
-        description="Create a new offset copy of the geometry. If disabled, move the existing edges to the offset location",
-        default=True,
-    )
 
     @classmethod
     def poll(cls, context):
@@ -413,11 +405,6 @@ class CadOffset(bpy.types.Operator):
         rotation = Matrix.Rotation(pi / 2, 2, "Z")
         rotation_i = Matrix.Rotation(-pi / 2, 2, "Z")
 
-        # When not copying, the offset positions are gathered here and applied to
-        # the existing verts only after all loops are processed, so that the
-        # original coordinates are still available while computing offsets.
-        moved_verts = []
-
         # Create loops from edges
         loop_edges = set(edges)
         loops = []
@@ -530,15 +517,12 @@ class CadOffset(bpy.types.Operator):
                     offset_length = self.distance / sqrt((1 + normals[0].dot(normals[1])) / 2)
                     offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ (new_normal * offset_length).to_3d())
                     new_vert = v1.co + offset
+                    new_verts.append(bm.verts.new(new_vert))
                 else:
                     normal = (normals[0] * self.distance).to_3d()
                     offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ normal)
                     new_vert = v1.co + offset
-
-                if self.copy:
                     new_verts.append(bm.verts.new(new_vert))
-                else:
-                    moved_verts.append((v1, new_vert))
 
                 processed_verts.add(v1.index)
 
@@ -547,14 +531,9 @@ class CadOffset(bpy.types.Operator):
 
                 v1 = v2
 
-            if self.copy:
-                [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
-                if is_closed:
-                    bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))
-
-        # Move the existing edges to the offset location.
-        for vert, new_co in moved_verts:
-            vert.co = new_co
+            [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
+            if is_closed:
+                bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))
 
         bm.verts.index_update()
         bm.edges.index_update()

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

@@ -27,11 +27,6 @@ class BIMCadProperties(PropertyGroup):
     resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
     radius: bpy.props.FloatProperty(name="Radius", default=0.1, subtype="DISTANCE")
     distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
-    copy: bpy.props.BoolProperty(
-        name="Copy",
-        description="Create a new offset copy of the geometry. If disabled, move the existing edges to the offset location",
-        default=True,
-    )
     x: bpy.props.FloatProperty(name="X", default=0.2, subtype="DISTANCE")
     y: bpy.props.FloatProperty(name="Y", default=0.1, subtype="DISTANCE")
     gable_roof_edge_angle: bpy.props.FloatProperty(
@@ -42,7 +37,6 @@ class BIMCadProperties(PropertyGroup):
         resolution: int
         radius: float
         distance: float
-        copy: bool
         x: float
         y: float
         gable_roof_edge_angle: float

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

@@ -256,8 +256,6 @@ class CadHotkey(bpy.types.Operator):
         elif self.hotkey == "S_O":
             row = self.layout.row()
             row.prop(props, "distance")
-            row = self.layout.row()
-            row.prop(props, "copy")
 
         elif self.hotkey == "S_R":
             if tool.Geometry.is_profile_object_active():
@@ -293,7 +291,7 @@ class CadHotkey(bpy.types.Operator):
             bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius)
 
     def hotkey_S_O(self):
-        bpy.ops.bim.cad_offset(distance=self.props.distance, copy=self.props.copy)
+        bpy.ops.bim.cad_offset(distance=self.props.distance)
 
     def hotkey_S_Q(self):
         obj = bpy.context.active_object

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

@@ -18,17 +18,43 @@
 
 import blf
 import gpu
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Vector
 
 import bonsai.tool as tool
 
 
-class ClashDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw_geometry", "POST_VIEW"),
-    )
+class ClashDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
 
     def draw_text(self, context):
         self.addon_prefs = tool.Blender.get_addon_preferences()

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

@@ -1,130 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-import bpy
-from bpy.app.handlers import persistent
-
-import bonsai.tool as tool
-
-from . import face_quad, gizmos, operator, prop, ui
-
-classes = (
-    operator.BIM_OT_add_clip_box,
-    operator.BIM_OT_add_clip_box_for_source,
-    operator.BIM_OT_align_view_to_clip_face,
-    operator.BIM_OT_duplicate_clip_box,
-    operator.BIM_OT_remove_clip_box,
-    operator.BIM_OT_set_active_clip_box,
-    operator.BIM_OT_toggle_clip_box_enabled,
-    prop.BIMClipBoxProperties,
-    prop.BIMSceneClipBoxProperties,
-    face_quad.BIM_GT_box_face_quad,
-    face_quad.BIM_GT_box_face_outline,
-    gizmos.OBJECT_GGT_bim_clip_box,
-    ui.BIM_MT_clip_box_add_for_source,
-    ui.BIM_MT_clip_box_info,
-    ui.BIM_MT_clip_box_settings,
-    ui.BIM_UL_clip_box,
-    ui.BIM_PT_clip_box,
-)
-
-
-@persistent
-def _on_depsgraph_update(scene, depsgraph):
-    tool.ClipBox.on_depsgraph_update(scene, depsgraph)
-    tool.ClipBox.on_depsgraph_update_caps(scene, depsgraph)
-
-
-@persistent
-def _on_load_pre(filepath):
-    # Tear down any in-flight clip-box timers before Blender frees the
-    # WM / screens / areas / regions for the loading file. A refresh timer
-    # that survives the teardown fires against the new file's freshly-
-    # allocated regions before their GPU state is wired, CTD-ing inside
-    # GPU_matrix_ortho_set. The gate also blocks the depsgraph IFC-reload
-    # branch and is held closed until on_pre_view fires for the first time
-    # on the new file (first paint = GPU contexts wired).
-    tool.ClipBox._file_loading = True
-    tool.ClipBox._post_load_paint_pending = True
-    tool.ClipBox._cancel_pending_refresh()
-    tool.ClipBox._cancel_pending_cap_rebuild()
-
-
-@persistent
-def _on_load_post(filepath):
-    # The _file_loading gate is NOT cleared here: load_post fires before
-    # the new file's first paint, so GPU contexts may still be uninitialised.
-    # on_pre_view consumes _post_load_paint_pending to open the gate at the
-    # safe moment and kick the post-load re-arm.
-    # Restore the per-scene clip-box list from the project's BBIM_ClipBoxes
-    # pset. Runs after the standard load_post that creates Blender objects.
-    tool.ClipBox._last_seen_object_matrices.clear()
-    tool.ClipBox.load_from_project_pset()
-
-
-_draw_handler_pre = None
-_draw_handler_post = None
-
-
-def register():
-    global _draw_handler_pre, _draw_handler_post
-    bpy.types.Object.BIMClipBoxProperties = bpy.props.PointerProperty(type=prop.BIMClipBoxProperties)
-    bpy.types.Scene.BIMSceneClipBoxProperties = bpy.props.PointerProperty(type=prop.BIMSceneClipBoxProperties)
-    tool.ClipBox.reset_ownership()
-    if _on_depsgraph_update not in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.append(_on_depsgraph_update)
-    if _on_load_pre not in bpy.app.handlers.load_pre:
-        bpy.app.handlers.load_pre.append(_on_load_pre)
-    if _on_load_post not in bpy.app.handlers.load_post:
-        bpy.app.handlers.load_post.append(_on_load_post)
-    if _draw_handler_pre is None:
-        _draw_handler_pre = bpy.types.SpaceView3D.draw_handler_add(tool.ClipBox.on_pre_view, (), "WINDOW", "PRE_VIEW")
-    if _draw_handler_post is None:
-        _draw_handler_post = bpy.types.SpaceView3D.draw_handler_add(
-            tool.ClipBox.on_post_view_caps, (), "WINDOW", "POST_VIEW"
-        )
-
-
-def unregister():
-    global _draw_handler_pre, _draw_handler_post
-    if _draw_handler_post is not None:
-        try:
-            bpy.types.SpaceView3D.draw_handler_remove(_draw_handler_post, "WINDOW")
-        except ValueError:
-            pass
-        _draw_handler_post = None
-    if _draw_handler_pre is not None:
-        try:
-            bpy.types.SpaceView3D.draw_handler_remove(_draw_handler_pre, "WINDOW")
-        except ValueError:
-            pass
-        _draw_handler_pre = None
-    if _on_load_post in bpy.app.handlers.load_post:
-        bpy.app.handlers.load_post.remove(_on_load_post)
-    if _on_load_pre in bpy.app.handlers.load_pre:
-        bpy.app.handlers.load_pre.remove(_on_load_pre)
-    if _on_depsgraph_update in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.remove(_on_depsgraph_update)
-    tool.ClipBox._cancel_pending_refresh()
-    tool.ClipBox._cancel_pending_cap_rebuild()
-    tool.ClipBox._last_seen_object_matrices.clear()
-    tool.ClipBox.clear_clip_planes()
-    del bpy.types.Object.BIMClipBoxProperties
-    del bpy.types.Scene.BIMSceneClipBoxProperties

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

@@ -1,212 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""EnumProperty ``items=`` callbacks for the source-based clip-box picker.
-
-Each callback returns ``[(id_str, label, description)]`` where ``id_str`` is
-an IFC entity id stringified for entity-driven kinds, an IFC class name for
-``CLASS``, or a fixed status name for ``STATUS``. The clip-box operator
-turns the picked id into a ``matrix_world`` via the source-preset helper.
-"""
-
-from __future__ import annotations
-
-import bonsai.tool as tool
-
-EnumItems = list[tuple[str, str, str]]
-
-# Module-level cache. Blender's EnumProperty stores raw char pointers from the
-# tuples a callback returns, so the Python strings must outlive the draw call.
-# Stashing the latest result per kind keeps them alive across callback firings.
-_items_cache: dict[str, EnumItems] = {}
-
-# Sentinel id used for the "no options available" placeholder. The operator
-# treats this as an invalid pick and surfaces an ERROR.
-NO_OPTIONS_ID = "__none__"
-
-
-def _cache(kind: str, items: EnumItems) -> EnumItems:
-    _items_cache[kind] = items
-    return items
-
-
-def _no_options(label: str) -> EnumItems:
-    # Blender refuses to draw an EnumProperty with zero entries — show a
-    # placeholder so the dialog renders and the user sees the empty state.
-    return [(NO_OPTIONS_ID, label, "")]
-
-
-def _label(entity, ifc_class: str | None = None) -> str:
-    name = (getattr(entity, "Name", None) or "Unnamed").strip() or "Unnamed"
-    return f"{ifc_class}: {name}" if ifc_class else name
-
-
-def _build_items(kind: str, empty_label: str, build_fn) -> EnumItems:
-    """Shared shape for the IFC-driven enum callbacks.
-
-    Returns the no-IFC placeholder if no file is loaded, then runs
-    ``build_fn(ifc_file)``, sorts the result alphabetically by label, and
-    returns the empty-result placeholder if nothing matched. The output is
-    always routed through the module cache.
-    """
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return _cache(kind, _no_options("No IFC loaded"))
-    items = build_fn(ifc)
-    items.sort(key=lambda t: t[1].lower())
-    if not items:
-        return _cache(kind, _no_options(empty_label))
-    return _cache(kind, items)
-
-
-# Top-down spatial hierarchy so the picker reads in the order an architect
-# already thinks in, rather than a flat alphabetical mix. IfcSpace is excluded
-# — spaces are typically empty volumes used for room metadata, so clipping to
-# one rarely matches the user intent of "show me what's in this container".
-SPATIAL_CLASSES: tuple[str, ...] = (
-    "IfcProject",
-    "IfcSite",
-    "IfcBuilding",
-    "IfcBuildingStorey",
-)
-
-
-def spatial_items(self, context) -> EnumItems:
-    # Special-case: per-class sort within the hierarchy order rather than a
-    # flat alphabetical sort, so the dropdown reads project → site → building.
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return _cache("SPATIAL", _no_options("No IFC loaded"))
-    items: EnumItems = []
-    for ifc_class in SPATIAL_CLASSES:
-        try:
-            entities = ifc.by_type(ifc_class, include_subtypes=False)
-        except RuntimeError:
-            continue
-        for entity in sorted(entities, key=lambda e: (e.Name or "").lower()):
-            items.append((str(entity.id()), _label(entity, ifc_class), ""))
-    if not items:
-        return _cache("SPATIAL", _no_options("No spatial containers"))
-    return _cache("SPATIAL", items)
-
-
-def class_items(self, context) -> EnumItems:
-    # Special-case: the picker value IS the IFC class name, not an entity id,
-    # so the build shape differs from the other entity-driven callbacks.
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return _cache("CLASS", _no_options("No IFC loaded"))
-    # List only IFC classes ACTUALLY present in the file (not the whole
-    # schema), so the user picks from classes that can produce a non-empty
-    # clip volume. ``e.is_a()`` returns the most specific class per element.
-    present = sorted({e.is_a() for e in ifc.by_type("IfcProduct")})
-    if not present:
-        return _cache("CLASS", _no_options("No products"))
-    return _cache("CLASS", [(cls, cls, "") for cls in present])
-
-
-def type_items(self, context) -> EnumItems:
-    return _build_items(
-        "TYPE",
-        "No types defined",
-        lambda ifc: [(str(e.id()), _label(e, e.is_a()), "") for e in ifc.by_type("IfcTypeProduct")],
-    )
-
-
-def material_items(self, context) -> EnumItems:
-    return _build_items(
-        "MATERIAL",
-        "No materials defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcMaterial")],
-    )
-
-
-def profile_items(self, context) -> EnumItems:
-    # ProfileName is optional. Skip unnamed profiles — they can't be
-    # meaningfully picked from a flat list.
-    return _build_items(
-        "PROFILE",
-        "No named profiles",
-        lambda ifc: [
-            (str(e.id()), f"{e.is_a()}: {e.ProfileName}", "")
-            for e in ifc.by_type("IfcProfileDef")
-            if getattr(e, "ProfileName", None)
-        ],
-    )
-
-
-def drawing_items(self, context) -> EnumItems:
-    return _build_items(
-        "DRAWING",
-        "No drawings defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcAnnotation") if e.ObjectType == "DRAWING"],
-    )
-
-
-# Display labels for each status value. The id strings on the left are the
-# canonical Pset_*Common.Status enum values accepted by Bonsai's status query.
-STATUS_LABELS: tuple[tuple[str, str], ...] = (
-    ("No Status", "No Status"),
-    ("NEW", "New"),
-    ("EXISTING", "Existing"),
-    ("DEMOLISH", "Demolish"),
-    ("TEMPORARY", "Temporary"),
-    ("OTHER", "Other"),
-    ("NOTKNOWN", "Not Known"),
-    ("UNSET", "Unset"),
-)
-
-
-def status_items(self, context) -> EnumItems:
-    # Fixed enum; no IFC needed. Still routed through the cache to share the
-    # same string-lifetime guarantee as the other callbacks.
-    return _cache("STATUS", [(value, label, "") for value, label in STATUS_LABELS])
-
-
-def system_items(self, context) -> EnumItems:
-    # IfcStructuralAnalysisModel is a structural-grouping container, not a
-    # distribution system — excluded to match Bonsai's other system pickers.
-    return _build_items(
-        "SYSTEM",
-        "No systems defined",
-        lambda ifc: [
-            (str(e.id()), _label(e, e.is_a()), "")
-            for e in ifc.by_type("IfcSystem")
-            if not e.is_a("IfcStructuralAnalysisModel")
-        ],
-    )
-
-
-def group_items(self, context) -> EnumItems:
-    # include_subtypes=False so IfcSystem and IfcZone instances don't appear
-    # under Group as well — those get their own picker entries.
-    return _build_items(
-        "GROUP",
-        "No groups defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcGroup", include_subtypes=False)],
-    )
-
-
-def zone_items(self, context) -> EnumItems:
-    return _build_items(
-        "ZONE",
-        "No zones defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcZone")],
-    )

src/bonsai/bonsai/bim/module/clip_box/face_quad.py

@@ -1,879 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Generic face-quad resize gizmos for any axis-aligned local box.
-
-This module contains the box-agnostic core of the interactive
-face-resize gizmos: two Gizmo classes (a near-invisible click target
-welded to each face, and a thin colored edge outline), a per-redraw
-orchestrator that places six of each on a box, and the pure one-sided
-resize arithmetic. None of it knows about IFC, clip boxes, or
-``BIMSceneClipBoxProperties`` — a future camera-view-box adapter can
-reuse the same classes and helpers.
-
-Consumer contract — the adapter group must:
-
-1. Create six ``BIM_GT_box_face_quad`` and six ``BIM_GT_box_face_outline``
-   instances at ``setup()`` time, in :data:`FACE_ROUTES` order, and bind
-   each quad's ``move_get_cb`` / ``move_set_cb`` to closures that read
-   and mutate the box's host (e.g. an Empty's ``location`` / ``scale``).
-2. Call :func:`apply_face_quad_layout` from ``refresh()`` /
-   ``draw_prepare()`` with the box's local-frame ``bmin`` / ``bmax``,
-   the host's ``matrix_world``, the OBB rotation as a 4x4
-   (``Matrix.Identity(4)`` when the rotation rides in ``matrix_world``),
-   and the current ``region`` / ``rv3d``.
-3. Implement ``_lock_for(active_gz)`` / ``_unlock_all()`` on the group
-   for drag mutual exclusion; the quad's ``invoke`` / ``exit`` call them.
-
-The resize arithmetic in :func:`compute_face_resize` is pure: feed it
-the modal scalar plus drag-start snapshots and it returns the host's
-new scale-on-axis and new origin location.
-"""
-
-from __future__ import annotations
-
-import math
-from collections.abc import Sequence
-from typing import Any
-
-import bpy
-from bpy_extras.view3d_utils import location_3d_to_region_2d, region_2d_to_location_3d
-from mathutils import Matrix, Vector
-
-# ---------------------------------------------------------------------------
-# Public iteration order
-# ---------------------------------------------------------------------------
-
-# (axis, is_max) pairs. The adapter group's ``setup()`` MUST create its
-# six face-quad gizmos in this order so positional indexing into the
-# layout helper stays correct.
-FACE_ROUTES: tuple[tuple[int, bool], ...] = (
-    (0, False),
-    (0, True),
-    (1, False),
-    (1, True),
-    (2, False),
-    (2, True),
-)
-
-
-# ---------------------------------------------------------------------------
-# Public visual constants (adapter reads these in setup())
-# ---------------------------------------------------------------------------
-
-# Standard XYZ axis colors (Blender convention).
-AXIS_COLOR: dict[int, tuple[float, float, float]] = {
-    0: (1.0, 0.2, 0.2),
-    1: (0.2, 1.0, 0.2),
-    2: (0.2, 0.4, 1.0),
-}
-
-# Documented "selectable but unpainted" trick: the GPU still writes the
-# selection buffer at this alpha so clicks register, but no visible
-# pixels are produced.
-FACE_QUAD_ALPHA: float = 0.001
-
-# Very faint hover tint — just enough to confirm "you're aiming at this
-# face" without painting visibly over geometry behind it.
-FACE_QUAD_ALPHA_HIGHLIGHT: float = 0.04
-
-# Setup-time default for ``select_bias``; the layout helper overwrites
-# it per frame to the front-facing or halo value below. Kept below the
-# canonical arrow bias so a bailed frame can't let a front quad steal
-# clicks meant for a hidden control.
-FACE_QUAD_SELECT_BIAS: float = 0.5
-
-
-# ---------------------------------------------------------------------------
-# Internal constants
-# ---------------------------------------------------------------------------
-
-# Unit quad in the local XY plane spanning [-0.5, 0.5]^2 at z=0. Two
-# CCW triangles viewed from +Z. matrix_basis stretches it onto the
-# face's perpendicular extents.
-_QUAD_TRIS: list[tuple[float, float, float]] = [
-    (-0.5, -0.5, 0.0),
-    (0.5, -0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (-0.5, -0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (-0.5, 0.5, 0.0),
-]
-
-# Unit-quad outline as 4 line segments in the local XY plane at z=0.
-_QUAD_OUTLINE_LINES: list[tuple[float, float, float]] = [
-    (-0.5, -0.5, 0.0),
-    (0.5, -0.5, 0.0),
-    (0.5, -0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (-0.5, 0.5, 0.0),
-    (-0.5, 0.5, 0.0),
-    (-0.5, -0.5, 0.0),
-]
-
-# Degenerate zero-area triangle for hidden back-facing quads with no
-# visible-adjacent neighbours (rare orientation). Blender tolerates
-# this; the gizmo is hidden anyway so nothing renders.
-_EMPTY_TRIS: list[tuple[float, float, float]] = [
-    (0.0, 0.0, 0.0),
-    (0.0, 0.0, 0.0),
-    (0.0, 0.0, 0.0),
-]
-
-# Rotates the gizmo's local +Z onto the outward face normal in the
-# box's local frame. Right-hand rotation around the named axis.
-_AXIS_ORIENT: dict[tuple[int, bool], Matrix] = {
-    (0, False): Matrix.Rotation(-math.pi / 2, 4, "Y"),
-    (0, True): Matrix.Rotation(math.pi / 2, 4, "Y"),
-    (1, False): Matrix.Rotation(math.pi / 2, 4, "X"),
-    (1, True): Matrix.Rotation(-math.pi / 2, 4, "X"),
-    (2, False): Matrix.Rotation(math.pi, 4, "X"),
-    (2, True): Matrix.Identity(4),
-}
-
-# Per-face mapping from face-quad local axes to local box axes for the
-# perpendicular-extent scale. ``(w_axis, h_axis)`` — the box-local axis
-# indices the quad's local X and Y span after the orientation rotation.
-_QUAD_PERP_AXES: dict[tuple[int, bool], tuple[int, int]] = {
-    (0, False): (2, 1),
-    (0, True): (2, 1),
-    (1, False): (0, 2),
-    (1, True): (0, 2),
-    (2, False): (0, 1),
-    (2, True): (0, 1),
-}
-
-# Front-facing quad sits ABOVE the halo strips so the cursor on the
-# visible face area always grabs the visible face, never accidentally
-# routes to a back-face halo strip in an adjacent screen region.
-_FACE_QUAD_FRONT_FACING_SELECT_BIAS: float = 1.5
-_FACE_QUAD_HALO_FRAME_SELECT_BIAS: float = 1.0
-
-# Target halo-strip thickness in screen pixels. The world-space margin
-# is recomputed per frame so the rim stays a roughly constant on-screen
-# size regardless of viewport zoom.
-_FACE_QUAD_HALO_TARGET_PIXELS: float = 20.0
-
-# Minimum world half-extent a face resize may shrink to. Stops a drag
-# from collapsing the host to zero or negative scale.
-_MIN_HALF_EXTENT: float = 1e-4
-
-
-# ---------------------------------------------------------------------------
-# Pure predicates (testable without Blender)
-# ---------------------------------------------------------------------------
-
-Vec3 = tuple[float, float, float]
-
-
-def face_outward_axis_local(axis: int, is_max: bool) -> Vec3:
-    """Un-rotated outward face normal in the box's local AABB coords.
-
-    For ``(axis=0, is_max=True)`` returns ``(+1, 0, 0)``; for the −X
-    face ``(-1, 0, 0)``; etc. The rotated world normal is obtained by
-    applying the host's rotation and the OBB rotation:
-    ``mw_rot @ cage_rotation @ this``.
-    """
-    sign = 1.0 if is_max else -1.0
-    out = [0.0, 0.0, 0.0]
-    out[axis] = sign
-    return (out[0], out[1], out[2])
-
-
-def front_facing_face_mask(
-    face_normals_world: Sequence[Vec3],
-    view_dir_world: Vec3,
-    eps: float = 1e-6,
-) -> tuple[bool, ...]:
-    """Which of the 6 box faces point toward the camera.
-
-    A face is front-facing iff its outward normal points AGAINST the
-    view direction (``dot(normal, view_dir) < -eps``). The ``-eps``
-    margin prevents flicker at grazing angles.
-
-    ``face_normals_world`` must be in :data:`FACE_ROUTES` order; returns
-    a 6-tuple of bool parallel to that order.
-    """
-    if len(face_normals_world) != 6:
-        msg = f"expected 6 face normals, got {len(face_normals_world)}"
-        raise ValueError(msg)
-    vx, vy, vz = view_dir_world
-    return tuple((n[0] * vx + n[1] * vy + n[2] * vz) < -eps for n in face_normals_world)
-
-
-def view_axis_parallel_face_mask(
-    face_normals_world: Sequence[Vec3],
-    view_dir_world: Vec3,
-    threshold: float = 0.95,
-) -> tuple[bool, ...]:
-    """Which faces have normals (anti-)parallel to the view direction.
-
-    True iff ``abs(dot(normal, view_dir)) >= threshold`` — i.e. the
-    face is nearly perpendicular to the screen plane. Provided as a
-    pure predicate for callers that want to detect degenerate-drag
-    conditions; the layout helper itself no longer gates on it.
-    """
-    if len(face_normals_world) != 6:
-        msg = f"expected 6 face normals, got {len(face_normals_world)}"
-        raise ValueError(msg)
-    vx, vy, vz = view_dir_world
-    return tuple(abs(n[0] * vx + n[1] * vy + n[2] * vz) >= threshold for n in face_normals_world)
-
-
-# ---------------------------------------------------------------------------
-# Pure resize arithmetic
-# ---------------------------------------------------------------------------
-
-
-def compute_face_resize(
-    *,
-    value: float,
-    init_world_half: float,
-    init_location: tuple[float, float, float],
-    world_axis: tuple[float, float, float],
-    display_size: float,
-) -> tuple[float, tuple[float, float, float]]:
-    """Pure one-sided face-resize arithmetic.
-
-    Returns ``(new_scale_axis, new_location)`` — the host's new scale
-    on the dragged axis and its new world origin — such that the
-    dragged face moves by the modal's outward delta while the OPPOSITE
-    face stays put.
-
-    ``value`` is ``init + delta``, where ``init`` is the unsigned
-    drag-start world half-extent and ``delta`` is the cursor projection
-    onto the face's OUTWARD world normal. Realized half-extent is
-    clamped to a small floor; the location shift uses the realized
-    (post-clamp) delta so the opposite face stays fixed even at the
-    clamp.
-    """
-    face_delta = value - init_world_half
-    new_world_half = init_world_half + 0.5 * face_delta
-    if new_world_half < _MIN_HALF_EXTENT:
-        new_world_half = _MIN_HALF_EXTENT
-    realized_delta = 2.0 * (new_world_half - init_world_half)
-
-    ds = display_size if display_size != 0.0 else 1.0
-    new_scale_axis = new_world_half / ds
-    shift = 0.5 * realized_delta
-    new_location = (
-        init_location[0] + shift * world_axis[0],
-        init_location[1] + shift * world_axis[1],
-        init_location[2] + shift * world_axis[2],
-    )
-    return new_scale_axis, new_location
-
-
-# ---------------------------------------------------------------------------
-# Internal geometry helpers
-# ---------------------------------------------------------------------------
-
-
-def _compute_face_quad_scale(bmin: Any, bmax: Any, axis: int, is_max: bool) -> tuple[float, float]:
-    """Return ``(w, h)`` for the face quad's scale matrix."""
-    w_axis, h_axis = _QUAD_PERP_AXES[(axis, is_max)]
-    w = float(bmax[w_axis] - bmin[w_axis])
-    h = float(bmax[h_axis] - bmin[h_axis])
-    return w, h
-
-
-def _shared_edge_corner_keys(
-    axis_a: int, is_max_a: bool, axis_b: int, is_max_b: bool
-) -> tuple[tuple[int, int, int], tuple[int, int, int]] | None:
-    """Return the 2 corner-bit triples shared by two adjacent faces.
-
-    Corner keys are 3-tuples of bits (0 = bmin, 1 = bmax). The two
-    returned corners are ordered with the free-axis bit ascending.
-    """
-    if axis_a == axis_b:
-        return None
-    free_axis = 3 - axis_a - axis_b
-    bit_a = 1 if is_max_a else 0
-    bit_b = 1 if is_max_b else 0
-    corner_lo = [0, 0, 0]
-    corner_hi = [0, 0, 0]
-    corner_lo[axis_a] = bit_a
-    corner_hi[axis_a] = bit_a
-    corner_lo[axis_b] = bit_b
-    corner_hi[axis_b] = bit_b
-    corner_lo[free_axis] = 0
-    corner_hi[free_axis] = 1
-    return (
-        (corner_lo[0], corner_lo[1], corner_lo[2]),
-        (corner_hi[0], corner_hi[1], corner_hi[2]),
-    )
-
-
-def _face_corner_keys(axis: int, is_max: bool) -> tuple[
-    tuple[int, int, int],
-    tuple[int, int, int],
-    tuple[int, int, int],
-    tuple[int, int, int],
-]:
-    """Return the 4 corner-bit triples of a face in CCW order.
-
-    Triangulation as ``[(0,1,2), (0,2,3)]`` covers the whole face with
-    two non-overlapping triangles.
-    """
-    fixed_bit = 1 if is_max else 0
-    free_axes = [a for a in (0, 1, 2) if a != axis]
-    fa0, fa1 = free_axes
-    corners = []
-    for ka, kb in ((0, 0), (1, 0), (1, 1), (0, 1)):
-        key = [0, 0, 0]
-        key[axis] = fixed_bit
-        key[fa0] = ka
-        key[fa1] = kb
-        corners.append((key[0], key[1], key[2]))
-    return (corners[0], corners[1], corners[2], corners[3])
-
-
-def _build_strip_tris_relative(
-    edge_p0_local: tuple[float, float, float],
-    edge_p1_local: tuple[float, float, float],
-    extrusion_local: tuple[float, float, float],
-) -> list[tuple[float, float, float]]:
-    """Build two CCW triangles (6 vertices) for a thin halo strip.
-
-    All inputs are in coords relative to the gizmo's ``matrix_basis``
-    anchor. The strip runs along ``[edge_p0_local, edge_p1_local]`` and
-    extrudes by ``extrusion_local`` perpendicular to the edge.
-    """
-    p0x, p0y, p0z = edge_p0_local
-    p1x, p1y, p1z = edge_p1_local
-    ex, ey, ez = extrusion_local
-    p0e = (p0x + ex, p0y + ey, p0z + ez)
-    p1e = (p1x + ex, p1y + ey, p1z + ez)
-    return [
-        (p0x, p0y, p0z),
-        p0e,
-        p1e,
-        (p0x, p0y, p0z),
-        p1e,
-        (p1x, p1y, p1z),
-    ]
-
-
-def _strips_geometry_changed(quad_gz, face_quad_local, all_tris) -> bool:
-    """True if the back-face quad's geometry differs from the cached upload.
-
-    Pure orbit/pan doesn't change either the box pose or the cage
-    rotation, so the computed strip vertices are byte-identical to the
-    previous frame's. Hitting the cache lets the back-facing branch
-    skip ``new_custom_shape`` and the GPU upload.
-    """
-    cached = getattr(quad_gz, "_strips_cache_key", None)
-    last_state = getattr(quad_gz, "_last_geometry_state", None)
-    key = (face_quad_local, all_tris)
-    if cached is None or last_state != "strips" or cached != key:
-        quad_gz._strips_cache_key = key
-        quad_gz._last_geometry_state = "strips"
-        return True
-    return False
-
-
-def _compute_face_basis(
-    mw: Any,
-    mw_rot: Any,
-    cage_rotation: Any,
-    pivot_local: Any,
-    face_local: Any,
-    orient: Any,
-) -> tuple[Any, Any]:
-    """World-space (translation, outward-normal-direction) for one face."""
-    rotated_face_local = cage_rotation.to_3x3() @ (face_local - pivot_local) + pivot_local
-    face_world = mw @ rotated_face_local
-    world_axis = (mw_rot @ cage_rotation.to_3x3() @ (orient.to_3x3() @ Vector((0.0, 0.0, 1.0)))).normalized()
-    return face_world, world_axis
-
-
-def _compose_face_matrix_basis(
-    face_world: Any,
-    mw_rot_scale: Any,
-    cage_rotation: Any,
-    orient: Any,
-    w: float,
-    h: float,
-) -> Any:
-    """Compose the 5-term ``matrix_basis`` for a face-plane gizmo.
-
-    Returns ``Translation @ mw_rot_scale @ cage_rotation @ orient @
-    Diagonal((w, h, 1, 1))`` — maps a unit-square local quad onto the
-    world-space face rectangle, including the host's scale.
-    """
-    quad_scale = Matrix.Diagonal((w, h, 1.0, 1.0))
-    return Matrix.Translation(face_world) @ mw_rot_scale.to_4x4() @ cage_rotation @ orient @ quad_scale
-
-
-def _compute_box_corners_world(
-    bmin: Any,
-    bmax: Any,
-    pivot_local: Any,
-    cage_rotation_3x3: Any,
-    mw: Any,
-) -> dict[tuple[int, int, int], Any]:
-    """Return the 8 OBB corners in world space, keyed by bit-triple."""
-    corners: dict[tuple[int, int, int], Any] = {}
-    for ix in (0, 1):
-        for iy in (0, 1):
-            for iz in (0, 1):
-                local = Vector(
-                    (
-                        float(bmax.x if ix else bmin.x),
-                        float(bmax.y if iy else bmin.y),
-                        float(bmax.z if iz else bmin.z),
-                    )
-                )
-                rotated = cage_rotation_3x3 @ (local - pivot_local) + pivot_local
-                corners[(ix, iy, iz)] = mw @ rotated
-    return corners
-
-
-def _abs_scale_matrix(mw: Any) -> Any:
-    """Return a copy of ``mw`` with all scale components ``abs()``-ed.
-
-    Without this, a negative-scale host produces a visible/clickable
-    face inversion: ``mw @ local_vec`` flips the +axis face onto the
-    -axis world side, while the rotation-only normal stays pointing
-    in the +axis direction — so the gizmo for "the +X face" sits at
-    world -X but reports its outward normal as +X.
-    """
-    loc, rot, scale = mw.decompose()
-    abs_scale = Vector((abs(scale.x), abs(scale.y), abs(scale.z)))
-    return Matrix.LocRotScale(loc, rot, abs_scale)
-
-
-def _world_radius_to_screen_pixels(
-    region: Any,
-    rv3d: Any,
-    center_world: Vector,
-    world_radius: float,
-    *,
-    min_pixels: float = 0.0,
-) -> float:
-    """Return the on-screen pixel radius of a world-space circle.
-
-    Projects ``center_world`` and a sample point offset by
-    ``world_radius`` along the camera's view-aligned right axis to
-    region pixels, and returns the screen-pixel distance between them.
-    Falls back to ``min_pixels`` if either projection fails.
-    """
-    try:
-        view_inv = rv3d.view_matrix.inverted()
-        right = Vector((view_inv[0][0], view_inv[0][1], view_inv[0][2])).normalized()
-    except (AttributeError, ValueError):
-        right = Vector((1.0, 0.0, 0.0))
-    sample_world = center_world + right * world_radius
-    return _world_segment_to_screen_pixels(region, rv3d, center_world, sample_world, min_pixels=min_pixels)
-
-
-def _world_segment_to_screen_pixels(
-    region: Any,
-    rv3d: Any,
-    p0_world: Vector,
-    p1_world: Vector,
-    *,
-    min_pixels: float = 0.0,
-) -> float:
-    """Return the on-screen pixel length of an arbitrary world segment.
-
-    Unlike :func:`_world_radius_to_screen_pixels`, this measures the
-    ACTUAL projected length of the segment — foreshortening included.
-    Use this when the segment direction is known to be oblique to the
-    screen plane (e.g. a back face's outward normal): a perpendicular
-    radius measurement overestimates the on-screen length, leaving
-    halo strips visually narrower than the requested pixel target.
-    """
-    p0 = location_3d_to_region_2d(region, rv3d, p0_world)
-    p1 = location_3d_to_region_2d(region, rv3d, p1_world)
-    if not p0 or not p1:
-        return min_pixels
-    dx = float(p1[0]) - float(p0[0])
-    dy = float(p1[1]) - float(p0[1])
-    return max(min_pixels, (dx * dx + dy * dy) ** 0.5)
-
-
-# ---------------------------------------------------------------------------
-# Gizmo classes
-# ---------------------------------------------------------------------------
-
-
-class BIM_GT_box_face_quad(bpy.types.Gizmo):  # noqa: N801 — Blender bl_idname convention
-    """Near-invisible face-quad click target with drag-to-resize modal.
-
-    Geometry: a unit quad in the local XY plane at z=0. The adapter
-    group's layout helper rotates and scales it onto the face plane;
-    the quad is welded to the world face (``use_draw_scale = False``).
-    """
-
-    bl_idname = "BIM_GT_box_face_quad"
-    bl_target_properties = ({"id": "offset", "type": "FLOAT", "array_length": 1},)
-
-    __slots__ = (
-        "custom_shape",
-        "custom_shape_select",
-        "init_value",
-        "move_get_cb",
-        "move_set_cb",
-        "axis",
-        "start_location",
-        "depth_point",
-        "callback",
-        "ctrl_click_cb",
-        "_group",
-        "_face_axis",
-        "is_max",
-        "_drag_snapshot",
-        "_last_geometry_state",
-        "_strips_cache_key",
-    )
-
-    def draw(self, context: Any) -> None:
-        self.draw_custom_shape(self.custom_shape)
-
-    def draw_select(self, context: Any, select_id: int) -> None:
-        # Back-facing quads bind ``custom_shape_select`` to the halo-strip
-        # TRIS so clicks OUTSIDE the box silhouette catch the back face.
-        # Front-facing quads leave it None and reuse ``custom_shape``.
-        shape = getattr(self, "custom_shape_select", None) or self.custom_shape
-        self.draw_custom_shape(shape, select_id=select_id)
-
-    def setup(self) -> None:
-        if not hasattr(self, "custom_shape_"):
-            self.custom_shape = self.new_custom_shape("TRIS", _QUAD_TRIS)
-        self.custom_shape_select = None
-        # Quad welded to world geometry — clicks must align with the
-        # visible face, not a screen-size widget. Disables Blender's
-        # per-frame pixel-constant autoscale.
-        self.use_draw_scale = False
-
-    # ---- modal -------------------------------------------------------------
-
-    def invoke(self, context: Any, event: Any) -> set[str]:
-        # CTRL+click handoff: dispatch a host-defined callback (e.g.
-        # align-view) instead of starting a drag.
-        if event.ctrl and getattr(self, "ctrl_click_cb", None) is not None:
-            self.ctrl_click_cb(context, event)
-            return {"FINISHED"}
-
-        region = context.region
-        rv3d = context.region_data
-        if region is None or rv3d is None:
-            return {"CANCELLED"}
-        self.init_value = self.move_get_cb()
-        # Freeze the projection plane at invoke — projection-plane
-        # drift on tilted axes causes exponential delta runaway.
-        self.depth_point = self.matrix_basis.translation.copy()
-        self.start_location = region_2d_to_location_3d(region, rv3d, (event.mouse_x, event.mouse_y), self.depth_point)
-
-        if getattr(self, "_group", None) is not None:
-            self._group._lock_for(self)
-        return {"RUNNING_MODAL"}
-
-    def exit(self, context: Any, cancel: bool) -> None:
-        try:
-            if context.area:
-                context.area.header_text_set(None)
-            if cancel:
-                self.move_set_cb(self.init_value)
-            if hasattr(self, "callback"):
-                self.callback(self.move_get_cb())
-        finally:
-            self._drag_snapshot = None
-            if getattr(self, "_group", None) is not None:
-                self._group._unlock_all()
-
-    def modal(self, context: Any, event: Any, tweak: set[str]) -> set[str]:
-        if event.type == "ESC":
-            return {"CANCELLED"}
-        region = context.region
-        rv3d = context.region_data
-        if region is None or rv3d is None:
-            return {"CANCELLED"}
-        end_location = region_2d_to_location_3d(region, rv3d, (event.mouse_x, event.mouse_y), self.depth_point)
-        delta = (end_location - self.start_location).dot(self.axis)
-        if "SNAP" in tweak:
-            delta = round(delta, 1)
-        if "PRECISE" in tweak:
-            delta /= 10.0
-        self.move_set_cb(self.init_value + delta)
-        if context.area:
-            context.area.header_text_set(f"Value: {self.move_get_cb():.3f} ({delta:.3f})")
-        return {"RUNNING_MODAL"}
-
-
-class BIM_GT_box_face_outline(bpy.types.Gizmo):  # noqa: N801 — Blender bl_idname convention
-    """Thin non-interactive colored edge outline for one face.
-
-    Drawn as 4 line segments in the face plane. The layout helper
-    toggles its ``alpha`` between near-zero and ``1.0`` based on the
-    sibling face-quad's ``is_highlight`` state — so hovering the quad
-    lights up the matching outline. ``hide_select = True`` keeps the
-    outline out of the GPU selection buffer.
-    """
-
-    bl_idname = "BIM_GT_box_face_outline"
-    bl_target_properties = ()
-
-    __slots__ = (
-        "custom_shape",
-        "_face_axis",
-        "is_max",
-        "_last_outline_state",
-    )
-
-    def draw(self, context: Any) -> None:
-        self.draw_custom_shape(self.custom_shape)
-
-    def draw_select(self, context: Any, select_id: int) -> None:
-        return None
-
-    def setup(self) -> None:
-        if not hasattr(self, "custom_shape_"):
-            self.custom_shape = self.new_custom_shape("LINES", _QUAD_OUTLINE_LINES)
-        self.use_draw_scale = False
-        self.hide_select = True
-        self._last_outline_state = "unit"
-
-
-# ---------------------------------------------------------------------------
-# Per-redraw orchestrator
-# ---------------------------------------------------------------------------
-
-
-def apply_face_quad_layout(
-    *,
-    quad_gizmos,
-    outline_gizmos,
-    bmin: Any,
-    bmax: Any,
-    matrix_world: Any,
-    cage_rotation: Any,
-    region: Any,
-    rv3d: Any,
-    locked: bool,
-) -> None:
-    """Lay out 6 face quads + 6 outlines on the box for this redraw.
-
-    ``quad_gizmos`` / ``outline_gizmos`` are length-6 sequences in
-    :data:`FACE_ROUTES` order. ``bmin`` / ``bmax`` are the box corners
-    in the host's local frame; ``matrix_world`` is the host's world
-    matrix; ``cage_rotation`` is the OBB rotation as a 4x4 (use
-    ``Matrix.Identity(4)`` when rotation rides in ``matrix_world``).
-    ``region`` / ``rv3d`` drive the view-dependent front/back split and
-    the screen-constant halo margin; passing ``rv3d = None`` bails.
-
-    Negative scale on the host is normalized to positive internally so
-    the visible cube and the clickable face gizmos stay aligned —
-    callers don't need to pre-process ``matrix_world``.
-
-    When ``locked`` (a drag is active), ``hide`` / ``select_bias``
-    writes are skipped — the active quad's geometry is still refreshed
-    so it tracks the moving box.
-    """
-    if rv3d is None or getattr(rv3d, "view_rotation", None) is None:
-        return
-    if len(quad_gizmos) != 6 or len(outline_gizmos) != 6:
-        return
-
-    mw = _abs_scale_matrix(matrix_world)
-    mw_rot = mw.to_quaternion().to_matrix()
-    mw_rot_scale = mw.to_3x3()
-    cage_rotation_3x3 = cage_rotation.to_3x3()
-    pivot_local = (bmin + bmax) * 0.5
-    box_center_local = pivot_local
-    face_midpoints_local = {
-        (0, False): Vector((float(bmin.x), box_center_local.y, box_center_local.z)),
-        (0, True): Vector((float(bmax.x), box_center_local.y, box_center_local.z)),
-        (1, False): Vector((box_center_local.x, float(bmin.y), box_center_local.z)),
-        (1, True): Vector((box_center_local.x, float(bmax.y), box_center_local.z)),
-        (2, False): Vector((box_center_local.x, box_center_local.y, float(bmin.z))),
-        (2, True): Vector((box_center_local.x, box_center_local.y, float(bmax.z))),
-    }
-
-    view_dir = (rv3d.view_rotation @ Vector((0.0, 0.0, -1.0))).normalized()
-    view_dir_tuple = (float(view_dir.x), float(view_dir.y), float(view_dir.z))
-    face_normals_world = []
-    for route_axis, route_is_max in FACE_ROUTES:
-        axis_local = Vector(face_outward_axis_local(route_axis, route_is_max))
-        n_world = (mw_rot @ cage_rotation_3x3 @ axis_local).normalized()
-        face_normals_world.append((float(n_world.x), float(n_world.y), float(n_world.z)))
-    front = front_facing_face_mask(tuple(face_normals_world), view_dir_tuple)
-
-    box_center_world = mw @ pivot_local
-    corners_world = _compute_box_corners_world(bmin, bmax, pivot_local, cage_rotation_3x3, mw)
-    route_to_index = {route: i for i, route in enumerate(FACE_ROUTES)}
-
-    for i, route in enumerate(FACE_ROUTES):
-        quad_gz = quad_gizmos[i]
-        is_front = front[i]
-        axis_b, is_max_b = route
-
-        # Place the colored OUTLINE on every face using the same composed
-        # face matrix the front-facing solid quad uses. Hidden/shown via
-        # alpha at the end of the pass.
-        outline_orient = _AXIS_ORIENT[route]
-        outline_face_world, _outline_axis = _compute_face_basis(
-            mw,
-            mw_rot,
-            cage_rotation,
-            pivot_local,
-            face_midpoints_local[route],
-            outline_orient,
-        )
-        ow, oh = _compute_face_quad_scale(bmin, bmax, axis_b, is_max_b)
-        outline_gizmos[i].matrix_basis = _compose_face_matrix_basis(
-            outline_face_world, mw_rot_scale, cage_rotation, outline_orient, ow, oh
-        )
-
-        if is_front:
-            if not locked:
-                quad_gz.hide = False
-                quad_gz.select_bias = _FACE_QUAD_FRONT_FACING_SELECT_BIAS
-            orient = _AXIS_ORIENT[route]
-            face_world, world_axis = _compute_face_basis(
-                mw,
-                mw_rot,
-                cage_rotation,
-                pivot_local,
-                face_midpoints_local[route],
-                orient,
-            )
-            w, h = _compute_face_quad_scale(bmin, bmax, axis_b, is_max_b)
-            quad_gz.matrix_basis = _compose_face_matrix_basis(face_world, mw_rot_scale, cage_rotation, orient, w, h)
-            quad_gz.axis = world_axis
-            if getattr(quad_gz, "_last_geometry_state", None) != "solid":
-                quad_gz.custom_shape = quad_gz.new_custom_shape("TRIS", _QUAD_TRIS)
-                quad_gz.custom_shape_select = None
-                quad_gz._last_geometry_state = "solid"
-            continue
-
-        # Back-facing: anchor at the back face centre; build halo strips
-        # in the planes of the adjacent FRONT faces, extruded outside
-        # the silhouette toward this face's outward normal.
-        face_world = mw @ (cage_rotation_3x3 @ (face_midpoints_local[route] - pivot_local) + pivot_local)
-        quad_gz.matrix_basis = Matrix.Translation(face_world)
-        quad_gz.axis = (mw_rot @ cage_rotation_3x3 @ Vector(face_outward_axis_local(axis_b, is_max_b))).normalized()
-
-        adjacent_front_routes = [
-            (axis_a, is_max_a)
-            for axis_a in range(3)
-            if axis_a != axis_b
-            for is_max_a in (False, True)
-            if front[route_to_index[(axis_a, is_max_a)]]
-        ]
-        # Per-face world margin: measure the screen-projected length of
-        # ONE world unit along THIS face's outward normal. The world
-        # margin that yields ~N pixels on screen is then ``N / length``.
-        # Foreshortening on oblique faces shortens the projected step,
-        # so the world step must grow to keep the strip the same width
-        # on screen.
-        face_world_margin = 0.0
-        if region is not None:
-            sample_end = box_center_world + quad_gz.axis * 1.0
-            screen_step = _world_segment_to_screen_pixels(region, rv3d, box_center_world, sample_end, min_pixels=0.0)
-            if screen_step > 0.0:
-                face_world_margin = _FACE_QUAD_HALO_TARGET_PIXELS / screen_step
-        if face_world_margin <= 0.0 or not adjacent_front_routes:
-            if not locked:
-                quad_gz.hide = True
-                quad_gz.select_bias = _FACE_QUAD_HALO_FRAME_SELECT_BIAS
-            if getattr(quad_gz, "_last_geometry_state", None) != "empty":
-                quad_gz.custom_shape = quad_gz.new_custom_shape("TRIS", _EMPTY_TRIS)
-                quad_gz.custom_shape_select = None
-                quad_gz._last_geometry_state = "empty"
-            continue
-
-        extrusion_world = quad_gz.axis * face_world_margin
-        extrusion_local = (
-            float(extrusion_world.x),
-            float(extrusion_world.y),
-            float(extrusion_world.z),
-        )
-        all_tris: list[tuple[float, float, float]] = []
-        for axis_a, is_max_a in adjacent_front_routes:
-            edge_keys = _shared_edge_corner_keys(axis_a, is_max_a, axis_b, is_max_b)
-            if edge_keys is None:
-                continue
-            key0, key1 = edge_keys
-            wp0 = corners_world[key0]
-            wp1 = corners_world[key1]
-            local_p0 = (
-                float(wp0.x - face_world.x),
-                float(wp0.y - face_world.y),
-                float(wp0.z - face_world.z),
-            )
-            local_p1 = (
-                float(wp1.x - face_world.x),
-                float(wp1.y - face_world.y),
-                float(wp1.z - face_world.z),
-            )
-            all_tris.extend(_build_strip_tris_relative(local_p0, local_p1, extrusion_local))
-
-        if not locked:
-            quad_gz.hide = False
-            quad_gz.select_bias = _FACE_QUAD_HALO_FRAME_SELECT_BIAS
-
-        corner_keys = _face_corner_keys(axis_b, is_max_b)
-        wc_local = [
-            (
-                float(corners_world[k].x - face_world.x),
-                float(corners_world[k].y - face_world.y),
-                float(corners_world[k].z - face_world.z),
-            )
-            for k in corner_keys
-        ]
-        face_quad_local = [
-            wc_local[0],
-            wc_local[1],
-            wc_local[2],
-            wc_local[0],
-            wc_local[2],
-            wc_local[3],
-        ]
-        if _strips_geometry_changed(quad_gz, tuple(face_quad_local), tuple(all_tris)):
-            quad_gz.custom_shape = quad_gz.new_custom_shape("TRIS", face_quad_local)
-            quad_gz.custom_shape_select = quad_gz.new_custom_shape("TRIS", all_tris)
-        quad_gz._last_geometry_state = "strips"
-
-    # Outline alpha follows ONLY the hovered quad's own state — light
-    # the outline of the face under the cursor, nothing else.
-    if not locked:
-        for outline_gz, quad_gz in zip(outline_gizmos, quad_gizmos, strict=True):
-            lit = bool(getattr(quad_gz, "is_highlight", False))
-            outline_gz.alpha = 1.0 if lit else 0.0
-            outline_gz.alpha_highlight = 1.0 if lit else 0.0
-
-
-__all__ = [
-    "AXIS_COLOR",
-    "FACE_QUAD_ALPHA",
-    "FACE_QUAD_ALPHA_HIGHLIGHT",
-    "FACE_QUAD_SELECT_BIAS",
-    "FACE_ROUTES",
-    "BIM_GT_box_face_outline",
-    "BIM_GT_box_face_quad",
-    "apply_face_quad_layout",
-    "compute_face_resize",
-    "face_outward_axis_local",
-    "front_facing_face_mask",
-    "view_axis_parallel_face_mask",
-]

src/bonsai/bonsai/bim/module/clip_box/gizmos.py

@@ -1,312 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Interactive face-quad resize gizmos for the active clip box.
-
-Adapter group that binds the generic :mod:`face_quad` core to a Bonsai
-clip-box Empty: six near-invisible click quads + six edge outlines on
-the cube's faces. Dragging a face does a ONE-SIDED resize — the dragged
-face moves along its outward world normal while the opposite face stays
-put — by writing the empty's ``location`` and ``scale``. Bonsai's
-depsgraph handler then re-arms the clip planes from the new matrix.
-"""
-
-from __future__ import annotations
-
-import contextlib
-from typing import Any
-
-import bpy
-from mathutils import Matrix, Vector
-
-import bonsai.tool as tool
-
-from . import face_quad
-
-# Local-frame bounds of the empty's CUBE display. The display spans
-# ``[-empty_display_size, +empty_display_size]^3``; Bonsai always sets
-# ``empty_display_size = 1.0`` on clip-box hosts, so the local box is
-# the unit cube. The empty's per-axis scale + rotation + translation
-# ride in ``matrix_world``, which the layout helper applies.
-_LOCAL_BMIN = Vector((-1.0, -1.0, -1.0))
-_LOCAL_BMAX = Vector((1.0, 1.0, 1.0))
-
-
-def _world_axis(empty: bpy.types.Object, axis: int, is_max: bool) -> Vector:
-    """Outward world-space unit normal of the ``(axis, is_max)`` face.
-
-    Uses the rotation-only matrix so a negative-scale empty doesn't
-    flip the resulting direction — the visible "+X face" then stays
-    associated with world +X (transformed through rotation).
-    """
-    rot_mat = empty.matrix_world.to_quaternion().to_matrix()
-    n = Vector(rot_mat.col[axis])
-    if n.length <= 0.0:
-        return Vector((0.0, 0.0, 0.0))
-    n.normalize()
-    return n if is_max else -n
-
-
-def _world_half_extent(empty: bpy.types.Object, axis: int) -> float:
-    """The empty's box half-extent along local ``axis`` in WORLD units.
-
-    A CUBE empty's local cube is ``±empty_display_size``; ``matrix_world``
-    stretches it by the column length on ``axis``. So the world
-    half-extent is ``|column[axis]| * empty_display_size``.
-    """
-    col_len = empty.matrix_world.to_3x3().col[axis].length
-    display_size = abs(float(getattr(empty, "empty_display_size", 1.0) or 1.0))
-    return float(col_len) * display_size
-
-
-def _make_face_get_cb(gz: Any, group: Any, axis: int, is_max: bool):
-    """Closure returning the world half-extent at drag start and
-    snapshotting the empty's full transform on the gizmo instance.
-
-    The snapshot lives on the gizmo (not the group) so a PERSISTENT
-    group servicing multiple clip boxes can't bleed one drag's state
-    onto another. Cleared on ``exit`` by the shared face-quad hook.
-    """
-
-    def getter() -> float:
-        empty = group._empty
-        if empty is None:
-            return 0.0
-        existing = getattr(gz, "_drag_snapshot", None)
-        if existing is not None and existing.get("empty_name") == getattr(empty, "name", None):
-            return float(existing["world_half"])
-
-        world_half = _world_half_extent(empty, axis)
-        display_size = abs(float(getattr(empty, "empty_display_size", 1.0) or 1.0))
-        gz._drag_snapshot = {
-            "empty_name": getattr(empty, "name", None),
-            "world_half": world_half,
-            "location": tuple(float(v) for v in empty.location),
-            "scale": tuple(float(v) for v in empty.scale),
-            "display_size": display_size if display_size != 0.0 else 1.0,
-            "world_axis": tuple(_world_axis(empty, axis, is_max)),
-        }
-        return float(world_half)
-
-    return getter
-
-
-def _make_ctrl_click_cb(axis: int, is_max: bool):
-    """Closure that dispatches CTRL+click on a face to the align-view operator.
-
-    Routing through an operator (rather than mutating ``rv3d`` here)
-    keeps the action F3-searchable and undoable.
-    """
-
-    def _callback(_context: Any, _event: Any) -> None:
-        bpy.ops.bim.align_view_to_clip_face("INVOKE_DEFAULT", axis=axis, is_max=is_max)
-
-    return _callback
-
-
-def _make_face_set_cb(gz: Any, group: Any, axis: int, is_max: bool):
-    """Closure that applies a one-sided face resize by writing the
-    empty's ``location`` + ``scale``.
-
-    The modal calls this with ``value = init + delta`` where ``delta``
-    is the cursor's projection onto the face's OUTWARD world normal.
-    Both reads come from ``gz._drag_snapshot`` so every frame is
-    relative to drag start, never compounding.
-    """
-    del is_max  # snapshot's world_axis carries the direction
-
-    def setter(value: float) -> None:
-        empty = group._empty
-        if empty is None:
-            return
-        snap = getattr(gz, "_drag_snapshot", None)
-        if snap is None or snap.get("empty_name") != getattr(empty, "name", None):
-            return
-
-        new_scale_axis, new_location = face_quad.compute_face_resize(
-            value=value,
-            init_world_half=snap["world_half"],
-            init_location=snap["location"],
-            world_axis=snap["world_axis"],
-            display_size=snap["display_size"],
-        )
-        new_scale = list(snap["scale"])
-        # Preserve the sign of the original scale so a user-flipped empty
-        # stays flipped after the resize — compute_face_resize returns a
-        # positive magnitude, the sign is the user's intent to keep.
-        sign = -1.0 if snap["scale"][axis] < 0.0 else 1.0
-        new_scale[axis] = sign * new_scale_axis
-
-        empty.scale = new_scale
-        empty.location = Vector(new_location)
-
-    return setter
-
-
-class OBJECT_GGT_bim_clip_box(bpy.types.GizmoGroup):  # noqa: N801 — Blender bl_idname convention
-    """Face-quad resize handles on the active clip box.
-
-    Renders six near-invisible click-target quads and six colored edge
-    outlines on the active clip-box empty whenever clipping is enabled.
-    Click-and-drag a face to resize one-sided; the opposite face stays
-    put. CTRL+click and plain click fall through to selection.
-    """
-
-    bl_idname = "OBJECT_GGT_bim_clip_box"
-    bl_label = "Bonsai Clip Box Faces"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "WINDOW"
-    bl_options = {"3D", "PERSISTENT", "SHOW_MODAL_ALL"}
-
-    @classmethod
-    def poll(cls, context: Any) -> bool:
-        scene = getattr(context, "scene", None)
-        if scene is None:
-            return False
-        scene_props = tool.ClipBox.get_scene_props(scene)
-        if not scene_props.enabled or not scene_props.enable_gizmos:
-            return False
-        active_clip_box = tool.ClipBox.get_active_clip_box(scene)
-        if active_clip_box is None:
-            return False
-        # Only render when the user has the active clip box itself
-        # selected — otherwise the face handles would intercept clicks
-        # meant for the geometry behind them.
-        return getattr(context, "active_object", None) is active_clip_box
-
-    @classmethod
-    def setup_keymap(cls, keyconfig):
-        # Bind CLICK_DRAG so plain LEFTMOUSE PRESS passes through to
-        # selection — the user can still click through a near-invisible
-        # face quad to pick a mesh behind it.
-        km = keyconfig.keymaps.new(
-            name=cls.bl_idname,
-            space_type=cls.bl_space_type,
-            region_type=cls.bl_region_type,
-        )
-        km.keymap_items.new("gizmogroup.gizmo_tweak", type="LEFTMOUSE", value="CLICK_DRAG")
-        km.keymap_items.new("gizmogroup.gizmo_tweak", type="LEFTMOUSE", value="PRESS", ctrl=True)
-        return km
-
-    def setup(self, context: Any) -> None:
-        # ``_empty`` is resolved each refresh so the PERSISTENT group
-        # follows whichever clip box is active in the scene PG.
-        self._empty: bpy.types.Object | None = None
-        self._locked = False
-        self._face_routes: list[tuple[int, bool]] = []
-
-        for axis, is_max in face_quad.FACE_ROUTES:
-            gz = self.gizmos.new(face_quad.BIM_GT_box_face_quad.bl_idname)
-            gz._group = self
-            gz._face_axis = axis
-            gz.is_max = is_max
-            gz._drag_snapshot = None
-            gz._last_geometry_state = "solid"
-            gz._strips_cache_key = None
-            gz.color = face_quad.AXIS_COLOR[axis]
-            gz.color_highlight = tuple(min(1.0, c + 0.3) for c in face_quad.AXIS_COLOR[axis])
-            gz.alpha = face_quad.FACE_QUAD_ALPHA
-            gz.alpha_highlight = face_quad.FACE_QUAD_ALPHA_HIGHLIGHT
-            gz.use_draw_modal = True
-            gz.scale_basis = 1.0
-            gz.select_bias = face_quad.FACE_QUAD_SELECT_BIAS
-            gz.move_get_cb = _make_face_get_cb(gz, self, axis, is_max)
-            gz.move_set_cb = _make_face_set_cb(gz, self, axis, is_max)
-            # CTRL+click on a face aligns the viewport to look at it.
-            gz.ctrl_click_cb = _make_ctrl_click_cb(axis, is_max)
-            self._face_routes.append((axis, is_max))
-
-        # Outlines added last so they composite on top of the quad
-        # fills (Blender draws gizmos in creation order).
-        for axis, is_max in face_quad.FACE_ROUTES:
-            ol = self.gizmos.new(face_quad.BIM_GT_box_face_outline.bl_idname)
-            ol._face_axis = axis
-            ol.is_max = is_max
-            ol.color = face_quad.AXIS_COLOR[axis]
-            ol.color_highlight = face_quad.AXIS_COLOR[axis]
-            ol.alpha = 0.0
-            ol.alpha_highlight = 0.0
-            ol.line_width = 2.5
-
-    def _quad_gizmos(self):
-        return self.gizmos[: len(self._face_routes)]
-
-    def _outline_gizmos(self):
-        n = len(self._face_routes)
-        return self.gizmos[n : 2 * n]
-
-    def refresh(self, context: Any) -> None:
-        """State-change path: resolve the active empty, then run the
-        shared face-quad layout so the quads aren't stale for a frame
-        after a selection or active-index change."""
-        empty = tool.ClipBox.get_active_clip_box(context.scene)
-        self._empty = empty
-        if empty is None:
-            for gz in self.gizmos:
-                gz.hide = True
-            return
-        self._layout(context, empty)
-
-    def draw_prepare(self, context: Any) -> None:
-        """Per-redraw — fires on orbit — re-run the layout so the
-        front/back split, halo strips, and outline highlights track
-        the camera and any live G/R/S on the empty."""
-        empty = self._empty
-        if empty is None:
-            return
-        self._layout(context, empty)
-
-    def _layout(self, context: Any, empty: bpy.types.Object) -> None:
-        face_quad.apply_face_quad_layout(
-            quad_gizmos=self._quad_gizmos(),
-            outline_gizmos=self._outline_gizmos(),
-            bmin=_LOCAL_BMIN,
-            bmax=_LOCAL_BMAX,
-            matrix_world=empty.matrix_world,
-            # The empty's rotation rides in matrix_world, so the
-            # box-local OBB rotation is identity.
-            cage_rotation=Matrix.Identity(4),
-            region=getattr(context, "region", None),
-            rv3d=getattr(context, "region_data", None),
-            locked=self._locked,
-        )
-
-    # ---- mutual exclusion (lock siblings during a drag) ------------------
-
-    def _lock_for(self, active_gizmo) -> None:
-        self._locked = True
-        for gz in self.gizmos:
-            if gz is not active_gizmo:
-                with contextlib.suppress(ReferenceError, RuntimeError):
-                    gz.hide = True
-
-    def _unlock_all(self) -> None:
-        self._locked = False
-        for gz in self.gizmos:
-            with contextlib.suppress(ReferenceError, RuntimeError):
-                gz.hide = False
-        # Rebuild caps synchronously so the cross-section overlay
-        # re-forms the instant the user releases the handle, rather
-        # than waiting for the depsgraph's debounced rebuild path.
-        with contextlib.suppress(RuntimeError, ReferenceError):
-            tool.ClipBox.rebuild_caps_now()
-        # Push an undo step so the user can revert a face drag with Ctrl+Z.
-        with contextlib.suppress(RuntimeError):
-            bpy.ops.ed.undo_push(message="Resize Clip Box")

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

@@ -1,294 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-import bpy
-from mathutils import Matrix, Vector
-
-import bonsai.tool as tool
-from bonsai.bim.helper import prop_with_search
-
-from . import data
-
-# NOTE: do NOT add ``from __future__ import annotations`` to this module.
-# PEP 563 stringifies the operator's EnumProperty class annotations, which
-# breaks any introspection that reads ``cls.__annotations__[name].keywords``
-# — including the enum-search helper that draws the search-button icon.
-
-CLIP_BOX_NAME = "ClipBox"
-
-# Display labels for the source-based picker, used for the menu entries and
-# the dialog title. The dict keys are the canonical source-kind identifiers.
-SOURCE_KIND_LABELS: dict[str, str] = {
-    "SPATIAL": "Spatial Element",
-    "CLASS": "Class",
-    "TYPE": "Type",
-    "MATERIAL": "Material",
-    "PROFILE": "Profile",
-    "DRAWING": "Drawing",
-    "STATUS": "Status",
-    "SYSTEM": "System",
-    "GROUP": "Group",
-    "ZONE": "Zone",
-}
-
-
-_SOURCE_ID_DISPATCH = {
-    "SPATIAL": data.spatial_items,
-    "CLASS": data.class_items,
-    "TYPE": data.type_items,
-    "MATERIAL": data.material_items,
-    "PROFILE": data.profile_items,
-    "DRAWING": data.drawing_items,
-    "STATUS": data.status_items,
-    "SYSTEM": data.system_items,
-    "GROUP": data.group_items,
-    "ZONE": data.zone_items,
-}
-
-
-def _source_id_items(self, context):
-    """Dispatch the ``source_id`` enum items based on the picked ``source_kind``."""
-    fn = _SOURCE_ID_DISPATCH.get(self.source_kind)
-    if fn is None:
-        return [(data.NO_OPTIONS_ID, "No options", "")]
-    return fn(self, context)
-
-
-def _source_display_name(kind, source_id):
-    """Human-readable name of the picked source, used in the clip-box name."""
-    if kind == "STATUS":
-        return next((label for value, label in data.STATUS_LABELS if value == source_id), source_id)
-    if kind == "CLASS":
-        # source_id IS the human-readable IFC class name.
-        return source_id
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return source_id
-    try:
-        entity = ifc.by_id(int(source_id))
-    except (TypeError, ValueError, RuntimeError):
-        return source_id
-    return (getattr(entity, "Name", None) or "Unnamed").strip() or "Unnamed"
-
-
-class BIM_OT_align_view_to_clip_face(bpy.types.Operator):
-    bl_idname = "bim.align_view_to_clip_face"
-    bl_label = "Align View to Clip Box Face"
-    bl_description = "Orient the 3D viewport to look directly at the picked clip-box face"
-    bl_options = {"REGISTER"}
-
-    axis: bpy.props.IntProperty(default=0, options={"SKIP_SAVE"})
-    is_max: bpy.props.BoolProperty(default=True, options={"SKIP_SAVE"})
-
-    def execute(self, context):
-        rv3d = getattr(context, "region_data", None)
-        if rv3d is None:
-            return {"CANCELLED"}
-        clip_box = tool.ClipBox.get_active_clip_box(context.scene)
-        if clip_box is None:
-            return {"CANCELLED"}
-        rot_mat = clip_box.matrix_world.to_quaternion().to_matrix()
-        outward_local = Vector((0.0, 0.0, 0.0))
-        outward_local[self.axis] = 1.0 if self.is_max else -1.0
-        outward = (rot_mat @ outward_local).normalized()
-        if outward.length == 0.0:
-            return {"CANCELLED"}
-        up_world = (rot_mat @ _local_up_for_face(self.axis, self.is_max)).normalized()
-        rv3d.view_rotation = _view_rotation_from_forward_and_up(-outward, up_world)
-        return {"FINISHED"}
-
-
-def _local_up_for_face(axis: int, is_max: bool) -> Vector:
-    """Box-local up direction for a face, following Blender numpad conventions.
-
-    Side faces (local ±X / ±Y normal) → local +Z is up. Top face (local +Z
-    normal) → local +Y is up; bottom face (local -Z normal) → local -Y is
-    up. The caller rotates this through the empty's matrix so the
-    resulting world up axis tracks the box's orientation.
-    """
-    if axis == 2:
-        return Vector((0.0, 1.0, 0.0)) if is_max else Vector((0.0, -1.0, 0.0))
-    return Vector((0.0, 0.0, 1.0))
-
-
-def _view_rotation_from_forward_and_up(forward: Vector, up_hint: Vector) -> "bpy.types.Quaternion":
-    """Build a camera ``view_rotation`` that looks along ``forward`` with
-    ``up_hint`` projected to the camera's local +Y."""
-    back = -forward.normalized()
-    right = up_hint.cross(back)
-    if right.length < 1e-6:
-        right = Vector((1.0, 0.0, 0.0))
-    right.normalize()
-    up = back.cross(right).normalized()
-    return Matrix(
-        (
-            (right.x, up.x, back.x),
-            (right.y, up.y, back.y),
-            (right.z, up.z, back.z),
-        )
-    ).to_quaternion()
-
-
-class BIM_OT_add_clip_box(bpy.types.Operator):
-    bl_idname = "bim.add_clip_box"
-    bl_label = "Add Clip Box"
-    bl_description = (
-        "Create a clip box empty at the 3D cursor. The empty's location, rotation, and scale "
-        "drive the viewport clip planes; resize with S, move with G, rotate with R"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        # Default to a 20m cube (scale 10 around [-1, +1] local cube) so
-        # the volume covers a typical building storey or two rather than
-        # the meaningless 2m unit cube. The user resizes with S.
-        matrix = Matrix.Translation(context.scene.cursor.location.copy()) @ Matrix.Diagonal((10.0, 10.0, 10.0, 1.0))
-        tool.ClipBox.create_clip_box_empty(context, matrix, name=CLIP_BOX_NAME)
-        return {"FINISHED"}
-
-
-class BIM_OT_add_clip_box_for_source(bpy.types.Operator):
-    bl_idname = "bim.add_clip_box_for_source"
-    bl_label = "Add Clip Box From Source"
-    bl_description = (
-        "Create a clip box sized to a chosen source: a spatial container, IFC type, material, "
-        "profile, drawing camera frustum, element status, system, group, or zone"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    source_kind: bpy.props.EnumProperty(
-        name="Source Kind",
-        items=[(kind, label, "") for kind, label in SOURCE_KIND_LABELS.items()],
-        default="SPATIAL",
-        options={"SKIP_SAVE"},
-    )
-    source_id: bpy.props.EnumProperty(
-        name="Source",
-        items=_source_id_items,
-        options={"SKIP_SAVE"},
-    )
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self)
-
-    def draw(self, context):
-        layout = self.layout
-        label = f"Clip {SOURCE_KIND_LABELS.get(self.source_kind, 'Source')}"
-        # Search button appears once the enum exceeds the helper's threshold,
-        # giving the user a popup picker instead of a plain dropdown.
-        prop_with_search(layout, self, "source_id", text=label)
-
-    def execute(self, context):
-        if not self.source_id or self.source_id == data.NO_OPTIONS_ID:
-            self.report({"ERROR"}, "No source selected.")
-            return {"CANCELLED"}
-        matrix = tool.ClipBox.compute_matrix_for_source(self.source_kind, self.source_id)
-        if matrix is None:
-            kind_label = SOURCE_KIND_LABELS.get(self.source_kind, self.source_kind)
-            self.report(
-                {"ERROR"},
-                f"No elements found for {kind_label} '{_source_display_name(self.source_kind, self.source_id)}'.",
-            )
-            return {"CANCELLED"}
-        name = f"ClipBox.{SOURCE_KIND_LABELS.get(self.source_kind, self.source_kind)}.{_source_display_name(self.source_kind, self.source_id)}"
-        tool.ClipBox.create_clip_box_empty(context, matrix, name=name)
-        return {"FINISHED"}
-
-
-class BIM_OT_remove_clip_box(bpy.types.Operator):
-    bl_idname = "bim.remove_clip_box"
-    bl_label = "Remove Clip Box"
-    bl_description = "Remove this clip box and its host empty"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty(default=-1, options={"SKIP_SAVE"})
-    delete_object: bpy.props.BoolProperty(default=True, name="Delete Host Object")
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        index = self.index if self.index >= 0 else scene_props.active_clip_box_index
-        if index < 0 or index >= len(scene_props.clip_boxes):
-            return {"CANCELLED"}
-
-        entry = scene_props.clip_boxes[index]
-        obj = entry.obj
-        scene_props.clip_boxes.remove(index)
-        if scene_props.active_clip_box_index >= len(scene_props.clip_boxes):
-            scene_props.active_clip_box_index = max(0, len(scene_props.clip_boxes) - 1)
-
-        if self.delete_object and obj is not None:
-            bpy.data.objects.remove(obj, do_unlink=True)
-
-        tool.ClipBox.refresh(context.scene)
-        tool.ClipBox.save_to_project_pset(context.scene)
-        return {"FINISHED"}
-
-
-class BIM_OT_set_active_clip_box(bpy.types.Operator):
-    bl_idname = "bim.set_active_clip_box"
-    bl_label = "Set Active Clip Box"
-    bl_description = "Set this clip box as the active one driving the viewport clip"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty(default=-1, options={"SKIP_SAVE"})
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        if self.index < 0 or self.index >= len(scene_props.clip_boxes):
-            return {"CANCELLED"}
-        scene_props.active_clip_box_index = self.index
-        return {"FINISHED"}
-
-
-class BIM_OT_toggle_clip_box_enabled(bpy.types.Operator):
-    bl_idname = "bim.toggle_clip_box_enabled"
-    bl_label = "Toggle Clip Box"
-    bl_description = "Toggle whether the active clip box is driving the viewport clip planes"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        scene_props.enabled = not scene_props.enabled
-        return {"FINISHED"}
-
-
-class BIM_OT_duplicate_clip_box(bpy.types.Operator):
-    bl_idname = "bim.duplicate_clip_box"
-    bl_label = "Duplicate Clip Box"
-    bl_description = "Duplicate this clip box: copy its empty + matrix into a new entry"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty(default=-1, options={"SKIP_SAVE"})
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        source_index = self.index if self.index >= 0 else scene_props.active_clip_box_index
-        if source_index < 0 or source_index >= len(scene_props.clip_boxes):
-            return {"CANCELLED"}
-        source = scene_props.clip_boxes[source_index].obj
-        if source is None:
-            return {"CANCELLED"}
-
-        copy = tool.ClipBox.create_clip_box_empty(context, source.matrix_world.copy(), name=source.name)
-        # Preserve the source's display attrs so the duplicate matches.
-        copy.empty_display_type = source.empty_display_type
-        copy.empty_display_size = source.empty_display_size
-        copy.show_in_front = source.show_in_front
-        return {"FINISHED"}

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

@@ -1,165 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import bpy
-from bpy.types import PropertyGroup
-
-import bonsai.tool as tool
-from bonsai.bim.prop import ObjProperty
-
-
-class BIMClipBoxProperties(PropertyGroup):
-    """Per-object marker for a clip-box host empty.
-
-    The host empty's ``matrix_world`` is the single source of truth for
-    the clip box's pose and dimensions: translation = box centre,
-    rotation = box orientation, per-axis scale = world half-extents. The
-    visible cube comes from the empty's CUBE display.
-
-    Only ``is_clip_box`` lives here; visibility (``enabled``) and overlay
-    (``show_caps``) are global per-file and live on the Scene PG.
-    """
-
-    is_clip_box: bpy.props.BoolProperty(
-        default=False,
-        description="True when this empty was created as a clip-box host. Internal flag; not user-edited.",
-    )
-
-    if TYPE_CHECKING:
-        is_clip_box: bool
-
-
-def update_active_clip_box_index(self, context):
-    tool.ClipBox.schedule_refresh()
-    tool.ClipBox.select_active_clip_box(context)
-    # Rebuild caps for the new active box's clip volume.
-    tool.ClipBox.invalidate_cap_cache(immediate=True)
-
-
-def update_show_caps(self, context):
-    tool.ClipBox.schedule_refresh()
-    # Off → on must trigger a rebuild so caps reappear immediately rather
-    # than wait for the next depsgraph tick. The rebuild is a no-op when
-    # show_caps is now False (it clears and returns), so this is safe in
-    # both directions.
-    tool.ClipBox.invalidate_cap_cache()
-
-
-def update_enabled(self, context):
-    tool.ClipBox.schedule_refresh()
-
-
-def update_clip_only_ifc_products(self, context):
-    # The eligibility set for capping changed — drop the cache and let the
-    # debounced rebuild pick up the new objects on the next idle tick.
-    tool.ClipBox.invalidate_cap_cache()
-
-
-def update_include_linked_ifc(self, context):
-    tool.ClipBox.invalidate_cap_cache()
-
-
-class BIMSceneClipBoxProperties(PropertyGroup):
-    """Scene-level registry of clip boxes in this file.
-
-    Multiple boxes may exist; ``active_clip_box_index`` selects which one
-    drives the viewport clip at any time. ``enabled`` and ``show_caps``
-    are global because the user's intent ("hide everything outside the
-    box", "draw cap overlays") applies file-wide, not per box.
-
-    ``enabled`` is intentionally not persisted to the project pset:
-    opening a fresh IFC should never silently hide geometry behind a
-    remembered toggle. Selecting any clip-box empty in the viewport
-    re-arms it (see :meth:`tool.ClipBox._sync_active_to_selection`).
-    """
-
-    clip_boxes: bpy.props.CollectionProperty(type=ObjProperty)
-    active_clip_box_index: bpy.props.IntProperty(
-        default=0,
-        min=0,
-        update=update_active_clip_box_index,
-        description="Index of the clip box currently driving the viewport clip planes",
-    )
-    enabled: bpy.props.BoolProperty(
-        name="Enabled",
-        default=False,
-        update=update_enabled,
-        description="When enabled, the active clip box hides all viewport geometry outside its 6 faces",
-    )
-    show_caps: bpy.props.BoolProperty(
-        name="Show Caps",
-        default=True,
-        update=update_show_caps,
-        description=(
-            "Draw filled cross-section caps where IFC product geometry "
-            "crosses the active clip planes. Disable for performance on "
-            "very heavy scenes"
-        ),
-    )
-    # Stored on the Scene PG so Blender persists it in the .blend; deliberately
-    # NOT written to the project pset so the IFC stays portable across users
-    # who may have different Blender-side reference geometry to clip.
-    clip_only_ifc_products: bpy.props.BoolProperty(
-        name="Only IFC Products",
-        default=True,
-        update=update_clip_only_ifc_products,
-        description=(
-            "When enabled, only IFC element geometry gets cross-section caps. "
-            "Disable to also cap Blender-side reference meshes (sketches, "
-            "imported obj, primitive cubes, …)"
-        ),
-    )
-    # Opt-in inclusion of geometry sitting inside loaded Project › Links
-    # collection-instance empties. Off by default — linked IFCs commonly
-    # carry the entire site / structural / MEP context, and bisecting
-    # them on every clip-box edit can be expensive.
-    include_linked_ifc: bpy.props.BoolProperty(
-        name="Include Linked IFC",
-        default=False,
-        update=update_include_linked_ifc,
-        description=(
-            "Also generate cross-section caps for geometry inside linked "
-            "IFC files (Project ▸ Links). Off by default — linked IFCs may "
-            "carry the entire site / structural backbone, and capping them "
-            "adds per-mesh bisect cost on every clip-box edit"
-        ),
-    )
-    # Also Scene-only — gizmo visibility is a per-user editing preference,
-    # not a portable IFC property.
-    enable_gizmos: bpy.props.BoolProperty(
-        name="Show Face Handles",
-        default=True,
-        description=(
-            "Show interactive face-resize handles on the active clip box. "
-            "Disable to fall back to plain G/R/S transforms on the empty"
-        ),
-    )
-
-    if TYPE_CHECKING:
-        active_clip_box_index: int
-        enabled: bool
-        show_caps: bool
-        clip_only_ifc_products: bool
-        include_linked_ifc: bool
-        enable_gizmos: bool

src/bonsai/bonsai/bim/module/clip_box/ui.py

@@ -1,145 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.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/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-from __future__ import annotations
-
-from bpy.types import Menu, Panel, UIList
-
-import bonsai.tool as tool
-
-# Per-kind icon for the source-picker menu. Picked from Blender's built-in
-# icon set; semantically close to the kind so users can scan the menu visually.
-_SOURCE_MENU_ENTRIES: tuple[tuple[str, str, str], ...] = (
-    ("SPATIAL", "Clip Spatial Element", "OUTLINER_COLLECTION"),
-    ("CLASS", "Clip by Class", "BLANK1"),
-    ("TYPE", "Clip Type", "FILE_3D"),
-    ("MATERIAL", "Clip Material", "MATERIAL"),
-    ("PROFILE", "Clip Profile", "MESH_CIRCLE"),
-    ("DRAWING", "Clip Drawing Extents", "CAMERA_DATA"),
-    ("STATUS", "Clip by Status", "INFO"),
-    ("SYSTEM", "Clip by System", "MOD_FLUID"),
-    ("GROUP", "Clip by Group", "OUTLINER_OB_GROUP_INSTANCE"),
-    ("ZONE", "Clip by Zone", "MOD_LATTICE"),
-)
-
-
-class BIM_MT_clip_box_add_for_source(Menu):
-    bl_idname = "BIM_MT_clip_box_add_for_source"
-    bl_label = "Add Clip Box From Source"
-
-    def draw(self, context):
-        layout = self.layout
-        for kind, label, icon in _SOURCE_MENU_ENTRIES:
-            op = layout.operator("bim.add_clip_box_for_source", text=label, icon=icon)
-            op.source_kind = kind
-
-
-class BIM_MT_clip_box_settings(Menu):
-    bl_idname = "BIM_MT_clip_box_settings"
-    bl_label = "Clip Box Settings"
-
-    def draw(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        self.layout.prop(scene_props, "clip_only_ifc_products")
-        self.layout.prop(scene_props, "include_linked_ifc")
-        self.layout.prop(scene_props, "enable_gizmos")
-
-
-class BIM_MT_clip_box_info(Menu):
-    bl_idname = "BIM_MT_clip_box_info"
-    bl_label = "Clip Box Face Handles"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="Face Handles", icon="INFO")
-        layout.separator()
-        layout.label(text="Drag a face to resize the clip box on that axis.")
-        layout.label(text="The opposite face stays fixed (one-sided resize).")
-        layout.label(text="Ctrl+Click a face to align the viewport to it.")
-        layout.separator()
-        layout.label(text="Toggle handles from the Settings (gear) menu.")
-
-
-class BIM_UL_clip_box(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index, flt_flag):
-        obj = item.obj
-        row = layout.row(align=True)
-        if obj is None:
-            # Host empty was deleted from outliner; still expose the
-            # remove button so the orphan entry isn't permanent.
-            row.label(text="(missing)", icon="ERROR")
-            row.operator("bim.remove_clip_box", text="", icon="X", emboss=False).index = index
-            return
-        row.prop(obj, "name", text="", emboss=False, icon="MESH_CUBE")
-        row.operator("bim.duplicate_clip_box", text="", icon="DUPLICATE", emboss=False).index = index
-        row.operator("bim.remove_clip_box", text="", icon="X", emboss=False).index = index
-
-
-class BIM_PT_clip_box(Panel):
-    bl_idname = "BIM_PT_clip_box"
-    bl_label = "Clip Box"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_parent_id = "BIM_PT_tab_sandbox"
-
-    def draw(self, context):
-        layout = self.layout
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-
-        toggles = layout.row(align=True)
-        toggles.scale_y = 2.0
-        toggles.prop(
-            scene_props,
-            "enabled",
-            text="Enable Clipping",
-            icon="HIDE_OFF" if scene_props.enabled else "HIDE_ON",
-            toggle=True,
-        )
-        toggles.prop(scene_props, "show_caps", text="Show Caps", icon="MOD_SOLIDIFY", toggle=True)
-        toggles.menu("BIM_MT_clip_box_settings", icon="PREFERENCES", text="")
-        toggles.menu("BIM_MT_clip_box_info", icon="INFO", text="")
-
-        layout.separator()
-        row = layout.row(align=True)
-        row.operator("bim.add_clip_box", icon="ADD", text="Add Clip Box")
-        row.menu("BIM_MT_clip_box_add_for_source", icon="DOWNARROW_HLT", text="")
-
-        layout.template_list(
-            "BIM_UL_clip_box",
-            "",
-            scene_props,
-            "clip_boxes",
-            scene_props,
-            "active_clip_box_index",
-            rows=3,
-        )
-
-        obj = tool.ClipBox.get_active_clip_box(context.scene)
-        if obj is None:
-            layout.label(text="No active clip box", icon="INFO")
-            return
-
-        col = layout.column(align=True)
-        col.label(text="Edit the empty with G / R / S to move / rotate / resize")
-        col.prop(obj, "location")
-        col.prop(obj, "rotation_euler")
-        col.prop(obj, "scale")

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

@@ -159,38 +159,6 @@ _SPECIAL = {"=", " "}  # Formula prefix, spaces
 NUMERIC_INPUT_CHARS = _DIGITS | _OPERATORS | _METRIC_UNITS | _IMPERIAL_UNITS | _SPECIAL
 
 
-def _is_transform_modal_active(context) -> bool:
-    """Module-local alias for ``tool.Blender.is_transform_modal_active``.
-
-    Preserved as a name so AST scans and call sites in this file stay
-    decoupled from the helper's home module.
-    """
-    return tool.Blender.is_transform_modal_active(context)
-
-
-def _hide_all_non_modal_gizmos(group) -> None:
-    """Set ``hide = True`` on every gizmo in ``group`` whose own ``is_modal``
-    is False. Used by parametric ``draw_prepare`` to suppress visible
-    re-positioning while a transform modal is dragging ``matrix_world``."""
-    for gz in group.gizmos:
-        if not getattr(gz, "is_modal", False):
-            gz.hide = True
-
-
-def apply_transform_modal_draw_gate(group, context) -> bool:
-    """Combined gate for ``draw_prepare`` overrides: hide non-modal gizmos and
-    return ``True`` when a Blender transform modal is dragging matrix_world.
-
-    Returns ``False`` when no transform modal is active so callers can fall
-    through to their normal positioning logic. ``True`` means the caller must
-    early-return without touching matrix_basis — the hidden gizmos will be
-    re-shown on the next idle frame once the modal exits."""
-    if not _is_transform_modal_active(context):
-        return False
-    _hide_all_non_modal_gizmos(group)
-    return True
-
-
 class GizmoColor(Enum):
     """Color identifiers for dimension gizmos.
 
@@ -1726,33 +1694,6 @@ def billboarded_at(world_pos: Vector, billboard_rot: Matrix, scale: float = DEFA
     return Matrix.Translation(world_pos) @ billboard_rot @ Matrix.Scale(scale, 4)
 
 
-def billboarded_along_axis(
-    world_pos: Vector,
-    billboard_rot: Matrix,
-    axis_world: Vector,
-    scale: float = DEFAULT_BILLBOARD_SCALE,
-) -> Matrix:
-    """Composed matrix_basis like ``billboarded_at`` but with local +X
-    rotated about the camera-forward axis to align with ``axis_world``
-    projected onto the screen plane.
-
-    The gizmo still faces the camera (local +Z stays along camera-forward),
-    only its in-plane orientation changes. Falls back to plain
-    ``billboarded_at`` when the axis is near-parallel to the view direction
-    (no usable screen projection)."""
-    camera_forward = billboard_rot @ Vector((0.0, 0.0, 1.0))
-    projected = axis_world - camera_forward * axis_world.dot(camera_forward)
-    if projected.length < 1e-4:
-        return billboarded_at(world_pos, billboard_rot, scale)
-    projected.normalize()
-    y_axis = camera_forward.cross(projected).normalized()
-    rot = Matrix.Identity(4)
-    rot[0][:3] = (projected.x, y_axis.x, camera_forward.x)
-    rot[1][:3] = (projected.y, y_axis.y, camera_forward.y)
-    rot[2][:3] = (projected.z, y_axis.z, camera_forward.z)
-    return Matrix.Translation(world_pos) @ rot @ Matrix.Scale(scale, 4)
-
-
 def get_screen_up(billboard_rot: Matrix) -> Vector:
     """Camera's screen-up direction in world space — local +Y of the billboard
     rotation. Use to lift a gizmo above an anchor in a way that stays
@@ -3314,16 +3255,11 @@ class GizmoArc(StaticTrisGizmoMixin, bpy.types.Gizmo):
     """Static quarter-arc glyph for swing visualisation.
 
     Consumers needing the mirrored (RIGHT) visual apply a flip-X matrix to
-    ``matrix_basis``. ``outline_alpha = 0.0`` suppresses the inherited 8-pass
-    dark halo: an open curve has no enclosed silhouette for the dilation to
-    ring, so the offset passes read as ghost arcs rather than a uniform
-    outline. The arc's own cross-section thickness keeps it legible without
-    the halo."""
+    ``matrix_basis``."""
 
     bl_idname = "VIEW3D_GT_arc"
     __slots__ = ("custom_shape",)
     tris = ARC_TRIS_DEFAULT
-    outline_alpha = 0.0
 
 
 def _link_toggle_icon_tris(broken: bool) -> tuple[tuple[float, float, float], ...]:
@@ -4850,14 +4786,7 @@ class GizmoDimension(GizmoMovable):
 
         self.init_value = click_distance
 
-        # Schematic gizmos opt out of dimension snap. Force the header
-        # indicator to ``off`` for the drag's duration so the user sees the
-        # state matches behaviour; ``exit`` restores ``initial_snap_state``.
-        # Skipping the snap cache here also avoids the per-drag mesh probe.
-        snap_supported = getattr(self.gizmo_group, "snap_enabled_on_dimensions", True)
-        if not snap_supported:
-            context.scene.tool_settings.use_snap = False
-        elif self.initial_snap_state and self.active_obj:
+        if self.initial_snap_state and self.active_obj:
             build_snap_cache(context, self.active_obj)
             self._snap_cache_built = True
 
@@ -4899,18 +4828,11 @@ class GizmoDimension(GizmoMovable):
         if not region or not rv3d:
             return {"RUNNING_MODAL"}
 
-        # Group-level opt-out: schematic gizmos float in viewport space, so
-        # global-snap-to-scene-vertices would produce spurious value jumps.
-        # The fallback (``True``) covers any gizmo whose group is not a
-        # ``BaseParametricGizmoGroup``.
-        snap_supported = getattr(self.gizmo_group, "snap_enabled_on_dimensions", True)
+        tool_settings.use_snap = not self.initial_snap_state if event.ctrl else self.initial_snap_state
 
-        if snap_supported:
-            tool_settings.use_snap = not self.initial_snap_state if event.ctrl else self.initial_snap_state
-
-            if tool_settings.use_snap and not self._snap_cache_built and self.active_obj:
-                build_snap_cache(context, self.active_obj)
-                self._snap_cache_built = True
+        if tool_settings.use_snap and not self._snap_cache_built and self.active_obj:
+            build_snap_cache(context, self.active_obj)
+            self._snap_cache_built = True
 
         current_coord = (event.mouse_region_x, event.mouse_region_y)
 
@@ -4934,7 +4856,7 @@ class GizmoDimension(GizmoMovable):
 
         delta = (current_3d - self.start_location).dot(axis_direction)
 
-        if snap_supported and tool_settings.use_snap and self.active_obj:
+        if tool_settings.use_snap and self.active_obj:
             # Snap the dimension tip (not mouse position) to target
             # Calculate where the dimension tip would be with current delta
             # The tip is at: gizmo_origin + axis * (init_value + delta)
@@ -5076,8 +4998,6 @@ class BillboardingGizmoGroupMixin:
         self.position_gizmos(context)
 
     def draw_prepare(self, context: bpy.types.Context) -> None:
-        if apply_transform_modal_draw_gate(self, context):
-            return
         self.position_gizmos(context)
 
     def setup_icon_gizmo(
@@ -5307,13 +5227,6 @@ class BaseParametricGizmoGroup:
     # Pre-computed flip matrix for negative value handling (180° rotation around Z)
     FLIP_MATRIX = Matrix.Rotation(math.pi, 4, "Z")
 
-    # Default: dimension drags respect Blender's global snap (Ctrl-toggleable
-    # during drag). Subclasses whose dimensions float in viewport space rather
-    # than aligning to real-world geometry should override to ``False`` —
-    # snapping to scene vertices in that case produces spurious value jumps
-    # as the mouse crosses unrelated meshes.
-    snap_enabled_on_dimensions: bool = True
-
     # === Icon Gizmo Layout (meters) ===
     # Icons are positioned in a horizontal row above the element:
     #   [Validate] [Cancel] [Cycle]
@@ -5739,8 +5652,6 @@ class BaseParametricGizmoGroup:
 
         if preview_base.any_preview_active(context):
             return False
-        if _is_transform_modal_active(context):
-            return False
         if cls.gizmo_pref_name:
             prefs = tool.Blender.get_addon_preferences()
             if not getattr(prefs.gizmos, cls.gizmo_pref_name, True):
@@ -6505,8 +6416,6 @@ class BaseParametricGizmoGroup:
         """
         if not self.is_setup_complete():
             return
-        if apply_transform_modal_draw_gate(self, context):
-            return
         obj = context.active_object
         if not obj:
             return
@@ -6574,11 +6483,6 @@ class BaseSchematicGizmoGroup(BaseParametricGizmoGroup):
     # list and become no-ops. The schematic equivalents below take their place.
     dimension_gizmo_props: list[DimensionGizmoConfig] = []
 
-    # Schematic dimensions float in billboarded viewport space, not aligned to
-    # real-world geometry. Snapping the dragged tip to scene vertices would
-    # produce nonsensical value jumps as the mouse crosses unrelated meshes.
-    snap_enabled_on_dimensions: bool = False
-
     # Declarative dimension configuration consumed by ``setup_schematic_dimensions``
     # and ``update_schematic_dimensions``. Each config produces one
     # ``BIM_GT_gizmo_dimension`` instance positioned at a schematic-local
@@ -6718,8 +6622,6 @@ class BaseSchematicGizmoGroup(BaseParametricGizmoGroup):
     def draw_prepare(self, context: bpy.types.Context) -> None:
         if not self.is_setup_complete():
             return
-        if apply_transform_modal_draw_gate(self, context):
-            return
         obj = context.active_object
         if not obj:
             return
@@ -7126,8 +7028,6 @@ class BaseIconActionGroup(BillboardingGizmoGroupMixin):
             return False
         if not tool.Blender.are_viewport_gizmos_enabled():
             return False
-        if _is_transform_modal_active(context):
-            return False
         return cls.is_eligible_object(obj)
 
     def setup(self, context: bpy.types.Context) -> None:

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

@@ -50,9 +50,6 @@ def set_active_camera_resolution(scene: bpy.types.Scene) -> None:
     if camera.type != props.camera_type:
         camera.type = props.camera_type
 
-    if props.update_props and (drawing := tool.Ifc.get_entity(camera_obj)):
-        tool.Drawing.sync_perspective_camera_shifts(drawing, camera)
-
     ortho_scale, aspect_ratio = props.get_scale_and_aspect_ratio()
     scene_render = scene.render
     if (camera.ortho_scale != ortho_scale) or not tool.Cad.is_x(

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

@@ -57,7 +57,7 @@ import shapely
 from bpy_extras.image_utils import load_image
 from bpy_extras.io_utils import ImportHelper
 from lxml import etree
-from mathutils import Color, Matrix, Vector
+from mathutils import Color, Vector
 
 import bonsai.bim.export_ifc
 import bonsai.bim.handler
@@ -602,7 +602,6 @@ class CreateDrawing(bpy.types.Operator):
         context_type: Literal["body", "annotation"],
         drawing_elements: set[ifcopenshell.entity_instance],
         target_view: str,
-        link_matrix: Optional[Matrix] = None,
     ) -> None:
         drawing_elements = drawing_elements.copy()
         contexts_: list[list[int]] = getattr(contexts, context_type)
@@ -614,19 +613,9 @@ class CreateDrawing(bpy.types.Operator):
                 geom_settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
                 geom_settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.NATIVE)
 
-                is_plan = ifc.by_id(context[0]).ContextType == "Plan" and "PLAN_VIEW" in target_view
-                z_offset = (0.002 if target_view == "PLAN_VIEW" else -0.002) if is_plan else 0.0
-
-                if link_matrix is not None:
-                    unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc)
-                    t = link_matrix.to_translation()
-                    offset = (t.x / unit_scale, t.y / unit_scale, t.z / unit_scale + z_offset)
-                    geom_settings.set("model-offset", offset)
-                    q = link_matrix.to_quaternion()
-                    geom_settings.set("model-rotation", (q.x, q.y, q.z, q.w))
-                elif z_offset:
+                if ifc.by_id(context[0]).ContextType == "Plan" and "PLAN_VIEW" in target_view:
                     # A 2mm Z offset to combat Z-fighting in plan or RCPs
-                    geom_settings.set("model-offset", (0.0, 0.0, z_offset))
+                    geom_settings.set("model-offset", (0.0, 0.0, 0.002 if target_view == "PLAN_VIEW" else -0.002))
 
                 geom_settings.set("context-ids", context)
                 it = ifcopenshell.geom.iterator(
@@ -934,16 +923,11 @@ class CreateDrawing(bpy.types.Operator):
 
         bim_props = tool.Blender.get_bim_props()
         prefs = tool.Blender.get_addon_preferences()
-        # Map ifc_path → (ifc_file, link_matrix); main file has no link_matrix (None)
-        files: dict[str, tuple[ifcopenshell.file, Optional[Matrix]]] = {bim_props.ifc_file: (tool.Ifc.get(), None)}
+        files = {bim_props.ifc_file: tool.Ifc.get()}
 
         props = tool.Project.get_project_props()
         for link in props.get_loaded_links_for_drawings():
-            try:
-                link_matrix = tool.Project.calculate_link_matrix(link)
-            except Exception:
-                link_matrix = None
-            files[link.filepath] = (self.get_linked_file(link), link_matrix)
+            files[link.filepath] = self.get_linked_file(link)
 
         target_view = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]["TargetView"]
         self.setup_serialiser(target_view)
@@ -951,13 +935,7 @@ class CreateDrawing(bpy.types.Operator):
         tree = ifcopenshell.geom.tree()
         tree.enable_face_styles(True)
 
-        # Accumulated across every file in the loop below (main model plus any
-        # linked models) so the SHAPELY fill pass after the loop covers all of
-        # them, not just whichever file happened to be processed last.
-        raycast_objs = set()
-        elements_with_faces = set()
-
-        for ifc_path, (ifc, link_matrix) in files.items():
+        for ifc_path, ifc in files.items():
             # Don't use draw.main() just whilst we're prototyping and experimenting
             # TODO: hash paths are never used
             ifc_hash = hashlib.md5(ifc_path.encode("utf-8")).hexdigest()
@@ -966,22 +944,13 @@ class CreateDrawing(bpy.types.Operator):
             self.serialiser.setFile(ifc)
             drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element, ifc_file=ifc)
 
-            if self.cprops.fill_mode == "SHAPELY":
-                for element in drawing_elements.copy():
-                    if element.is_a("IfcAnnotation"):
-                        continue
-                    obj = tool.Ifc.get_object(element)
-                    if obj and obj.type == "MESH" and len(obj.data.polygons):
-                        elements_with_faces.add(element.GlobalId)
-                        raycast_objs.add(obj)
-
             # Get all representation contexts to see what we're dealing with.
             # Drawings only draw bodies and annotations (and facetation, due to a Revit bug).
             # A drawing prioritises a target view context first, followed by a model view context as a fallback.
             # Specifically for PLAN_VIEW and REFLECTED_PLAN_VIEW, any Plan context is also prioritised.
             contexts = self.get_linework_contexts(ifc, target_view)
-            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view, link_matrix)
-            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view, link_matrix)
+            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view)
+            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view)
 
             if tool.Ifc.get() == ifc and self.camera_element not in drawing_elements:
                 with profile("Camera element"):
@@ -1048,6 +1017,16 @@ class CreateDrawing(bpy.types.Operator):
             # shapely variant
             group = root.find("{http://www.w3.org/2000/svg}g")
 
+            raycast_objs = set()
+            elements_with_faces = set()
+            for element in drawing_elements.copy():
+                if element.is_a("IfcAnnotation"):
+                    continue
+                obj = tool.Ifc.get_object(element)
+                if obj and obj.type == "MESH" and len(obj.data.polygons):
+                    elements_with_faces.add(element.GlobalId)
+                    raycast_objs.add(obj)
+
             projections = root.xpath(
                 ".//svg:g[contains(@class, 'projection')]", namespaces={"svg": "http://www.w3.org/2000/svg"}
             )
@@ -2340,8 +2319,7 @@ class ActivateDrawingBase(tool.Ifc.Operator):
     bl_description = (
         "Activates the selected drawing view.\n\n"
         + "ALT+CLICK to keep the viewport position.\n\n"
-        + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views"
+        + "SHIFT+CLICK to load a quick preview of the drawing view"
     )
 
     drawing: bpy.props.IntProperty()
@@ -2357,23 +2335,13 @@ class ActivateDrawingBase(tool.Ifc.Operator):
         default=False,
         options={"SKIP_SAVE"},
     )
-    load_selected_annotations: bpy.props.BoolProperty(
-        name="Load Selected Annotations",
-        description="Load the annotations of all selected drawings without switching the active view.",
-        default=False,
-        options={"SKIP_SAVE"},
-    )
 
     if TYPE_CHECKING:
         drawing: int
         should_view_from_camera: bool
         use_quick_preview: bool
-        load_selected_annotations: bool
 
     def invoke(self, context, event) -> set["rna_enums.OperatorReturnItems"]:
-        if event.type == "LEFTMOUSE" and event.shift and event.ctrl:
-            self.load_selected_annotations = True
-            return self.execute(context)
         if event.type == "LEFTMOUSE" and event.alt:
             self.should_view_from_camera = False
         if event.type == "LEFTMOUSE" and event.shift:
@@ -2386,18 +2354,6 @@ class ActivateDrawingBase(tool.Ifc.Operator):
         if props.is_editing_drawings == False:
             bpy.ops.bim.load_drawings()
 
-        if self.load_selected_annotations:
-            for d in props.drawings:
-                if not (d.is_drawing and d.is_selected):
-                    continue
-                selected_drawing = tool.Ifc.get().by_id(d.ifc_definition_id)
-                # Importing the camera (if missing) ensures the drawing's
-                # collection exists so the annotations get collected into it.
-                if not tool.Ifc.get_object(selected_drawing):
-                    tool.Drawing.import_drawing(selected_drawing)
-                tool.Drawing.import_annotations_in_group(tool.Drawing.get_drawing_group(selected_drawing))
-            return {"FINISHED"}
-
         drawing = tool.Ifc.get().by_id(self.drawing)
         dprops = tool.Drawing.get_document_props()
 
@@ -2483,8 +2439,7 @@ class ActivateDrawing(bpy.types.Operator, ActivateDrawingBase):
     bl_description = (
         "Activates the selected drawing view.\n\n"
         + "ALT+CLICK to keep the viewport position.\n\n"
-        + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views"
+        + "SHIFT+CLICK to load a quick preview of the drawing view"
     )
 
 

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

@@ -604,7 +604,6 @@ class BIMCameraProperties(PropertyGroup):
         return tool.Blender.get_active_uilist_element(dprops.drawing_styles, self.active_drawing_style_index)
 
     # For now, this JSON dump are all the parameters that determine a camera's "Block representation"
-    # Perspective camera shift is stored in EPset_Drawing and intentionally excluded here.
     # By checking this, you will know whether or not the camera IFC representation needs to be refreshed
     def update_representation(self, matrix_world: Matrix) -> bool:
         """Update ``representation`` based on current camera properties and the provided world matrix.

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

@@ -99,10 +99,6 @@ class BIM_PT_camera(Panel):
         if props.target_view == "MODEL_VIEW":
             row = self.layout.row()
             row.prop(props, "camera_type")
-            if props.camera_type == "PERSP":
-                row = self.layout.row(align=True)
-                row.prop(camera_data, "shift_x", text="Camera Shift X/Y:")
-                row.prop(camera_data, "shift_y", text="")
 
         row = self.layout.row()
         row.prop(props, "linework_mode")

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

@@ -16,6 +16,8 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
+from collections.abc import Sequence
+
 import blf
 import bpy
 import gpu
@@ -23,16 +25,15 @@ import ifcopenshell
 import numpy as np
 from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Matrix, Vector
 
 import bonsai.tool as tool
 
 
-class ItemDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw", "POST_VIEW"),
-    )
+class ItemDecorator:
+    is_installed = False
+    handlers = []
     objs: dict[str, dict[str, list]]
     obj_is_selected: dict[str, bool]
     obj_is_boolean: dict[str, list[ifcopenshell.entity_instance]]
@@ -118,6 +119,23 @@ class ItemDecorator(tool.Blender.ViewportDecorator):
             "special_edges": special_edges,
         }
 
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
     def draw_text(self, context):
         self.addon_prefs = tool.Blender.get_addon_preferences()
         selected_elements_color = self.addon_prefs.decorator_color_selected
@@ -145,6 +163,11 @@ class ItemDecorator(tool.Blender.ViewportDecorator):
         blf.disable(font_id, blf.SHADOW)
 
     def draw(self, context: bpy.types.Context) -> None:
+        def transparent_color(color: Sequence[float], alpha: float = 0.05) -> list[float]:
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
         self.addon_prefs = tool.Blender.get_addon_preferences()
         selected_elements_color = self.addon_prefs.decorator_color_selected
         unselected_elements_color = self.addon_prefs.decorator_color_unselected
@@ -174,33 +197,15 @@ class ItemDecorator(tool.Blender.ViewportDecorator):
                     if context.mode != "OBJECT":
                         continue
                     self.draw_batch("LINES", data["verts"], selected_elements_color, data["edges"])
-                    self.draw_batch(
-                        "TRIS",
-                        data["verts"],
-                        tool.Blender.transparent_color(selected_elements_color, alpha=0.05),
-                        data["tris"],
-                    )
+                    self.draw_batch("TRIS", data["verts"], transparent_color(selected_elements_color), data["tris"])
                     self.draw_batch("LINES", data["special_verts"], selected_elements_color, data["special_edges"])
                 elif self.obj_is_boolean[obj_name]:
                     self.draw_batch("LINES", data["verts"], special_elements_color, data["edges"])
-                    self.draw_batch(
-                        "TRIS",
-                        data["verts"],
-                        tool.Blender.transparent_color(special_elements_color, alpha=0.05),
-                        data["tris"],
-                    )
+                    self.draw_batch("TRIS", data["verts"], transparent_color(special_elements_color), data["tris"])
                     self.draw_batch("LINES", data["special_verts"], special_elements_color, data["special_edges"])
                 else:
                     self.draw_batch(
-                        "LINES",
-                        data["verts"],
-                        tool.Blender.transparent_color(unselected_elements_color, alpha=0.2),
-                        data["edges"],
-                    )
-                    self.draw_batch(
-                        "TRIS",
-                        data["verts"],
-                        tool.Blender.transparent_color(special_elements_color, alpha=0.05),
-                        data["tris"],
+                        "LINES", data["verts"], transparent_color(unselected_elements_color, alpha=0.2), data["edges"]
                     )
+                    self.draw_batch("TRIS", data["verts"], transparent_color(special_elements_color), data["tris"])
                     self.draw_batch("LINES", data["special_verts"], special_elements_color, data["special_edges"])

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

@@ -546,13 +546,6 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
         objs = [bpy.data.objects[obj_name]] if obj_name else context.selected_objects
         self.file = tool.Ifc.get()
 
-        # Tessellated face sets (IfcTriangulatedFaceSet/IfcPolygonalFaceSet) were
-        # introduced in IFC4 and do not exist in IFC2X3. Catch this early so we
-        # don't silently fall back to a faceted brep after stripping materials.
-        if self.ifc_representation_class == "IfcTessellatedFaceSet" and self.file.schema == "IFC2X3":
-            self.report({"ERROR"}, "Tessellated face sets are not supported in IFC2X3.")
-            return {"CANCELLED"}
-
         for obj in objs:
             # TODO: write unit tests to see how this bulk operation handles
             # contradictory ifc_representation_class values and when
@@ -890,16 +883,6 @@ class OverrideDelete(bpy.types.Operator):
         # Track aggregates before deleting their parts
         aggregates_to_check = self.track_aggregates(objects_to_remove)
 
-        # Snapshot the set of IFC entity ids being deleted in this batch so the
-        # connection-rel cascade inside `delete_ifc_object` can suppress
-        # partner-side regenerate when the partner is also about to vanish.
-        batch_being_deleted_ids: set[int] = set()
-        for obj in objects_to_remove:
-            if not tool.Blender.is_valid_data_block(obj):
-                continue
-            if (entity := tool.Ifc.get_entity(obj)) is not None:
-                batch_being_deleted_ids.add(entity.id())
-
         clear_active_object = True
 
         for i, obj in enumerate(objects_to_remove, 1):
@@ -941,7 +924,7 @@ class OverrideDelete(bpy.types.Operator):
                 if tool.Drawing.is_auto_annotation(element):
                     self.report({"INFO"}, "References cannot be deleted. Exclude the referenced element instead.")
                     continue
-                tool.Geometry.delete_ifc_object(obj, batch_being_deleted_ids=batch_being_deleted_ids)
+                tool.Geometry.delete_ifc_object(obj)
             elif tool.Geometry.is_representation_item(obj):
                 tool.Geometry.delete_ifc_item(obj)
             else:
@@ -1040,10 +1023,7 @@ class OverrideDelete(bpy.types.Operator):
             pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
             if not pset:
                 continue
-            try:
-                array_parents.add(ifc_file.by_guid(pset["Parent"]))
-            except RuntimeError:
-                continue
+            array_parents.add(ifc_file.by_guid(pset["Parent"]))
 
         for array_parent in array_parents:
             array_parent_obj = tool.Ifc.get_object(array_parent)
@@ -3186,7 +3166,7 @@ class EnableEditingRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
                 product_reps = element.RepresentationMaps
             item_aspect = {}
             for product_rep in product_reps:
-                for aspect in getattr(product_rep, "HasShapeAspects", ()):
+                for aspect in product_rep.HasShapeAspects:
                     for aspect_rep in aspect.ShapeRepresentations:
                         if aspect_rep.ContextOfItems != representation.ContextOfItems:
                             continue

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

@@ -17,9 +17,9 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-import ifcopenshell.util.unit
 from bpy.types import Menu, Panel, UIList
 
+import ifcopenshell.util.unit
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import prop_with_search

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

@@ -21,6 +21,7 @@ from math import radians
 import blf
 import gpu
 import ifcopenshell.util.geolocation
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
 from gpu_extras.batch import batch_for_shader
 from mathutils import Matrix, Vector
@@ -29,11 +30,27 @@ import bonsai.tool as tool
 from bonsai.bim.module.georeference.data import GeoreferenceData
 
 
-class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw_geometry", "POST_VIEW"),
-    )
+class GeoreferenceDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
 
     def draw_batch(self, shader_type, content_pos, color, indices=None, should_scale=True):
         if not tool.Blender.validate_shader_batch_data(content_pos, indices):
@@ -180,10 +197,6 @@ class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
         decorator_color_error = self.addon_prefs.decorator_color_error
 
         gpu.state.blend_set("ALPHA")
-        # The georef gizmo is a coordinate-system overlay: it must communicate
-        # orientation regardless of model contents, so depth testing is bypassed.
-        original_depth_test = gpu.state.depth_test_get()
-        gpu.state.depth_test_set("ALWAYS")
 
         self.line_shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
         self.line_shader.bind()  # required to be able to change uniforms of the shader
@@ -322,8 +335,6 @@ class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
                 self.draw_batch("LINES", verts, decorator_color_special, edges)
                 self.draw_dashed_line(location * 3, location * 6, decorator_color_error)
 
-        gpu.state.depth_test_set(original_depth_test)
-
     def draw_dashed_line(self, start, end, colour, should_scale=True):
         direction = (end - start).normalized()
         distance = (end - start).length

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

@@ -20,18 +20,44 @@
 import blf
 import bpy
 import gpu
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Matrix, Vector
 
 import bonsai.tool as tool
 from bonsai.bim.module.light.data import SolarData
 
 
-class SolarDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw_geometry", "POST_VIEW"),
-    )
+class SolarDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
 
     def draw_text(self, context: bpy.types.Context) -> None:
         self.addon_prefs = tool.Blender.get_addon_preferences()

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

@@ -33,7 +33,6 @@ from . import (
     handler,
     host_add_opening_gizmo,
     mep,
-    mep_bend_preview,
     opening,
     product,
     profile,
@@ -85,7 +84,6 @@ classes = (
     product.SetActiveType,
     workspace.Hotkey,
     workspace.BIM_MT_add_representation_item,
-    wall.AddPerpendicularWall,
     wall.AddWallsFromSlab,
     wall.AlignWall,
     wall.CancelEditingWall,
@@ -110,9 +108,6 @@ classes = (
     wall.GizmoWallFilletPreview,
     wall.GizmoWallFilletReedit,
     wall.GizmoWallFilletToggleOpenings,
-    wall.GizmoPairDisconnect,
-    wall.GizmoSlabEdition,
-    wall.GizmoSlabUnjoinWalls,
     wall.GizmoWallJoinIntersection,
     wall.GizmoWallLinkToggle,
     wall.GizmoWallUnjoinSingle,
@@ -123,7 +118,7 @@ classes = (
     wall.RotateWall90,
     wall.SplitWall,
     wall.SplitWallAtCursor,
-    wall.DisconnectElements,
+    wall.UnjoinWallPathConnection,
     wall.UnjoinWalls,
     wall.EnableWallFilletPreview,
     wall.FinishWallFilletPreview,
@@ -157,14 +152,11 @@ classes = (
     slab.DisableEditingExtrusionProfile,
     slab.DisableEditingSketchExtrusionProfile,
     slab.AddSlabFromWall,
-    slab.CancelEditingSlab,
     slab.DrawPolylineSlab,
     slab.EditExtrusionProfile,
     slab.EditSketchExtrusionProfile,
     slab.EnableEditingExtrusionProfile,
     slab.EnableEditingSketchExtrusionProfile,
-    slab.EnableEditingSlab,
-    slab.FinishEditingSlab,
     slab.RecalculateSlab,
     slab.ResetVertex,
     slab.SetArcIndex,
@@ -191,16 +183,11 @@ classes = (
     prop.BIMDoorProperties,
     prop.BIMRailingProperties,
     prop.BIMRoofProperties,
-    prop.BIMSlabProperties,
     prop.BIMWallProperties,
-    prop.BIMPipeSegmentProperties,
-    prop.BIMDuctSegmentProperties,
     prop.BIMPolylineProperties,
     prop.BIMExternalParametricGeometryProperties,
-    prop.BIMBendPreviewProperties,
     prop.BIMWallFilletPreviewProperties,
     prop.BIMPreviewProperties,
-    prop.BIMParametricEditDialogPrefs,
     ui.BIM_PT_array,
     ui.BIM_PT_stair,
     ui.BIM_PT_wall,
@@ -253,13 +240,9 @@ classes = (
     railing.CopyRailingParameters,
     railing.AddRailing,
     railing.CancelEditingRailing,
-    railing.CycleRailingType,
     railing.FinishEditingRailing,
-    railing.PickRailingTerminalType,
     railing.FlipRailingPathOrder,
     railing.EnableEditingRailing,
-    railing.GizmoRailingSchematic,
-    railing.ToggleRailingUseManualSupports,
     railing.CancelEditingRailingPath,
     railing.FinishEditingRailingPath,
     railing.EnableEditingRailingPath,
@@ -280,27 +263,6 @@ classes = (
     mep.MEPAddObstruction,
     mep.MEPAddTransition,
     mep.MEPAddBend,
-    mep.MEPRemoveTerminalFitting,
-    mep.SelectMEPPathMembers,
-    mep.MEPJoinSegments,
-    mep_bend_preview.EnableBendPreview,
-    mep_bend_preview.FinishBendPreview,
-    mep_bend_preview.CancelBendPreview,
-    mep_bend_preview.EnableBendPreviewFromBend,
-    mep_bend_preview.GizmoBendPreview,
-    mep.EnableEditingPipeSegment,
-    mep.FinishEditingPipeSegment,
-    mep.CancelEditingPipeSegment,
-    mep.EnableEditingDuctSegment,
-    mep.FinishEditingDuctSegment,
-    mep.CancelEditingDuctSegment,
-    mep.ExtendPipeSegmentToCursor,
-    mep.ExtendDuctSegmentToCursor,
-    mep.SplitPipeSegmentAtCursor,
-    mep.SplitDuctSegmentAtCursor,
-    mep.GizmoPipeSegmentEdition,
-    mep.GizmoDuctSegmentEdition,
-    mep.GizmoMEPActions,
     external.ApplyExternalParametricGeometry,
 )
 
@@ -360,9 +322,6 @@ def register():
         type=prop.BIMExternalParametricGeometryProperties
     )
     bpy.types.Scene.BIMPreviewProperties = bpy.props.PointerProperty(type=prop.BIMPreviewProperties)
-    bpy.types.WindowManager.BIMParametricEditDialogPrefs = bpy.props.PointerProperty(
-        type=prop.BIMParametricEditDialogPrefs
-    )
 
     bpy.types.VIEW3D_MT_add.prepend(ui.add_menu)
     bpy.app.handlers.load_post.append(handler.load_post)
@@ -377,11 +336,6 @@ def unregister():
     # half-unloaded module state.
     opening.DecorationsHandler.uninstall()
 
-    # Network path overlays attach SpaceView3D draw handlers on toggle;
-    # uninstall here so addon disable / Blender shutdown doesn't leak them.
-    decorator.MEPSystemPathDecorator.uninstall()
-    decorator.WallSystemPathDecorator.uninstall()
-
     if not bpy.app.background:
         for tool_data in reversed(tools):
             bpy.utils.unregister_tool(tool_data.tool)
@@ -393,7 +347,6 @@ def unregister():
     tool.Parametric.unregister_object_properties()
     del bpy.types.Object.BIMExternalParametricGeometryProperties
     del bpy.types.Scene.BIMPreviewProperties
-    del bpy.types.WindowManager.BIMParametricEditDialogPrefs
 
     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

@@ -15,8 +15,6 @@
 #
 # 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 modified with the assistance of an AI coding tool.
 
 import json
 from typing import ClassVar
@@ -329,7 +327,6 @@ class _ArrayEditMixin(ParametricEditMixinBase):
         # Unhide the (possibly newly-regenerated) children so the user sees
         # the committed result. Mirrors the hide in ``_enable_one``.
         cls._set_children_visibility(element, hidden=False)
-        tool.Array.select_only_parent(obj, context)
 
     @classmethod
     def _cancel_one(cls, obj: bpy.types.Object) -> None:
@@ -422,28 +419,18 @@ class RegenerateArray(bpy.types.Operator, tool.Ifc.Operator):
         pset = ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array")
         arrays = json.loads(pset["Data"])
         pset = tool.Ifc.get().by_id(pset["id"])
-        # Coalesce host recuts across the child-delete loop, the regenerate,
-        # and the per-child opening mirror: each fans out its own host body
-        # recut without the batch wrapper.
-        with tool.Geometry.batch_host_recut():
-            for array in arrays:
-                for child in set(array["children"]):
-                    try:
-                        child_element = tool.Ifc.get().by_guid(child)
-                    except RuntimeError:
-                        continue
-                    if child_obj := tool.Ifc.get_object(child_element):
-                        tool.Geometry.delete_ifc_object(child_obj)
-                array["children"].clear()
-            # Always operate on the parent — this operator can be invoked with
-            # either the parent OR any array child as active_object (the per-child
-            # gizmo group fires it from a child selection). Using ``obj`` /
-            # ``element`` directly would feed a child to ``regenerate_array`` and
-            # constrain children against a sibling, silently corrupting the array.
-            tool.Model.regenerate_array(parent, arrays)
-            tool.Array.constrain_children_to_parent(parent_element)
-
-        tool.Array.select_only_parent(parent, context)
+        for array in arrays:
+            for child in set(array["children"]):
+                if child_obj := tool.Ifc.get_object(tool.Ifc.get().by_guid(child)):
+                    tool.Geometry.delete_ifc_object(child_obj)
+            array["children"].clear()
+        # Always operate on the parent — this operator can be invoked with
+        # either the parent OR any array child as active_object (the per-child
+        # gizmo group fires it from a child selection). Using ``obj`` /
+        # ``element`` directly would feed a child to ``regenerate_array`` and
+        # constrain children against a sibling, silently corrupting the array.
+        tool.Model.regenerate_array(parent, arrays)
+        tool.Array.constrain_children_to_parent(parent_element)
 
 
 class RemoveArray(bpy.types.Operator, tool.Ifc.Operator):
@@ -478,24 +465,23 @@ class RemoveArray(bpy.types.Operator, tool.Ifc.Operator):
         except:
             return {"FINISHED"}
 
-        with tool.Geometry.batch_host_recut():
-            if self.keep_objs:
-                tool.Array.bake_children_transform(element, self.item)
-                tool.Array.set_children_lock_state(element, self.item, False)
+        if self.keep_objs:
+            tool.Array.bake_children_transform(element, self.item)
+            tool.Array.set_children_lock_state(element, self.item, False)
 
-            if not self.keep_objs:
-                data[self.item]["count"] = 1
-            tool.Array.remove_constraints(parent_element)
-            tool.Model.regenerate_array(parent, data, array_layers_to_apply=[self.item] if self.keep_objs else [])
+        if not self.keep_objs:
+            data[self.item]["count"] = 1
+        tool.Array.remove_constraints(parent_element)
+        tool.Model.regenerate_array(parent, data, array_layers_to_apply=[self.item] if self.keep_objs else [])
 
-            pset = tool.Pset.get_element_pset(element, "BBIM_Array")
-            if len(data) == 1:
-                ifcopenshell.api.pset.remove_pset(tool.Ifc.get(), product=element, pset=pset)
-            else:
-                del data[self.item]
-                data = tool.Ifc.get().createIfcText(json.dumps(data))
-                ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": data})
-                tool.Array.constrain_children_to_parent(element)
+        pset = tool.Pset.get_element_pset(element, "BBIM_Array")
+        if len(data) == 1:
+            ifcopenshell.api.pset.remove_pset(tool.Ifc.get(), product=element, pset=pset)
+        else:
+            del data[self.item]
+            data = tool.Ifc.get().createIfcText(json.dumps(data))
+            ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": data})
+            tool.Array.constrain_children_to_parent(element)
 
 
 class SelectArrayParent(bpy.types.Operator):
@@ -895,36 +881,6 @@ class EnableEditingParametric(bpy.types.Operator):
         default="",
         description="Operator bl_idname to invoke (e.g., 'bim.enable_editing_door').",
     )
-    sibling_count: bpy.props.IntProperty(default=0, options={"HIDDEN"})
-
-    @staticmethod
-    def should_show_shared_rep_dialog(*, suppress: bool, has_entity: bool, sibling_count: int) -> bool:
-        """Pure decision for the pre-edit warning. Returns ``True`` only when the
-        edit will silently mutate other elements' geometry AND the user has not
-        opted out of the warning for this session."""
-        if suppress or not has_entity:
-            return False
-        return sibling_count > 0
-
-    def invoke(self, context, event):
-        prefs = getattr(context.window_manager, "BIMParametricEditDialogPrefs", None)
-        suppress = bool(prefs and prefs.suppress_shared_rep_warning)
-        obj = context.active_object
-        element = tool.Ifc.get_entity(obj) if obj else None
-        self.sibling_count = tool.Model.get_sibling_occurrence_count(element) if element is not None else 0
-        if self.should_show_shared_rep_dialog(
-            suppress=suppress, has_entity=element is not None, sibling_count=self.sibling_count
-        ):
-            return context.window_manager.invoke_props_dialog(self, width=400)
-        return self.execute(context)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="Shared geometry", icon="ERROR")
-        layout.label(text=f"Geometry is shared with {self.sibling_count} other element(s).")
-        layout.label(text="Edits will affect them too.")
-        prefs = context.window_manager.BIMParametricEditDialogPrefs
-        layout.prop(prefs, "suppress_shared_rep_warning", text="Don't show this again for this session")
 
     def execute(self, context):
         # Malformed ``feature_enable_op`` (missing dot) would otherwise crash

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

@@ -51,10 +51,6 @@ class AuthoringData:
 
     @classmethod
     def load(cls, ifc_element_type: Optional[str] = None):
-        # ``is_loaded`` is set first as a recursion guard: one of the data
-        # computations evaluates a PropertyGroup enum's ``items`` callback,
-        # which re-enters this method. Without the guard, load recurses to
-        # RecursionError.
         cls.is_loaded = True
         cls.props = tool.Model.get_model_props()
         cls.data["default_container"] = cls.default_container()

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

@@ -33,7 +33,6 @@ from mathutils import Vector
 
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
-from bonsai.bim.module.model.opening import is_filling_supported
 from bonsai.bim.module.model.wall import (
     _get_wall_geom_cached,
     _wall_camera_facing_icon_y,
@@ -53,20 +52,6 @@ def is_supported_host(element) -> bool:
     return tool.Parametric.is_path_connectable_wall(element) or element.is_a("IfcSlab") or element.is_a("IfcRoof")
 
 
-def is_supported_filling_or_opening(element) -> bool:
-    """Total predicate for the add-opening gizmo poll. ``None`` (raw Blender
-    mesh) is accepted because the operator converts unclassified meshes
-    into ``IfcOpeningElement`` instances. ``IfcOpeningElement`` is accepted
-    because reassigning an existing opening to a new host is a legal path
-    through the operator. Otherwise defer to the generator's own
-    supported-filling predicate."""
-    if element is None:
-        return True
-    if element.is_a("IfcOpeningElement"):
-        return True
-    return is_filling_supported(element)
-
-
 def _resolve_active_host(context: bpy.types.Context, n_selected: int):
     """Shared poll prologue: gizmo gate + selection cardinality + active-in-
     selected + IFC entity lookup + supported-host predicate. Returns the
@@ -87,14 +72,12 @@ def _resolve_active_host(context: bpy.types.Context, n_selected: int):
 
 
 class GizmoHostAddOpening(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
-    """Activates when exactly two objects are selected and one is a fillable
-    host (wall / slab / roof) while the other is a valid filling (door /
-    window / existing opening, or a plain Blender mesh).
+    """Activates when a host element (wall / slab / roof) is the active object
+    and exactly one other selected object is *not* itself a host.
 
-    Selection-order independent: the host role is identified by class, not
-    by active state. The "+" icon anchors on the host's surface regardless
-    of which object was clicked first. The dispatched ``bim.add_opening``
-    operator also handles either order.
+    Renders a single ``VIEW3D_GT_add_opening`` icon at the void object's
+    projected location on the host. A click dispatches ``bim.add_opening``,
+    which handles any element exposing the ``HasOpenings`` inverse.
 
     Per-frame positioning keeps the icon facing the camera as the viewport
     orbits."""
@@ -107,29 +90,22 @@ class GizmoHostAddOpening(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin
 
     @classmethod
     def poll(cls, context: bpy.types.Context) -> bool:
-        if not _wall_gizmo_poll_gate(context):
+        element = _resolve_active_host(context, n_selected=2)
+        if element is None:
             return False
-        selected = list(tool.Blender.get_selected_objects())
-        if len(selected) != 2:
+        # The operator itself filters on HasOpenings, but checking here keeps
+        # the icon from appearing on host classes that can't accept openings
+        # in the active IFC schema.
+        if not hasattr(element, "HasOpenings"):
             return False
         active = context.active_object
-        if active is None or active not in selected:
+        other = next(o for o in tool.Blender.get_selected_objects() if o is not active)
+        # Host + host pairings are claimed by host-specific gizmos (wall-join,
+        # extend-vertical, …) — suppress here so the add-opening icon never
+        # stacks on top of them.
+        if is_supported_host(tool.Ifc.get_entity(other)):
             return False
-        a_element = tool.Ifc.get_entity(selected[0])
-        b_element = tool.Ifc.get_entity(selected[1])
-        return cls._is_apply_opening_pair(a_element, b_element) or cls._is_apply_opening_pair(b_element, a_element)
-
-    @staticmethod
-    def _is_apply_opening_pair(host_element, filling_element) -> bool:
-        """``host_element`` qualifies as a fillable host AND ``filling_element``
-        qualifies as a filling. Used twice with the operands swapped so the
-        gizmo polls true regardless of which of the two selected objects is
-        active."""
-        if not is_supported_host(host_element):
-            return False
-        if not hasattr(host_element, "HasOpenings"):
-            return False
-        return is_supported_filling_or_opening(filling_element)
+        return True
 
     def setup(self, context: bpy.types.Context) -> None:
         default_color, highlight_color = self.get_decoration_colors()
@@ -138,20 +114,18 @@ class GizmoHostAddOpening(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin
         )
 
     def position_gizmos(self, context: bpy.types.Context) -> None:
-        selected = list(tool.Blender.get_selected_objects())
-        if len(selected) != 2:
+        host_obj = context.active_object
+        if not host_obj:
             return
-        a, b = selected[0], selected[1]
-        a_element = tool.Ifc.get_entity(a)
-        b_element = tool.Ifc.get_entity(b)
-        if is_supported_host(a_element):
-            host_obj, host_element, other = a, a_element, b
-        elif is_supported_host(b_element):
-            host_obj, host_element, other = b, b_element, a
-        else:
+        selected = tool.Blender.get_selected_objects()
+        other = next((o for o in selected if o is not host_obj), None)
+        if not other:
+            return
+        element = tool.Ifc.get_entity(host_obj)
+        if not element:
             return
 
-        if tool.Parametric.is_path_connectable_wall(host_element):
+        if tool.Parametric.is_path_connectable_wall(element):
             world_pos = wall_anchor(context, self, host_obj, other)
         else:
             world_pos = layer3_anchor(host_obj, other)

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

@@ -1,444 +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.
-
-"""Bend-preview lifecycle for MEP segment joins.
-
-Holds the four lifecycle operators (Enable / Finish / Cancel /
-EnableFromBend) and the ``GizmoBendPreview`` group that surfaces the
-tunable dimensions and validate/cancel icons during preview. Draft state
-lives at ``Scene.BIMPreviewProperties.bend`` per CLAUDE.md §2.9 (Scene
-for cross-element previews).
-
-The geometry math (``compute_bend_preview_polylines``,
-``_bend_profile_cross_section``, ``_sweep_profile_along_polyline``)
-stays in ``mep.py`` because the commit operator ``MEPAddBend`` reuses
-it; this module imports the polyline helper for per-frame gizmo
-positioning. The GPU lines themselves are drawn by
-``decorator.BendPreviewDecorator``, kept in ``decorator.py`` with its
-sibling decorators."""
-
-from typing import ClassVar
-
-import bpy
-import ifcopenshell.util.element
-import ifcopenshell.util.unit
-from mathutils import Matrix, Vector
-
-import bonsai.tool as tool
-from bonsai.bim.module.drawing import gizmos as gizmo
-from bonsai.bim.module.model import preview_base
-from bonsai.bim.module.model.mep import (
-    _is_bend_fitting,
-    _n_mep_selected,
-    cached_compute_bend_preview_polylines,
-    segments_are_parallel,
-    validate_bend_preconditions,
-)
-
-
-class EnableBendPreview(bpy.types.Operator):
-    """Enter bend-preview mode for two selected MEP segments. Populates
-    scene.BIMPreviewProperties.bend with segment IFC ids and default
-    start_length / end_length / radius; no IFC mutation until finish."""
-
-    bl_idname = "bim.enable_bend_preview"
-    bl_label = "Enter Bend Preview"
-    bl_description = "Begin tuning bend parameters before committing the bend"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        if not _n_mep_selected(2):
-            cls.poll_message_set("Select exactly 2 MEP segments to bend.")
-            return False
-        return True
-
-    def execute(self, context):
-        selected = tool.Blender.get_selected_objects()
-        active = context.active_object
-        if active is None or active not in selected:
-            self.report({"ERROR"}, "Active object must be one of the selected MEP segments.")
-            return {"CANCELLED"}
-        other = next((o for o in selected if o is not active), None)
-        if other is None:
-            self.report({"ERROR"}, "Two MEP segments must be selected.")
-            return {"CANCELLED"}
-        active_element = tool.Ifc.get_entity(active)
-        other_element = tool.Ifc.get_entity(other)
-        if active_element is None or other_element is None:
-            self.report({"ERROR"}, "Both selected objects must be IFC elements.")
-            return {"CANCELLED"}
-        if segments_are_parallel(active, other):
-            self.report({"ERROR"}, "Bend preview is for non-parallel segments only.")
-            return {"CANCELLED"}
-
-        # Pre-check the same preconditions MEPAddBend enforces so the user
-        # sees the rejection here rather than after tuning a doomed preview.
-        precondition_error = validate_bend_preconditions(active_element, other_element)
-        if precondition_error is not None:
-            self.report({"ERROR"}, precondition_error)
-            return {"CANCELLED"}
-
-        preview_base.sync_uncommitted_moves([active, other])
-
-        props = preview_base.get_preview_props(context, "bend")
-        # Auto-cancel any prior preview so re-clicking join on a different
-        # pair doesn't silently commit the previous tuning.
-        if props is not None and props.is_active:
-            bpy.ops.bim.cancel_bend_preview()
-
-        props.start_segment_id = active_element.id()
-        props.end_segment_id = other_element.id()
-        props.start_length = 0.1
-        props.end_length = 0.1
-        props.radius = 0.2
-        props.is_active = True
-        return {"FINISHED"}
-
-
-class FinishBendPreview(bpy.types.Operator):
-    """Commit the previewed bend with the tuned parameters and exit preview.
-
-    Preview state survives a failed commit so the user can re-tune without
-    re-selecting."""
-
-    bl_idname = "bim.finish_bend_preview"
-    bl_label = "Apply Bend"
-    bl_description = "Commit the bend with the previewed parameters"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return preview_base.commit_preview(
-            self,
-            context,
-            "bend",
-            "mep_add_bend",
-            ("start_segment_id", "end_segment_id", "start_length", "end_length", "radius", "editing_bend_id"),
-        )
-
-
-class CancelBendPreview(bpy.types.Operator):
-    """Exit bend preview without committing."""
-
-    bl_idname = "bim.cancel_bend_preview"
-    bl_label = "Cancel Bend"
-    bl_description = "Discard the previewed bend"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        if context.screen is None:
-            return {"CANCELLED"}
-        props = preview_base.get_preview_props(context, "bend")
-        if props is None or not props.is_active:
-            return {"CANCELLED"}
-        preview_base.clear_preview_state(props)
-        return {"FINISHED"}
-
-
-class EnableBendPreviewFromBend(bpy.types.Operator):
-    """Re-open the bend preview on an existing bend fitting.
-
-    Resolves the two connected segments via the bend's ports +
-    ``IfcRelConnectsPorts``, reads parametric values back from the bend's
-    ``BBIM_Fitting`` pset, and flags the preview so committing replaces
-    the existing bend in place."""
-
-    bl_idname = "bim.enable_bend_preview_from_bend"
-    bl_label = "Edit Bend"
-    bl_description = "Re-open the bend preview to retune an existing bend"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        active = context.active_object
-        if active is None:
-            cls.poll_message_set("No active object.")
-            return False
-        element = tool.Ifc.get_entity(active)
-        if element is None or not _is_bend_fitting(element):
-            cls.poll_message_set("Active object must be a bend fitting.")
-            return False
-        return True
-
-    def execute(self, context):
-        active = context.active_object
-        bend_element = tool.Ifc.get_entity(active)
-        if bend_element is None or not _is_bend_fitting(bend_element):
-            self.report({"ERROR"}, "Active object is not a bend fitting.")
-            return {"CANCELLED"}
-
-        connected_segments: list = []
-        for port in tool.System.get_ports(bend_element):
-            connected_port = tool.System.get_connected_port(port)
-            if connected_port is None:
-                continue
-            related = tool.System.get_port_relating_element(connected_port)
-            if related is not None and related.is_a("IfcFlowSegment") and related not in connected_segments:
-                connected_segments.append(related)
-
-        if len(connected_segments) != 2:
-            self.report(
-                {"ERROR"},
-                f"Bend has {len(connected_segments)} connected segments; need exactly 2 to re-edit.",
-            )
-            return {"CANCELLED"}
-
-        # Read parametric values from the bend type's BBIM_Fitting pset. The
-        # type carries the canonical parameters; querying the occurrence
-        # would force a get_type round-trip and miss user-edited types.
-        bend_type = ifcopenshell.util.element.get_type(bend_element)
-        if bend_type is None:
-            self.report({"ERROR"}, "Bend fitting has no type to read parameters from.")
-            return {"CANCELLED"}
-        bend_type_obj = tool.Ifc.get_object(bend_type)
-        if bend_type_obj is None:
-            self.report({"ERROR"}, "Bend type has no Blender object — cannot read pset.")
-            return {"CANCELLED"}
-        bbim = tool.Model.get_modeling_bbim_pset_data(bend_type_obj, "BBIM_Fitting")
-        if bbim is None:
-            self.report({"ERROR"}, "Bend fitting has no BBIM_Fitting pset — not a parametric bend.")
-            return {"CANCELLED"}
-        data = bbim.get("data_dict", {})
-
-        props = preview_base.get_preview_props(context, "bend")
-        if props is not None and props.is_active:
-            bpy.ops.bim.cancel_bend_preview()
-
-        # Segment order is load-bearing: the bend's lateral sign and z-axis
-        # flip are derived from which segment is "start" vs "end". Re-edit
-        # must reuse the same pairing as the original create so the recreate
-        # lands at the same orientation.
-        start_segment, end_segment = connected_segments
-        props.start_segment_id = start_segment.id()
-        props.end_segment_id = end_segment.id()
-        # Pset values are in IFC native units; scene units come from si_conversion.
-        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-        props.start_length = float(data.get("start_length", 0.1)) * si_conversion
-        props.end_length = float(data.get("end_length", 0.1)) * si_conversion
-        props.radius = float(data.get("radius", 0.2)) * si_conversion
-        props.editing_bend_id = bend_element.id()
-        props.is_active = True
-        return {"FINISHED"}
-
-
-def _bend_preview_segments(context):
-    """Resolve the two segment objects from the scene-level preview props.
-
-    Re-resolves by IFC id each frame so undo / file reload during preview
-    never dangles a stale bpy reference."""
-    props = context.scene.BIMPreviewProperties.bend
-    ifc_file = tool.Ifc.get()
-    if ifc_file is None or not props.is_active:
-        return None, None
-    try:
-        start_element = ifc_file.by_id(props.start_segment_id)
-        end_element = ifc_file.by_id(props.end_segment_id)
-    except Exception:
-        return None, None
-    start_obj = tool.Ifc.get_object(start_element) if start_element else None
-    end_obj = tool.Ifc.get_object(end_element) if end_element else None
-    return start_obj, end_obj
-
-
-def _gizmo_x_matrix(location: Vector, x_direction: Vector) -> Matrix:
-    """Build a 4x4 matrix placing a gizmo at ``location`` with its local +X
-    axis aligned to ``x_direction`` in world space. ``BIM_GT_gizmo_dimension``
-    draws + drags along local +X by convention."""
-    x = x_direction.normalized()
-    seed = Vector((0, 0, 1)) if abs(x.z) < 0.9 else Vector((1, 0, 0))
-    y = (seed - x * seed.dot(x)).normalized()
-    z = x.cross(y)
-    mat = Matrix.Identity(4)
-    mat[0][:3] = (x.x, y.x, z.x)
-    mat[1][:3] = (x.y, y.y, z.y)
-    mat[2][:3] = (x.z, y.z, z.z)
-    mat.translation = location
-    return mat
-
-
-class GizmoBendPreview(bpy.types.GizmoGroup):
-    """Interactive gizmo group for the bend preview flow.
-
-    Three dimension widgets drag start_length / end_length / radius; two
-    icon gizmos commit or cancel. When the geometry is degenerate the
-    dimensions and validate hide but cancel stays visible so the user
-    always has an exit."""
-
-    bl_idname = "OBJECT_GGT_bim_bend_preview"
-    bl_label = "Bend Preview Gizmos"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "WINDOW"
-    bl_options = {"3D", "PERSISTENT"}
-
-    ICON_SCALE: ClassVar[float] = 0.375
-    ICON_SPACING_X: ClassVar[float] = 0.4
-    ICON_Z_OFFSET: ClassVar[float] = 1.5
-
-    @classmethod
-    def poll(cls, context):
-        preview = getattr(context.scene, "BIMPreviewProperties", None)
-        props = preview.bend if preview is not None else None
-        if props is None or not props.is_active:
-            return False
-        if not tool.Blender.are_viewport_gizmos_enabled():
-            return False
-        ifc_file = tool.Ifc.get()
-        if ifc_file is None:
-            return False
-        try:
-            ifc_file.by_id(props.start_segment_id)
-            ifc_file.by_id(props.end_segment_id)
-        except (RuntimeError, KeyError):
-            return False
-        return True
-
-    def setup(self, context):
-        prefs = tool.Blender.get_addon_preferences()
-        default_color = tuple(prefs.decorations_colour[:3])
-        highlight_color = tuple(prefs.decorator_color_selected[:3])
-
-        _props = preview_base.make_props_callback("bend")
-
-        def setup_dimension(attr: str, prop_name: str, invert_delta: bool = False) -> bpy.types.Gizmo:
-            gz = self.gizmos.new("BIM_GT_gizmo_dimension")
-            gz.move_get_cb = preview_base.make_dim_getter(_props, attr)
-            gz.move_set_cb = preview_base.make_dim_setter(_props, attr)
-            gz.axis = Vector((1, 0, 0))
-            gz.invert_delta = invert_delta
-            gz.delta_scale = 1.0
-            gz.prop_name = prop_name
-            gz.gizmo_group = self
-            gz.color = default_color
-            gz.color_highlight = highlight_color
-            gz.alpha = 1.0
-            gz.use_draw_modal = True
-            gz.use_draw_scale = False
-            gz.text_offset_sign = 1
-            gz.text_alignment = gizmo.TextAlignment.CENTER
-            gz.show_start_arrow = False
-            gz.show_end_arrow = True
-            gz.show_extension_lines = False
-            gz.text_formatter = None
-            return gz
-
-        self.start_dim = setup_dimension("start_length", "Start Length")
-        self.end_dim = setup_dimension("end_length", "End Length")
-        self.radius_dim = setup_dimension("radius", "Radius")
-
-        from bonsai.bim.module.drawing.gizmos import BaseParametricGizmoGroup
-
-        self.validate_icon = self.gizmos.new("VIEW3D_GT_validate")
-        self.validate_icon.use_draw_scale = False
-        self.validate_icon.color = BaseParametricGizmoGroup.COLOR_GREEN
-        self.validate_icon.color_highlight = highlight_color
-        self.validate_icon.target_set_operator("bim.finish_bend_preview")
-
-        self.cancel_icon = self.gizmos.new("VIEW3D_GT_cancel")
-        self.cancel_icon.use_draw_scale = False
-        self.cancel_icon.color = BaseParametricGizmoGroup.COLOR_RED
-        self.cancel_icon.color_highlight = highlight_color
-        self.cancel_icon.target_set_operator("bim.cancel_bend_preview")
-
-    def refresh(self, context):
-        self._position_gizmos(context)
-
-    def draw_prepare(self, context):
-        self._position_gizmos(context)
-
-    def _position_gizmos(self, context):
-        """Place gizmos at the bend intersection using the current scene
-        props. Cancel stays visible on degenerate geometry so the user
-        always has an exit; the other widgets hide when there's no defined
-        tangent / arc to anchor them on."""
-        start_obj, end_obj = _bend_preview_segments(context)
-        if start_obj is None or end_obj is None:
-            for gz in (self.start_dim, self.end_dim, self.radius_dim, self.validate_icon, self.cancel_icon):
-                gz.hide = True
-            return
-
-        props = context.scene.BIMPreviewProperties.bend
-        preview = cached_compute_bend_preview_polylines(
-            start_obj, end_obj, props.start_length, props.end_length, props.radius
-        )
-        if not preview["valid"]:
-            for gz in (self.start_dim, self.end_dim, self.radius_dim, self.validate_icon):
-                gz.hide = True
-            self.cancel_icon.hide = False
-            axes = preview.get("invalid_axes") or []
-            if axes:
-                intersection_point = axes[0][1]
-                billboard_rot = gizmo.get_billboard_rotation(context)
-                anchor = intersection_point + Vector((0, 0, self.ICON_Z_OFFSET))
-                self.cancel_icon.matrix_basis = gizmo.billboarded_at(anchor, billboard_rot, scale=self.ICON_SCALE)
-            return
-
-        for gz in (self.start_dim, self.end_dim, self.radius_dim, self.validate_icon, self.cancel_icon):
-            gz.hide = False
-
-        leg_a_far, leg_a_end = preview["leg_a"]
-        leg_b_far, leg_b_end = preview["leg_b"]
-        toward_bend_a = (
-            (leg_a_end - leg_a_far).normalized() if (leg_a_end - leg_a_far).length > 1e-6 else Vector((0, 0, 1))
-        )
-        toward_bend_b = (
-            (leg_b_end - leg_b_far).normalized() if (leg_b_end - leg_b_far).length > 1e-6 else Vector((0, 0, 1))
-        )
-        leg_a_tangent = leg_a_end + toward_bend_a * props.start_length
-        leg_b_tangent = leg_b_end + toward_bend_b * props.end_length
-
-        # axis is set in world space every frame so the drag projection
-        # matches the visual regardless of either segment's matrix_world.
-        self.start_dim.matrix_basis = _gizmo_x_matrix(leg_a_tangent, -toward_bend_a)
-        self.start_dim.axis = -toward_bend_a
-        self.start_dim.set_dimension_length(props.start_length)
-        self.end_dim.matrix_basis = _gizmo_x_matrix(leg_b_tangent, -toward_bend_b)
-        self.end_dim.axis = -toward_bend_b
-        self.end_dim.set_dimension_length(props.end_length)
-
-        arc = preview["arc"]
-        if len(arc) >= 3:
-            mid = len(arc) // 2
-            chord_mid = (arc[0] + arc[-1]) * 0.5
-            toward_mid = arc[mid] - chord_mid
-            if toward_mid.length > 1e-6:
-                toward_mid = toward_mid.normalized()
-                half_chord = (arc[-1] - arc[0]).length * 0.5
-                center_dist = max(0.0, props.radius * props.radius - half_chord * half_chord) ** 0.5
-                arc_center = chord_mid - toward_mid * center_dist
-                radial_out = arc[mid] - arc_center
-                if radial_out.length > 1e-6:
-                    radial_out.normalize()
-                    inward = -radial_out
-                    self.radius_dim.matrix_basis = _gizmo_x_matrix(arc[mid], inward)
-                    self.radius_dim.axis = inward
-                    self.radius_dim.set_dimension_length(props.radius)
-                else:
-                    self.radius_dim.hide = True
-            else:
-                self.radius_dim.hide = True
-        else:
-            self.radius_dim.hide = True
-
-        billboard_rot = gizmo.get_billboard_rotation(context)
-        anchor_base = arc[len(arc) // 2] if arc else (leg_a_end + leg_b_end) * 0.5
-        anchor = anchor_base + Vector((0, 0, self.ICON_Z_OFFSET))
-        offset_x = billboard_rot @ Vector((self.ICON_SPACING_X, 0.0, 0.0))
-        self.validate_icon.matrix_basis = gizmo.billboarded_at(anchor, billboard_rot, scale=self.ICON_SCALE)
-        self.cancel_icon.matrix_basis = gizmo.billboarded_at(anchor + offset_x, billboard_rot, scale=self.ICON_SCALE)

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

@@ -15,8 +15,6 @@
 #
 # 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 modified with the assistance of an AI coding tool.
 
 from collections.abc import Sequence
 from math import radians
@@ -209,21 +207,6 @@ def _get_cached_world_draw_data(
 # handle each call), so they stay drawable across frames.
 _batch_cache: dict[tuple[int, str], tuple[int, "gpu.types.GPUBatch"]] = {}
 
-# CAD hidden-line convention for the occluded back-pass: world-space dashes so
-# density stays coherent across zoom. Dash + gap = period; dash_width controls
-# the "on" portion.
-_DASH_PERIOD_METERS: float = 0.20
-_DASH_WIDTH_METERS: float = 0.10
-# Solid front pass is rendered wider than the dashed back pass so its halo
-# overpowers the dashed center on visible edges even when the WIRE-display
-# overlay biases the depth buffer at outline pixels.
-_DASH_LINE_WIDTH: float = 1.5
-_SOLID_LINE_WIDTH: float = 2.5
-# Per-iteration default line width used by every non-occlusion draw call in
-# this decorator's ``__call__``. Restored after each occlusion pair so the
-# next draw isn't silently inheriting the wider solid-pass override.
-_DEFAULT_LINE_WIDTH: float = 2.0
-
 
 def _get_cached_batch_or_none(cache_key: tuple[int, str]) -> "gpu.types.GPUBatch | None":
     uid = cache_key[0]
@@ -240,15 +223,6 @@ def _store_batch_in_cache(cache_key: tuple[int, str], batch: "gpu.types.GPUBatch
     _batch_cache[cache_key] = (epoch, batch)
 
 
-def is_filling_supported(element) -> bool:
-    """True when Bonsai's opening generator can derive an opening from this
-    element. IFC's schema permits any IfcElement as a filling; Bonsai
-    currently supports only IfcDoor and IfcWindow because those are the
-    classes with OverallWidth/OverallHeight attributes (or their types'
-    ELEVATION_VIEW profiles) that the generator can consume."""
-    return element is not None and element.is_a() in ("IfcDoor", "IfcWindow")
-
-
 class FilledOpeningGenerator:
     def generate(
         self,
@@ -418,16 +392,18 @@ class FilledOpeningGenerator:
                 representation = tool.Geometry.get_representation_by_context(voided_element, context)
                 assert representation
 
-                tool.Geometry.recut_host(voided_obj, representation)
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc,
+                    tool.Geometry,
+                    obj=voided_obj,
+                    representation=representation,
+                )
 
     def regenerate_from_type(self, usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
         relating_type = settings["relating_type"]
 
-        # Filling type-switch on an array of fillings fans out N host recuts —
-        # one per related object — without batching. Coalesce them.
-        with tool.Geometry.batch_host_recut():
-            for related_object in settings["related_objects"]:
-                self._regenerate_from_type(related_object)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)
 
     def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
         filling = related_object
@@ -476,7 +452,12 @@ class FilledOpeningGenerator:
             representation = tool.Geometry.get_active_representation(voided_obj)
             if not representation:
                 continue
-            tool.Geometry.recut_host(voided_obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc,
+                tool.Geometry,
+                obj=voided_obj,
+                representation=representation,
+            )
 
     def generate_opening_from_filling(
         self,
@@ -611,31 +592,6 @@ class RecalculateFill(bpy.types.Operator, tool.Ifc.Operator):
         return context.selected_objects
 
     def _execute(self, context):
-        # N selected fillings × M voided host parts would fire N×M host recuts
-        # without batching. Coalesce per host.
-        with tool.Geometry.batch_host_recut():
-            return self._recalculate_fills(context)
-
-    def _recalculate_fills(self, context):
-        # Refresh each selected filling's mapped opening source before
-        # recutting the host. Dedup by source id covers the common shared-
-        # source case in one rewrite while leaving unrelated sibling sources
-        # untouched.
-        seen_source_ids: set[int] = set()
-        for obj in context.selected_objects:
-            element = tool.Ifc.get_entity(obj)
-            if not element or not element.FillsVoids:
-                continue
-            opening = element.FillsVoids[0].RelatingOpeningElement
-            body = tool.Geometry.get_body_representation(opening)
-            if body is None:
-                continue
-            source = tool.Geometry.resolve_mapped_representation(body)
-            if source.id() in seen_source_ids:
-                continue
-            seen_source_ids.add(source.id())
-            tool.Model.regenerate_filling_opening_body(element)
-
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
             if not element or not element.FillsVoids:
@@ -664,7 +620,12 @@ class RecalculateFill(bpy.types.Operator, tool.Ifc.Operator):
                 if building_obj and building_obj.data:
                     representation = tool.Geometry.get_active_representation(building_obj)
                     if representation:
-                        tool.Geometry.recut_host(building_obj, representation)
+                        bonsai.core.geometry.switch_representation(
+                            tool.Ifc,
+                            tool.Geometry,
+                            obj=building_obj,
+                            representation=representation,
+                        )
 
         # Refresh cut decorator
         DecoratorData.cut_cache.clear()
@@ -986,29 +947,27 @@ class EditOpenings(Operator, tool.Ifc.Operator):
         for opening_element in opening_elements:
             opening_obj = tool.Ifc.get_object(opening_element)
 
+            similar_openings = bonsai.core.geometry.get_similar_openings(tool.Ifc, opening_element)
+            similar_openings_building_objs = bonsai.core.geometry.get_similar_openings_building_objs(
+                tool.Ifc, similar_openings
+            )
+            building_objs.update(similar_openings_building_objs)
+
             if opening_obj:
-                opening_edited = tool.Ifc.is_edited(opening_obj)
-                opening_moved = tool.Ifc.is_moved(opening_obj)
-                # Sibling walls only need a viewport-level refresh when the
-                # opening's shape or placement actually changed — a pure
-                # show/hide toggle leaves them in their existing state.
-                if opening_edited or opening_moved:
-                    similar_openings = bonsai.core.geometry.get_similar_openings(tool.Ifc, opening_element)
-                    similar_openings_building_objs = bonsai.core.geometry.get_similar_openings_building_objs(
-                        tool.Ifc, similar_openings
-                    )
-                    building_objs.update(similar_openings_building_objs)
-                    if opening_edited:
-                        tool.Geometry.run_geometry_update_representation(obj=opening_obj)
-                    else:
-                        bonsai.core.geometry.edit_object_placement(
-                            tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj
-                        )
+                if tool.Ifc.is_edited(opening_obj):
+                    tool.Geometry.run_geometry_update_representation(obj=opening_obj)
+                    bonsai.core.geometry.edit_similar_opening_placement(
+                        tool.Geometry, opening_element, similar_openings
+                    )
+                elif tool.Ifc.is_moved(opening_obj):
+                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj)
                     bonsai.core.geometry.edit_similar_opening_placement(
                         tool.Geometry, opening_element, similar_openings
                     )
-                    building_objs.update(self.get_all_building_objects_of_similar_openings(opening_element))
 
+                building_objs.update(
+                    self.get_all_building_objects_of_similar_openings(opening_element)
+                )  # NB this has nothing to do with clone similar_opening
                 tool.Ifc.unlink(element=opening_element)
                 if props.representation_obj == opening_obj:
                     props.representation_obj = None
@@ -1046,12 +1005,6 @@ class CloneOpening(Operator, tool.Ifc.Operator):
         return True
 
     def _execute(self, context):
-        # The voided host may be an aggregate whose parts each get recut.
-        # Coalesce per host so a many-parts aggregate doesn't fan out.
-        with tool.Geometry.batch_host_recut():
-            return self._clone_opening(context)
-
-    def _clone_opening(self, context):
         # NOTE: Operator displayed in UI only with IfcOpeningElement being active.
         ifc_file = tool.Ifc.get()
         objects = bpy.context.selected_objects
@@ -1081,7 +1034,12 @@ class CloneOpening(Operator, tool.Ifc.Operator):
                 continue
             representation = tool.Geometry.get_active_representation(obj)
             assert representation
-            tool.Geometry.recut_host(obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc,
+                tool.Geometry,
+                obj=obj,
+                representation=representation,
+            )
 
         return {"FINISHED"}
 
@@ -1231,55 +1189,22 @@ class DecorationsHandler:
         shader.uniform_float("color", color)
         batch.draw(shader)
 
-    def _draw_lines_with_occlusion(self, verts, color, edges_indices, cache_key=None):
-        # Two-pass CAD hidden-line convention. Both passes use POLYLINE_UNIFORM_COLOR.
-        #
-        # The solid front pass is rendered WIDER than the dashed back pass so it
-        # produces a halo around the line center, beyond the depth-bias zone that
-        # Blender's overlay engine writes when an opening is set to WIRE display.
-        # Without the width difference, the wire bias makes the center-pixel
-        # ``LESS_EQUAL`` comparison fail (line ends up slightly behind the biased
-        # wire depth) so the solid pass would lose to the dashed back pass even
-        # on visible edges. The halo gives the solid pass enough screen-space to
-        # overpower the dashed pattern visually.
-        #
-        # Dashed renders first at the standard width so the solid overlay's wider
-        # halo cleanly hides it on visible edges; on occluded edges the solid
-        # ``LESS_EQUAL`` pass fails against the wall depth and the dashed remains.
-        front_batch = self._get_or_build_batch(self.line_shader, "LINES", verts, edges_indices, cache_key=cache_key)
-        if front_batch is None:
+    def _draw_lines_with_occlusion(self, verts, color, edges_indices, occluded_alpha: float = 0.25, cache_key=None):
+        # One batch, two draws: front pass at full color, occluded pass at
+        # `occluded_alpha`. Save/restore depth_test matches the pattern in
+        # bim/module/structural/decorator.py so callers' state survives.
+        batch = self._get_or_build_batch(self.line_shader, "LINES", verts, edges_indices, cache_key=cache_key)
+        if batch is None:
             return
-
-        dashed_cache_key = (cache_key[0], cache_key[1] + "_dashed") if cache_key is not None else None
-        dash_batch = None
-        if dashed_cache_key is not None:
-            dash_batch = _get_cached_batch_or_none(dashed_cache_key)
-        if dash_batch is None:
-            dash_verts, dash_edges = tool.Blender.build_dashed_line_segments(
-                verts, edges_indices, _DASH_PERIOD_METERS, _DASH_WIDTH_METERS
-            )
-            dash_batch = self._get_or_build_batch(self.line_shader, "LINES", dash_verts, dash_edges)
-            if dash_batch is not None and dashed_cache_key is not None:
-                _store_batch_in_cache(dashed_cache_key, dash_batch)
-
         original_depth_test = gpu.state.depth_test_get()
-        front_color = list(color)
-        front_color[3] = 1.0
-        self.line_shader.uniform_float("color", front_color)
-
-        if dash_batch is not None:
-            self.line_shader.uniform_float("lineWidth", _DASH_LINE_WIDTH)
-            gpu.state.depth_test_set("ALWAYS")
-            dash_batch.draw(self.line_shader)
-
-        self.line_shader.uniform_float("lineWidth", _SOLID_LINE_WIDTH)
         gpu.state.depth_test_set("LESS_EQUAL")
-        front_batch.draw(self.line_shader)
-
-        # Restore the per-iteration default set at the top of __call__ so
-        # subsequent draws (the HalfSpaceSolid arrow, future call-sites) are
-        # not silently affected by the front-pass width override.
-        self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
+        self.line_shader.uniform_float("color", color)
+        batch.draw(self.line_shader)
+        gpu.state.depth_test_set("GREATER")
+        dimmed = list(color)
+        dimmed[3] = occluded_alpha
+        self.line_shader.uniform_float("color", dimmed)
+        batch.draw(self.line_shader)
         gpu.state.depth_test_set(original_depth_test)
 
     def __call__(self, context):
@@ -1315,7 +1240,7 @@ class DecorationsHandler:
             self.line_shader.bind()  # required to be able to change uniforms of the shader
             # POLYLINE_UNIFORM_COLOR specific uniforms
             self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
-            self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
+            self.line_shader.uniform_float("lineWidth", 2.0)
 
             # general shader
             self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
@@ -1353,7 +1278,9 @@ class DecorationsHandler:
                 self.draw_batch("LINES", verts, selected_elements_color, selected_edges)
                 self.draw_batch("POINTS", unselected_vertices, unselected_elements_color)
                 self.draw_batch("POINTS", selected_vertices, selected_elements_color)
-                tool.Blender.draw_bmesh_face_tris(bm, verts, transparent_color(special_elements_color), self.draw_batch)
+                obj.data.calc_loop_triangles()
+                tris = [tuple(t.vertices) for t in obj.data.loop_triangles]
+                self.draw_batch("TRIS", verts, transparent_color(special_elements_color), tris)
             else:
                 line_verts, verts, edges_indices, tris = _get_cached_world_draw_data(obj)
                 color = selected_elements_color if obj in context.selected_objects else special_elements_color

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

@@ -163,59 +163,6 @@ def sync_uncommitted_moves(objects: list) -> None:
         tool.Geometry.commit_placement_if_moved(obj, apply_scale=False)
 
 
-def clear_preview_state(props: bpy.types.PropertyGroup) -> None:
-    """Reset a preview PropertyGroup to its idle state on commit / cancel.
-
-    Sets ``is_active`` to False and zeros every ``IntProperty`` whose name
-    ends in ``_id`` (the entity-reference convention every preview follows).
-    Other fields are left at their last value — defaults are re-applied on
-    the next enable, so leaving them alone avoids a redundant write."""
-    props.is_active = False
-    for name, rna in props.bl_rna.properties.items():
-        if name.endswith("_id") and rna.type == "INT":
-            setattr(props, name, 0)
-
-
-# --- Standard Finish flow ----------------------------------------------------
-
-
-def commit_preview(
-    operator: bpy.types.Operator,
-    context: bpy.types.Context,
-    attr: str,
-    target_op_name: str,
-    kwarg_names: tuple[str, ...],
-) -> set[str]:
-    """Standard Finish-Preview dispatch: validate context + active preview,
-    read kwargs off the draft, call ``bpy.ops.bim.<target_op_name>(**kwargs)``,
-    and clear the preview on success.
-
-    The dispatched operator's own ``self.report({"ERROR"})`` paths are promoted
-    by ``bpy.ops`` to ``RuntimeError`` — catching it here surfaces the message
-    to the user via ``operator.report`` rather than leaving Blender's operator
-    state half-broken (which silently disables downstream gizmo polls).
-
-    Returns the dispatched operator's result set verbatim so callers can
-    pass it straight back from their own ``execute``."""
-    if context.screen is None:
-        return {"CANCELLED"}
-    props = get_preview_props(context, attr)
-    if props is None or not props.is_active:
-        return {"CANCELLED"}
-    if tool.Ifc.get() is None:
-        operator.report({"ERROR"}, "No IFC file loaded.")
-        return {"CANCELLED"}
-    kwargs = {name: getattr(props, name) for name in kwarg_names}
-    try:
-        result = getattr(bpy.ops.bim, target_op_name)(**kwargs)
-    except RuntimeError as exc:
-        operator.report({"ERROR"}, str(exc))
-        return {"CANCELLED"}
-    if "FINISHED" in result:
-        clear_preview_state(props)
-    return result
-
-
 # --- Esc dispatch ------------------------------------------------------------
 
 PREVIEW_CANCEL_OPS: tuple[tuple[str, str], ...] = (

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

@@ -1002,14 +1002,6 @@ class EnableEditingExtrusionAxis(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         obj = context.active_object
-
-        # Commit any in-progress parametric (gizmo) draft on this object
-        # before switching to axis-edit. Otherwise the in-memory draft
-        # state is overwritten when the axis mesh is imported below,
-        # silently discarding the user's pending dimension edits.
-        if feature := tool.Parametric.is_object_editing(obj):
-            tool.Parametric.commit_object_draft(obj, feature.finish_op)
-
         element = tool.Ifc.get_entity(obj)
 
         axis = ifcopenshell.util.representation.get_representation(element, "Model", "Axis", "GRAPH_VIEW")
@@ -1165,8 +1157,7 @@ class DrawPolylineProfile(bpy.types.Operator, PolylineOperator, tool.Ifc.Operato
                         DumbProfileJoiner().join_V(profile2["obj"], profile1["obj"])
                         if connect_IfcFlowSegments:
                             bpy.ops.bim.mep_connect_elements(
-                                obj1_guid=tool.Ifc.get_entity(profile1["obj"]).GlobalId,
-                                obj2_guid=tool.Ifc.get_entity(profile2["obj"]).GlobalId,
+                                obj1_name=profile1["obj"].name, obj2_name=profile2["obj"].name
                             )
 
     def modal(self, context, event):

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

@@ -33,10 +33,8 @@ from bonsai.bim.module.drawing.decoration import CutDecorator
 from bonsai.bim.module.model.data import AuthoringData
 from bonsai.bim.module.model.decorator import (
     BoundingBoxDecorator,
-    MEPSystemPathDecorator,
     SlabDirectionDecorator,
     WallAxisDecorator,
-    WallSystemPathDecorator,
 )
 from bonsai.bim.module.model.door import update_door_modifier_bmesh
 from bonsai.bim.module.model.window import update_window_modifier_bmesh
@@ -134,19 +132,6 @@ def update_slab_direction_decorator(self: "BIMModelProperties", context: bpy.typ
         SlabDirectionDecorator.uninstall()
 
 
-def update_paths_decorator(self: "BIMModelProperties", context: bpy.types.Context) -> None:
-    """Unified toggle for connected-element path overlays. Drives both the
-    MEP and wall path decorators — each decorator's ``draw`` short-circuits
-    when its kind of element isn't selected, so leaving both installed is
-    cheap and lets one toggle cover any connected-element family."""
-    if self.show_paths:
-        MEPSystemPathDecorator.install(bpy.context)
-        WallSystemPathDecorator.install(bpy.context)
-    else:
-        MEPSystemPathDecorator.uninstall()
-        WallSystemPathDecorator.uninstall()
-
-
 def update_measure_xyz(self: "BIMModelProperties", context: bpy.types.Context) -> None:
     if self.show_bounding_box:
         BoundingBoxDecorator.install(context)
@@ -243,7 +228,11 @@ def update_wall_offset_baseline(self: "BIMWallProperties", context: bpy.types.Co
 def update_railing(self: "BIMRailingProperties", context: bpy.types.Context) -> None:
     """Regenerate railing mesh when property changes."""
     if self.is_editing:
-        _get_updater("railing", "update_railing_modifier_bmesh")(context)
+        # Only FRAMELESS_PANEL can update live via bmesh.
+        # WALL_MOUNTED_HANDRAIL geometry is generated from IFC representation,
+        # so it only updates on "Finish Editing" to avoid modifying IFC during preview.
+        if self.railing_type == "FRAMELESS_PANEL":
+            _get_updater("railing", "update_railing_modifier_bmesh")(context)
 
 
 def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
@@ -253,20 +242,6 @@ def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
         _get_updater("roof", "update_roof_modifier_bmesh")(obj)
 
 
-def update_pipe_segment(self: "BIMPipeSegmentProperties", context: bpy.types.Context) -> None:
-    """Regenerate pipe-segment preview mesh from props during edit. Does NOT touch IFC."""
-    obj = context.active_object
-    if obj and self.is_editing:
-        _get_updater("mep", "regenerate_pipe_segment_mesh_from_props")(obj)
-
-
-def update_duct_segment(self: "BIMDuctSegmentProperties", context: bpy.types.Context) -> None:
-    """Regenerate duct-segment preview mesh from props during edit. Does NOT touch IFC."""
-    obj = context.active_object
-    if obj and self.is_editing:
-        _get_updater("mep", "regenerate_duct_segment_mesh_from_props")(obj)
-
-
 class BIMModelProperties(PropertyGroup):
     ifc_class: bpy.props.EnumProperty(items=get_ifc_class, name="Construction Class", update=update_ifc_class)
     relating_type_id: bpy.props.EnumProperty(
@@ -369,19 +344,6 @@ class BIMModelProperties(PropertyGroup):
         default=False,
         update=update_slab_direction_decorator,
     )
-    show_paths: bpy.props.BoolProperty(
-        name="Show Paths",
-        default=False,
-        update=update_paths_decorator,
-        description=(
-            "Trace the connected element path from the selected element. For "
-            "walls, follows IfcRelConnectsPathElements and draws each "
-            "connected wall's reference axis with endpoint dots. For MEP "
-            "elements, follows IfcRelConnectsPorts and draws each segment's "
-            "axis plus a port-to-port spider for each fitting. Toggle off to "
-            "skip the BFS traversal entirely."
-        ),
-    )
 
     prev_transform_orientation_slot_type: bpy.props.StringProperty(name="Previous Gizmo Orientation Type")
     prev_show_gizmo_object_translate: bpy.props.BoolProperty(name="Previous Gizmo Translate")
@@ -429,7 +391,6 @@ class BIMModelProperties(PropertyGroup):
         offset: float
         show_wall_axis: bool
         show_slab_direction: bool
-        show_paths: bool
 
         prev_transform_orientation_slot_type: str
         prev_show_gizmo_object_translate: bool
@@ -1718,21 +1679,6 @@ class BIMRoofProperties(PropertyGroup):
             setattr(target_props, prop_name, prop_value)
 
 
-class BIMSlabProperties(PropertyGroup):
-    """Transient state for the slab disconnect-access gizmo.
-
-    ``is_editing`` flips True when the user clicks the pen icon on a slab
-    that has wall connections — gating the per-wall disconnect icons in
-    ``GizmoSlabUnjoinWalls`` so they're hidden until the user opts in. No
-    IFC draft state lives here: the disconnect operator commits directly,
-    so this PropertyGroup carries only the UI gate."""
-
-    is_editing: bpy.props.BoolProperty(name="Slab Edit Active", default=False, options={"SKIP_SAVE"})
-
-    if TYPE_CHECKING:
-        is_editing: bool
-
-
 class BIMWallProperties(PropertyGroup):
     """Transient draft state for parametric wall gizmo editing.
 
@@ -1978,155 +1924,6 @@ class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
         sverchok_nodes: Union[sverchok.node_tree.SverchCustomTree, None]
 
 
-class BIMPipeSegmentProperties(PropertyGroup):
-    """Transient draft state for parametric pipe-segment gizmo editing."""
-
-    is_editing: bpy.props.BoolProperty(
-        default=False,
-        description="True while pipe-segment parametric edit mode is active.",
-    )
-    mesh_dirty: bpy.props.BoolProperty(
-        default=False,
-        options={"HIDDEN", "SKIP_SAVE"},
-        description=(
-            "True while the visible mesh is the preview shape; cleared once the "
-            "real IFC-derived geometry is restored (on commit or cancel)."
-        ),
-    )
-    length: bpy.props.FloatProperty(
-        name="Length",
-        default=1.0,
-        min=0.01,
-        subtype="DISTANCE",
-        update=update_pipe_segment,
-        description="Pipe-segment extrusion length (preview value; committed on finish).",
-    )
-    snap_length: bpy.props.FloatProperty(
-        description="Snapshot of length at edit-enable; commit skips no-op writes.",
-    )
-    snap_object_scale_z: bpy.props.FloatProperty(
-        default=1.0,
-        description=(
-            "Snapshot of obj.scale.z at edit-enable. Cancel / no-op-finish restore "
-            "this exact value so a user's non-identity pre-edit scale isn't silently "
-            "zeroed by the scale-based preview."
-        ),
-    )
-
-    if TYPE_CHECKING:
-        is_editing: bool
-        mesh_dirty: bool
-        length: float
-        snap_length: float
-        snap_object_scale_z: float
-
-
-class BIMDuctSegmentProperties(PropertyGroup):
-    """Transient draft state for parametric duct-segment gizmo editing."""
-
-    is_editing: bpy.props.BoolProperty(
-        default=False,
-        description="True while duct-segment parametric edit mode is active.",
-    )
-    mesh_dirty: bpy.props.BoolProperty(
-        default=False,
-        options={"HIDDEN", "SKIP_SAVE"},
-        description=(
-            "True while the visible mesh is the preview shape; cleared once the "
-            "real IFC-derived geometry is restored (on commit or cancel)."
-        ),
-    )
-    length: bpy.props.FloatProperty(
-        name="Length",
-        default=1.0,
-        min=0.01,
-        subtype="DISTANCE",
-        update=update_duct_segment,
-        description="Duct-segment extrusion length (preview value; committed on finish).",
-    )
-    snap_length: bpy.props.FloatProperty(
-        description="Snapshot of length at edit-enable; commit skips no-op writes.",
-    )
-    snap_object_scale_z: bpy.props.FloatProperty(
-        default=1.0,
-        description=(
-            "Snapshot of obj.scale.z at edit-enable. Cancel / no-op-finish restore "
-            "this exact value so a user's non-identity pre-edit scale isn't silently "
-            "zeroed by the scale-based preview."
-        ),
-    )
-
-    if TYPE_CHECKING:
-        is_editing: bool
-        mesh_dirty: bool
-        length: float
-        snap_length: float
-        snap_object_scale_z: float
-
-
-class BIMBendPreviewProperties(PropertyGroup):
-    """Scene-level pending state for the bend-creation preview flow.
-
-    Scene-level (not per-object) because the bend involves two segments by
-    IFC id — neither alone owns the draft."""
-
-    is_active: bpy.props.BoolProperty(
-        default=False,
-        options={"SKIP_SAVE"},
-        description="True while the bend-creation preview flow is active.",
-    )
-    start_segment_id: bpy.props.IntProperty(
-        default=0,
-        options={"SKIP_SAVE"},
-        description="IFC element id of the start (active) segment.",
-    )
-    end_segment_id: bpy.props.IntProperty(
-        default=0,
-        options={"SKIP_SAVE"},
-        description="IFC element id of the end (other selected) segment.",
-    )
-    start_length: bpy.props.FloatProperty(
-        name="Start Length",
-        default=0.1,
-        min=0.001,
-        subtype="DISTANCE",
-        description="Length of the bend fitting's tangent leg on the start (active) segment side",
-    )
-    end_length: bpy.props.FloatProperty(
-        name="End Length",
-        default=0.1,
-        min=0.001,
-        subtype="DISTANCE",
-        description="Length of the bend fitting's tangent leg on the end (other) segment side",
-    )
-    radius: bpy.props.FloatProperty(
-        name="Radius",
-        default=0.2,
-        min=0.001,
-        subtype="DISTANCE",
-        description="Inner radius of the bend curve",
-    )
-    editing_bend_id: bpy.props.IntProperty(
-        default=0,
-        options={"SKIP_SAVE"},
-        description=(
-            "IFC element id of an existing bend fitting being re-edited "
-            "(non-zero only on the pen-icon re-edit flow). The create "
-            "operator deletes this bend + its port connections before "
-            "recreating with the new parameters."
-        ),
-    )
-
-    if TYPE_CHECKING:
-        is_active: bool
-        start_segment_id: int
-        end_segment_id: int
-        start_length: float
-        end_length: float
-        radius: float
-        editing_bend_id: int
-
-
 class BIMWallFilletPreviewProperties(PropertyGroup):
     """Scene-level pending state for the wall-fillet preview flow.
 
@@ -2183,29 +1980,7 @@ class BIMWallFilletPreviewProperties(PropertyGroup):
 class BIMPreviewProperties(PropertyGroup):
     """Umbrella for parametric-edit preview drafts attached to ``Scene``."""
 
-    bend: bpy.props.PointerProperty(type=BIMBendPreviewProperties)
     wall_fillet: bpy.props.PointerProperty(type=BIMWallFilletPreviewProperties)
 
     if TYPE_CHECKING:
-        bend: BIMBendPreviewProperties
         wall_fillet: BIMWallFilletPreviewProperties
-
-
-class BIMParametricEditDialogPrefs(PropertyGroup):
-    """Session-scoped flag for the parametric-edit pen-icon dispatcher.
-
-    Attached to ``WindowManager`` so the state lives for one Blender session
-    and resets on restart — the right scope for "don't show this again for
-    this session" toggles."""
-
-    suppress_shared_rep_warning: bpy.props.BoolProperty(
-        name="Suppress shared-representation warning",
-        description=(
-            "When true, the pen-icon dispatcher skips the shared-geometry "
-            "confirmation dialog. Resets on Blender restart."
-        ),
-        default=False,
-    )
-
-    if TYPE_CHECKING:
-        suppress_shared_rep_warning: bool

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

@@ -18,7 +18,6 @@
 
 
 import json
-import math
 from typing import Any
 
 import bmesh
@@ -28,24 +27,14 @@ import ifcopenshell.api.geometry
 import ifcopenshell.api.pset
 import ifcopenshell.util.representation
 import ifcopenshell.util.unit
-from mathutils import Matrix, Vector
+from mathutils import Vector
 
 import bonsai.core.geometry
 import bonsai.core.root
 import bonsai.tool as tool
-from bonsai.bim.module.drawing import gizmos as gizmo
-from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
-from bonsai.bim.module.model import prop
 from bonsai.bim.module.model.data import RailingData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
-from bonsai.bim.parametric_lifecycle import (
-    CycleTypeMixin,
-    PathPreservingEditMixin,
-    PickTypeMixin,
-)
-from bonsai.tool.cad import WELD_TOLERANCE
-
-V_ = tool.Blender.V_
+from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin
 
 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRailing.htm
@@ -136,56 +125,6 @@ def update_bbim_railing_pset(element: ifcopenshell.entity_instance, railing_data
     ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": railing_data})
 
 
-def generate_wall_mounted_handrail_preview(
-    obj: bpy.types.Object,
-    props: "BIMRailingProperties",
-    path_data: dict[str, Any],
-    si_conversion: float,
-) -> None:
-    """Viewport-only WALL_MOUNTED_HANDRAIL preview: rebuild ``obj.data`` from the same
-    geometry helper the IFC representation builder uses, without writing any IFC."""
-    railing_path = [Vector(v) * si_conversion for v in path_data["verts"]]
-    looped_path = path_data["edges"][-1][-1] == path_data["edges"][0][0]
-
-    geom = ifcopenshell.api.geometry.compute_wall_mounted_handrail_geometry(
-        railing_path=railing_path,
-        support_spacing=props.support_spacing,
-        railing_diameter=props.railing_diameter,
-        clear_width=props.clear_width,
-        height=props.height,
-        use_manual_supports=props.use_manual_supports,
-        terminal_type=props.terminal_type,
-        looped_path=looped_path,
-        unit_scale=1.0,  # props are already SI; bypass the IFC project-units conversion
-    )
-
-    bm = tool.Blender.get_bmesh_for_mesh(obj.data, clean=True)
-
-    tool.Cad.sweep_disk_along_polyline(
-        bm,
-        [Vector(p) for p in geom.handrail_polyline],
-        geom.handrail_radius,
-        arc_indices=geom.handrail_arc_point_indices,
-    )
-
-    for support in geom.supports:
-        tool.Cad.sweep_disk_along_polyline(
-            bm,
-            [Vector(p) for p in support.arc_polyline],
-            support.arc_radius,
-        )
-        tool.Cad.add_disk_extrusion(
-            bm,
-            Vector(support.disk_position),
-            support.disk_radius,
-            support.disk_depth,
-            support.disk_z_rotation,
-        )
-
-    bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
-    tool.Blender.apply_bmesh(obj.data, bm)
-
-
 def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
     """before using should make sure that Data contains up-to-date information.
     If BBIM Pset just changed should call refresh() before updating bmesh
@@ -201,13 +140,6 @@ def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
     path_data = RailingData.data["path_data"]
 
     si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-
-    # WALL_MOUNTED_HANDRAIL renders the preview from the compute helper; IFC stays
-    # untouched until Finish Editing rebuilds the representation.
-    if not props.is_editing_path and props.railing_type == "WALL_MOUNTED_HANDRAIL":
-        generate_wall_mounted_handrail_preview(obj, props, path_data, si_conversion)
-        return
-
     # need to make sure we support edit mode
     # since users will probably be in edit mode when they'll be changing railing path
     bm = tool.Blender.get_bmesh_for_mesh(obj.data, clean=True)
@@ -233,6 +165,8 @@ def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
         thickness = props.thickness
         spacing = props.spacing
 
+        # spacing
+        # split each edge in 3 segments by 0.5 * spacing by x-y plane
         main_edges = bm.edges[:]
         for main_edge in main_edges:
             bm_split_edge_at_offset(main_edge, spacing)
@@ -277,7 +211,7 @@ def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
         bmesh.ops.dissolve_edges(bm, edges=edges_to_dissolve)
         bmesh.ops.dissolve_verts(bm, verts=verts_to_dissolve)
         # to remove unnecessary verts in 0 spacing case
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=WELD_TOLERANCE)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
 
         bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
 
@@ -337,8 +271,8 @@ def get_path_data(obj: bpy.types.Object) -> dict[str, Any]:
             segments.append((i - 1, 0))
             break
 
-        # Vertical-only segments project to a degenerate XY edge; skip to avoid divide-by-zero downstream.
-        if (v.co.xy - prev_v.co.xy).length <= WELD_TOLERANCE:
+        # skip path verts if they just go vertical to avoid errors
+        if (v.co.xy - prev_v.co.xy).length <= 0.0001:
             continue
 
         points.append(v.co)
@@ -473,8 +407,9 @@ class CopyRailingParameters(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class _RailingEditMixin(PathPreservingEditMixin):
-    """Single-object (active_object) railing-edit hooks; path_data is preserved
-    through the edit (path editing is a separate operator family)."""
+    """Type-specific hooks for railing parametric-edit operators. Single-object
+    (active_object). ``path_data`` is preserved through the edit; the separate
+    ``Enable/Finish/CancelEditingRailingPath`` operators handle path editing."""
 
     pset_name = "BBIM_Railing"
 
@@ -501,21 +436,7 @@ class _RailingEditMixin(PathPreservingEditMixin):
         update_railing_modifier_ifc_data(context)
 
     @classmethod
-    def _restore_viewport_after_cancel(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        """WALL_MOUNTED_HANDRAIL reloads the committed Body; others rebuild the preview bmesh."""
-        props = tool.Model.get_railing_props(obj)
-        if props.railing_type == "WALL_MOUNTED_HANDRAIL":
-            element = tool.Ifc.get_entity(obj)
-            assert element
-            body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-            if body:
-                bonsai.core.geometry.switch_representation(
-                    tool.Ifc,
-                    tool.Geometry,
-                    obj=obj,
-                    representation=body,
-                )
-            return
+    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
         update_railing_modifier_bmesh(context)
 
 
@@ -546,554 +467,6 @@ class FinishEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Opera
         return self._finish_targets(context)
 
 
-class CycleRailingType(bpy.types.Operator, tool.Ifc.Operator, CycleTypeMixin):
-    """Cycle railing_type (FRAMELESS_PANEL ↔ WALL_MOUNTED_HANDRAIL). Shift+click reverses."""
-
-    bl_idname = "bim.cycle_railing_type"
-    bl_label = "Cycle Railing Type"
-    bl_options = {"REGISTER", "UNDO"}
-
-    element_checker = tool.Parametric.is_railing
-    props_getter = tool.Model.get_railing_props
-    type_literal = tool.Model.RailingType
-    type_attr = "railing_type"
-
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cycle_type(context)
-
-
-class ToggleRailingUseManualSupports(bpy.types.Operator):
-    """Flip use_manual_supports on the active WALL_MOUNTED_HANDRAIL railing.
-
-    No-op unless a parametric edit is active and the railing is wall-mounted.
-    """
-
-    bl_idname = "bim.toggle_railing_use_manual_supports"
-    bl_label = "Toggle Railing Manual Supports"
-    bl_description = "Switch between automatic support spacing and manual per-vertex placement"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        resolved = tool.Model.resolve_active_props_for_edit(
-            context,
-            tool.Model.get_railing_props,
-            subtype=("railing_type", "WALL_MOUNTED_HANDRAIL"),
-        )
-        if resolved is None:
-            return {"CANCELLED"}
-        _obj, props = resolved
-        props.use_manual_supports = not props.use_manual_supports
-        return {"FINISHED"}
-
-
-class PickRailingTerminalType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
-    """Pick ``terminal_type`` for the active WALL_MOUNTED_HANDRAIL railing."""
-
-    bl_idname = "bim.pick_railing_terminal_type"
-    bl_label = "Pick Railing Terminal Type"
-    bl_description = "Pick the cap geometry applied at the rail ends"
-    bl_options = {"REGISTER", "UNDO"}
-
-    skip_element_check = True
-    props_getter = tool.Model.get_railing_props
-    type_literal = prop.CapType
-    type_attr = "terminal_type"
-
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        if (
-            tool.Model.resolve_active_props_for_edit(
-                context,
-                tool.Model.get_railing_props,
-                subtype=("railing_type", "WALL_MOUNTED_HANDRAIL"),
-            )
-            is None
-        ):
-            return {"CANCELLED"}
-        return self._pick_type(context)
-
-
-def _format_attr_distance(attr_name: str):
-    """text_formatter that renders the named property as a distance, ignoring the
-    dimension's visible-length argument (which is fixed for schematic gizmos)."""
-    return lambda p, _v: tool.Unit.format_distance(getattr(p, attr_name))
-
-
-class GizmoRailingSchematic(bpy.types.GizmoGroup, gizmo.BaseSchematicGizmoGroup):
-    """Schematic-frame parametric editor for railings. Mutually exclusive with path-edit mode."""
-
-    bl_idname = "OBJECT_GGT_bim_railing_edition"
-    bl_label = "Railing Editing Gizmo"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "WINDOW"
-    bl_options = {"3D", "PERSISTENT"}
-
-    enable_editing_operator = "bim.enable_editing_railing"
-    finish_editing_operator = "bim.finish_editing_railing"
-    cancel_editing_operator = "bim.cancel_editing_railing"
-    cycle_type_operator = "bim.cycle_railing_type"
-
-    props_getter = tool.Model.get_railing_props
-    gizmo_pref_name = "railing"
-
-    # Schematic-local layout. +X → screen RIGHT, +Y → screen UP, +Z → toward viewer
-    # (post billboard rotation). Each dimension is anchored alongside the feature it
-    # measures so the label, not the bar length, carries the value.
-    SCHEMATIC_MESH_HEIGHT_FRAC = 0.9  # Mesh top edge in schematic-local +Y
-    SCHEMATIC_MESH_WIDTH_FRAC = 0.7  # Mesh side edges in schematic-local ±X
-    SCHEMATIC_MESH_RAIL_Y_FRAC = SCHEMATIC_MESH_HEIGHT_FRAC / 2  # WALL_MOUNTED_HANDRAIL rail centreline
-    SCHEMATIC_MESH_DEPTH_FRAC = 0.06  # Panel depth — small so the schematic reads as slabs not boxes
-    # WALL_MOUNTED_HANDRAIL dimensions — fractions of schematic_box_size so they
-    # scale with the host group's box size.
-    SCHEMATIC_RAIL_RADIUS_FRAC = 0.05
-    SCHEMATIC_RAIL_CLEAR_FRAC = 0.5  # Stylised — wider than real-world for visible bracket arm
-    SCHEMATIC_RAIL_INSET_FRAC = 0.08  # Wall extends past the outermost support on both sides
-
-    @classmethod
-    def schematic_rail_radius(cls) -> float:
-        return cls.schematic_box_size * cls.SCHEMATIC_RAIL_RADIUS_FRAC
-
-    @classmethod
-    def schematic_rail_clear(cls) -> float:
-        return cls.schematic_box_size * cls.SCHEMATIC_RAIL_CLEAR_FRAC
-
-    # Axonometric 3/4 view: +Z projects down-and-left so the depth axis
-    # is visibly separated from the back face. Without the X tilt, panel
-    # thickness (schematic-local Z) collapses to a near-horizontal bar.
-    schematic_view_rotation = Matrix.Rotation(math.radians(20), 4, "X") @ Matrix.Rotation(math.radians(-25), 4, "Y")
-
-    # Hover a dimension → highlight the schematic edges tagged with the matching feature.
-    # Tags are written by the mesh builders. "spacing" is empty space (no edges) so it's
-    # absent from this map and gracefully no-ops on hover.
-    schematic_attr_to_feature = {
-        "height": "panel_height",
-        "thickness": "panel_thickness",
-        "railing_diameter": "rail_tube",
-        "clear_width": "bracket",
-        "support_spacing": "bracket",
-    }
-
-    schematic_dimension_props = [
-        # ── FRAMELESS_PANEL ─────────────────────────────────────────────
-        DimensionGizmoConfig(
-            attr_name="height",
-            axis=(0, 1, 0),
-            min_value=0.01,
-            # Gated to FRAMELESS_PANEL: in WALL_MOUNTED_HANDRAIL, height only
-            # feeds TO_FLOOR / TO_END_POST_AND_FLOOR terminals so dragging it
-            # is a no-op under the default "180" terminal.
-            visibility_condition=lambda p: p.railing_type == "FRAMELESS_PANEL",
-            matrix_position=lambda p: Vector((-GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2 - 0.08, 0.0, 0.0)),
-            schematic_visible_length=SCHEMATIC_MESH_HEIGHT_FRAC,
-            text_formatter=_format_attr_distance("height"),
-        ),
-        DimensionGizmoConfig(
-            attr_name="thickness",
-            axis=(0, 0, 1),  # panel depth — projects to a true depth direction under the 3/4 tilt
-            min_value=0.005,
-            visibility_condition=lambda p: p.railing_type == "FRAMELESS_PANEL",
-            matrix_position=lambda p: Vector(
-                (
-                    (
-                        -GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2
-                        - GizmoRailingSchematic.SCHEMATIC_MESH_GAP_HALF_WIDTH
-                    )
-                    / 2,
-                    GizmoRailingSchematic.SCHEMATIC_MESH_HEIGHT_FRAC + 0.05,
-                    -GizmoRailingSchematic.SCHEMATIC_MESH_DEPTH_FRAC / 2,
-                )
-            ),
-            schematic_visible_length=0.4,  # longer than default to survive depth foreshortening
-            text_formatter=_format_attr_distance("thickness"),
-        ),
-        DimensionGizmoConfig(
-            attr_name="spacing",
-            axis=(1, 0, 0),
-            min_value=0.0,  # zero-spacing collapses the picket gap into a single continuous panel
-            visibility_condition=lambda p: p.railing_type == "FRAMELESS_PANEL",
-            matrix_position=lambda p: Vector((0.0, -0.1, 0.0)),
-            text_formatter=_format_attr_distance("spacing"),
-        ),
-        # ── WALL_MOUNTED_HANDRAIL ──────────────────────────────────────
-        DimensionGizmoConfig(
-            attr_name="railing_diameter",
-            axis=(0, 1, 0),
-            min_value=0.001,
-            visibility_condition=lambda p: p.railing_type == "WALL_MOUNTED_HANDRAIL",
-            matrix_position=lambda p: Vector(
-                (
-                    -GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2 - 0.05,
-                    GizmoRailingSchematic.SCHEMATIC_MESH_RAIL_Y_FRAC - 0.09,
-                    GizmoRailingSchematic.schematic_rail_clear(),
-                )
-            ),
-            text_formatter=_format_attr_distance("railing_diameter"),
-        ),
-        DimensionGizmoConfig(
-            attr_name="clear_width",
-            axis=(0, 0, 1),  # +Z is the wall-to-rail perpendicular axis under the 3/4 tilt
-            min_value=0.001,
-            visibility_condition=lambda p: p.railing_type == "WALL_MOUNTED_HANDRAIL",
-            matrix_position=lambda p: Vector(
-                (
-                    0.0,
-                    GizmoRailingSchematic.SCHEMATIC_MESH_RAIL_Y_FRAC,
-                    0.0,
-                )
-            ),
-            schematic_visible_length=0.36,  # 2× default so the call-out survives depth projection
-            text_formatter=_format_attr_distance("clear_width"),
-        ),
-        DimensionGizmoConfig(
-            attr_name="support_spacing",
-            axis=(1, 0, 0),
-            min_value=0.05,
-            visibility_condition=lambda p: (p.railing_type == "WALL_MOUNTED_HANDRAIL" and not p.use_manual_supports),
-            matrix_position=lambda p: Vector(
-                (
-                    -GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2
-                    + GizmoRailingSchematic.SCHEMATIC_RAIL_INSET_FRAC,
-                    -0.18,
-                    0.0,
-                )
-            ),
-            # Bare names (not Gizmo…SCHEMATIC_…) because the class is still under construction here.
-            schematic_visible_length=SCHEMATIC_MESH_WIDTH_FRAC - 2 * SCHEMATIC_RAIL_INSET_FRAC,
-            text_formatter=_format_attr_distance("support_spacing"),
-        ),
-    ]
-
-    @classmethod
-    def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Parametric.is_railing(element)
-
-    @classmethod
-    def schematic_cache_key(cls, props) -> tuple:
-        """Cache the schematic mesh by ``railing_type`` — proportions are fixed
-        per type, so the bmesh build runs at most twice across a session
-        (once for ``FRAMELESS_PANEL``, once for ``WALL_MOUNTED_HANDRAIL``)
-        rather than once per draw call."""
-        return (props.railing_type,)
-
-    def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create the WALL_MOUNTED_HANDRAIL-only affordances on the schematic.
-
-        Two static lock glyphs (open/closed) for toggling
-        ``use_manual_supports``: instantiate both and let the per-frame state
-        query pick which one to show. State-aware icons use a static pair
-        rather than a single dynamic gizmo to avoid ``prop_path`` resolution
-        in the render path.
-
-        Plus a cycle-glyph at the rail end that opens the ``terminal_type``
-        popup when clicked.
-        """
-        default_color, highlight_color = self.get_decoration_colors()
-
-        self.lock_open_gizmo, self.lock_closed_gizmo = self.create_icon_gizmo_lock_pair(
-            "bim.toggle_railing_use_manual_supports",
-            open_color=default_color,
-        )
-
-        self.terminal_gizmo = self.gizmos.new("VIEW3D_GT_menu")
-        self.terminal_gizmo.color = default_color
-        self.terminal_gizmo.color_highlight = highlight_color
-        self.terminal_gizmo.use_draw_scale = False
-        self.terminal_gizmo.alpha = 0.8
-        self.terminal_gizmo.target_set_operator("bim.pick_railing_terminal_type")
-
-    def _refresh_element_specific(self, context: bpy.types.Context, mw: "Matrix", props) -> None:
-        """Position and gate the WALL_MOUNTED_HANDRAIL-only gizmos.
-
-        - Lock glyphs: only WALL_MOUNTED_HANDRAIL while editing. Show
-          ``lock_open`` when ``use_manual_supports`` is True, the closed
-          padlock when False ("auto-spacing is locked to support_spacing").
-        - Terminal gizmo: same gating, positioned just past the right rail
-          end so it reads as "configure the rail's end cap".
-        """
-        super()._refresh_element_specific(context, mw, props)
-
-        # ``draw_prepare`` can fire on a freshly recreated GizmoGroup instance
-        # before ``setup_element_specific_gizmos`` has populated the lock /
-        # terminal attributes (Blender 5.x recreates per-region groups on
-        # reload). Bail out cheaply; the next refresh after setup completes
-        # will reposition them correctly.
-        if not hasattr(self, "lock_open_gizmo"):
-            return
-
-        # Single gate for all WALL_MOUNTED_HANDRAIL extras.
-        active = props.is_editing and not props.is_editing_path and props.railing_type == "WALL_MOUNTED_HANDRAIL"
-
-        if not active:
-            self.lock_open_gizmo.hide = True
-            self.lock_closed_gizmo.hide = True
-            self.terminal_gizmo.hide = True
-            return
-
-        billboard_rot = self._frame_billboard_rot
-        view_rotation = self.schematic_view_rotation
-        anchor = self._compute_schematic_anchor(props, mw, billboard_rot)
-
-        # ── Lock glyphs for use_manual_supports ──────────────────────────
-        # Sit just above the wall's bottom line, near the centre of the
-        # schematic — visually grouped with the dimension it controls
-        # (support_spacing) without overlapping the arrow tail below.
-        is_manual = bool(props.use_manual_supports)
-        self.lock_open_gizmo.hide = not is_manual
-        self.lock_closed_gizmo.hide = is_manual
-        lock_local = Vector((0.0, 0.05, 0.0))
-        lock_world = anchor + billboard_rot @ view_rotation @ lock_local
-        lock_matrix = gizmo.billboarded_at(lock_world, billboard_rot, 0.09)
-        self.lock_open_gizmo.matrix_basis = lock_matrix
-        self.lock_closed_gizmo.matrix_basis = lock_matrix
-
-        # ── Terminal-type popup gizmo at the right rail end ──────────────
-        # Pushed well past the right wall edge so the icon doesn't crowd
-        # the wall outline or the bracket attach point. At rail height and
-        # rail depth so it reads as "attached to the rail terminal".
-        self.terminal_gizmo.hide = False
-        terminal_local = Vector(
-            (
-                self.SCHEMATIC_MESH_WIDTH_FRAC / 2 + 0.25,
-                self.SCHEMATIC_MESH_RAIL_Y_FRAC,
-                self.schematic_rail_clear(),
-            )
-        )
-        terminal_world = anchor + billboard_rot @ view_rotation @ terminal_local
-        self.terminal_gizmo.matrix_basis = gizmo.billboarded_at(terminal_world, billboard_rot, 0.18)
-
-    def update_editing_gizmos(self, context: bpy.types.Context, mw: "Matrix", props: "BIMRailingProperties") -> None:
-        """Hide the pen gizmo while polyline path-edit is active; reposition the cycle icon.
-
-        The base class shows the pen gizmo whenever ``is_editing`` is False,
-        which is the case during path-edit too. Allowing the user to click
-        through into parametric edit while the polyline mesh is open in EDIT
-        mode mixes two distinct editing states and leaves a stale draft if
-        they cancel out — block the entry point instead. The operator itself
-        is intentionally not guarded (callers via scripting can still invoke
-        it); this is the UX-level enforcement.
-
-        The cycle icon defaults to the editing icon row (next to validate /
-        cancel) via the parent's positioning. We move it to just above the
-        schematic mesh so it reads as "cycle the railing type *shown here*"
-        — associated with the preview the user is interacting with, not a
-        generic editing button at the bottom of the schematic.
-        """
-        super().update_editing_gizmos(context, mw, props)
-        if props.is_editing_path:
-            self.pen_gizmo.hide = True
-
-        if props.is_editing and not props.is_editing_path:
-            billboard_rot = self._frame_billboard_rot
-            view_rotation = self.schematic_view_rotation
-            anchor = self._compute_schematic_anchor(props, mw, billboard_rot)
-            # Comfortably above the mesh top edge so the icon doesn't crowd
-            # the ``thickness`` / ``clear_width`` dimension callouts that
-            # already sit just above the panel/wall.
-            cycle_local = Vector((0.0, self.SCHEMATIC_MESH_HEIGHT_FRAC + 0.25, 0.0))
-            world_pos = anchor + billboard_rot @ view_rotation @ cycle_local
-            # 30% smaller than the editing-icon-row default (0.30 → 0.21):
-            # the cycle is a tertiary affordance compared to pen/validate/cancel.
-            self.cycle_gizmo.matrix_basis = gizmo.billboarded_at(world_pos, billboard_rot, 0.21)
-
-    @classmethod
-    def build_schematic_mesh(cls, props) -> "bmesh.types.BMesh":
-        """Build a wireframe preview of the railing in schematic-local coordinates.
-
-        FRAMELESS_PANEL renders as a box whose proportions track the bound
-        properties (height / thickness / spacing); WALL_MOUNTED_HANDRAIL
-        renders as a horizontal tube with two L-shaped supports whose
-        proportions track railing_diameter / clear_width / support_spacing.
-        Both are scaled to fit inside ``[-schematic_box_size, +schematic_box_size]``
-        on each axis so the schematic reads the same regardless of absolute
-        property values.
-
-        The mesh is decorative — clicks land on the labeled sliders, not on
-        the preview geometry. See ``BaseSchematicGizmoGroup`` for the
-        draw-handler lifecycle.
-        """
-        bm = bmesh.new()
-        if props.railing_type == "FRAMELESS_PANEL":
-            cls._build_frameless_panel_schematic(bm, props)
-        else:
-            cls._build_wall_mounted_handrail_schematic(bm, props)
-        return bm
-
-    # Schematic-local half-width of the visible gap between the two panel boxes.
-    # Conveys the "spacing" semantic at a glance — the user sees two pickets
-    # separated by air, with the spacing dimension emerging from that gap.
-    SCHEMATIC_MESH_GAP_HALF_WIDTH = 0.05
-
-    @classmethod
-    def _build_frameless_panel_schematic(cls, bm: "bmesh.types.BMesh", props) -> None:
-        """Stylised panel: two wireframe boxes with a visible gap between them.
-
-        The box edges sit at the ``SCHEMATIC_MESH_*_FRAC`` positions
-        (matching where the dimension gizmos anchor), so each dimension line
-        visually starts at the geometry feature it measures. Internal
-        proportions are stable across drags — the actual values are shown
-        through the dimension labels, while the schematic communicates
-        which feature each label refers to. The gap between the two boxes
-        (set by ``SCHEMATIC_MESH_GAP_HALF_WIDTH``) gives the "spacing"
-        dimension a real visual referent.
-
-        Edges are tagged on a string layer so hover-highlight can colour
-        the geometric feature being measured: vertical edges → height,
-        depth edges → thickness. The X-aligned edges along the panel
-        width are untagged (they don't correspond to a single dimension).
-        """
-        hw = cls.SCHEMATIC_MESH_WIDTH_FRAC / 2
-        hd = cls.SCHEMATIC_MESH_DEPTH_FRAC / 2
-        h_top = cls.SCHEMATIC_MESH_HEIGHT_FRAC
-        gap = cls.SCHEMATIC_MESH_GAP_HALF_WIDTH
-
-        layer_name = cls.SCHEMATIC_FEATURE_LAYER_NAME
-        feat_layer = bm.edges.layers.string.get(layer_name) or bm.edges.layers.string.new(layer_name)
-
-        # Edge index → feature tag for one box. Order matches the (a, b)
-        # tuple order below: bottom ring (4) + top ring (4) + verticals (4).
-        edge_tags_per_box = (
-            b"",  # (0,1) bottom-back, X-aligned
-            b"panel_thickness",  # (1,2) bottom-right, Z-aligned
-            b"",  # (2,3) bottom-front, X-aligned
-            b"panel_thickness",  # (3,0) bottom-left, Z-aligned
-            b"",  # (4,5) top-back, X-aligned
-            b"panel_thickness",  # (5,6) top-right, Z-aligned
-            b"",  # (6,7) top-front, X-aligned
-            b"panel_thickness",  # (7,4) top-left, Z-aligned
-            b"panel_height",  # (0,4) vertical back-left
-            b"panel_height",  # (1,5) vertical back-right
-            b"panel_height",  # (2,6) vertical front-right
-            b"panel_height",  # (3,7) vertical front-left
-        )
-
-        # Build two separate wireframe boxes — one on each side of the central
-        # gap. The boxes share the same Y range (0..h_top) and Z range (±hd)
-        # but split the X range so the gap from -gap to +gap stays empty.
-        for x_left, x_right in ((-hw, -gap), (gap, hw)):
-            corners = [
-                bm.verts.new((x_left, 0.0, -hd)),
-                bm.verts.new((x_right, 0.0, -hd)),
-                bm.verts.new((x_right, 0.0, hd)),
-                bm.verts.new((x_left, 0.0, hd)),
-                bm.verts.new((x_left, h_top, -hd)),
-                bm.verts.new((x_right, h_top, -hd)),
-                bm.verts.new((x_right, h_top, hd)),
-                bm.verts.new((x_left, h_top, hd)),
-            ]
-            for tag, (a, b) in zip(
-                edge_tags_per_box,
-                (
-                    (0, 1),
-                    (1, 2),
-                    (2, 3),
-                    (3, 0),  # bottom ring
-                    (4, 5),
-                    (5, 6),
-                    (6, 7),
-                    (7, 4),  # top ring
-                    (0, 4),
-                    (1, 5),
-                    (2, 6),
-                    (3, 7),  # vertical edges
-                ),
-            ):
-                edge = bm.edges.new((corners[a], corners[b]))
-                if tag:
-                    edge[feat_layer] = tag
-
-    @classmethod
-    def _build_wall_mounted_handrail_schematic(cls, bm: "bmesh.types.BMesh", props) -> None:
-        """Stylised wall-mounted handrail: wall outline, hex tube, two L-brackets.
-
-        Three visual elements convey "rail mounted on a wall":
-
-        - **Wall outline** — a wireframe rectangle in the YZ plane at ``z=0``,
-          extending slightly past the rail ends so the wall reads as a
-          surface the rail is *attached to* rather than a coincident frame.
-        - **Handrail tube** — a hexagonal cross-section extruded along ±X
-          at ``z=+clear_s`` (in front of the wall), at ``y=rail_y``.
-        - **L-shaped brackets** at each rail end — from the rail centreline
-          drop a short distance, then run perpendicular back to the wall
-          plane. Mirrors the standard wall-mount bracket geometry: a
-          horizontal arm holding the rail off the wall, a vertical drop
-          attaching to the rail.
-
-        Like ``_build_frameless_panel_schematic``, the schematic uses fixed
-        proportions so the dimension gizmos' anchor points stay aligned
-        with the geometry features regardless of property values.
-        """
-        half_len = cls.SCHEMATIC_MESH_WIDTH_FRAC / 2
-        wall_top = cls.SCHEMATIC_MESH_HEIGHT_FRAC
-        rail_y = cls.SCHEMATIC_MESH_RAIL_Y_FRAC  # rail sits at half wall height
-        radius_s = cls.schematic_rail_radius()
-        clear_s = cls.schematic_rail_clear()
-
-        layer_name = cls.SCHEMATIC_FEATURE_LAYER_NAME
-        feat_layer = bm.edges.layers.string.get(layer_name) or bm.edges.layers.string.new(layer_name)
-
-        # ── Wall outline (rectangle at z=0, slightly wider than the rail) ──
-        # Spans the full schematic height; the rail attaches in the middle,
-        # so the wall reads as "continuing past the rail above and below".
-        # Wall edges stay untagged — they're background context, not a
-        # feature any dimension measures.
-        wall_extra = 0.08
-        wall_x_left = -half_len - wall_extra
-        wall_x_right = half_len + wall_extra
-        wall_corners = [
-            bm.verts.new((wall_x_left, 0.0, 0.0)),
-            bm.verts.new((wall_x_right, 0.0, 0.0)),
-            bm.verts.new((wall_x_right, wall_top, 0.0)),
-            bm.verts.new((wall_x_left, wall_top, 0.0)),
-        ]
-        for a, b in ((0, 1), (1, 2), (2, 3), (3, 0)):
-            bm.edges.new((wall_corners[a], wall_corners[b]))
-
-        # ── Handrail tube (hex cross-section in YZ, extruded along X) ──────
-        # Centred on the rail centreline at (±(half_len - rail_inset),
-        # rail_y, +clear_s) — in front of the wall plane at z=0. The tube
-        # is shorter than the wall so the wall visibly extends past it on
-        # both sides; the L-brackets sit at the tube ends, so the leftmost
-        # bracket no longer coincides with the wall's left edge.
-        rail_inset = cls.SCHEMATIC_RAIL_INSET_FRAC
-        rail_x_left = -half_len + rail_inset
-        rail_x_right = half_len - rail_inset
-        segments = 6
-        ring_left, ring_right = [], []
-        for i in range(segments):
-            theta = 2 * math.pi * i / segments
-            dy = math.cos(theta) * radius_s
-            dz = math.sin(theta) * radius_s
-            ring_left.append(bm.verts.new((rail_x_left, rail_y + dy, clear_s + dz)))
-            ring_right.append(bm.verts.new((rail_x_right, rail_y + dy, clear_s + dz)))
-        # All hex-tube edges tagged "rail_tube" so they highlight together
-        # when the railing_diameter dimension is hovered.
-        for i in range(segments):
-            j = (i + 1) % segments
-            e_left = bm.edges.new((ring_left[i], ring_left[j]))
-            e_right = bm.edges.new((ring_right[i], ring_right[j]))
-            e_axial = bm.edges.new((ring_left[i], ring_right[i]))
-            e_left[feat_layer] = b"rail_tube"
-            e_right[feat_layer] = b"rail_tube"
-            e_axial[feat_layer] = b"rail_tube"
-
-        # ── L-brackets at each rail end (rail → drop → wall) ───────────────
-        # Bracket attach points follow the rail ends, so they're pulled
-        # inward by ``rail_inset`` from the wall edges. From the rail
-        # centreline, drop ``bracket_drop`` in Y, then run perpendicular
-        # back to the wall plane (z=0). The L shape reads as a wall-mount
-        # bracket under the 3/4 tilt. Both bracket segments tagged
-        # "bracket" so they highlight when clear_width OR support_spacing
-        # is hovered (both dimensions measure features of the supports).
-        bracket_drop = 0.06
-        for x in (rail_x_left, rail_x_right):
-            v_rail = bm.verts.new((x, rail_y, clear_s))
-            v_corner = bm.verts.new((x, rail_y - bracket_drop, clear_s))
-            v_wall = bm.verts.new((x, rail_y - bracket_drop, 0.0))
-            e1 = bm.edges.new((v_rail, v_corner))
-            e2 = bm.edges.new((v_corner, v_wall))
-            e1[feat_layer] = b"bracket"
-            e2[feat_layer] = b"bracket"
-
-
 class FlipRailingPathOrder(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.flip_railing_path_order"
     bl_label = "Flip Railing Path Order"
@@ -1137,16 +510,6 @@ class EnableEditingRailingPath(bpy.types.Operator, tool.Ifc.Operator):
         [o.select_set(False) for o in context.selected_objects if o != obj]
         assert obj
         props = tool.Model.get_railing_props(obj)
-
-        # Auto-commit any in-progress parametric draft before switching to
-        # path-edit. ``set_props_kwargs_from_ifc_data`` a few lines below
-        # overwrites props with the pset's stored values — without committing
-        # first, anything the user dragged on a dimension gizmo (height,
-        # diameter, …) would be silently discarded the moment path-edit
-        # starts.
-        if props.is_editing:
-            tool.Parametric.commit_object_draft(obj, "bim.finish_editing_railing")
-
         data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
         # required since we could load pset from .ifc and BIMRoofProperties won't be set
         props.set_props_kwargs_from_ifc_data(data)

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

@@ -271,7 +271,7 @@ class DumbSlabPlaner:
                 # For instances, a 30 degrees angled extrusion with positive direction has the same extrusion direction as a
                 # -150 degrees angled extrusion with negative direction. The difference lies in the object's rotation.
                 # This means that things can get messy if the user changes the object x angle somehow. We have to figure out an alternative approach.
-                existing_x_angle = tool.Model.get_existing_x_angle(extrusion)
+                existing_x_angle = obj.rotation_euler.x
                 existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, 0, tolerance=0.001) else existing_x_angle
                 existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, pi, tolerance=0.001) else existing_x_angle
                 existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, 2 * pi, tolerance=0.001) else existing_x_angle
@@ -620,14 +620,6 @@ class EnableEditingExtrusionProfile(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         obj = context.active_object
-
-        # Commit any in-progress parametric (gizmo) draft on this object
-        # before switching to profile-edit. Otherwise the in-memory draft
-        # state is overwritten when the profile mesh is imported below,
-        # silently discarding the user's pending dimension edits.
-        if feature := tool.Parametric.is_object_editing(obj):
-            tool.Parametric.commit_object_draft(obj, feature.finish_op)
-
         element = tool.Ifc.get_entity(obj)
 
         body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
@@ -999,74 +991,3 @@ class RecalculateSlab(bpy.types.Operator, tool.Ifc.Operator):
 
         tool.Model.recalculate_walls(walls)
         return {"FINISHED"}
-
-
-class EnableEditingSlab(bpy.types.Operator, tool.Ifc.Operator):
-    """Open the slab disconnect-access mode. Pure UI toggle: flips
-    ``obj.BIMSlabProperties.is_editing`` so the per-wall disconnect
-    gizmos surface on the slab. ``tool.Ifc.Operator`` base because the
-    parametric framework's universal dispatcher routes through
-    ``tool.Parametric.run_bim_op``, which only accepts that subclass for
-    undo-safe lifecycle. No IFC mutation."""
-
-    bl_idname = "bim.enable_editing_slab"
-    bl_label = "Edit Slab Connections"
-    bl_description = "Show disconnect icons for every wall clipped to this slab"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        if obj is None:
-            return False
-        element = tool.Ifc.get_entity(obj)
-        return element is not None and element.is_a("IfcSlab")
-
-    def _execute(self, context):
-        context.active_object.BIMSlabProperties.is_editing = True
-        return {"FINISHED"}
-
-
-class CancelEditingSlab(bpy.types.Operator, tool.Ifc.Operator):
-    """Close the slab disconnect-access mode."""
-
-    bl_idname = "bim.cancel_editing_slab"
-    bl_label = "Close Slab Edit"
-    bl_description = "Hide the slab disconnect icons"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        if obj is None:
-            return False
-        element = tool.Ifc.get_entity(obj)
-        return element is not None and element.is_a("IfcSlab")
-
-    def _execute(self, context):
-        context.active_object.BIMSlabProperties.is_editing = False
-        return {"FINISHED"}
-
-
-class FinishEditingSlab(bpy.types.Operator, tool.Ifc.Operator):
-    """Close the slab disconnect-access mode. Same body as Cancel — slab
-    edit is a pure UI gate with no IFC draft to commit; the framework
-    requires both ``bim.finish_editing_<name>`` and
-    ``bim.cancel_editing_<name>`` to exist by name convention."""
-
-    bl_idname = "bim.finish_editing_slab"
-    bl_label = "Finish Slab Edit"
-    bl_description = "Hide the slab disconnect icons"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        if obj is None:
-            return False
-        element = tool.Ifc.get_entity(obj)
-        return element is not None and element.is_a("IfcSlab")
-
-    def _execute(self, context):
-        context.active_object.BIMSlabProperties.is_editing = False
-        return {"FINISHED"}

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

@@ -22,9 +22,9 @@ from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 import bpy
-import ifcopenshell.util.unit
 from bpy.types import Panel
 
+import ifcopenshell.util.unit
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import prop_with_search

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

@@ -963,11 +963,7 @@ class EditObjectUI:
 
     @classmethod
     def draw_regen_operations(cls, row, ui_context):
-        # ``AuthoringData.load`` flips ``is_loaded`` at entry as a recursion
-        # guard, so a partial load (any computation along the way raising)
-        # leaves the tail keys unset. ``.get()`` keeps the header draw alive
-        # until the underlying failure is investigated.
-        if AuthoringData.data.get("is_regenable_element"):
+        if AuthoringData.data["is_regenable_element"]:
             row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
             add_layout_hotkey_operator(row, "Regen", "S_G", "Recalculate Element Geometry", ui_context)
 
@@ -1321,7 +1317,7 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
                 bpy.ops.bim.recalculate_profile()
         elif self.active_class in ("IfcWindow", "IfcWindowStandardCase", "IfcDoor", "IfcDoorStandardCase"):
             bpy.ops.bim.recalculate_fill()
-        elif self.active_class in ("IfcSpace",):
+        elif self.active_class in ("IfcSpace"):
             bpy.ops.bim.generate_space()
 
     def hotkey_S_M(self):

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

@@ -20,6 +20,7 @@ import blf
 import bpy
 import gpu
 import ifcopenshell.util.element
+from bpy.types import SpaceView3D
 from bpy_extras import view3d_utils
 from gpu_extras.batch import batch_for_shader
 from mathutils import Vector
@@ -27,6 +28,12 @@ from mathutils import Vector
 import bonsai.tool as tool
 
 
+def transparent_color(color, alpha=0.1):
+    color = [i for i in color]
+    color[3] = alpha
+    return color
+
+
 def create_bounding_box(objs):
     # Initialize the bounding box coordinates
     min_x, min_y, min_z = float("inf"), float("inf"), float("inf")
@@ -72,8 +79,26 @@ def create_bounding_box(objs):
     return indices, edges
 
 
-class NestDecorator(tool.Blender.ViewportDecorator):
-    draw_method = "draw_nest"
+class NestDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_nest, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
 
     def dotted_line_shader(self):
         vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
@@ -129,6 +154,14 @@ class NestDecorator(tool.Blender.ViewportDecorator):
         shader.uniform_float("u_Scale", 25)
         batch.draw(shader)
 
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
     def draw_nest(self, context: bpy.types.Context) -> None:
         props = tool.Nest.get_nest_props()
         if props.in_nest_mode:
@@ -193,11 +226,35 @@ class NestDecorator(tool.Blender.ViewportDecorator):
             self.draw_custom_batch(line, decorator_color_unselected)
 
 
-class NestModeDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_nest_name", "POST_PIXEL"),
-        ("draw_nest_empty", "POST_VIEW"),
-    )
+class NestModeDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_nest_name, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_nest_empty, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
 
     def draw_nest_name(self, context):
         if context.mode == "EDIT_MESH":

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

@@ -21,7 +21,6 @@ import bpy
 from . import operator, prop, ui
 
 classes = (
-    operator.AddIfcPatchPreset,
     operator.ExecuteIfcPatch,
     operator.ExtractSelectedElements,
     operator.RunMigratePatch,
@@ -29,7 +28,6 @@ classes = (
     operator.SelectIfcPatchOutput,
     operator.UpdateIfcPatchArguments,
     prop.BIMPatchProperties,
-    ui.BIM_MT_ifc_patch_presets,
     ui.BIM_PT_patch,
 )
 

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

@@ -23,7 +23,6 @@ from typing import TYPE_CHECKING, cast
 import bpy
 import ifcopenshell
 import ifcpatch
-from bl_operators.presets import AddPresetBase
 from bpy_extras.io_utils import ExportHelper, ImportHelper
 
 import bonsai.bim.handler
@@ -78,27 +77,6 @@ class ExecuteIfcPatch(bpy.types.Operator):
             return False
         return True
 
-    def invoke(self, context, event):
-        # Migrating IFC4 → IFC2X3 is lossy (enum drops, IFC4-only classes
-        # become IfcBuildingElementProxy, tessellated meshes get rebuilt as
-        # IfcFacetedBrep). Confirm before running so the user knows.
-        if tool.Patch.migration_is_lossy_downgrade():
-            return context.window_manager.invoke_props_dialog(self, width=480)
-        return self.execute(context)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="Downgrading to IFC2X3 is lossy.", icon="ERROR")
-        column = layout.column(align=True)
-        column.label(text="Geometry will be preserved as faithfully as possible:")
-        column.label(text="• IfcIndexedPolyCurve → IfcPolyline (arcs approximated by chords)")
-        column.label(text="• IfcPolygonalFaceSet / IfcTriangulatedFaceSet → IfcFacetedBrep")
-        column.separator()
-        column.label(text="The following information is lost:")
-        column.label(text="• IFC4-only classes (IfcLamp, IfcPipeSegment, …) → IfcBuildingElementProxy")
-        column.label(text="• PredefinedType enum values absent from IFC2X3 are dropped")
-        column.label(text="  (original class + enum saved as ObjectType, e.g. 'IfcLamp/COMPACTFLUORESCENT')")
-
     def execute(self, context):
         props = tool.Patch.get_patch_props()
         recipe_name = props.ifc_patch_recipes
@@ -246,38 +224,3 @@ class ExtractSelectedElements(bpy.types.Operator):
         query = tool.Search.get_query_for_selected_elements()
         props.ifc_patch_args_attr[0].string_value = query
         return {"FINISHED"}
-
-
-class AddIfcPatchPreset(AddPresetBase, bpy.types.Operator):
-    """Save / remove ifc-patch argument presets, scoped per recipe.
-
-    Presets live in the standard Blender preset directory under
-    ``bonsai/ifc_patch/<recipe>/`` so a preset created for ``ExtractElements``
-    does not pollute the preset list for ``Migrate``. Persistence across files
-    and sessions is inherited from Blender's preset system."""
-
-    bl_idname = "bim.add_ifc_patch_preset"
-    bl_label = "Add IFC Patch Preset"
-    preset_menu = "BIM_MT_ifc_patch_presets"
-    preset_defines = ["props = bpy.context.scene.BIMPatchProperties"]
-
-    @property
-    def preset_subdir(self) -> str:
-        return tool.Patch.get_preset_subdir()
-
-    @property
-    def preset_values(self) -> list[str]:
-        # `Attribute.get_value_name()` returns the storage field for the
-        # argument's data_type (string_value, bool_value, …). For file
-        # arguments it returns the wrapping PointerProperty (`filepath_value`)
-        # — the scalar path the preset needs is `.single_file` on that.
-        props = tool.Patch.get_patch_props()
-        values = []
-        for i, arg in enumerate(props.ifc_patch_args_attr):
-            field = arg.get_value_name()
-            if not field:
-                continue
-            if arg.data_type == "file":
-                field = f"{field}.single_file"
-            values.append(f"props.ifc_patch_args_attr[{i}].{field}")
-        return values

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

@@ -71,15 +71,6 @@ def get_ifcpatch_recipes(self: "BIMPatchProperties", context: bpy.types.Context)
 
 def update_ifc_patch_recipe(self: "BIMPatchProperties", context: bpy.types.Context) -> None:
     bpy.ops.bim.update_ifc_patch_arguments(recipe=self.ifc_patch_recipes)
-    # Blender's script.execute_preset mutates the menu class's bl_label to
-    # the loaded preset's display name (used as a "currently selected"
-    # indicator). The label persists across recipe changes — making the new
-    # recipe's menu falsely show the previous recipe's preset name. Reset
-    # the label to the menu's canonical title so it always matches the
-    # active recipe's preset list.
-    menu_cls = getattr(bpy.types, "BIM_MT_ifc_patch_presets", None)
-    if menu_cls is not None:
-        menu_cls.bl_label = "IFC Patch Presets"
 
 
 class BIMPatchProperties(PropertyGroup):

src/bonsai/bonsai/bim/module/patch/ui.py

@@ -29,20 +29,6 @@ if TYPE_CHECKING:
     from bonsai.bim.prop import Attribute
 
 
-class BIM_MT_ifc_patch_presets(bpy.types.Menu):
-    """Lists ifc-patch presets for the currently selected recipe.
-
-    ``preset_subdir`` is resolved per draw so switching recipes swaps the
-    preset list without re-registering the menu."""
-
-    bl_label = "IFC Patch Presets"
-    preset_operator = "script.execute_preset"
-
-    def draw(self, context: bpy.types.Context) -> None:
-        self.preset_subdir = tool.Patch.get_preset_subdir()
-        bpy.types.Menu.draw_preset(self, context)
-
-
 class BIM_PT_patch(bpy.types.Panel):
     bl_label = "Patch"
     bl_idname = "BIM_PT_patch"
@@ -80,11 +66,6 @@ class BIM_PT_patch(bpy.types.Panel):
                 row.operator("bim.patch_query_from_selected", text="", icon="EYEDROPPER")
 
         if props.ifc_patch_args_attr:
-            preset_row = layout.row(heading="Preset", align=True)
-            preset_row.menu("BIM_MT_ifc_patch_presets", text=BIM_MT_ifc_patch_presets.bl_label)
-            preset_row.operator("bim.add_ifc_patch_preset", text="", icon="ADD")
-            preset_row.operator("bim.add_ifc_patch_preset", text="", icon="REMOVE").remove_active = True
-
             draw_callback = draw_callback_ if props.ifc_patch_recipes == "ExtractElements" else None
             draw_attributes(props.ifc_patch_args_attr, layout, callback=draw_callback)
 

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

@@ -28,12 +28,6 @@ classes = (
     operator.AppendLibraryElementByQuery,
     operator.AssignLibraryDeclaration,
     operator.BIM_FH_import_ifc,
-    operator.BIM_OT_apply_pending_opening_cuts,
-    operator.BIM_OT_dismiss_multi_instance_warning,
-    operator.BIM_OT_dismiss_pending_array_repair,
-    operator.BIM_OT_dismiss_pending_opening_cuts,
-    operator.BIM_OT_select_pending_array_repair,
-    operator.BIM_OT_select_pending_opening_cuts,
     operator.BIM_OT_load_clipping_planes,
     operator.BIM_OT_save_clipping_planes,
     operator.ChangeLibraryElement,
@@ -88,8 +82,6 @@ classes = (
     prop.FilterCategory,
     prop.Link,
     prop.EditedObj,
-    prop.PendingArrayRepair,
-    prop.PendingOpeningRecut,
     prop.BIMProjectProperties,
     prop.MeasureToolSettings,
     ui.BIM_MT_new_project,

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

@@ -162,8 +162,8 @@ class ProjectLibraryData:
         library_file = IfcStore.library_file
         if library_file is None or library_file.schema == "IFC2X3":
             return results
-        root = tool.Project.get_root_context(library_file)
-        results.append((str(root.id()), f"{root.is_a()} {root.Name or 'Unnamed'}", root.Description or ""))
+        project = library_file.by_type("IfcProject")[0]
+        results.append((str(project.id()), f"IfcProject {project.Name or 'Unnamed'}", project.Description or ""))
         for library_id, data in cls.data["project_libraries"].items():
             results.append((str(library_id), data["Name"] or "Unnamed", data["Description"] or ""))
         return results

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

@@ -42,6 +42,12 @@ def toggle_decorations_on_load(*args):
     # as queried object is linked from separate .blend file.
 
 
+def transparent_color(color, alpha=0.1):
+    color = [i for i in color]
+    color[3] = alpha
+    return color
+
+
 class ProjectDecorator:
     installed = None
 
@@ -74,6 +80,11 @@ class ProjectDecorator:
         unselected_elements_color = self.addon_prefs.decorator_color_unselected
         special_elements_color = self.addon_prefs.decorator_color_special
 
+        def transparent_color(color, alpha=0.1):
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
         gpu.state.point_size_set(6)
         gpu.state.blend_set("ALPHA")
 
@@ -99,9 +110,7 @@ class ProjectDecorator:
 
         if geom.selected_edges:
             self.draw_batch("LINES", selected_vertices, selected_elements_color, geom.selected_edges)
-            self.draw_batch(
-                "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), geom.selected_tris
-            )
+            self.draw_batch("TRIS", selected_vertices, transparent_color(selected_elements_color), geom.selected_tris)
 
 
 class ClippingPlaneDecorator:
@@ -136,6 +145,11 @@ class ClippingPlaneDecorator:
         unselected_elements_color = self.addon_prefs.decorator_color_unselected
         special_elements_color = self.addon_prefs.decorator_color_special
 
+        def transparent_color(color, alpha=0.1):
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
         gpu.state.point_size_set(6)
         gpu.state.blend_set("ALPHA")
 
@@ -196,21 +210,37 @@ class ClippingPlaneDecorator:
 
             if unselected_edges:
                 self.draw_batch("LINES", unselected_vertices, special_elements_color, unselected_edges)
-                self.draw_batch(
-                    "TRIS", unselected_vertices, tool.Blender.transparent_color(special_elements_color), unselected_tris
-                )
+                self.draw_batch("TRIS", unselected_vertices, transparent_color(special_elements_color), unselected_tris)
             if selected_edges:
                 self.draw_batch("LINES", selected_vertices, selected_elements_color, selected_edges)
-                self.draw_batch(
-                    "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), selected_tris
-                )
+                self.draw_batch("TRIS", selected_vertices, transparent_color(selected_elements_color), selected_tris)
 
 
-class MeasureDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_measurements_text", "POST_PIXEL"),
-        ("draw_measurements_poly", "POST_VIEW"),
-    )
+class MeasureDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(
+            SpaceView3D.draw_handler_add(handler.draw_measurements_text, (context,), "WINDOW", "POST_PIXEL")
+        )
+        cls.handlers.append(
+            SpaceView3D.draw_handler_add(handler.draw_measurements_poly, (context,), "WINDOW", "POST_VIEW")
+        )
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
 
     def draw_measurements_text(self, context):
         PolylineDecorator().select_and_draw_measurements_text(context)

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

@@ -281,9 +281,9 @@ class RefreshLibrary(bpy.types.Operator):
         elements = {e for e in elements if not tool.Project.is_element_assigned_to_project_library(e, rels)}
         self.props.add_library_project_library("Unassigned", len(elements), 0, False)
 
-        root_context = tool.Project.get_root_context(library_file)
+        ifc_project = library_file.by_type("IfcProject")[0]
         hierarchy = tool.Project.get_project_hierarchy(library_file)
-        tool.Project.load_project_libraries_to_ui(root_context, hierarchy)
+        tool.Project.load_project_libraries_to_ui(ifc_project, hierarchy)
         return {"FINISHED"}
 
 
@@ -763,10 +763,7 @@ class EditProjectLibrary(bpy.types.Operator):
         previous_parent_library = tool.Project.get_parent_library(project_library)
         new_parent_library = library_file.by_id(int(props.parent_library))
         if previous_parent_library != new_parent_library:
-            if previous_parent_library is None:
-                # Edited library was a root in a library-only file; nest it under the new parent.
-                ifcopenshell.api.nest.assign_object(library_file, [project_library], new_parent_library)
-            elif previous_parent_library.is_a("IfcProject"):
+            if previous_parent_library.is_a("IfcProject"):
                 # Then new one is IfcProjectLibrary.
                 ifcopenshell.api.nest.assign_object(library_file, [project_library], new_parent_library)
             else:  # Previous is IfcProjectLibrary.
@@ -807,12 +804,9 @@ class AddProjectLibrary(bpy.types.Operator):
         props = tool.Project.get_project_props()
         library_file = IfcStore.library_file
         assert library_file
-        root_context = tool.Project.get_root_context(library_file)
+        project = library_file.by_type("IfcProject")[0]
         project_library = ifcopenshell.api.root.create_entity(library_file, "IfcProjectLibrary")
-        if root_context.is_a("IfcProject"):
-            ifcopenshell.api.project.assign_declaration(library_file, [project_library], root_context)
-        else:
-            ifcopenshell.api.nest.assign_object(library_file, [project_library], root_context)
+        ifcopenshell.api.project.assign_declaration(library_file, [project_library], project)
         ProjectLibraryData.load()  # Update enum.
         props.selected_project_library = str(project_library.id())
         props.is_editing_project_library = True
@@ -970,11 +964,11 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
     use_relative_path: bpy.props.BoolProperty(
         name="Use Relative Path",
         description="Store the IFC project path relative to the .blend file. Requires .blend file to be saved",
-        default=False,
+        default=True,
     )
     should_start_fresh_session: bpy.props.BoolProperty(
         name="Should Start Fresh Session",
-        description="Clear current Blender session before loading IFC. Not supported with 'Use Relative Path' option",
+        description="Clear current Blender session before loading IFC",
         default=True,
     )
     import_without_ifc_data: bpy.props.BoolProperty(
@@ -1082,9 +1076,6 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
             bpy.app.handlers.load_post.remove(load_handler)
             self.finish_loading_project(context)
 
-        if self.use_relative_path:
-            self.should_start_fresh_session = False
-
         if self.should_start_fresh_session:
             # WARNING: wm.read_homefile clears context which could lead to some
             # operators to fail:
@@ -1119,14 +1110,6 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
                     f"Error loading IFC file from filepath '{filepath}'. See logs above in the system console for the details.",
                 )
                 return {"CANCELLED"}
-            if not tool.Ifc.get().by_type("IfcProject"):
-                self.report(
-                    {"ERROR"},
-                    "This file contains no IfcProject. It is likely an IFC project library — "
-                    "load it via Project Setup → Project Library → Select Library File instead.",
-                )
-                IfcStore.purge()
-                return {"CANCELLED"}
             props = tool.Project.get_project_props()
             props.is_loading = True
             props.total_elements = len(tool.Ifc.get().by_type("IfcElement"))
@@ -1157,8 +1140,6 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
         return ImportHelper.invoke(self, context, event)
 
     def draw(self, context):
-        if self.use_relative_path:
-            self.should_start_fresh_session = False
         self.layout.prop(self, "is_advanced")
         self.layout.prop(self, "should_start_fresh_session")
         self.layout.prop(self, "import_without_ifc_data")
@@ -1237,30 +1218,6 @@ class LoadProjectElements(bpy.types.Operator):
         props = tool.Project.get_project_props()
         props.is_loading = False
 
-        # Stash elements the kernel skipped opening cuts on (HasOpenings > void_limit).
-        # The Project panel banner offers the user a one-click recut.
-        props.pending_opening_recut.clear()
-        if ifc_importer.gross_elements:
-            for element in ifc_importer.gross_elements:
-                item = props.pending_opening_recut.add()
-                item.ifc_definition_id = element.id()
-            self.report(
-                {"WARNING"},
-                f"{len(ifc_importer.gross_elements)} element(s) had too many openings and were loaded without cuts. "
-                f"Apply manually from the Project panel.",
-            )
-
-        props.pending_array_repair.clear()
-        if ifc_importer.broken_arrays:
-            for element in ifc_importer.broken_arrays:
-                item = props.pending_array_repair.add()
-                item.ifc_definition_id = element.id()
-            self.report(
-                {"WARNING"},
-                f"{len(ifc_importer.broken_arrays)} array parent(s) reference missing child GUIDs. "
-                f"Inspect from the Project panel.",
-            )
-
         tool.Project.load_default_thumbnails()
         tool.Project.set_default_context()
         tool.Project.set_default_modeling_dimensions()
@@ -1294,11 +1251,6 @@ class LoadProjectElements(bpy.types.Operator):
             if element.IsDecomposedBy:
                 for subelement in element.IsDecomposedBy[0].RelatedObjects:
                     decomposed_elements.add(subelement)
-            # IfcSurfaceFeature (e.g. road markings) adhere to a host element
-            # via IfcRelAdheresToElement, a [1:1] hierarchical relationship in
-            # the same family as aggregation, containment and nesting (IFC4.3).
-            for rel in getattr(element, "HasSurfaceFeatures", ()):
-                decomposed_elements.update(rel.RelatedSurfaceFeatures)
         if decomposed_elements:
             self.append_decomposed_elements(decomposed_elements)
         elements.update(decomposed_elements)
@@ -1427,7 +1379,6 @@ class LinkIfc(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
                 new.ifc_definition_id = reference.id()
             new.name = filepath
             new.filepath = filepath
-            new.query = self.query
             bpy.ops.bim.load_link(link_index=-1, use_cache=self.use_cache, query=self.query)
 
 
@@ -1498,10 +1449,6 @@ class LoadLink(bpy.types.Operator, tool.Ifc.Operator):
 
     def _execute(self, context):
         self.link = tool.Project.get_project_props().links[self.link_index]
-        # Fall back to the Link's stored query so callers that omit it
-        # still replay the filter the link was created with.
-        if not self.query and self.link.query:
-            self.query = self.link.query
         filepath = Path(tool.Ifc.resolve_uri(self.link.filepath))
         if not filepath.exists():
             self.report({"ERROR"}, f"File does not exist: '{filepath}'")
@@ -1669,36 +1616,13 @@ class ReloadLink(bpy.types.Operator):
     bl_description = "Reload the selected file"
 
     link_index: bpy.props.IntProperty(name="Link Index")
-    query: bpy.props.StringProperty(
-        name="Query",
-        description=(
-            "Custom selector query to use to load element from a linked model. E.g. 'IfcElement'.\n\n"
-            "Default query - IfcElement, but excluding IfcProxy, IfcSpatialStructureElement, IfcSpatialElement, IfcFeatureElement."
-        ),
-    )
 
     if TYPE_CHECKING:
         link_index: int
-        query: str
-
-    def invoke(self, context, event):
-        link = tool.Project.get_project_props().links[self.link_index]
-        self.query = link.query
-        return context.window_manager.invoke_props_dialog(self)
-
-    def draw(self, context):
-        assert self.layout
-        self.layout.prop(self, "query", placeholder="IfcElement")
 
     def execute(self, context):
-        link = tool.Project.get_project_props().links[self.link_index]
-        # An unset query means the operator was called without the dialog
-        # (e.g. from a script) - preserve the link's stored query instead
-        # of overwriting it with the empty default.
-        if self.properties.is_property_set("query"):
-            link.query = self.query
         bpy.ops.bim.unload_link(link_index=self.link_index)
-        return bpy.ops.bim.load_link(link_index=self.link_index, use_cache=False, query=link.query) or {"FINISHED"}
+        return bpy.ops.bim.load_link(link_index=self.link_index, use_cache=False) or {"FINISHED"}
 
 
 class ToggleLinkSelectability(bpy.types.Operator):
@@ -1946,7 +1870,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
     json_version: bpy.props.EnumProperty(items=[("4", "4", ""), ("5a", "5a", "")], name="IFC JSON Version")
     json_compact: bpy.props.BoolProperty(name="Export Compact IFCJSON", default=False)
     should_save_as: bpy.props.BoolProperty(name="Should Save As", default=False, options={"HIDDEN"})
-    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=False)
+    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=True)
 
     if TYPE_CHECKING:
         filter_glob: str
@@ -3492,149 +3416,3 @@ class GenerateUVMap(bpy.types.Operator):
         tool.Loader.load_generated_uv_map(obj.data)
         self.report({"INFO"}, "Generated UV map for selected mesh.")
         return {"FINISHED"}
-
-
-class BIM_OT_apply_pending_opening_cuts(bpy.types.Operator, tool.Ifc.Operator):
-    """Recompute the wall mesh including opening subtractions for every host
-    that the load-time ``void_limit`` filter skipped. Clears the deferred
-    list on completion so the panel banner disappears."""
-
-    bl_idname = "bim.apply_pending_opening_cuts"
-    bl_label = "Apply Pending Opening Cuts"
-    bl_description = (
-        "Recompute meshes for elements whose openings were skipped at load because they had too many openings"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        pending = tool.Project.get_project_props().pending_opening_recut
-        applied = 0
-        skipped = 0
-        failed = 0
-        for item in pending:
-            try:
-                element = tool.Ifc.get().by_id(item.ifc_definition_id)
-            except RuntimeError:
-                skipped += 1
-                continue
-            obj = tool.Ifc.get_object(element)
-            if obj is None:
-                skipped += 1
-                continue
-            body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-            if body is None:
-                skipped += 1
-                continue
-            try:
-                tool.Geometry.reimport_element_representations(obj, body, apply_openings=True)
-                applied += 1
-            except (RuntimeError, OSError, AttributeError) as exc:
-                # Programmer errors (TypeError, ValueError, etc.) must surface — don't swallow them.
-                failed += 1
-                print(f"apply_pending_opening_cuts: failed to recompute {element} ({exc})")
-
-        pending.clear()
-        message = f"Applied opening cuts to {applied} element(s)."
-        if skipped:
-            message += f" {skipped} entry/entries skipped (entity or object no longer available)."
-        if failed:
-            message += f" {failed} entry/entries failed (see system console)."
-            self.report({"WARNING"}, message)
-        else:
-            self.report({"INFO"}, message)
-        return {"FINISHED"}
-
-
-class BIM_OT_dismiss_pending_opening_cuts(bpy.types.Operator):
-    bl_idname = "bim.dismiss_pending_opening_cuts"
-    bl_label = "Dismiss Pending Opening Cuts"
-    bl_description = "Clear the pending opening-cut list without applying it. Walls stay solid where openings would have been subtracted."
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context: bpy.types.Context) -> set[str]:
-        tool.Project.get_project_props().pending_opening_recut.clear()
-        return {"FINISHED"}
-
-
-class BIM_OT_dismiss_multi_instance_warning(bpy.types.Operator):
-    bl_idname = "bim.dismiss_multi_instance_warning"
-    bl_label = "Dismiss Multi-Instance Warning"
-    bl_description = (
-        "Hide the warning that another Blender instance has this IFC file open. Sticky for the current session."
-    )
-    bl_options = {"REGISTER"}
-
-    def execute(self, context: bpy.types.Context) -> set[str]:
-        from bonsai.bim.ifc import dismiss_multi_instance_warning
-
-        dismiss_multi_instance_warning()
-        return {"FINISHED"}
-
-
-class BIM_OT_select_pending_opening_cuts(bpy.types.Operator):
-    bl_idname = "bim.select_pending_opening_cuts"
-    bl_label = "Select Elements With Skipped Opening Cuts"
-    bl_description = "Select the Blender objects whose openings were skipped at load. Useful for locating which elements need attention."
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context: bpy.types.Context) -> set[str]:
-        ifc_file = tool.Ifc.get()
-        if ifc_file is None:
-            self.report({"INFO"}, "No IFC file loaded.")
-            return {"CANCELLED"}
-        objects: list[bpy.types.Object] = []
-        for item in tool.Project.get_project_props().pending_opening_recut:
-            try:
-                element = ifc_file.by_id(item.ifc_definition_id)
-            except RuntimeError:
-                continue
-            obj = tool.Ifc.get_object(element)
-            if obj is not None:
-                objects.append(obj)
-        if not objects:
-            self.report({"INFO"}, "No matching Blender objects found for the pending list.")
-            return {"CANCELLED"}
-        tool.Blender.set_objects_selection(context, active_object=objects[0], selected_objects=objects)
-        self.report({"INFO"}, f"Selected {len(objects)} element(s).")
-        return {"FINISHED"}
-
-
-class BIM_OT_select_pending_array_repair(bpy.types.Operator):
-    bl_idname = "bim.select_pending_array_repair"
-    bl_label = "Select Array Parents With Missing Children"
-    bl_description = "Select the Blender objects of array parents whose BBIM_Array.Data references children that don't resolve in the file."
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context: bpy.types.Context) -> set[str]:
-        ifc_file = tool.Ifc.get()
-        if ifc_file is None:
-            self.report({"INFO"}, "No IFC file loaded.")
-            return {"CANCELLED"}
-        objects: list[bpy.types.Object] = []
-        for item in tool.Project.get_project_props().pending_array_repair:
-            try:
-                element = ifc_file.by_id(item.ifc_definition_id)
-            except RuntimeError:
-                continue
-            obj = tool.Ifc.get_object(element)
-            if obj is not None:
-                objects.append(obj)
-        if not objects:
-            self.report({"INFO"}, "No matching Blender objects found for the pending list.")
-            return {"CANCELLED"}
-        tool.Blender.set_objects_selection(context, active_object=objects[0], selected_objects=objects)
-        self.report({"INFO"}, f"Selected {len(objects)} array parent(s).")
-        return {"FINISHED"}
-
-
-class BIM_OT_dismiss_pending_array_repair(bpy.types.Operator):
-    bl_idname = "bim.dismiss_pending_array_repair"
-    bl_label = "Dismiss Pending Array Repair"
-    bl_description = (
-        "Clear the pending array-repair list without acting on it. The underlying BBIM_Array.Data stays unchanged."
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context: bpy.types.Context) -> set[str]:
-        tool.Project.get_project_props().pending_array_repair.clear()
-        return {"FINISHED"}

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

@@ -98,8 +98,7 @@ def is_editing_project_library_update(self: "BIMProjectProperties", context: bpy
         project_library = library_file.by_id(int(self.selected_project_library))
         self.project_library_attributes.clear()
         bonsai.bim.helper.import_attributes(project_library, self.project_library_attributes)
-        if parent_library := tool.Project.get_parent_library(project_library):
-            self.parent_library = str(parent_library.id())
+        self.parent_library = str(tool.Project.get_parent_library(project_library).id())
         ProjectLibraryData.load()  # Show edit icon in enum.
         return
 
@@ -260,11 +259,6 @@ class Link(PropertyGroup):
         description="STEP ID of the IfcDocumentReference when linked to a parent IFC project. Zero when no parent IFC exists",
         default=0,
     )
-    query: StringProperty(
-        name="Query",
-        description="Selector query used to filter elements when loading the linked model",
-        default="",
-    )
 
     if TYPE_CHECKING:
         name: str
@@ -280,7 +274,6 @@ class Link(PropertyGroup):
         include_in_drawings: bool
         empty_handle: Union[bpy.types.Object, None]
         ifc_definition_id: int
-        query: str
 
 
 class EditedObj(PropertyGroup):
@@ -302,28 +295,6 @@ class LibraryBreadcrumb(PropertyGroup):
         library_id: int
 
 
-class PendingOpeningRecut(PropertyGroup):
-    """One element whose ``HasOpenings`` exceeded ``void_limit`` at load time
-    and was imported without opening subtractions. The user can later apply
-    them on demand from the Project panel banner."""
-
-    ifc_definition_id: IntProperty(name="IFC Definition ID")
-
-    if TYPE_CHECKING:
-        ifc_definition_id: int
-
-
-class PendingArrayRepair(PropertyGroup):
-    """One array parent whose ``BBIM_Array.Data`` references at least one
-    child GUID that does not resolve in the current IFC file. The user can
-    select these parents from the Project panel banner to inspect them."""
-
-    ifc_definition_id: IntProperty(name="IFC Definition ID")
-
-    if TYPE_CHECKING:
-        ifc_definition_id: int
-
-
 class BIMProjectProperties(PropertyGroup):
     is_editing: BoolProperty(name="Is Editing", default=False)
     is_loading: BoolProperty(name="Is Loading", default=False)
@@ -389,8 +360,6 @@ class BIMProjectProperties(PropertyGroup):
         default=30,
         description="Maxium number of openings that object can have. If object has more openings, it will be loaded without openings",
     )
-    pending_opening_recut: CollectionProperty(name="Pending Opening Recut", type=PendingOpeningRecut)
-    pending_array_repair: CollectionProperty(name="Pending Array Repair", type=PendingArrayRepair)
     style_limit: IntProperty(
         name="Style Limit",
         default=300,
@@ -475,7 +444,7 @@ class BIMProjectProperties(PropertyGroup):
         items=get_parent_libaries,
     )
 
-    use_relative_project_path: BoolProperty(name="Use Relative Project Path", default=False)
+    use_relative_project_path: BoolProperty(name="Use Relative Project Path", default=True)
     should_save_metadata_for_this_file: BoolProperty(
         name="Save Session Data for This File",
         description="Enable saving session data (window layout, settings) to a metadata blend file for this specific IFC file",
@@ -556,8 +525,6 @@ class BIMProjectProperties(PropertyGroup):
         deflection_tolerance: float
         angular_tolerance: float
         void_limit: int
-        pending_opening_recut: bpy.types.bpy_prop_collection_idprop[PendingOpeningRecut]
-        pending_array_repair: bpy.types.bpy_prop_collection_idprop[PendingArrayRepair]
         style_limit: int
         distance_limit: float
         false_origin_mode: Literal["AUTOMATIC", "MANUAL", "DISABLED"]

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

@@ -18,17 +18,43 @@
 
 import blf
 import gpu
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Vector
 
 import bonsai.tool as tool
 
 
-class GridDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw", "POST_VIEW"),
-    )
+class GridDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
 
     def draw_text(self, context):
         if not tool.Blender.is_addon_enabled():

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

@@ -31,17 +31,11 @@ import bonsai.tool as tool
 from bonsai.bim.module.structural.load_decoration_data import ShaderInfo
 
 
-class LoadsDecorator(tool.Blender.ViewportDecorator):
+class LoadsDecorator:
     """Decorator to show structural loads in 3D"""
 
-    # draw_methods exists to satisfy ViewportDecorator.__init_subclass__'s
-    # method-existence check; the override install below is what actually
-    # registers handlers (the POST_VIEW binding passes no context arg, which
-    # the base's generic install cannot express).
-    draw_methods = (
-        ("draw_load_values", "POST_PIXEL"),
-        ("__call__", "POST_VIEW"),
-    )
+    is_installed = False
+    handlers = []
     decoration_data = None
     text_info = []
     shader_info = []
@@ -60,6 +54,15 @@ class LoadsDecorator(tool.Blender.ViewportDecorator):
         cls.update()
         cls.is_installed = True
 
+    @classmethod
+    def uninstall(cls) -> None:
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
     @classmethod
     def update(cls) -> None:
         cls.decoration_data.update()

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

@@ -744,7 +744,7 @@ class EnableEditingSurfaceStyle(bpy.types.Operator):
         if self.ifc_class == "IfcSurfaceStyleLighting":
 
             def callback(attribute_name: str, _: object, data: dict[str, Any]) -> None:
-                assert attributes is not None
+                assert attributes
                 color = attributes.add()
                 assert isinstance(color, ColourRgb)
                 color.name = attribute_name
@@ -782,40 +782,34 @@ class EditSurfaceStyle(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         self.props = tool.Style.get_style_props()
         self.style = tool.Ifc.get().by_id(self.props.is_editing_style)
-        prev_update_graph = self.props.update_graph
-        self.props["update_graph"] = False
 
-        try:
-            style_elements = tool.Style.get_style_elements(self.style)
+        style_elements = tool.Style.get_style_elements(self.style)
+        # NOTE: currently this operator is used to edit existing (and only existing) IfcSurfaceStyles
+        # or new or existing IfcSurfaceStyle components (shading, etc)
+        # which is kind of confusing.
+        if self.props.is_editing_class == "IfcSurfaceStyle":
+            self.surface_style = self.style
+        else:
+            self.surface_style = style_elements.get(self.props.is_editing_class, None)
+            self.shading_style = style_elements.get("IfcSurfaceStyleShading", None)
+            self.rendering_style = style_elements.get("IfcSurfaceStyleRendering", None)
+            self.texture_style = style_elements.get("IfcSurfaceStyleWithTextures", None)
 
-            # NOTE: currently this operator is used to edit existing (and only existing) IfcSurfaceStyles
-            # or new or existing IfcSurfaceStyle components (shading, etc)
-            # which is kind of confusing.
-            if self.props.is_editing_class == "IfcSurfaceStyle":
-                self.surface_style = self.style
-            else:
-                self.surface_style = style_elements.get(self.props.is_editing_class, None)
-                self.shading_style = style_elements.get("IfcSurfaceStyleShading", None)
-                self.rendering_style = style_elements.get("IfcSurfaceStyleRendering", None)
-                self.texture_style = style_elements.get("IfcSurfaceStyleWithTextures", None)
+        if self.surface_style:
+            result = self.edit_existing_style()
+        else:
+            result = self.add_new_style()
 
-            if self.surface_style:
-                result = self.edit_existing_style()
-            else:
-                result = self.add_new_style()
+        if result:
+            return result
 
-            if result:
-                return result
+        tool.Style.disable_editing()
+        core.load_styles(tool.Style, style_type=self.props.style_type)
 
-            tool.Style.disable_editing()
-            core.load_styles(tool.Style, style_type=self.props.style_type)
-
-            # restore selected style type
-            material = tool.Ifc.get_object(self.style)
-            msprops = tool.Style.get_material_style_props(material)
-            msprops.active_style_type = msprops.active_style_type
-        finally:
-            self.props["update_graph"] = prev_update_graph
+        # restore selected style type
+        material = tool.Ifc.get_object(self.style)
+        msprops = tool.Style.get_material_style_props(material)
+        msprops.active_style_type = msprops.active_style_type
 
     def edit_existing_style(self) -> None:
         ifc_file = tool.Ifc.get()
@@ -1237,5 +1231,4 @@ class RemoveSurfaceStyle(bpy.types.Operator, tool.Ifc.Operator):
         surface_style = tool.Style.get_style_elements(style)[props.is_editing_class]
         ifcopenshell.api.style.remove_surface_style(ifc_file, surface_style)
         core.disable_editing_style(tool.Style)
-        core.load_styles(tool.Style, style_type=props.style_type)
         return {"FINISHED"}

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

@@ -185,13 +185,6 @@ class ColourRgb(PropertyGroup):
     # to fit blender.bim.helper.draw_attribute
     is_optional = False
     special_type = ""
-    data_type = ""
-    ifc_class = ""
-    use_explorer_ui = False
-
-    @property
-    def display_name(self):
-        return self.name
 
     def get_value_name(self, *args, **kwargs):
         return "color_value"

src/bonsai/bonsai/bim/module/style/ui.py

@@ -176,30 +176,8 @@ class BIM_PT_styles(Panel):
         row.prop(self.props, "reflectance_method")
 
         if self.props.reflectance_method not in ("PHYSICAL", "NOTDEFINED", "FLAT"):
-            self.layout.label(
-                text=f"{self.props.reflectance_method} will be skipped: only PHYSICAL / NOTDEFINED / FLAT are supported",
-                icon="ERROR",
-            )
-        elif self.props.reflectance_method in ("PHYSICAL", "NOTDEFINED"):
-            if self.props.specular_colour_class == "IfcColourRgb":
-                self.layout.label(
-                    text="Metallic color is IFC-only in PHYSICAL/NOTDEFINED and does not affect Blender appearance",
-                    icon="ERROR",
-                )
-        elif self.props.reflectance_method == "FLAT":
-            if self.props.diffuse_colour_class == "IfcNormalisedRatioMeasure":
-                self.layout.label(
-                    text="Emissive ratio is IFC-only in FLAT Reflectance method and does not affect Blender appearance",
-                    icon="ERROR",
-                )
-            self.layout.label(
-                text="Specular value is IFC-only in FLAT Reflectance method and does not affect Blender appearance",
-                icon="ERROR",
-            )
-            self.layout.label(
-                text="Highlight value is IFC-only in FLAT Reflectance method and does not affect Blender appearance",
-                icon="ERROR",
-            )
+            self.layout.label(text="Supported reflectance methods are:")
+            self.layout.label(text="PHYSICAL / NOTDEFINED / FLAT")
 
         row = self.layout.row(align=True)
         row.label(text="Emissive" if self.props.reflectance_method == "FLAT" else "Diffuse")
@@ -254,8 +232,6 @@ class BIM_PT_styles(Panel):
         row.operator("bim.add_surface_texture", text="", icon="ADD")
         if textures:
             self.layout.prop(self.props, "uv_mode")
-            if self.props.uv_mode in ("Generated", "Camera"):
-                self.layout.label(text="Not available in SOLID Mode", icon="INFO")
 
         for i, texture in enumerate(textures):
             split = self.layout.split(factor=0.30, align=True)
@@ -268,22 +244,6 @@ class BIM_PT_styles(Panel):
             op_clear = row.operator("bim.remove_texture_map", text="", icon="X")
             op_path.texture_map_index = op_clear.texture_map_index = i
 
-            reflectance = self.props.reflectance_method
-            mode = texture.mode
-            if reflectance == "FLAT":
-                if mode != "EMISSIVE":
-                    self.layout.label(
-                        text=f"{mode} will be skipped: only EMISSIVE is supported for Render Reflectance FLAT",
-                        icon="ERROR",
-                    )
-            elif reflectance in ("PHYSICAL", "NOTDEFINED"):
-                _SUPPORTED = {"DIFFUSE", "NORMAL", "METALLICROUGHNESS", "EMISSIVE", "OCCLUSION"}
-                if mode not in _SUPPORTED:
-                    self.layout.label(
-                        text=f"{mode} will be skipped: not supported for Render Reflectance PHYSICAL/NOTDEFINED",
-                        icon="ERROR",
-                    )
-
     def draw_externally_defined_surface_style(self):
         row = self.layout.row()
         op = row.operator("bim.browse_external_style", icon="APPEND_BLEND", text="Append From Blend File")
@@ -292,17 +252,10 @@ class BIM_PT_styles(Panel):
         bonsai.bim.helper.draw_attributes(self.props.external_style_attributes, self.layout, enable_search=True)
 
     def draw_refraction_surface_style(self):
-        self.layout.label(
-            text="Refraction values are IFC-only and do not affect Blender surface appearance",
-            icon="ERROR",
-        )
         bonsai.bim.helper.draw_attributes(self.props.refraction_style_attributes, self.layout, enable_search=True)
+        row = self.layout.row(align=True)
 
     def draw_lighting_surface_style(self):
-        self.layout.label(
-            text="Lighting values are IFC-only and do not affect Blender surface appearance",
-            icon="ERROR",
-        )
         bonsai.bim.helper.draw_attributes(self.props.lighting_style_colours, self.layout)
 
     def draw_edit_ui(self, edit_label: str):

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

@@ -15,10 +15,9 @@
 #
 # 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 modified with the assistance of an AI coding tool.
 
 
+import bmesh
 import bpy
 import gpu
 from bpy.app.handlers import persistent
@@ -31,6 +30,12 @@ ERROR_ELEMENTS_COLOR = (1, 0.2, 0.322, 1)  # RED
 UNSPECIAL_ELEMENT_COLOR = (0.2, 0.2, 0.2, 1)  # GREY
 
 
+def transparent_color(color, alpha=0.1):
+    color = [i for i in color]
+    color[3] = alpha
+    return color
+
+
 @persistent
 def toggle_decorations_on_load(*args):
     props = tool.System.get_system_props()
@@ -73,9 +78,15 @@ class SystemDecorator:
         batch.draw(shader)
 
     def draw_faces(self, bm, vertices_coords):
-        """Submit a non-mutating beauty-triangulated TRIS batch over ``bm``'s faces."""
-        faces_color = tool.Blender.transparent_color(self.addon_prefs.decorator_color_special)
-        tool.Blender.draw_bmesh_face_tris(bm, vertices_coords, faces_color, self.draw_batch)
+        """mutates original bm (triangulates it)
+        so the triangulation edges will be shown too
+        """
+        traingulated_bm = bm
+        bmesh.ops.triangulate(traingulated_bm, faces=traingulated_bm.faces)
+
+        face_indices = [[v.index for v in f.verts] for f in traingulated_bm.faces]
+        faces_color = transparent_color(self.addon_prefs.decorator_color_special)
+        self.draw_batch("TRIS", vertices_coords, faces_color, face_indices)
 
     def __call__(self, context, get_custom_bmesh=None, draw_faces=False, exit_edit_mode_callback=None):
         self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -122,15 +133,13 @@ class SystemDecorator:
         self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
         self.shader.bind()
 
-        self.draw_batch(
-            "LINES", all_vertices, tool.Blender.transparent_color(unselected_elements_color), unselected_edges
-        )
+        self.draw_batch("LINES", all_vertices, transparent_color(unselected_elements_color), unselected_edges)
         self.draw_batch("LINES", all_vertices, selected_elements_color, selected_edges)
         self.draw_batch("LINES", all_vertices, UNSPECIAL_ELEMENT_COLOR, arc_edges)
         self.draw_batch("LINES", all_vertices, special_elements_color, preview_edges)
         self.draw_batch("LINES", all_vertices, special_elements_color, roof_angle_edges)
 
-        self.draw_batch("POINTS", unselected_vertices, tool.Blender.transparent_color(unselected_elements_color, 0.5))
+        self.draw_batch("POINTS", unselected_vertices, transparent_color(unselected_elements_color, 0.5))
         self.draw_batch("POINTS", error_vertices, ERROR_ELEMENTS_COLOR)
         self.draw_batch("POINTS", special_vertices, special_elements_color)
         self.draw_batch("POINTS", selected_vertices, selected_elements_color)

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

@@ -317,23 +317,13 @@ class MEPConnectElements(bpy.types.Operator, tool.Ifc.Operator):
     bl_label = "Connect MEP Elements"
     bl_description = "Connects two selected elements by their closest located ports and adjusts them"
     bl_options = {"REGISTER", "UNDO"}
-    obj1_guid: bpy.props.StringProperty(name="Object 1 GlobalId")
-    obj2_guid: bpy.props.StringProperty(name="Object 2 GlobalId")
+    obj1_name: bpy.props.StringProperty(name="Object 1")
+    obj2_name: bpy.props.StringProperty(name="Object 2")
 
     def _execute(self, context):
-        if self.obj1_guid and self.obj2_guid:
-            ifc_file = tool.Ifc.get()
-            try:
-                el1_lookup = ifc_file.by_guid(self.obj1_guid)
-                el2_lookup = ifc_file.by_guid(self.obj2_guid)
-            except RuntimeError:
-                self.report({"ERROR"}, "Could not resolve MEP elements from supplied GlobalIds.")
-                return {"CANCELLED"}
-            obj1 = tool.Ifc.get_object(el1_lookup)
-            obj2 = tool.Ifc.get_object(el2_lookup)
-            if not obj1 or not obj2:
-                self.report({"ERROR"}, "Supplied MEP elements have no Blender object bound.")
-                return {"CANCELLED"}
+        if self.obj1_name and self.obj2_name:
+            obj1 = bpy.data.objects.get(self.obj1_name)
+            obj2 = bpy.data.objects.get(self.obj2_name)
         else:
             if not context.selected_objects or len(context.selected_objects) != 2:
                 self.report({"ERROR"}, "Need to select 2 objects.")

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

@@ -65,28 +65,10 @@ class AssignType(bpy.types.Operator, tool.Ifc.Operator):
             if active_drawing:
                 active_target_view = tool.Drawing.get_drawing_target_view(active_drawing)
 
-        compatible: list[tuple[bpy.types.Object, ifcopenshell.entity_instance]] = []
-        skipped_classes: set[str] = set()
         for obj in related_objects:
             element = tool.Ifc.get_entity(obj)
             if not element or not element.is_a("IfcObject"):
                 continue
-            if not tool.Type.is_relating_type_compatible(element, relating_type):
-                skipped_classes.add(element.is_a())
-                continue
-            compatible.append((obj, element))
-
-        if skipped_classes:
-            self.report(
-                {"WARNING"},
-                f"Skipped {', '.join(sorted(skipped_classes))}: not a valid occurrence for " f"{relating_type.is_a()}.",
-            )
-
-        if not compatible:
-            self.report({"ERROR"}, f"No selected object can be typed by {relating_type.is_a()}.")
-            return {"CANCELLED"}
-
-        for obj, element in compatible:
             core.assign_type(tool.Ifc, tool.Model, tool.Type, element=element, type=relating_type)
 
             # Switch to the drawing's target view if available
@@ -394,22 +376,12 @@ class DuplicateType(bpy.types.Operator, tool.Ifc.Operator):
         if self.assign_selected_objects:
             selected_objects = tool.Blender.get_selected_objects()
             prefs = tool.Blender.get_addon_preferences()
-            skipped_classes: set[str] = set()
             for selected_obj in selected_objects:
                 selected_element = tool.Ifc.get_entity(selected_obj)
-                if not selected_element or not selected_element.is_a("IfcObject"):
-                    continue
-                if not tool.Type.is_relating_type_compatible(selected_element, new):
-                    skipped_classes.add(selected_element.is_a())
-                    continue
-                core.assign_type(tool.Ifc, tool.Model, tool.Type, element=selected_element, type=new)
-                if prefs.occurrence_name_style == "TYPE":
-                    selected_obj.name = tool.Model.generate_occurrence_name(new, selected_element.is_a())
-            if skipped_classes:
-                self.report(
-                    {"WARNING"},
-                    f"Skipped {', '.join(sorted(skipped_classes))}: not a valid occurrence for " f"{new.is_a()}.",
-                )
+                if selected_element and selected_element.is_a("IfcObject"):
+                    core.assign_type(tool.Ifc, tool.Model, tool.Type, element=selected_element, type=new)
+                    if prefs.occurrence_name_style == "TYPE":
+                        selected_obj.name = tool.Model.generate_occurrence_name(new, selected_element.is_a())
 
         if obj in context.selectable_objects:
             tool.Blender.select_and_activate_single_object(context, new_obj)

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

@@ -26,7 +26,7 @@ import bonsai.bim.handler
 import bonsai.core.geometry
 import bonsai.core.root
 import bonsai.tool as tool
-from bonsai.bim.module.model.opening import FilledOpeningGenerator, is_filling_supported
+from bonsai.bim.module.model.opening import FilledOpeningGenerator
 
 
 class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
@@ -34,13 +34,11 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
     bl_label = "Apply Opening"
     bl_options = {"REGISTER", "UNDO"}
     bl_description = (
-        "Cuts openings in a wall, slab, or roof using selected shape objects — "
-        "doors, windows, existing openings, or plain (non-IFC) meshes. "
-        "Selection order doesn't matter.\n\n"
-        "Doors and windows also fill the opening. Other IFC classes are currently "
-        "unsupported by the opening generator and get skipped with a warning.\n\n"
-        "Shift+click: keep each opening at its shape object's current position "
-        "instead of snapping to the wall."
+        "Apply opening objects to an Element.\n\n"
+        "The Element and the openings to be applied should be selected. The order of selection is not important.\n"
+        "Opening can be just a Blender mesh object.\n\n"
+        "Shift+click: keep the filling at its current matrix_world — skip the wall-axis snap "
+        "and the rl1/rl2 Z-elevation default that the regular click applies."
     )
 
     # Toggled by ``invoke`` when the user holds SHIFT during a gizmo / hotkey
@@ -61,12 +59,6 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
         return self.execute(context)
 
     def _execute(self, context):
-        # Multi-opening drops on the same host fan out N update_representation
-        # writes + N switch_representation recuts without batching. Coalesce.
-        with tool.Geometry.batch_host_recut():
-            return self._add_openings(context)
-
-    def _add_openings(self, context):
         selected_objects = context.selected_objects
         target_object = selected_objects[0]
 
@@ -86,14 +78,8 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
                     self.report({"INFO"}, "You can't add an opening to another opening.")
                     continue
                 elif not element1.is_a("IfcOpeningElement") and not element2.is_a("IfcOpeningElement"):
-                    if is_filling_supported(element1):  # Add a fill to an element.
+                    if element1.is_a("IfcWindow") or element1.is_a("IfcDoor"):  # Add a fill to an element.
                         obj1, obj2 = obj2, obj1
-                    elif not is_filling_supported(element2):
-                        self.report(
-                            {"INFO"},
-                            f"Cannot apply {element2.is_a()} as an opening — Bonsai currently supports only IfcDoor and IfcWindow as parametric fillings.",
-                        )
-                        continue
                     FilledOpeningGenerator().generate(
                         obj2,
                         obj1,
@@ -179,7 +165,7 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
                             voided_obj.scale = (1.0, 1.0, 1.0)
                             tool.Ifc.finish_edit(voided_obj)
                         else:
-                            tool.Geometry.update_host_representation(voided_obj)
+                            bpy.ops.bim.update_representation(obj=voided_obj.name)
 
                     if tool.Ifc.is_moved(voided_obj):
                         bonsai.core.geometry.edit_object_placement(
@@ -188,7 +174,12 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
 
                     representation = tool.Geometry.get_active_representation(voided_obj)
                     assert representation
-                    tool.Geometry.recut_host(voided_obj, representation)
+                    bonsai.core.geometry.switch_representation(
+                        tool.Ifc,
+                        tool.Geometry,
+                        obj=voided_obj,
+                        representation=representation,
+                    )
                 tool.Geometry.lock_scale(voided_obj)
 
             if not has_visible_openings:
@@ -226,7 +217,12 @@ class RemoveOpening(bpy.types.Operator, tool.Ifc.Operator):
             if building_obj and building_obj.data:
                 representation = tool.Geometry.get_active_representation(building_obj)
                 assert representation
-                tool.Geometry.recut_host(building_obj, representation)
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc,
+                    tool.Geometry,
+                    obj=building_obj,
+                    representation=representation,
+                )
         tool.Geometry.unlock_scale_object_with_openings(obj)
         tool.Geometry.clear_cache(element)
         return {"FINISHED"}

src/bonsai/bonsai/bim/operator.py

@@ -219,7 +219,7 @@ class SelectIfcFile(bpy.types.Operator, IFCFileSelector, ImportHelper):
     bl_options = {"REGISTER", "UNDO"}
     bl_description = f"Select a different IFC file.\n{tool.Blender.operator_invoke_filepath_hotkeys_description}"
     filter_glob: bpy.props.StringProperty(default="*.ifc;*.ifczip;*.ifcxml", options={"HIDDEN"})
-    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=False)
+    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=True)
     filename_ext = ".ifc"
 
     def execute(self, context):

src/bonsai/bonsai/bim/ui.py

@@ -39,10 +39,21 @@ from natsort import natsorted
 import bonsai.bim
 import bonsai.bim.helper
 import bonsai.tool as tool
-from bonsai.bim.ifc import is_cache_locked_by_other_process
 from bonsai.bim.module.bsdd.prop import BIMBSDDProperties, BSDDProperty
-from bonsai.bim.module.model import prop as _model_prop
-from bonsai.bim.module.model import ui as _model_ui
+from bonsai.bim.module.model.prop import (
+    BIMDoorProperties,
+    BIMRailingProperties,
+    BIMRoofProperties,
+    BIMStairProperties,
+    BIMWindowProperties,
+)
+from bonsai.bim.module.model.ui import (
+    draw_door_properties,
+    draw_railing_properties,
+    draw_roof_properties,
+    draw_stair_properties,
+    draw_window_properties,
+)
 from bonsai.bim.module.pset.prop import IfcProperty
 from bonsai.bim.prop import Attribute
 
@@ -83,7 +94,10 @@ class IFCFileSelector:
         filepath = self.get_filepath_abs()
 
         if self.use_relative_path:
-            filepath = filepath.relative_to(bpy.path.abspath("//"))
+            try:
+                filepath = filepath.relative_to(bpy.path.abspath("//"))
+            except ValueError:
+                pass  # IFC file is not under the blend directory; keep absolute path
         return filepath.as_posix().replace("\\", "/")
 
     def draw(self, context: bpy.types.Context) -> None:
@@ -267,29 +281,30 @@ class BIM_UL_panel_visibilities(bpy.types.UIList):
 class GizmoPreferences(bpy.types.PropertyGroup):
     """Aggregator for parametric gizmo visibility settings. One flat bool per
     parametric feature; controls whether that feature's gizmo group polls
-    visible in the viewport.
-
-    The per-feature ``<name>: BoolProperty`` fields are derived from
-    ``tool.Parametric.EDIT_TYPES`` at module load — adding a new parametric
-    type to the registry automatically surfaces its toggle here, with no
-    parallel hand-maintained list to keep in sync."""
+    visible in the viewport."""
 
     draw_gizmos_in_3d_viewport: BoolProperty(
         name="Draw Gizmos In 3D Viewport",
         default=True,
         description="Show interactive gizmos in the 3D viewport for parametric elements",
     )
+    door: BoolProperty(name="Door", default=True)
+    window: BoolProperty(name="Window", default=True)
+    stair: BoolProperty(name="Stair", default=True)
+    railing: BoolProperty(name="Railing", default=True)
+    roof: BoolProperty(name="Roof", default=True)
+    array: BoolProperty(name="Array", default=True)
+    wall: BoolProperty(name="Wall", default=True)
 
     if TYPE_CHECKING:
         draw_gizmos_in_3d_viewport: bool
-
-
-for _gizmo_pref_entry in tool.Parametric.EDIT_TYPES:
-    GizmoPreferences.__annotations__[_gizmo_pref_entry.name] = BoolProperty(
-        name=_gizmo_pref_entry.name.replace("_", " ").title(),
-        default=True,
-    )
-del _gizmo_pref_entry
+        door: bool
+        window: bool
+        stair: bool
+        railing: bool
+        roof: bool
+        array: bool
+        wall: bool
 
 
 class DocPreferences(bpy.types.PropertyGroup):
@@ -385,22 +400,11 @@ class DocPreferences(bpy.types.PropertyGroup):
 
 
 class DefaultParameters(bpy.types.PropertyGroup):
-    """Per-type preset values used to seed new parametric instances.
-
-    The ``<name>: PointerProperty`` fields are derived from the subset of
-    ``tool.Parametric.EDIT_TYPES`` flagged ``has_default_parameters=True``,
-    each pointing at the matching ``BIM<Name>Properties`` class. Adding a
-    new entry with that flag automatically surfaces a preferences section
-    and gives the create operator a preset to copy from."""
-
-
-for _default_params_entry in tool.Parametric.EDIT_TYPES:
-    if not _default_params_entry.has_default_parameters:
-        continue
-    DefaultParameters.__annotations__[_default_params_entry.name] = bpy.props.PointerProperty(
-        type=getattr(_model_prop, _default_params_entry.props_attr),
-    )
-del _default_params_entry
+    door: bpy.props.PointerProperty(type=BIMDoorProperties)
+    window: bpy.props.PointerProperty(type=BIMWindowProperties)
+    railing: bpy.props.PointerProperty(type=BIMRailingProperties)
+    roof: bpy.props.PointerProperty(type=BIMRoofProperties)
+    stair: bpy.props.PointerProperty(type=BIMStairProperties)
 
 
 class BIM_ADDON_preferences(bpy.types.AddonPreferences):
@@ -512,15 +516,6 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         size=4,
         description="Color of not selected verts/edges (used in profile editing mode)",
     )
-    clip_box_cap_color: bpy.props.FloatVectorProperty(
-        name="Clip Box Caps Color",
-        subtype="COLOR",
-        default=(0.0, 0.0, 0.0, 1.0),
-        min=0.0,
-        max=1.0,
-        size=4,
-        description="Fill color of clip-box cross-section caps",
-    )
     decorator_color_special: bpy.props.FloatVectorProperty(
         name="Special Elements Color",
         subtype="COLOR",
@@ -810,29 +805,39 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         layout.row().prop(self, "decorator_color_special")
         layout.row().prop(self, "decorator_color_error")
         layout.row().prop(self, "decorator_color_background")
-        bonsai.bim.helper.draw_expandable_panel(
-            layout,
-            context,
-            "Clip Box",
-            self.draw_clip_box_colors,
-        )
-
-    def draw_clip_box_colors(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        layout.row().prop(self, "clip_box_cap_color")
 
     def draw_default_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         box = layout.box()
-        for entry in tool.Parametric.EDIT_TYPES:
-            if not entry.has_default_parameters:
-                continue
-            props = getattr(self.default_parameters, entry.name)
-            draw_props = getattr(_model_ui, f"draw_{entry.name}_properties")
-            bonsai.bim.helper.draw_expandable_panel(
-                box,
-                context,
-                entry.name.replace("_", " ").title(),
-                lambda _layout, _context, _draw=draw_props, _props=props: _draw(_layout, _props),
-            )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Door",
+            lambda _layout, _context: draw_door_properties(_layout, self.default_parameters.door),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Window",
+            lambda _layout, _context: draw_window_properties(_layout, self.default_parameters.window),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Railing",
+            lambda _layout, _context: draw_railing_properties(_layout, self.default_parameters.railing),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Roof",
+            lambda _layout, _context: draw_roof_properties(_layout, self.default_parameters.roof),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Stair",
+            lambda _layout, _context: draw_stair_properties(_layout, self.default_parameters.stair),
+        )
 
     def draw_other_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "opening_focus_opacity")
@@ -950,50 +955,6 @@ class BIM_PT_tabs(Panel):
             op.uri = "https://docs.bonsaibim.org/guides/troubleshooting.html#saving-and-loading-blend-files"
             row.operator("bim.close_blend_warning", text="", icon="CANCEL")
 
-        if is_cache_locked_by_other_process():
-            box = self.layout.box()
-            box.alert = True
-            row = box.row(align=True)
-            row.label(text="IFC Already Open in Another Blender Instance", icon="ERROR")
-            row.operator("bim.dismiss_multi_instance_warning", text="", icon="CANCEL")
-            draw_multiline_text(
-                box.column(align=True),
-                "This file is open in another Blender instance. Editing the same "
-                "IFC from two instances at once can lose your work or display "
-                "outdated geometry. Close the other Blender instances to continue safely.",
-                context=context,
-            )
-
-        pprops = tool.Project.get_project_props()
-        if pending := pprops.pending_opening_recut:
-            box = self.layout.box()
-            box.alert = True
-            box.label(text="Opening Cuts Skipped", icon="ERROR")
-            draw_multiline_text(
-                box.column(align=True),
-                f"{len(pending)} element(s) had too many openings to cut during load. "
-                f"Apply to recompute their meshes, or dismiss to leave them as they are.",
-                context=context,
-            )
-            row = box.row(align=True)
-            row.operator("bim.select_pending_opening_cuts", text="Select Elements", icon="RESTRICT_SELECT_OFF")
-            row.operator("bim.apply_pending_opening_cuts", text="Apply Openings", icon="PLAY")
-            row.operator("bim.dismiss_pending_opening_cuts", text="", icon="CANCEL")
-
-        if pending := pprops.pending_array_repair:
-            box = self.layout.box()
-            box.alert = True
-            box.label(text="Arrays With Missing Children", icon="ERROR")
-            draw_multiline_text(
-                box.column(align=True),
-                f"{len(pending)} array parent(s) reference child GUIDs that don't exist in this file. "
-                f"The arrays loaded incomplete. Select to inspect, or dismiss.",
-                context=context,
-            )
-            row = box.row(align=True)
-            row.operator("bim.select_pending_array_repair", text="Select Elements", icon="RESTRICT_SELECT_OFF")
-            row.operator("bim.dismiss_pending_array_repair", text="", icon="CANCEL")
-
         gprops = tool.Geometry.get_geometry_props()
         # Check that Blender mode and IFC Mode do match.
         if context.mode == "OBJECT" and gprops.mode in ("OBJECT", "ITEM"):
@@ -1945,7 +1906,6 @@ class BIM_PT_decorators_overlay(Panel):
         aggregate_props = tool.Aggregate.get_aggregate_props()
         nest_props = tool.Nest.get_nest_props()
         model_props = tool.Model.get_model_props()
-        system_props = tool.System.get_system_props()
         display_all = overlay.show_overlays
 
         col = layout.column()
@@ -1963,20 +1923,10 @@ class BIM_PT_decorators_overlay(Panel):
         row = col.row(align=True)
         row.prop(model_props, "show_slab_direction", text="Slab Direction")
         row = col.row(align=True)
-        row.prop(model_props, "show_paths", text="Element Paths")
-        row.prop(system_props, "should_draw_decorations", text="System Decorations")
-        row = col.row(align=True)
         row.prop(model_props, "show_bounding_box", text="Bounding Box Dimensions")
         row = col.row(align=True)
         row.prop(model_props, "show_cut_decorator", text="Cut Decorator")
         row.prop(model_props, "show_cut_decorator_fill", text="Fill Cut Decorator")
-        clip_box_props = tool.ClipBox.get_scene_props(context.scene)
-        row = col.row(align=True)
-        # Grey out the toggles when there is no clip box to act on, so the
-        # user can see the controls but can't flip a switch that does nothing.
-        row.enabled = bool(clip_box_props.clip_boxes)
-        row.prop(clip_box_props, "enabled", text="Enable Clipping")
-        row.prop(clip_box_props, "show_caps", text="Show Caps")
 
 
 class BIM_PT_snappping(Panel):

src/bonsai/bonsai/core/connection.py

@@ -1,113 +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.
-
-"""Shared post-disconnect cleanup dispatch.
-
-Used by both ``bim.disconnect_elements`` (explicit user disconnect) and the
-connection cascade in ``tool.Geometry.delete_ifc_object`` (implicit
-disconnect-on-delete). Each kind returned by
-:py:meth:`bonsai.tool.connection.Connection.find_rels` /
-:py:meth:`find_rels_for_element` maps to a single arm here, so adding a new
-kind means extending one dispatch table — both call sites benefit
-automatically and the AST forward-compat guard enforces coverage.
-
-The ``subject`` parameter is the entity whose teardown effects the
-disconnect: for ``"path"`` / ``"element"`` / ``"element-top"`` kinds it
-carries an ``IfcRel*`` relationship entity (the rel that gets removed);
-for ``"mep-pair-fitting"`` it carries an ``IfcFlowFitting`` (the fitting
-that gets deleted). The slot is uniform on intent — the dispatch decides
-the teardown mechanism by kind.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import bonsai.core.geometry
-from bonsai.core.model import regenerate_wall_to_underside
-
-if TYPE_CHECKING:
-    import ifcopenshell
-
-    import bonsai.tool as tool
-
-
-def disconnect_rel(
-    ifc: type[tool.Ifc],
-    geometry: type[tool.Geometry],
-    model: type[tool.Model],
-    connection: type[tool.Connection],
-    subject: ifcopenshell.entity_instance,
-    kind: str,
-    elem: ifcopenshell.entity_instance,
-    partner: ifcopenshell.entity_instance,
-    skip_elem_recreate: bool = False,
-    skip_partner_recreate: bool = False,
-) -> None:
-    """Run the post-disconnect cleanup for one connection.
-
-    ``elem`` and ``partner`` are the two endpoints. The ``skip_*_recreate``
-    flags suppress per-side regenerate / recreate work — used by the
-    cascade-on-delete to avoid re-extruding entities that are about to be
-    removed by ``remove_product``. For the disconnect operator (where neither
-    endpoint is being deleted), both flags stay False and the full cleanup
-    runs on both sides.
-    """
-    if kind == "path":
-        bonsai.core.geometry.remove_connection(geometry, connection=subject)
-        if not skip_elem_recreate:
-            elem_obj = ifc.get_object(elem)
-            if elem_obj is not None:
-                model.recreate_wall(elem, elem_obj)
-        if not skip_partner_recreate:
-            partner_obj = ifc.get_object(partner)
-            if partner_obj is not None:
-                model.recreate_wall(partner, partner_obj)
-    elif kind == "element-top":
-        wall, _slab = connection.orient_element_top(subject, elem, partner)
-        ifc.run(
-            "geometry.disconnect_element",
-            relating_element=subject.RelatingElement,
-            related_element=subject.RelatedElement,
-        )
-        # Skip the wall-side regenerate when the wall is itself being deleted —
-        # either it's the elem of this cascade pass, or it's the partner that
-        # was queued earlier in the same batch.
-        if (wall is elem and skip_elem_recreate) or (wall is partner and skip_partner_recreate):
-            return
-        wall_obj = ifc.get_object(wall)
-        if wall_obj is not None:
-            regenerate_wall_to_underside(ifc, geometry, model, [wall_obj])
-    elif kind == "element":
-        ifc.run(
-            "geometry.disconnect_element",
-            relating_element=subject.RelatingElement,
-            related_element=subject.RelatedElement,
-        )
-    elif kind == "mep-pair-fitting":
-        if skip_elem_recreate and subject is elem:
-            return
-        if skip_partner_recreate and subject is partner:
-            return
-        fitting_obj = ifc.get_object(subject)
-        if fitting_obj is not None:
-            geometry.delete_ifc_object(fitting_obj)
-    else:
-        raise ValueError(f"Unknown kind: {kind!r}")

src/bonsai/bonsai/core/drawing.py

@@ -302,23 +302,9 @@ def add_drawing(
         context=drawing.get_body_context(),
         ifc_representation_class=None,
     )
-    
-    drawings_parent_group = None
-    for group in ifc.get().by_type("IfcGroup"):
-        if group.Name == "DRAWINGS" and group.ObjectType == "DRAWINGS":
-            drawings_parent_group = group
-            break
-    
-    if not drawings_parent_group:
-        drawings_parent_group = ifc.run("group.add_group")
-        ifc.run("group.edit_group", group=drawings_parent_group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"})
-    
     group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
     ifc.run("group.assign_group", group=group, products=[element])
-    
-    ifc.run("group.assign_group", group=drawings_parent_group, products=[group])
-    
     collector.assign(camera)
     pset = ifc.run("pset.add_pset", product=element, name="EPset_Drawing")
     if drawing.get_unit_system() == "METRIC":
@@ -349,22 +335,7 @@ def add_drawing(
         },
     )
     drawing.setup_shading_styles_path(shading_styles_path)
-
-    drawings_parent_document = None
-    for document in ifc.get().by_type("IfcDocumentInformation"):
-        if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
-            drawings_parent_document = document
-            break
-    
-    if not drawings_parent_document:
-        drawings_parent_document = ifc.run("document.add_information")
-        if ifc.get_schema() == "IFC2X3":
-            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        else:
-            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        ifc.run("document.edit_information", information=drawings_parent_document, attributes=attributes)
-    
-    information = ifc.run("document.add_information", parent=drawings_parent_document)
+    information = ifc.run("document.add_information")
     uri = drawing.get_default_drawing_path(drawing_name)
     reference = ifc.run("document.add_reference", information=information)
     if ifc.get_schema() == "IFC2X3":
@@ -392,21 +363,9 @@ def duplicate_drawing(
     drawing_tool.set_name(new_drawing, drawing_name)
     group = drawing_tool.get_drawing_group(new_drawing)
     ifc.run("group.unassign_group", group=group, products=[new_drawing])
-    
-    drawings_parent_group = None
-    for parent_group in ifc.get().by_type("IfcGroup"):
-        if parent_group.Name == "DRAWINGS" and parent_group.ObjectType == "DRAWINGS":
-            drawings_parent_group = parent_group
-            break
-    
-    if not drawings_parent_group:
-        drawings_parent_group = ifc.run("group.add_group")
-        ifc.run("group.edit_group", group=drawings_parent_group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"})
-    
     new_group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=new_group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
     ifc.run("group.assign_group", group=new_group, products=[new_drawing])
-    ifc.run("group.assign_group", group=drawings_parent_group, products=[new_group])
     if should_duplicate_annotations:
         new_annotations: list[ifcopenshell.entity_instance] = []
         annotation_objs = [ifc.get_object(a) for a in drawing_tool.get_group_elements(group) if a != drawing]
@@ -422,21 +381,7 @@ def duplicate_drawing(
     old_reference = drawing_tool.get_drawing_document(new_drawing)
     ifc.run("document.unassign_document", products=[new_drawing], document=old_reference)
 
-    drawings_parent_document = None
-    for document in ifc.get().by_type("IfcDocumentInformation"):
-        if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
-            drawings_parent_document = document
-            break
-    
-    if not drawings_parent_document:
-        drawings_parent_document = ifc.run("document.add_information")
-        if ifc.get_schema() == "IFC2X3":
-            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        else:
-            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        ifc.run("document.edit_information", information=drawings_parent_document, attributes=attributes)
-
-    information = ifc.run("document.add_information", parent=drawings_parent_document)
+    information = ifc.run("document.add_information")
     uri = drawing_tool.get_default_drawing_path(drawing_name)
     reference = ifc.run("document.add_reference", information=information)
     if ifc.get_schema() == "IFC2X3":

src/bonsai/bonsai/core/model.py

@@ -167,22 +167,12 @@ def regenerate_wall_to_underside(
     model: type[tool.Model],
     wall_objs: list[bpy.types.Object],
 ) -> None:
-    """Re-clip walls to their connected underside objects after the slab has moved.
-
-    When a wall has no remaining slab connections — the case reached after the
-    last TOP rel is severed (via disconnect or via cascade-on-slab-delete) — the
-    stale trim booleans are cleaned up so the wall reverts to its pre-clip
-    extrusion instead of holding orphan ``IfcBooleanResult`` items and a dead
-    ``BBIM_Boolean`` pset.
-    """
+    """Re-clip walls to their connected underside objects after the slab has moved."""
     clipped_objs = []
-    reverted_objs = []
     for obj in wall_objs:
         wall = ifc.get_entity(obj)
         slab_objs = model.get_connected_slab_objs(wall)
         if not slab_objs:
-            model.remove_wall_to_underside_booleans(wall)
-            reverted_objs.append(obj)
             continue
         if ifc.is_moved(obj):
             geometry.run_edit_object_placement(obj=obj)
@@ -195,9 +185,8 @@ def regenerate_wall_to_underside(
             if clip:
                 model.clip_wall_to_slab(wall, clip)
         clipped_objs.append(obj)
-    refresh_objs = clipped_objs + reverted_objs
-    if refresh_objs:
-        model.reload_body_representation(refresh_objs)
+    if clipped_objs:
+        model.reload_body_representation(clipped_objs)
 
 
 def extend_wall_to_slab(

src/bonsai/bonsai/core/tool.py

@@ -195,14 +195,6 @@ class Collector:
     def assign(cls, obj, should_clean_users_collection=False): pass
 
 
-@interface
-class Connection:
-    def find_rel(cls, elem_a, elem_b): pass
-    def find_rels(cls, elem_a, elem_b): pass
-    def find_rels_for_element(cls, elem): pass
-    def orient_element_top(cls, rel, elem_a, elem_b): pass
-
-
 @interface
 class Context:
     def clear_context(cls): pass
@@ -702,13 +694,11 @@ class Model:
     def load_openings(cls, openings): pass
     def purge_scene_openings(cls): pass
     def recalculate_walls(cls, objs): pass
-    def recreate_wall(cls, element, obj): pass
     def regenerate_array(cls, parent, data): pass
     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 strip_underside_booleans(cls, wall): pass
     def replace_object_ifc_representation(cls, ifc_file, ifc_context, obj, new_representation): pass
 
 
@@ -1208,7 +1198,6 @@ class Type:
     def get_representation_context(cls, representation): pass
     def get_type_occurrences(cls, element_type): pass
     def has_material_usage(cls, element): pass
-    def is_relating_type_compatible(cls, occurrence, relating_type): pass
     def record_material_usage_attributes(cls, element): pass
     def restore_material_usage_attributes(cls, element, usage_attributes): pass
     def run_geometry_add_representation(cls, obj=None, context=None, ifc_representation_class=None, profile_set_usage=None): pass

src/bonsai/bonsai/tool/__init__.py

@@ -30,9 +30,7 @@ from bonsai.tool.bsdd import Bsdd
 from bonsai.tool.cad import Cad
 from bonsai.tool.clash import Clash
 from bonsai.tool.classification import Classification
-from bonsai.tool.clip_box import ClipBox
 from bonsai.tool.collector import Collector
-from bonsai.tool.connection import Connection
 from bonsai.tool.context import Context
 from bonsai.tool.cost import Cost
 from bonsai.tool.covering import Covering

src/bonsai/bonsai/tool/array.py

@@ -178,25 +178,6 @@ class Array(bonsai.core.tool.Array):
         element_root = cls.get_array_root_guid(element)
         return [o for o in occurrences if cls.get_array_root_guid(o) == element_root]
 
-    @classmethod
-    def select_only_parent(cls, parent_obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        """Post-condition for the user-facing regenerate and finish-edit paths:
-        only ``parent_obj`` is selected + active. Grow and shrink otherwise
-        diverge on which objects stay selected, surfacing an inconsistency."""
-        tool.Blender.select_and_activate_single_object(context, parent_obj)
-
-    @classmethod
-    def is_array_child(cls, element: entity_instance) -> bool:
-        """True when ``element`` is a child of a parametric array — has a
-        BBIM_Array pset whose Parent GUID points to a different element.
-        Lighter than ``get_child_layer_index`` (no ``by_guid`` lookup, no
-        Data parse); suitable for per-element checks in draw handlers."""
-        pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
-        if not pset:
-            return False
-        parent_guid = pset.get("Parent")
-        return bool(parent_guid) and parent_guid != element.GlobalId
-
     @classmethod
     def get_child_layer_index(cls, child_element: entity_instance) -> int | None:
         """Index of the layer that produced ``child_element``, or ``None``

src/bonsai/bonsai/tool/blender.py

@@ -22,7 +22,6 @@ from __future__ import annotations
 
 import contextlib
 import importlib
-import math
 import os
 import platform
 import subprocess
@@ -30,15 +29,7 @@ import sys
 import tempfile
 import traceback
 import types
-from collections.abc import (
-    Callable,
-    Generator,
-    Iterable,
-    Iterator,
-    Mapping,
-    Sequence,
-    Sized,
-)
+from collections.abc import Callable, Generator, Iterable, Mapping, Sequence, Sized
 from datetime import datetime
 from functools import cache, lru_cache
 from pathlib import Path
@@ -55,11 +46,9 @@ from typing import (
 
 import bmesh
 import bpy
-import gpu
 import ifcopenshell.util.element
 import numpy as np
 import numpy.typing as npt
-from gpu_extras.batch import batch_for_shader
 from ifcopenshell import entity_instance
 from mathutils import Matrix, Vector
 
@@ -538,19 +527,6 @@ class Blender(bonsai.core.tool.Blender):
             cls.handlers.clear()
             cls.is_installed = False
 
-        def draw_batch(self, shader_type, content_pos, color, indices=None):
-            """Submit a GPU batch through ``self.line_shader`` (for ``"LINES"``)
-            or ``self.shader`` (for any other primitive). Skips empty batches
-            via ``validate_shader_batch_data`` so Blender 4.4+ doesn't crash on
-            empty ``indices``. Subclasses bind both shaders in their draw method
-            before calling this helper."""
-            if not Blender.validate_shader_batch_data(content_pos, indices):
-                return
-            shader = self.line_shader if shader_type == "LINES" else self.shader
-            batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
-            shader.uniform_float("color", color)
-            batch.draw(shader)
-
         @staticmethod
         def _lookup_active_instance(gizmo_cls: type, context: bpy.types.Context) -> Optional[Any]:
             """Return the live ``GizmoGroup`` instance registered under
@@ -598,120 +574,6 @@ class Blender(bonsai.core.tool.Blender):
                 else:
                     decorator_cls.uninstall()
 
-    # Bonsai overrides Blender's default move/duplicate keymaps with macros
-    # that wrap TRANSFORM_OT_translate. While a macro is the outer modal
-    # entry, the inner TRANSFORM_OT_translate does not surface in
-    # window.modal_operators — the macro's own idname does. The ``BIM_OT_``
-    # prefix is what Blender returns from ``bl_idname`` at runtime (the
-    # class declaration uses the dotted ``bim.`` form).
-    BONSAI_TRANSFORM_MACROS: frozenset[str] = frozenset(
-        {
-            "BIM_OT_override_move_macro",  # G key
-            "BIM_OT_override_object_duplicate_move_macro",  # Shift+D
-            "BIM_OT_override_object_duplicate_move_linked_macro",  # Alt+D
-            "BIM_OT_object_duplicate_move_linked_aggregate_macro",  # Ctrl+Shift+D
-        }
-    )
-
-    @classmethod
-    def is_transform_modal_active(cls, context: bpy.types.Context) -> bool:
-        """True iff a Blender transform modal (G/R/S and siblings, including
-        Bonsai's macro overrides) is currently driving per-frame
-        ``matrix_world`` updates. Reads ``window.modal_operators`` — the
-        Blender 4.2+ collection of running modal operators. Callers gate
-        per-frame side effects (gizmo positioning, IFC persistence, etc.)
-        on this so they don't fire during the drag.
-
-        Falls back to scanning every window in the window manager when
-        ``context.window`` is ``None`` — depsgraph callbacks run with a
-        limited context where ``context.window`` is typically missing,
-        but the modal is still active on one of the WM's windows.
-        """
-        window = getattr(context, "window", None)
-        if window is not None and getattr(window, "modal_operators", None):
-            windows = [window]
-        else:
-            wm = getattr(context, "window_manager", None) or bpy.context.window_manager
-            if wm is None:
-                return False
-            windows = list(wm.windows)
-        for w in windows:
-            modal_ops = getattr(w, "modal_operators", None)
-            if not modal_ops:
-                continue
-            for op in modal_ops:
-                idname = op.bl_idname
-                if idname.startswith("TRANSFORM_OT_") or idname in cls.BONSAI_TRANSFORM_MACROS:
-                    return True
-        return False
-
-    @classmethod
-    def is_in_edit_mode(cls, context: Optional[bpy.types.Context] = None) -> bool:
-        """True iff the active object is in any edit-style mode.
-
-        Catches every ``EDIT_*`` variant (mesh, curve, armature,
-        metaball, lattice, surface, text, grease pencil). Defaults to
-        ``OBJECT`` when the mode attribute is missing so background-mode
-        callers (no UI context) don't false-positive.
-        """
-        ctx = context if context is not None else bpy.context
-        mode = getattr(ctx, "mode", "OBJECT")
-        return mode.startswith("EDIT_")
-
-    @classmethod
-    def iter_view3d_regions(cls) -> Iterator[tuple[bpy.types.Area, bpy.types.Region, bpy.types.RegionView3D]]:
-        """Yield ``(area, region, region_3d)`` for every WINDOW region in every 3D viewport.
-
-        Useful for features that need to act on every visible 3D viewport
-        (clip planes, draw handlers, region redraw fanout). Empty
-        generator when ``bpy.context.screen`` is unavailable (shutdown,
-        background mode without a screen).
-        """
-        screen = getattr(getattr(bpy, "context", None), "screen", None)
-        if screen is None:
-            return
-        for area in screen.areas:
-            if area.type != "VIEW_3D":
-                continue
-            for region in area.regions:
-                if region.type != "WINDOW":
-                    continue
-                region_3d = getattr(region, "data", None)
-                if region_3d is None:
-                    continue
-                yield area, region, region_3d
-
-    @classmethod
-    def get_or_create_collection(cls, scene: bpy.types.Scene, name: str) -> bpy.types.Collection:
-        """Return the named collection, creating + linking it to ``scene`` if absent."""
-        collection = bpy.data.collections.get(name)
-        if collection is None:
-            collection = bpy.data.collections.new(name)
-            scene.collection.children.link(collection)
-        return collection
-
-    @classmethod
-    def serialize_matrix(cls, matrix: Matrix) -> str:
-        """Serialize a 4x4 matrix as a 16-float comma-separated string.
-
-        Round-trip pair with :meth:`deserialize_matrix`. Used for storing
-        a matrix in an IFC pset string property without losing precision
-        (``%.9g`` carries ~9 significant digits, enough for ``float32``
-        round-trip).
-        """
-        return ",".join(f"{matrix[r][c]:.9g}" for r in range(4) for c in range(4))
-
-    @classmethod
-    def deserialize_matrix(cls, text: str) -> Matrix:
-        """Inverse of :meth:`serialize_matrix`."""
-        floats = [float(v) for v in text.split(",")]
-        return Matrix([tuple(floats[r * 4 : r * 4 + 4]) for r in range(4)])
-
-    @classmethod
-    def hash_matrix(cls, matrix: Matrix) -> int:
-        """Hash a 4x4 matrix by its 16 floats. Useful as a cache key."""
-        return hash(tuple(matrix[r][c] for r in range(4) for c in range(4)))
-
     @classmethod
     def is_view_top_down(cls, context: bpy.types.Context, threshold: float = 0.9659) -> bool:
         """True when the viewport camera is looking ~straight down (or up) the world Z axis.
@@ -1411,10 +1273,7 @@ class Blender(bonsai.core.tool.Blender):
 
     @classmethod
     def get_object_from_guid(cls, guid: str) -> Union[bpy.types.Object, None]:
-        try:
-            element = tool.Ifc.get().by_guid(guid)
-        except RuntimeError:
-            return None
+        element = tool.Ifc.get().by_guid(guid)
         obj = tool.Ifc.get_object(element)
         if obj:
             return obj
@@ -1537,10 +1396,6 @@ class Blender(bonsai.core.tool.Blender):
                 bpy.ops.bim.enable_editing_railing_path()
             elif feature := tool.Parametric.is_object_editing(obj):
                 tool.Parametric.run_bim_op(feature.finish_op)
-            elif tool.Parametric.is_wall(element):
-                # Placed after the generic finish dispatch so the TAB toggle splits:
-                # wall already editing → finish above; wall not editing → enter here.
-                bpy.ops.bim.enable_editing_wall()
             else:
                 return False
             return True
@@ -1603,38 +1458,6 @@ class Blender(bonsai.core.tool.Blender):
             parent_guid = pset.get("Parent")
             return parent_guid is not None and parent_guid != element.GlobalId
 
-        @classmethod
-        def any_selected_is_array_child(cls) -> bool:
-            """True if any selected IFC-linked object is a Bonsai array child.
-
-            Multi-object wall topology gizmos (merge / join / extend / unjoin
-            / fillet) and their bound operators gate on this: any mutation
-            applied to a child is overwritten on the next
-            ``regenerate_array``, and merge specifically would leave the
-            parent's ``BBIM_Array.Data`` list pointing at a deleted GUID.
-
-            Memoised against (selection signature, IFC geometry generation)
-            so gizmo polls that fire per input event don't re-walk the pset
-            for every selected object every frame. Identity-keyed so plain
-            Python objects (used by tests) work alongside real Blender
-            ``bpy_struct`` wrappers."""
-            selected = tool.Blender.get_selected_objects()
-            selection_sig = frozenset(id(obj) for obj in selected)
-            current_gen = tool.Parametric.get_geom_generation()
-            cached = cls._any_selected_array_child_memo
-            if cached is not None and cached[0] == selection_sig and cached[1] == current_gen:
-                return cached[2]
-            result = False
-            for obj in selected:
-                element = tool.Ifc.get_entity(obj)
-                if element is not None and cls.is_array_child(element):
-                    result = True
-                    break
-            cls._any_selected_array_child_memo = (selection_sig, current_gen, result)
-            return result
-
-        _any_selected_array_child_memo: tuple[frozenset[int], int, bool] | None = None
-
         @classmethod
         def is_slab(cls, element: entity_instance) -> bool:
             """A slab is host-eligible for the parametric add-opening gizmo if
@@ -2404,149 +2227,6 @@ class Blender(bonsai.core.tool.Blender):
             return False
         return True
 
-    @staticmethod
-    def transparent_color(color: Iterable[float], alpha: float = 0.1) -> list[float]:
-        """Copy an RGBA color with its alpha channel overridden."""
-        out = [c for c in color]
-        out[3] = alpha
-        return out
-
-    @classmethod
-    def draw_bmesh_face_tris(
-        cls,
-        bm: bmesh.types.BMesh,
-        world_vert_coords: list,
-        color: Any,
-        draw_batch: Callable[[str, list, Any, list], None],
-    ) -> None:
-        """Submit a non-mutating beauty-triangulated TRIS batch for ``bm``'s faces.
-
-        ``world_vert_coords`` must be indexed by ``bm.verts`` index. Never call
-        ``bmesh.ops.triangulate`` on a live bmesh to compute draw indices — it
-        mutates the input and produces ear-clip fans that render as visible
-        streaks at low alpha.
-        """
-        tris = [[loop.vert.index for loop in tri] for tri in bm.calc_loop_triangles()]
-        draw_batch("TRIS", world_vert_coords, color, tris)
-
-    @classmethod
-    def draw_quads(
-        cls,
-        context: bpy.types.Context,
-        quads: Sequence[
-            tuple[
-                tuple[float, float, float],
-                tuple[float, float, float],
-                tuple[float, float, float],
-                tuple[float, float, float],
-            ]
-        ],
-        *,
-        fill_color: Optional[tuple[float, float, float, float]] = None,
-        outline_color: Optional[tuple[float, float, float, float]] = None,
-        outline_width: float = 1.0,
-    ) -> None:
-        """Render ``quads`` (each a 4-tuple of CCW world-space corners) as
-        a filled TRIS batch, an outline LINES batch, or both.
-
-        Both colors are RGBA 4-tuples. Pass ``fill_color=None`` to skip
-        the fill pass and ``outline_color=None`` to skip the outline.
-        Skipping both is a no-op.
-
-        Replaces the per-decorator quad-fill helpers that used to live
-        inline in each feature module.
-        """
-        if not quads or (fill_color is None and outline_color is None):
-            return
-        region = getattr(context, "region", None)
-        if region is None:
-            return
-
-        verts: list[tuple[float, float, float]] = []
-        tri_indices: list[tuple[int, int, int]] = []
-        line_indices: list[tuple[int, int]] = []
-        for quad in quads:
-            if len(quad) != 4:
-                continue
-            base = len(verts)
-            verts.extend(tuple(v) for v in quad)
-            if fill_color is not None:
-                tri_indices.append((base, base + 1, base + 2))
-                tri_indices.append((base, base + 2, base + 3))
-            if outline_color is not None:
-                line_indices.append((base, base + 1))
-                line_indices.append((base + 1, base + 2))
-                line_indices.append((base + 2, base + 3))
-                line_indices.append((base + 3, base))
-
-        if not cls.validate_shader_batch_data(verts, None):
-            return
-
-        gpu.state.blend_set("ALPHA")
-        try:
-            if fill_color is not None and tri_indices:
-                shader = gpu.shader.from_builtin("UNIFORM_COLOR")
-                shader.bind()
-                shader.uniform_float("color", fill_color)
-                batch = batch_for_shader(shader, "TRIS", {"pos": verts}, indices=tri_indices)
-                batch.draw(shader)
-            if outline_color is not None and line_indices:
-                shader = gpu.shader.from_builtin("UNIFORM_COLOR")
-                shader.bind()
-                shader.uniform_float("color", outline_color)
-                # Outline width: the UNIFORM_COLOR shader respects the
-                # GPU's current line-width state; restore on exit.
-                prev_width = gpu.state.line_width_get()
-                gpu.state.line_width_set(outline_width)
-                try:
-                    batch = batch_for_shader(shader, "LINES", {"pos": verts}, indices=line_indices)
-                    batch.draw(shader)
-                finally:
-                    gpu.state.line_width_set(prev_width)
-        finally:
-            gpu.state.blend_set("NONE")
-
-    @classmethod
-    def build_dashed_line_segments(
-        cls,
-        world_verts: Sequence[Sequence[float]],
-        edges_indices: Sequence[Sequence[int]],
-        dash_period: float,
-        dash_width: float,
-    ) -> tuple[list[tuple[float, float, float]], list[tuple[int, int]]]:
-        """Pre-segment edges into world-space dash chunks for a vanilla LINES batch.
-
-        Each input edge is sliced into segments of length ``dash_width`` spaced
-        ``dash_period`` apart (dash phase resets per-edge). The result is a fresh
-        ``(verts, edges)`` pair that draws as dashes through any standard line
-        shader — letting both passes of a visible/occluded outline reuse the
-        same shader so depth values match exactly across passes.
-        """
-        new_verts: list[tuple[float, float, float]] = []
-        new_edges: list[tuple[int, int]] = []
-        if dash_period <= 0 or dash_width <= 0:
-            return new_verts, new_edges
-        n = len(world_verts)
-        for i, j in edges_indices:
-            if not (0 <= i < n and 0 <= j < n) or i == j:
-                continue
-            v0 = world_verts[i]
-            v1 = world_verts[j]
-            dx, dy, dz = v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]
-            edge_length = math.sqrt(dx * dx + dy * dy + dz * dz)
-            if edge_length == 0.0:
-                continue
-            ux, uy, uz = dx / edge_length, dy / edge_length, dz / edge_length
-            t = 0.0
-            while t < edge_length:
-                t_end = min(t + dash_width, edge_length)
-                idx = len(new_verts)
-                new_verts.append((v0[0] + ux * t, v0[1] + uy * t, v0[2] + uz * t))
-                new_verts.append((v0[0] + ux * t_end, v0[1] + uy * t_end, v0[2] + uz * t_end))
-                new_edges.append((idx, idx + 1))
-                t += dash_period
-        return new_verts, new_edges
-
     @classmethod
     def extract_error_reports(cls, exception: RuntimeError) -> list[str]:
         """Extracts error report lines from a runtime exception during operator execution.
@@ -2697,7 +2377,7 @@ class Blender(bonsai.core.tool.Blender):
 
         See https://projects.blender.org/blender/blender/issues/149283
         """
-        if len(bytedata) == (n * 8):  # float64 has 8 bytes per element
+        if len(bytedata) == (n * 2):
             return np.frombuffer(bytedata, dtype=np.float64).astype(np.float32)
         return np.frombuffer(bytedata, dtype=np.float32)
 

src/bonsai/bonsai/tool/cad.py

@@ -177,14 +177,6 @@ class Cad:
             return False
         return (x + tolerance) > value > (x - tolerance)
 
-    @classmethod
-    def is_multiple_of_pi(cls, value: float) -> bool:
-        """True when ``value`` is an integer multiple of π within tolerance —
-        the parallelism / anti-parallelism check rotation-difference logic
-        reaches for (segments aligned modulo a 180° flip)."""
-        n = round(value / math.pi)
-        return cls.is_x(abs(value - n * math.pi), 0)
-
     @classmethod
     def normalise_angle(cls, angle: float) -> float:
         """Normalise an angle between -179 and 180"""
@@ -206,237 +198,6 @@ class Cad:
         """
         return geometry.intersect_line_plane(v1, v2, plane_co, plane_no)
 
-    @classmethod
-    def obb_world_clip_planes(
-        cls,
-        center: Vector,
-        axes: tuple[Vector, Vector, Vector],
-        half_extents: Vector,
-    ) -> tuple[tuple[float, float, float, float], ...]:
-        """Return the 6 inward world clip planes of an oriented bounding box.
-
-        Each plane is a 4-tuple ``(a, b, c, d)`` for the equation
-        ``a*x + b*y + c*z + d``; a point is KEPT when the value is ``>= 0``
-        for every plane, matching ``RegionView3D.clip_planes`` semantics.
-        Return order is ``(+x, -x, +y, -y, +z, -z)`` where ``+x`` is the face
-        on the positive side of ``axes[0]``. ``axes`` are assumed orthonormal.
-        """
-        cx, cy, cz = center.x, center.y, center.z
-        planes: list[tuple[float, float, float, float]] = []
-        for i in range(3):
-            ux, uy, uz = axes[i].x, axes[i].y, axes[i].z
-            h = float(half_extents[i])
-            px, py, pz = cx + h * ux, cy + h * uy, cz + h * uz
-            nx, ny, nz = -ux, -uy, -uz
-            planes.append((nx, ny, nz, -(nx * px + ny * py + nz * pz)))
-            px, py, pz = cx - h * ux, cy - h * uy, cz - h * uz
-            planes.append((ux, uy, uz, -(ux * px + uy * py + uz * pz)))
-        return tuple(planes)
-
-    @classmethod
-    def obb_clip_planes_from_matrix(
-        cls,
-        matrix_world: Matrix,
-        expand: float = 0.0,
-        expand_rel: float = 0.0,
-    ) -> tuple[tuple[float, float, float, float], ...]:
-        """Return the 6 inward world clip planes for the unit cube under ``matrix_world``.
-
-        The implicit box is ``[-1, +1]^3`` in object-local space, so the
-        host's ``matrix_world`` translation is the world centre, its
-        rotation orients the box axes, and each column's magnitude is the
-        world half-extent along that local axis. ``expand`` (absolute
-        world units) and ``expand_rel`` (fraction of each axis's
-        half-extent) both add an outward margin — callers that visualise
-        the box with overlapping geometry (e.g. an empty CUBE display
-        sharing edges with the clip planes) pass non-zero values so the
-        box's own wireframe sits safely INSIDE the clip volume. Use the
-        relative form when the box is rendered at varying scales, since
-        the depth-buffer precision needed to keep an edge unclipped grows
-        with world-coordinate magnitude.
-        """
-        world_center = matrix_world.col[3].xyz
-        linear = matrix_world.to_3x3()
-        world_axes = []
-        world_half_list = []
-        for i in range(3):
-            v = linear.col[i].copy()
-            length = v.length
-            if length > 0.0:
-                world_axes.append(v / length)
-            else:
-                world_axes.append(Vector((0.0, 0.0, 0.0)))
-            world_half_list.append(length + expand + length * expand_rel)
-        return cls.obb_world_clip_planes(
-            world_center,
-            (world_axes[0], world_axes[1], world_axes[2]),
-            Vector(world_half_list),
-        )
-
-    @classmethod
-    def point_is_inside_clip_planes(
-        cls,
-        planes: tuple[tuple[float, float, float, float], ...],
-        point: Vector,
-        eps: float = 1e-6,
-    ) -> bool:
-        """True iff ``point`` is on the kept side of every plane (inclusive)."""
-        x, y, z = point.x, point.y, point.z
-        for a, b, c, d in planes:
-            if a * x + b * y + c * z + d < -eps:
-                return False
-        return True
-
-    @classmethod
-    def newell_normal(cls, points: Sequence) -> Vector:
-        """Newell's-method normal for a (possibly non-planar) 3D polygon ring.
-
-        Robust for thin / near-degenerate rings where a two-edge cross
-        product would be unstable.
-        """
-        nx = ny = nz = 0.0
-        n = len(points)
-        for i in range(n):
-            cur = points[i]
-            nxt = points[(i + 1) % n]
-            nx += (cur[1] - nxt[1]) * (cur[2] + nxt[2])
-            ny += (cur[2] - nxt[2]) * (cur[0] + nxt[0])
-            nz += (cur[0] - nxt[0]) * (cur[1] + nxt[1])
-        return Vector((nx, ny, nz))
-
-    @classmethod
-    def plane_basis(cls, points: Sequence) -> tuple[Vector, Vector]:
-        """Return an orthonormal ``(u, v)`` basis for the ring's best-fit plane."""
-        normal = cls.newell_normal(points)
-        if normal.length < 1e-12:
-            normal = Vector((0.0, 0.0, 1.0))
-        normal = normal.normalized()
-        ref = Vector((1.0, 0.0, 0.0))
-        if abs(normal.x) > 0.9:
-            ref = Vector((0.0, 1.0, 0.0))
-        u = normal.cross(ref)
-        if u.length < 1e-12:
-            ref = Vector((0.0, 0.0, 1.0))
-            u = normal.cross(ref)
-        u = u.normalized()
-        v = normal.cross(u).normalized()
-        return u, v
-
-    @classmethod
-    def tessellate_ring_planar(cls, polyline_list: list[list]) -> list[tuple[int, int, int]]:
-        """Triangulate ``[outer, *inners]`` 3D coord rings in their own plane.
-
-        Projects every ring onto the outer ring's best-fit plane and
-        returns ``(i, j, k)`` index triples into the flat
-        ``outer + inners[0] + inners[1] + ...`` vertex list. Falls
-        back to a shapely constrained Delaunay triangulation when
-        ``mathutils.geometry.tessellate_polygon`` silently leaves ring
-        vertices unused (its known failure mode on complex concave
-        polygons-with-holes).
-        """
-        from mathutils.geometry import tessellate_polygon
-
-        if not polyline_list or not polyline_list[0]:
-            return []
-        outer = polyline_list[0]
-        u, v = cls.plane_basis(outer)
-        origin = Vector(outer[0])
-
-        def _project_xy(ring):
-            return [((Vector(co) - origin).dot(u), (Vector(co) - origin).dot(v)) for co in ring]
-
-        projected_xy = [_project_xy(ring) for ring in polyline_list]
-        projected = [[Vector((x, y, 0.0)) for x, y in ring] for ring in projected_xy]
-        triangles = tessellate_polygon(projected)
-
-        n_total = sum(len(r) for r in projected_xy)
-        used = {i for tri in triangles for i in tri}
-        if triangles and len(used) >= n_total:
-            return triangles
-
-        fallback = cls._tessellate_via_shapely(projected_xy)
-        return fallback if fallback else triangles
-
-    @classmethod
-    def _tessellate_via_shapely(cls, projected_xy: list[list[tuple[float, float]]]) -> list[tuple[int, int, int]]:
-        """Constrained-Delaunay fallback for :meth:`tessellate_ring_planar`.
-
-        Honours the polygon's boundary AND holes. Returns ``[]`` when
-        shapely is unavailable or the polygon can't be cleaned via
-        ``buffer(0)``.
-        """
-        try:
-            from shapely.geometry import Polygon
-        except Exception:
-            return []
-        outer = projected_xy[0]
-        inners = projected_xy[1:]
-        if len(outer) < 3:
-            return []
-        try:
-            poly = Polygon(outer, inners)
-            poly = poly if poly.is_valid else poly.buffer(0)
-            if poly.is_empty:
-                return []
-        except Exception:
-            return []
-
-        flat = list(outer)
-        for r in inners:
-            flat.extend(r)
-
-        def _key(x, y):
-            return (round(x, 6), round(y, 6))
-
-        index_of: dict[tuple[float, float], int] = {}
-        for idx, (x, y) in enumerate(flat):
-            index_of.setdefault(_key(x, y), idx)
-
-        try:
-            from shapely import constrained_delaunay_triangles
-
-            res = constrained_delaunay_triangles(poly)
-            tri_geoms = list(getattr(res, "geoms", []) or [])
-        except Exception:
-            try:
-                from shapely.ops import triangulate
-
-                tri_geoms = [t for t in triangulate(poly) if poly.contains(t.representative_point())]
-            except Exception:
-                return []
-
-        out: list[tuple[int, int, int]] = []
-        for t in tri_geoms:
-            coords = list(t.exterior.coords)[:-1]
-            if len(coords) != 3:
-                continue
-            idxs = [index_of.get(_key(x, y)) for x, y in coords]
-            if any(i is None for i in idxs):
-                continue
-            out.append(tuple(idxs))
-        return out
-
-    @classmethod
-    def corners_might_cross_clip_planes(
-        cls,
-        planes: tuple[tuple[float, float, float, float], ...],
-        corners: Sequence[Vector],
-    ) -> bool:
-        """Conservative reject test: True if ``corners`` might cross the clip volume.
-
-        Returns False only when at least one plane has ALL corners on its
-        rejected side — meaning the convex hull of ``corners`` is fully
-        outside the clip volume and a per-mesh bisect can be skipped.
-        Returns True otherwise (possibly with false positives — never
-        false negatives), so callers always cap any object that actually
-        crosses the box. ``corners`` is typically the 8 world-space corners
-        of an object's bound box.
-        """
-        for a, b, c, d in planes:
-            if all(a * v.x + b * v.y + c * v.z + d < 0.0 for v in corners):
-                return False
-        return True
-
     def intersect_edge_plane_v2(v1, v2, plane_co, plane_no, eps=1e-9):
         """
         Numpy version of intersect_edge_plane

src/bonsai/bonsai/tool/connection.py

@@ -1,168 +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.
-
-"""Generic discovery of the connection linking two IFC elements.
-
-Used by ``bim.disconnect_elements`` so the operator surface is one operator
-per disconnect intent (active vs. partner, identified by GlobalId) rather
-than one per rel class. Each lookup returns ``(subject, kind)`` tuples where
-``subject`` is the entity whose teardown effects the disconnect:
-
-- ``"path"`` — ``IfcRelConnectsPathElements`` (wall-wall, wall-roof, etc.).
-  ``subject`` is the rel; removing it disconnects.
-- ``"element-top"`` — ``IfcRelConnectsElements`` with ``Description=="TOP"``
-  (created by ``extend_walls_to_underside``). ``subject`` is the rel.
-- ``"element"`` — any other ``IfcRelConnectsElements``. ``subject`` is the rel.
-- ``"mep-pair-fitting"`` — two MEP elements joined via ``IfcRelConnectsPorts``
-  through a single bridging ``IfcFlowFitting``. ``subject`` is the fitting
-  itself; removing it disconnects. ``OBSTRUCTION`` fittings are excluded
-  here; those go through ``bim.mep_add_obstruction(mode=REMOVE)``.
-
-Add new kinds by extending :py:meth:`Connection.find_rels`. The dispatch in
-``bonsai.core.connection.disconnect_rel`` maps each kind to the right
-post-mutation cleanup; the AST forward-compat guard enforces coverage."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import bonsai.tool as tool
-
-if TYPE_CHECKING:
-    import ifcopenshell
-
-
-class Connection:
-    @classmethod
-    def find_rels(
-        cls,
-        elem_a: ifcopenshell.entity_instance,
-        elem_b: ifcopenshell.entity_instance,
-    ) -> list[tuple[ifcopenshell.entity_instance, str]]:
-        """Return every supported connection linking ``elem_a`` to ``elem_b``
-        as a list of ``(subject, kind)`` tuples — ``subject`` is the entity
-        whose teardown effects the disconnect (the rel itself for
-        relationship-kinds, the bridging fitting for ``"mep-pair-fitting"``).
-        Walks both ``ConnectedTo`` and ``ConnectedFrom`` because either side
-        of a rel can be the relating element, and the same pair may carry
-        rels authored with opposite orientations."""
-        rels: list[tuple[ifcopenshell.entity_instance, str]] = []
-        seen: set[int] = set()
-
-        def _record(rel, kind):
-            if rel.id() not in seen:
-                seen.add(rel.id())
-                rels.append((rel, kind))
-
-        for rel in getattr(elem_a, "ConnectedTo", []) or ():
-            if rel.is_a("IfcRelConnectsPathElements") and getattr(rel, "RelatedElement", None) == elem_b:
-                _record(rel, "path")
-        for rel in getattr(elem_a, "ConnectedFrom", []) or ():
-            if rel.is_a("IfcRelConnectsPathElements") and getattr(rel, "RelatingElement", None) == elem_b:
-                _record(rel, "path")
-
-        for rel in getattr(elem_a, "ConnectedFrom", []) or ():
-            if rel.is_a("IfcRelConnectsElements") and getattr(rel, "RelatingElement", None) == elem_b:
-                kind = "element-top" if getattr(rel, "Description", None) == "TOP" else "element"
-                _record(rel, kind)
-        for rel in getattr(elem_a, "ConnectedTo", []) or ():
-            if rel.is_a("IfcRelConnectsElements") and getattr(rel, "RelatedElement", None) == elem_b:
-                kind = "element-top" if getattr(rel, "Description", None) == "TOP" else "element"
-                _record(rel, kind)
-
-        fitting = tool.System.find_bridging_fitting(elem_a, elem_b)
-        if fitting is not None:
-            _record(fitting, "mep-pair-fitting")
-
-        return rels
-
-    @classmethod
-    def find_rel(
-        cls,
-        elem_a: ifcopenshell.entity_instance,
-        elem_b: ifcopenshell.entity_instance,
-    ) -> tuple[ifcopenshell.entity_instance | None, str | None]:
-        """Return the first ``(subject, kind)`` or ``(None, None)``. Cheaper
-        than ``find_rels`` when callers only need to know whether a connection
-        exists or what kind it is."""
-        rels = cls.find_rels(elem_a, elem_b)
-        return rels[0] if rels else (None, None)
-
-    @classmethod
-    def find_rels_for_element(
-        cls,
-        elem: ifcopenshell.entity_instance,
-    ) -> list[tuple[ifcopenshell.entity_instance, str, ifcopenshell.entity_instance]]:
-        """Return every supported connection touching ``elem`` as
-        ``(subject, kind, partner)`` triples. ``partner`` is the *other*
-        element on the connection — the side cascade cleanup must operate on
-        when ``elem`` is being deleted.
-
-        Mirrors :py:meth:`find_rels`'s relationship-kind taxonomy. Notably
-        does NOT emit ``"mep-pair-fitting"`` triples: ``IfcRelConnectsPorts``
-        cleanup is owned by ``tool.Geometry.delete_ifc_object``'s
-        ``remove_port`` loop, which runs unconditionally on any IFC root
-        deletion. Including MEP here would cause the cascade to also remove
-        the bridging fitting when one of its connected segments is deleted —
-        a policy choice (fitting may still join other live segments) that's
-        better left to the user via the explicit disconnect operator.
-        """
-        result: list[tuple[ifcopenshell.entity_instance, str, ifcopenshell.entity_instance]] = []
-        seen: set[int] = set()
-
-        def _record(rel, kind, partner):
-            if partner is None or rel.id() in seen:
-                return
-            seen.add(rel.id())
-            result.append((rel, kind, partner))
-
-        for rel in getattr(elem, "ConnectedTo", []) or ():
-            if rel.is_a("IfcRelConnectsPathElements"):
-                _record(rel, "path", getattr(rel, "RelatedElement", None))
-            elif rel.is_a("IfcRelConnectsElements"):
-                kind = "element-top" if getattr(rel, "Description", None) == "TOP" else "element"
-                _record(rel, kind, getattr(rel, "RelatedElement", None))
-        for rel in getattr(elem, "ConnectedFrom", []) or ():
-            if rel.is_a("IfcRelConnectsPathElements"):
-                _record(rel, "path", getattr(rel, "RelatingElement", None))
-            elif rel.is_a("IfcRelConnectsElements"):
-                kind = "element-top" if getattr(rel, "Description", None) == "TOP" else "element"
-                _record(rel, kind, getattr(rel, "RelatingElement", None))
-
-        return result
-
-    @classmethod
-    def orient_element_top(
-        cls,
-        rel: ifcopenshell.entity_instance,
-        elem_a: ifcopenshell.entity_instance,
-        elem_b: ifcopenshell.entity_instance,
-    ) -> tuple[ifcopenshell.entity_instance, ifcopenshell.entity_instance]:
-        """Return ``(wall, slab)`` for an ``IfcRelConnectsElements(TOP)`` rel.
-
-        The ``extend_walls_to_underside`` flow stores slab as the relating
-        side and wall as related — orientation is recovered by checking
-        which input matches which rel attribute. Callers pass any two
-        elements; this resolves which is the wall and which is the slab so
-        post-disconnect cleanup (regenerate-wall-to-underside) targets the
-        right object."""
-        if getattr(rel, "RelatingElement", None) == elem_a:
-            return elem_b, elem_a
-        return elem_a, elem_b

src/bonsai/bonsai/tool/drawing.py

@@ -78,7 +78,6 @@ if TYPE_CHECKING:
 
 class Drawing(bonsai.core.tool.Drawing):
     ANNOTATION_DATA_TYPE = Literal["empty", "curve", "mesh"]
-    PERSPECTIVE_CAMERA_SHIFT_PROPERTIES = ("PerspectiveShiftX", "PerspectiveShiftY")
     DOCUMENT_TYPE = Literal["SCHEDULE", "REFERENCE"]
     LocationHintLiteral = Literal["PERSPECTIVE", "ORTHOGRAPHIC", "NORTH", "SOUTH", "EAST", "WEST"]
     LOCATION_HINT_LITERALS = ("PERSPECTIVE", "ORTHOGRAPHIC", "NORTH", "SOUTH", "EAST", "WEST")
@@ -454,41 +453,6 @@ class Drawing(bonsai.core.tool.Drawing):
         camera.matrix_world = matrix
         return camera
 
-    @classmethod
-    def get_perspective_camera_shifts(cls, drawing: ifcopenshell.entity_instance) -> dict[str, float]:
-        pset = ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing") or {}
-        shift_x_prop, shift_y_prop = cls.PERSPECTIVE_CAMERA_SHIFT_PROPERTIES
-        return {
-            "shift_x": float(pset.get(shift_x_prop, 0.0) or 0.0),
-            "shift_y": float(pset.get(shift_y_prop, 0.0) or 0.0),
-        }
-
-    @classmethod
-    def sync_perspective_camera_shifts(cls, drawing: ifcopenshell.entity_instance, camera: bpy.types.Camera) -> None:
-        if camera.type != "PERSP":
-            return
-
-        shift_x_prop, shift_y_prop = cls.PERSPECTIVE_CAMERA_SHIFT_PROPERTIES
-        current_shifts = cls.get_perspective_camera_shifts(drawing)
-        new_shifts = {"shift_x": float(camera.shift_x or 0.0), "shift_y": float(camera.shift_y or 0.0)}
-        if tool.Cad.is_x(current_shifts["shift_x"], new_shifts["shift_x"]) and tool.Cad.is_x(
-            current_shifts["shift_y"], new_shifts["shift_y"]
-        ):
-            return
-
-        ifc_file = tool.Ifc.get()
-        pset = tool.Pset.get_element_pset(drawing, "EPset_Drawing")
-        if not pset:
-            pset = ifcopenshell.api.pset.add_pset(ifc_file, product=drawing, name="EPset_Drawing")
-        ifcopenshell.api.pset.edit_pset(
-            ifc_file,
-            pset=pset,
-            properties={
-                shift_x_prop: new_shifts["shift_x"],
-                shift_y_prop: new_shifts["shift_y"],
-            },
-        )
-
     @classmethod
     def create_svg_schedule(cls, schedule: ifcopenshell.entity_instance) -> None:
         import bonsai.bim.module.drawing.scheduler as scheduler
@@ -1045,8 +1009,6 @@ class Drawing(bonsai.core.tool.Drawing):
         camera_props.has_annotation = True
         camera_props.target_view = "PLAN_VIEW"
         camera_props.is_nts = False
-        camera.shift_x = 0.0
-        camera.shift_y = 0.0
 
         pset = ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing")
         if pset:
@@ -1082,10 +1044,6 @@ class Drawing(bonsai.core.tool.Drawing):
                 camera_props.fill_mode = str(pset["FillMode"])
             if "CutMode" in pset:
                 camera_props.cut_mode = str(pset["CutMode"])
-            if camera.type == "PERSP":
-                shifts = cls.get_perspective_camera_shifts(drawing)
-                camera.shift_x = shifts["shift_x"]
-                camera.shift_y = shifts["shift_y"]
 
         camera_props.update_props = update_props
 
@@ -2309,19 +2267,14 @@ class Drawing(bonsai.core.tool.Drawing):
         cls, drawing: ifcopenshell.entity_instance, ifc_file: Optional[ifcopenshell.file] = None
     ) -> set[ifcopenshell.entity_instance]:
         """returns a set of elements that are included in the drawing"""
-        param_was_none = ifc_file is None
-        if param_was_none:
+        if ifc_file is None:
             ifc_file = tool.Ifc.get()
+            elements = cls.get_elements_in_camera_view(tool.Ifc.get_object(drawing), bpy.data.objects)
+        else:
+            # This can probably be smarter
+            elements = set(ifc_file.by_type("IfcElement"))
         pset = ifcopenshell.util.element.get_psets(drawing).get("EPset_Drawing", {})
         include = pset.get("Include", None)
-
-        # Only the active IFC file has Blender objects we can test against the
-        # camera's view frustum, which lets us drop elements - including those
-        # picked by an Include filter - that fall outside the drawing boundary.
-        camera_view_elements = None
-        if (param_was_none or include) and ifc_file is tool.Ifc.get():
-            camera_view_elements = cls.get_elements_in_camera_view(tool.Ifc.get_object(drawing), bpy.data.objects)
-
         if include:
             try:
                 data = json.loads(include)
@@ -2333,16 +2286,7 @@ class Drawing(bonsai.core.tool.Drawing):
                     elements = ifcopenshell.util.selector.filter_elements(ifc_file, include)
             except (json.JSONDecodeError, ValueError):
                 elements = ifcopenshell.util.selector.filter_elements(ifc_file, include)
-            # The Include filter chooses which elements may appear, but they must
-            # still fall within the drawing's camera boundary.
-            if camera_view_elements is not None:
-                elements &= camera_view_elements
         else:
-            if param_was_none:
-                elements = camera_view_elements
-            else:
-                # This can probably be smarter
-                elements = set(ifc_file.by_type("IfcElement"))
             if ifc_file.schema == "IFC2X3":
                 base_elements = set(ifc_file.by_type("IfcElement") + ifc_file.by_type("IfcSpatialStructureElement"))
             else:
@@ -2440,13 +2384,13 @@ class Drawing(bonsai.core.tool.Drawing):
     @classmethod
     def is_drawing_active(cls) -> bool:
         camera = bpy.context.scene.camera
-        if not (camera is not None and camera.type == "CAMERA" and tool.Blender.get_ifc_definition_id(camera)):
-            return False
-        # A VIEW_3D area is meaningless (and unobtainable) in background
-        # mode, but isn't otherwise required to generate a drawing.
-        if bpy.app.background:
-            return True
-        return tool.Blender.get_view3d_area() is not None
+        area = tool.Blender.get_view3d_area()
+        return bool(
+            camera is not None
+            and camera.type == "CAMERA"
+            and tool.Blender.get_ifc_definition_id(camera)
+            and area is not None
+        )
 
     @classmethod
     def is_camera_orthographic(cls) -> bool:
@@ -2577,19 +2521,10 @@ class Drawing(bonsai.core.tool.Drawing):
                     has_context = True
                     break
 
-        linked_handles: set[bpy.types.Object] = set()
-        for link in tool.Project.get_project_props().get_loaded_links_for_drawings():
-            try:
-                handle = tool.Project.get_link_empty_handle(link)
-            except Exception:
-                continue
-            if handle:
-                linked_handles.add(handle)
-
         visible_objects = []
         for obj in bpy.context.view_layer.objects:
             if element := tool.Ifc.get_entity(obj):
-                if element in filtered_elements or obj in linked_handles:
+                if element in filtered_elements:
                     visible_objects.append(obj)
             else:
                 if obj.hide_get() is False:

src/bonsai/bonsai/tool/duplicate.py

@@ -248,30 +248,32 @@ class Duplicate(bonsai.core.tool.Duplicate):
         old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
     ) -> None:
         for element, data in relationship.items():
-            new_relating_elements = old_to_new.get(data.relating_element) or []
-            new_related_elements = old_to_new.get(data.related_element) or []
+            try:
+                new_relating_element = old_to_new.get(data.relating_element)[0]
+                new_related_element = old_to_new.get(data.related_element)[0]
+            except (KeyError, IndexError, TypeError):
+                continue
+            new_rel = tool.Ifc.run(
+                "geometry.connect_path",
+                relating_element=new_relating_element,
+                related_element=new_related_element,
+                relating_connection=data.relating_connection_type,
+                related_connection=data.related_connection_type,
+            )
             # connect_path hardcodes priorities to []; restore them post-hoc.
             priority_attrs: dict[str, Any] = {}
             if data.relating_priorities:
                 priority_attrs["RelatingPriorities"] = data.relating_priorities
             if data.related_priorities:
                 priority_attrs["RelatedPriorities"] = data.related_priorities
-            for new_relating_element, new_related_element in zip(new_relating_elements, new_related_elements):
-                new_rel = tool.Ifc.run(
-                    "geometry.connect_path",
-                    relating_element=new_relating_element,
-                    related_element=new_related_element,
-                    relating_connection=data.relating_connection_type,
-                    related_connection=data.related_connection_type,
-                )
-                if new_rel is not None and priority_attrs:
-                    try:
-                        tool.Ifc.run("attribute.edit_attributes", product=new_rel, attributes=priority_attrs)
-                    except (RuntimeError, ifcopenshell.Error) as e:
-                        cls._emit_warning(
-                            f"connection priority restore failed for {new_rel}; "
-                            f"duplicate has empty RelatingPriorities/RelatedPriorities: {e}"
-                        )
+            if new_rel is not None and priority_attrs:
+                try:
+                    tool.Ifc.run("attribute.edit_attributes", product=new_rel, attributes=priority_attrs)
+                except (RuntimeError, ifcopenshell.Error) as e:
+                    cls._emit_warning(
+                        f"connection priority restore failed for {new_rel}; "
+                        f"duplicate has empty RelatingPriorities/RelatedPriorities: {e}"
+                    )
 
     @classmethod
     def recreate_port_connections(
@@ -281,43 +283,46 @@ class Duplicate(bonsai.core.tool.Duplicate):
     ) -> None:
         """Recreate ``IfcRelConnectsPorts`` between duplicates; skip records whose duplicate's port count diverges from the snapshot."""
         for relating_element, records in snapshot.by_element.items():
-            new_relatings = old_to_new.get(relating_element) or []
-            expected_relating = snapshot.port_counts.get(relating_element)
             for record in records:
                 related_element = record.related_element
-                new_relateds = old_to_new.get(related_element) or []
+                try:
+                    new_relating = old_to_new[relating_element][0]
+                    new_related = old_to_new[related_element][0]
+                except (KeyError, IndexError):
+                    continue
+
+                new_relating_ports = tool.System.get_ports(new_relating)
+                new_related_ports = tool.System.get_ports(new_related)
+
+                expected_relating = snapshot.port_counts.get(relating_element)
+                if expected_relating is not None and len(new_relating_ports) != expected_relating:
+                    cls._emit_warning(
+                        f"port reconnect skipped — duplicate has {len(new_relating_ports)} ports, "
+                        f"snapshot had {expected_relating}"
+                    )
+                    continue
                 expected_related = snapshot.port_counts.get(related_element)
-                for new_relating, new_related in zip(new_relatings, new_relateds):
-                    new_relating_ports = tool.System.get_ports(new_relating)
-                    new_related_ports = tool.System.get_ports(new_related)
+                if expected_related is not None and len(new_related_ports) != expected_related:
+                    cls._emit_warning(
+                        f"port reconnect skipped — duplicate has {len(new_related_ports)} ports, "
+                        f"snapshot had {expected_related}"
+                    )
+                    continue
 
-                    if expected_relating is not None and len(new_relating_ports) != expected_relating:
-                        cls._emit_warning(
-                            f"port reconnect skipped — duplicate has {len(new_relating_ports)} ports, "
-                            f"snapshot had {expected_relating}"
-                        )
-                        continue
-                    if expected_related is not None and len(new_related_ports) != expected_related:
-                        cls._emit_warning(
-                            f"port reconnect skipped — duplicate has {len(new_related_ports)} ports, "
-                            f"snapshot had {expected_related}"
-                        )
-                        continue
-
-                    try:
-                        new_port_a = new_relating_ports[record.relating_port_index]
-                        new_port_b = new_related_ports[record.related_port_index]
-                    except IndexError:
-                        cls._emit_warning(
-                            f"port reconnect skipped — record references port index past the duplicate's port list"
-                        )
-                        continue
-                    try:
-                        tool.Ifc.run(
-                            "system.connect_port",
-                            port1=new_port_a,
-                            port2=new_port_b,
-                            direction=record.direction or "NOTDEFINED",
-                        )
-                    except (RuntimeError, ifcopenshell.Error) as e:
-                        cls._emit_warning(f"port reconnect failed between duplicates: {e}")
+                try:
+                    new_port_a = new_relating_ports[record.relating_port_index]
+                    new_port_b = new_related_ports[record.related_port_index]
+                except IndexError:
+                    cls._emit_warning(
+                        f"port reconnect skipped — record references port index past the duplicate's port list"
+                    )
+                    continue
+                try:
+                    tool.Ifc.run(
+                        "system.connect_port",
+                        port1=new_port_a,
+                        port2=new_port_b,
+                        direction=record.direction or "NOTDEFINED",
+                    )
+                except (RuntimeError, ifcopenshell.Error) as e:
+                    cls._emit_warning(f"port reconnect failed between duplicates: {e}")

src/bonsai/bonsai/tool/geometry.py

@@ -24,7 +24,6 @@ import multiprocessing
 import struct
 from collections import defaultdict
 from collections.abc import Generator, Iterable, Iterator
-from contextlib import contextmanager
 from math import pi, radians
 from typing import (
     TYPE_CHECKING,
@@ -66,7 +65,6 @@ from typing_extensions import TypeIs
 
 import bonsai.bim.helper
 import bonsai.bim.import_ifc
-import bonsai.core.connection
 import bonsai.core.drawing
 import bonsai.core.geometry
 import bonsai.core.root
@@ -131,85 +129,6 @@ class Geometry(bonsai.core.tool.Geometry):
         if cache and hasattr(element, "GlobalId"):
             cache.remove(element.GlobalId)
 
-    # Per-host work coalesced by `batch_host_recut`. Keys are voided element ifc ids;
-    # dict insertion preserves call ordering. Recut values store the representation at
-    # enqueue time, but the drain re-reads `get_active_representation` so the recut
-    # always reflects current IFC state.
-    _host_batch_depth: int = 0
-    _host_recut_queue: dict[int, tuple[bpy.types.Object, ifcopenshell.entity_instance]] = {}
-    _host_update_queue: dict[int, bpy.types.Object] = {}
-
-    @classmethod
-    @contextmanager
-    def batch_host_recut(cls) -> Generator[None, None, None]:
-        """Coalesce host body work — `recut_host` and `update_host_representation`
-        calls inside the with-block enqueue by voided element id. On the outermost
-        exit: every host's `update_representation` runs first (writes Blender mesh
-        back to IFC), then every host's `switch_representation` runs (reads IFC +
-        openings → Blender mesh). The two-phase order matters: a recut that ran
-        before the matching update_representation would re-tessellate against stale
-        IFC, losing the user's edits.
-
-        Nests safely — only the outermost exit drains. The depth counter and queues
-        are reset on exit even if the body raises."""
-        cls._host_batch_depth += 1
-        try:
-            yield
-        finally:
-            cls._host_batch_depth -= 1
-            if cls._host_batch_depth == 0:
-                update_queue = cls._host_update_queue
-                recut_queue = cls._host_recut_queue
-                cls._host_update_queue = {}
-                cls._host_recut_queue = {}
-                for voided_obj in update_queue.values():
-                    try:
-                        if not voided_obj or not voided_obj.data:
-                            continue
-                    except ReferenceError:
-                        # Blender object was deleted while the batch was open
-                        # (e.g. user removed it via the outliner mid-op).
-                        continue
-                    if tool.Ifc.get_entity(voided_obj) is None:
-                        continue
-                    bpy.ops.bim.update_representation(obj=voided_obj.name)
-                for voided_obj, _ in recut_queue.values():
-                    try:
-                        if not voided_obj or not voided_obj.data:
-                            continue
-                    except ReferenceError:
-                        continue
-                    if tool.Ifc.get_entity(voided_obj) is None:
-                        continue
-                    current_rep = cls.get_active_representation(voided_obj)
-                    if current_rep is None:
-                        continue
-                    bonsai.core.geometry.switch_representation(
-                        tool.Ifc, cls, obj=voided_obj, representation=current_rep
-                    )
-
-    @classmethod
-    def recut_host(cls, voided_obj: bpy.types.Object, representation: ifcopenshell.entity_instance) -> None:
-        """Recut a host's body representation. Inside `batch_host_recut`, enqueues
-        by voided element id; outside, fires `switch_representation` directly."""
-        if cls._host_batch_depth > 0:
-            element = tool.Ifc.get_entity(voided_obj)
-            if element is not None:
-                cls._host_recut_queue[element.id()] = (voided_obj, representation)
-            return
-        bonsai.core.geometry.switch_representation(tool.Ifc, cls, obj=voided_obj, representation=representation)
-
-    @classmethod
-    def update_host_representation(cls, voided_obj: bpy.types.Object) -> None:
-        """Run `bim.update_representation` on a host. Inside `batch_host_recut`,
-        enqueues by voided element id; outside, fires the operator directly."""
-        if cls._host_batch_depth > 0:
-            element = tool.Ifc.get_entity(voided_obj)
-            if element is not None:
-                cls._host_update_queue[element.id()] = voided_obj
-            return
-        bpy.ops.bim.update_representation(obj=voided_obj.name)
-
     @classmethod
     def has_axis_representation(cls, element: ifcopenshell.entity_instance) -> bool:
         """True if the element carries a shape representation whose
@@ -237,112 +156,6 @@ class Geometry(bonsai.core.tool.Geometry):
         for modifier in obj.modifiers:
             obj.modifiers.remove(modifier)
 
-    @classmethod
-    def _group_edges_into_loops(cls, edges) -> list[list]:
-        """Group an edge set into connected components by shared vertices.
-
-        Each returned group is a list of edges that share at least one
-        vertex chain. A hollow profile's bisect produces two disjoint
-        loops (outer ring + inner ring) — grouping splits them so each
-        can be filled independently as a separate cap face, rather than
-        ``contextual_create`` welding them into one solid outer face
-        with the inner loop demoted to interior decoration.
-        """
-        edge_set = set(edges)
-        visited: set = set()
-        groups: list[list] = []
-        for start in edges:
-            if start in visited:
-                continue
-            group: list = []
-            stack: list = [start]
-            while stack:
-                e = stack.pop()
-                if e in visited:
-                    continue
-                visited.add(e)
-                group.append(e)
-                for v in e.verts:
-                    for adj in v.link_edges:
-                        if adj in edge_set and adj not in visited:
-                            stack.append(adj)
-            groups.append(group)
-        return groups
-
-    @classmethod
-    def bisect_and_cap(
-        cls,
-        bm,
-        planes_local,
-        *,
-        tag_layer_name: str = "bbim_cap",
-        dist: float = 1e-4,
-        weld_dist: float = 1e-5,
-    ):
-        """Clip ``bm`` against each ``(plane_co, plane_no)`` and fill the cuts.
-
-        Per plane, ``bmesh.ops.bisect_plane(clear_outer=True)`` discards
-        the outside half-space and ``bmesh.ops.contextual_create`` fills
-        the resulting cut edges with cap faces tagged via a BMesh int
-        layer so the tag propagates to any split-children from subsequent
-        planes. After all planes, near-coincident vertices are welded
-        (``weld_dist``) so adjacent caps from the same cross-section
-        merge cleanly.
-
-        Callers are responsible for input mesh quality. Non-watertight
-        inputs (terrain, single-shell surfaces) may produce degenerate
-        cap faces; that's an accepted user-supplied data limitation.
-
-        Returns the cap-tag BMLayerItem, or ``None`` if ``bm`` is empty.
-        """
-        import bmesh
-
-        if not bm.faces:
-            return None
-
-        # Pre-weld nearby verts: T-junctions in messy IFC meshes (a third
-        # vertex sitting in the middle of an edge from a Boolean
-        # operation) make the bisect cut terminate early, leaving open
-        # loops that no fill op can close. Welding the T-junction's
-        # near-coincident vertex into the host edge before bisecting
-        # turns the cut into a closed loop.
-        bmesh.ops.remove_doubles(bm, verts=bm.verts[:], dist=max(weld_dist, 1e-4))
-
-        cap_layer = bm.faces.layers.int.new(tag_layer_name)
-        for plane_co, plane_no in planes_local:
-            geom = bm.verts[:] + bm.edges[:] + bm.faces[:]
-            if not geom:
-                break
-            results = bmesh.ops.bisect_plane(
-                bm,
-                geom=geom,
-                dist=dist,
-                plane_co=plane_co,
-                plane_no=plane_no,
-                clear_outer=True,
-            )
-            cut_edges = [e for e in results["geom_cut"] if isinstance(e, bmesh.types.BMEdge)]
-            if not cut_edges:
-                continue
-            # Group cut edges into connected components BEFORE filling.
-            # Feeding ``contextual_create`` all edges at once (outer +
-            # inner of a hollow profile) makes it create a SINGLE outer
-            # face and treat inner edges as decoration — collapsing the
-            # hole. Filling each connected loop separately produces one
-            # cap face per ring.
-            for loop_edges in cls._group_edges_into_loops(cut_edges):
-                try:
-                    fill = bmesh.ops.contextual_create(bm, geom=loop_edges)
-                except (RuntimeError, TypeError):
-                    continue
-                for f in fill.get("faces", []):
-                    if isinstance(f, bmesh.types.BMFace) and f.is_valid:
-                        f[cap_layer] = 1
-
-        if weld_dist > 0.0:
-            bmesh.ops.remove_doubles(bm, verts=bm.verts[:], dist=weld_dist)
-        return cap_layer
-
     @classmethod
     def clear_scale(cls, obj: bpy.types.Object) -> None:
         """Apply and clear object scale.
@@ -458,38 +271,12 @@ class Geometry(bonsai.core.tool.Geometry):
         bpy.data.objects.remove(obj)
 
     @classmethod
-    def delete_ifc_object(
-        cls,
-        obj: bpy.types.Object,
-        batch_being_deleted_ids: Optional[set[int]] = None,
-    ) -> None:
+    def delete_ifc_object(cls, obj: bpy.types.Object) -> None:
         ifc_file = tool.Ifc.get()
         element = tool.Ifc.get_entity(obj)
         if not element:
             return
-        # Cascade connection-rel teardown — symmetric to bim.disconnect_elements.
-        # When a slab connected to a wall via IfcRelConnectsElements(TOP) is deleted,
-        # the wall's trim booleans + BBIM_Boolean pset would otherwise be orphaned.
-        # skip_elem_recreate is always True here because we're inside delete: the
-        # element is about to vanish, so re-extruding it would be wasted work.
-        # skip_partner_recreate fires only when the partner is also queued in the
-        # same OverrideDelete batch.
-        if element.is_a("IfcRoot"):
-            skip_ids = batch_being_deleted_ids or set()
-            for subject, kind, partner in tool.Connection.find_rels_for_element(element):
-                bonsai.core.connection.disconnect_rel(
-                    tool.Ifc,
-                    tool.Geometry,
-                    tool.Model,
-                    tool.Connection,
-                    subject=subject,
-                    kind=kind,
-                    elem=element,
-                    partner=partner,
-                    skip_elem_recreate=True,
-                    skip_partner_recreate=(partner.id() in skip_ids),
-                )
-        if element.is_a("IfcAnnotation"):
+        elif element.is_a("IfcAnnotation"):
             if element.ObjectType == "DRAWING":
                 return bonsai.core.drawing.remove_drawing(tool.Ifc, tool.Drawing, drawing=element)
             elif tool.Drawing.is_auto_annotation(element):
@@ -854,13 +641,7 @@ class Geometry(bonsai.core.tool.Geometry):
             and isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES)
             and (ifc_id := tool.Geometry.get_mesh_props(data).ifc_definition_id)
         ):
-            try:
-                return tool.Ifc.get().by_id(ifc_id)
-            except RuntimeError:
-                # Stale id: a representation rebuild freed the old entity
-                # while obj.data still tracks its id. Treated as "no active
-                # representation" — same contract as a mesh with id 0.
-                return None
+            return tool.Ifc.get().by_id(ifc_id)
 
     @classmethod
     def get_data_representation(cls, data: bpy.types.ID) -> ifcopenshell.entity_instance | None:
@@ -2489,16 +2270,84 @@ class Geometry(bonsai.core.tool.Geometry):
         old_obj_name_to_new_obj_name: dict[str, str] = {}
 
         for obj in objects_to_duplicate:
-            new_active = cls._duplicate_ifc_object_once(
-                obj,
-                active_object,
-                linked,
-                arrays_to_duplicate,
-                old_to_new,
-                old_obj_name_to_new_obj_name,
-            )
-            if new_active is not None:
-                new_active_obj = new_active
+            element = tool.Ifc.get_entity(obj)
+            if element:
+                if element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
+                    tool.Blender.deselect_object(obj)
+                    continue  # For now, don't copy drawings until we stabilise a bit more. It's tricky.
+                elif tool.Geometry.is_locked(element):
+                    tool.Blender.deselect_object(obj)
+                    continue
+            elif tool.Geometry.is_representation_item(obj):
+                cls.duplicate_ifc_item(obj)
+                continue
+
+            tracked_opening_type = tool.Model.get_tracked_opening_type(obj)
+            is_tracked_opening = bool(tracked_opening_type)
+            keep_data_linked = linked and not element and not is_tracked_opening
+
+            # Prior to duplicating, sync the object placement to make decomposition recreation more stable.
+            cls.commit_placement_if_moved(obj, apply_scale=False)
+
+            new_obj = obj.copy()
+            temp_data = None
+
+            # Currently for optimization we do not apply pending changes (scale or changed .data)
+            # to the original and duplicated objects.
+            # Keep new object edited if original is.
+            if tool.Ifc.is_edited(obj, ignore_scale=True):
+                tool.Ifc.edit(new_obj)
+
+            if obj.data and not keep_data_linked:
+                # assure root.copy_class won't replace the previous mesh globally
+                temp_data = obj.data.copy()
+                new_obj.data = temp_data
+
+                # Unlink from previous boolean element
+                # and keep object tracked for decorations.
+                if is_tracked_opening:
+                    mprops = tool.Geometry.get_mesh_props(new_obj.data)
+                    mprops.ifc_boolean_id = 0
+                    tool.Root.add_tracked_opening(new_obj, tracked_opening_type)
+
+            if obj == active_object:
+                new_active_obj = new_obj
+            for collection in obj.users_collection:
+                collection.objects.link(new_obj)
+            obj.select_set(False)
+            new_obj.select_set(True)
+            old_obj_name_to_new_obj_name[obj.name] = new_obj.name
+
+            if not element:
+                continue
+
+            # clear object's collection so it will be able to have it's own
+            tool.Blender.get_object_bim_props(new_obj).collection = None
+            # copy the actual class
+            new = bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
+
+            # clean up the orphaned mesh with ifc id of the original object to avoid confusion
+            # IfcGridAxis keeps the same mesh data (it's pointing to ifc id 0, so it's not a problem)
+            if new and temp_data and not new.is_a("IfcGridAxis"):
+                if new.is_a("IfcRelSpaceBoundary"):
+                    surface = new.ConnectionGeometry.SurfaceOnRelatingElement
+                    temp_data.name = f"0/{surface.id()}"
+                    tool.Ifc.link(surface, temp_data)
+                else:
+                    tool.Blender.remove_data_block(temp_data)
+
+            if new:
+                # TODO: handle array data for other cases of duplication
+                array_data = arrays_to_duplicate.get(obj, None)
+                tool.Model.handle_array_on_copied_element(new, array_data)
+                if array_data:
+                    for child in tool.Array.get_all_children_objects(new):
+                        child.select_set(True)
+
+                # TODO: add new array children to recreate their decomposition too
+                old_to_new[element] = [new]
+                if new.is_a("IfcRelSpaceBoundary"):
+                    tool.Boundary.decorate_boundary(new_obj)
 
         # Remap Blender parent relationships for duplicated objects
         for old_obj_name, new_obj_name in old_obj_name_to_new_obj_name.items():
@@ -2526,211 +2375,10 @@ class Geometry(bonsai.core.tool.Geometry):
         # Recreate decompositions
         tool.Duplicate.recreate_decompositions(decomposition_relationships, old_to_new)
         cls.remove_linked_aggregate_data(old_to_new)
-
-        # In-loop regenerate_wall runs before recreate_connections, so any new
-        # walls that just received an IfcRelConnectsPathElements have stale
-        # junction geometry — recalculate them now that their connection graph
-        # is complete.
-        cls._recalculate_walls_with_new_connections(old_to_new)
-
         bonsai.bim.handler.refresh_ui_data()
         tool.Root.reload_grid_decorator()
         return old_to_new, new_active_obj or active_object
 
-    @classmethod
-    def duplicate_ifc_object_n_times(
-        cls, source: bpy.types.Object, count: int
-    ) -> dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]:
-        """N-way duplicate of a single source.
-
-        Same per-copy semantics as duplicate_ifc_objects (IFC class copy,
-        decomposition + connection recreation, body regen for walls), but
-        bypasses the set() dedupe and the arrays_to_duplicate pre-scan so
-        callers building a fresh array don't pay per-call overhead N times.
-        Returns the same old_to_new dict shape, with the source element
-        mapping to the N new entities."""
-        if count <= 0:
-            return {}
-
-        sources = {source}
-        decomposition_relationships = tool.Duplicate.get_decomposition_relationships(sources)
-        connection_relationships = tool.Duplicate.get_connection_relationships(sources)
-        port_connection_snapshot = tool.Duplicate.get_port_connection_relationships(sources)
-        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]] = {}
-        old_obj_name_to_new_obj_name: dict[str, str] = {}
-
-        for _ in range(count):
-            cls._duplicate_ifc_object_once(
-                source,
-                None,
-                False,
-                {},
-                old_to_new,
-                old_obj_name_to_new_obj_name,
-                keep_source_selected=True,
-            )
-
-        for old_obj_name, new_obj_name in old_obj_name_to_new_obj_name.items():
-            new_obj = bpy.data.objects.get(new_obj_name)
-            if new_obj and new_obj.parent and new_obj.parent.name in old_obj_name_to_new_obj_name:
-                world_matrix = new_obj.matrix_world.copy()
-                new_parent_name = old_obj_name_to_new_obj_name[new_obj.parent.name]
-                new_parent = bpy.data.objects.get(new_parent_name)
-                if new_parent:
-                    new_obj.parent = new_parent
-                    new_obj.matrix_world = world_matrix
-
-        for old in old_to_new.keys():
-            if old.is_a("IfcElementAssembly"):
-                tool.Root.recreate_aggregate(old_to_new)
-
-        cls.remove_old_connections(old_to_new)
-        tool.Duplicate.recreate_connections(connection_relationships, old_to_new)
-        tool.Duplicate.recreate_port_connections(port_connection_snapshot, old_to_new)
-        tool.Duplicate.recreate_decompositions(decomposition_relationships, old_to_new)
-        cls.remove_linked_aggregate_data(old_to_new)
-        cls._recalculate_walls_with_new_connections(old_to_new)
-        bonsai.bim.handler.refresh_ui_data()
-        tool.Root.reload_grid_decorator()
-        return old_to_new
-
-    @classmethod
-    def _duplicate_ifc_object_once(
-        cls,
-        obj: bpy.types.Object,
-        active_object: Optional[bpy.types.Object],
-        linked: bool,
-        arrays_to_duplicate: dict[bpy.types.Object, Any],
-        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
-        old_obj_name_to_new_obj_name: dict[str, str],
-        keep_source_selected: bool = False,
-    ) -> Optional[bpy.types.Object]:
-        """Per-source body of the duplicate flow. Mutates old_to_new and
-        old_obj_name_to_new_obj_name in place. Returns new_obj when obj is
-        the active_object, else None.
-
-        keep_source_selected: when True, skip the source deselect so batched
-        callers can run N iterations without N×2 select flips and without
-        needing a post-loop restore on the source."""
-        new_active_obj: Optional[bpy.types.Object] = None
-        element = tool.Ifc.get_entity(obj)
-        if element:
-            if element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
-                tool.Blender.deselect_object(obj)
-                return None  # For now, don't copy drawings until we stabilise a bit more. It's tricky.
-            elif tool.Geometry.is_locked(element):
-                tool.Blender.deselect_object(obj)
-                return None
-        elif tool.Geometry.is_representation_item(obj):
-            cls.duplicate_ifc_item(obj)
-            return None
-
-        tracked_opening_type = tool.Model.get_tracked_opening_type(obj)
-        is_tracked_opening = bool(tracked_opening_type)
-        keep_data_linked = linked and not element and not is_tracked_opening
-
-        # Prior to duplicating, sync the object placement to make decomposition recreation more stable.
-        cls.commit_placement_if_moved(obj, apply_scale=False)
-
-        new_obj = obj.copy()
-        temp_data = None
-
-        # Currently for optimization we do not apply pending changes (scale or changed .data)
-        # to the original and duplicated objects.
-        # Keep new object edited if original is.
-        if tool.Ifc.is_edited(obj, ignore_scale=True):
-            tool.Ifc.edit(new_obj)
-
-        if obj.data and not keep_data_linked:
-            # assure root.copy_class won't replace the previous mesh globally
-            temp_data = obj.data.copy()
-            new_obj.data = temp_data
-
-            # Unlink from previous boolean element
-            # and keep object tracked for decorations.
-            if is_tracked_opening:
-                mprops = tool.Geometry.get_mesh_props(new_obj.data)
-                mprops.ifc_boolean_id = 0
-                tool.Root.add_tracked_opening(new_obj, tracked_opening_type)
-
-        if obj == active_object:
-            new_active_obj = new_obj
-        for collection in obj.users_collection:
-            collection.objects.link(new_obj)
-        if not keep_source_selected:
-            obj.select_set(False)
-        new_obj.select_set(True)
-        old_obj_name_to_new_obj_name[obj.name] = new_obj.name
-
-        if not element:
-            return new_active_obj
-
-        # clear object's collection so it will be able to have it's own
-        tool.Blender.get_object_bim_props(new_obj).collection = None
-        # copy the actual class
-        new = bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
-
-        # clean up the orphaned mesh with ifc id of the original object to avoid confusion
-        # IfcGridAxis keeps the same mesh data (it's pointing to ifc id 0, so it's not a problem)
-        if new and temp_data and not new.is_a("IfcGridAxis"):
-            if new.is_a("IfcRelSpaceBoundary"):
-                surface = new.ConnectionGeometry.SurfaceOnRelatingElement
-                temp_data.name = f"0/{surface.id()}"
-                tool.Ifc.link(surface, temp_data)
-            else:
-                tool.Blender.remove_data_block(temp_data)
-
-        if new:
-            # TODO: handle array data for other cases of duplication
-            array_data = arrays_to_duplicate.get(obj, None)
-            tool.Model.handle_array_on_copied_element(new, array_data)
-            if array_data:
-                for child in tool.Array.get_all_children_objects(new):
-                    child.select_set(True)
-
-            # TODO: add new array children to recreate their decomposition too
-            old_to_new.setdefault(element, []).append(new)
-            if new.is_a("IfcRelSpaceBoundary"):
-                tool.Boundary.decorate_boundary(new_obj)
-            # Slab-trim booleans (from extend_walls_to_underside) belong to
-            # the source wall's connection, not the copy. Strip them so the
-            # duplicate reverts to its pre-clip extrusion — mirrors the way
-            # filling rels are dropped while manual booleans persist on copy.
-            # Reload the body when something was stripped so the viewport
-            # immediately shows the unclipped geometry; otherwise the user
-            # sees a stale mesh until they Shift+G, which is easy to miss.
-            if new.is_a("IfcWall"):
-                if tool.Model.strip_underside_booleans(new):
-                    tool.Model.reload_body_representation(new_obj)
-                # HasOpenings rels don't follow object duplication, so
-                # the duplicate's body must rebuild to match its current
-                # opening set.
-                else:
-                    tool.Model.regenerate_wall(new_obj)
-
-        return new_active_obj
-
-    @classmethod
-    def _recalculate_walls_with_new_connections(
-        cls, old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]
-    ) -> None:
-        """Recalculate new IfcWall duplicates that just received an
-        ``IfcRelConnectsPathElements``. The in-loop ``regenerate_wall`` runs
-        before ``recreate_connections``, so wall body geometry doesn't reflect
-        the junction until this second pass."""
-        walls_to_recalc: list[bpy.types.Object] = []
-        for new_list in old_to_new.values():
-            for new_entity in new_list:
-                if not new_entity.is_a("IfcWall"):
-                    continue
-                if not (getattr(new_entity, "ConnectedTo", None) or getattr(new_entity, "ConnectedFrom", None)):
-                    continue
-                new_obj = tool.Ifc.get_object(new_entity)
-                if new_obj is not None:
-                    walls_to_recalc.append(new_obj)
-        if walls_to_recalc:
-            tool.Model.recalculate_walls(walls_to_recalc)
-
     @classmethod
     def duplicate_ifc_item(cls, obj: bpy.types.Object) -> None:
         props = tool.Geometry.get_geometry_props()
@@ -2782,10 +2430,7 @@ class Geometry(bonsai.core.tool.Geometry):
             pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
             if not pset:
                 continue
-            try:
-                array_parents.add(tool.Ifc.get().by_guid(pset["Parent"]))
-            except RuntimeError:
-                continue
+            array_parents.add(tool.Ifc.get().by_guid(pset["Parent"]))
 
         for array_parent in array_parents:
             array_parent_obj = tool.Ifc.get_object(array_parent)

src/bonsai/bonsai/tool/loader.py

@@ -189,7 +189,7 @@ class Loader(bonsai.core.tool.Loader):
                 uv_mode = "Generated"
             elif coordinates.is_a("IfcTextureCoordinateGenerator") and coordinates.Mode == "COORD-EYE":
                 uv_mode = "Camera"
-        surface_texture["uv_mode"] = uv_mode or "UV"
+        surface_texture["uv_mode"] = uv_mode or "Generated"
         return surface_texture
 
     @classmethod
@@ -315,7 +315,7 @@ class Loader(bonsai.core.tool.Loader):
                     image_url = str(image_url)
                     if is_relative and bpy.data.filepath:
                         image_url = bpy.path.relpath(image_url)
-                    return bpy.data.images.load(image_url, check_existing=True)
+                    return bpy.data.images.load(image_url)
 
                 elif texture["type"] == "IfcBlobTexture":
                     # https://blender.stackexchange.com/questions/173206/how-to-efficiently-convert-a-pil-image-to-bpy-types-image
@@ -472,23 +472,12 @@ class Loader(bonsai.core.tool.Loader):
                         print(f"{mode} Mode texture will be skipped.")
                     continue
 
-                if (image := get_image()) is None:
+                if (image := get_image) is None:
                     continue
 
-                # Replace whatever currently feeds the FLAT color input (RGB or previous texture chain).
-                for link in list(bsdf.inputs[2].links):
-                    prev_node = link.from_node
-                    blender_material.node_tree.links.remove(link)
-                    if prev_node.type == "TEX_IMAGE":
-                        # Remove linked texture coordinate node if it's no longer used.
-                        for vec_link in list(prev_node.inputs["Vector"].links):
-                            coord_node = vec_link.from_node
-                            blender_material.node_tree.links.remove(vec_link)
-                            if coord_node.type == "TEX_COORD" and not any(o.links for o in coord_node.outputs):
-                                blender_material.node_tree.nodes.remove(coord_node)
-                        blender_material.node_tree.nodes.remove(prev_node)
-                    elif prev_node.type == "RGB":
-                        blender_material.node_tree.nodes.remove(prev_node)
+                # remove RGB node from `create_surface_style_rendering`
+                prev_node = bsdf.inputs[2].links[0].from_node
+                blender_material.node_tree.nodes.remove(prev_node)
 
                 node = blender_material.node_tree.nodes.new(type="ShaderNodeTexImage")
                 node.location = bsdf.location - Vector((200, 250))

src/bonsai/bonsai/tool/model.py

@@ -75,14 +75,11 @@ if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import (
         BIMArrayProperties,
         BIMDoorProperties,
-        BIMDuctSegmentProperties,
         BIMExternalParametricGeometryProperties,
         BIMModelProperties,
-        BIMPipeSegmentProperties,
         BIMPolylineProperties,
         BIMRailingProperties,
         BIMRoofProperties,
-        BIMSlabProperties,
         BIMStairProperties,
         BIMSverchokProperties,
         BIMWallProperties,
@@ -119,18 +116,6 @@ class Model(bonsai.core.tool.Model):
     def get_railing_props(cls, obj: bpy.types.Object) -> BIMRailingProperties:
         return obj.BIMRailingProperties  # pyright: ignore[reportAttributeAccessIssue]
 
-    @classmethod
-    def get_slab_props(cls, obj: bpy.types.Object) -> BIMSlabProperties:
-        return obj.BIMSlabProperties  # pyright: ignore[reportAttributeAccessIssue]
-
-    @classmethod
-    def get_pipe_segment_props(cls, obj: bpy.types.Object) -> BIMPipeSegmentProperties:
-        return obj.BIMPipeSegmentProperties  # pyright: ignore[reportAttributeAccessIssue]
-
-    @classmethod
-    def get_duct_segment_props(cls, obj: bpy.types.Object) -> BIMDuctSegmentProperties:
-        return obj.BIMDuctSegmentProperties  # pyright: ignore[reportAttributeAccessIssue]
-
     @classmethod
     def get_sverchok_props(cls, obj: bpy.types.Object) -> BIMSverchokProperties:
         return obj.BIMSverchokProperties  # pyright: ignore[reportAttributeAccessIssue]
@@ -377,28 +362,6 @@ class Model(bonsai.core.tool.Model):
             else:
                 break
 
-    @classmethod
-    def get_sibling_occurrence_count(cls, element: ifcopenshell.entity_instance) -> int:
-        """Number of *other* products sharing this element's body representation.
-
-        Returns the count of products bound to the same resolved body rep, minus
-        ``element`` itself and minus its type (if any). Zero when the element has
-        no body rep, no resolved rep, or no siblings. A non-zero result means a
-        parametric edit on ``element`` will silently mutate other instances'
-        geometry."""
-        body_rep = tool.Geometry.get_body_representation(element)
-        if not body_rep:
-            return 0
-        resolved = ifcopenshell.util.representation.resolve_representation(body_rep)
-        if not resolved:
-            return 0
-        elements = tool.Geometry.get_elements_by_representation(resolved)
-        elements.discard(element)
-        element_type = ifcopenshell.util.element.get_type(element)
-        if element_type is not None:
-            elements.discard(element_type)
-        return len(elements)
-
     unit_scale: float
     vertices: list[Vector]
     edges: list[Sequence[int]]
@@ -814,7 +777,7 @@ class Model(bonsai.core.tool.Model):
         unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         layer_params = tool.Model.get_material_layer_parameters(element)
         layer_offset = layer_params["offset"]
-        thickness = layer_params["thickness"]
+        thickness = layer_params["thickness"] / unit_scale
         props = tool.Material.get_object_material_props(obj)
 
         # Try to load from pset if not already in props
@@ -822,7 +785,7 @@ class Model(bonsai.core.tool.Model):
             pset = ifcopenshell.util.element.get_pset(element, "BBIM_MaterialLayer")
             if pset and pset.get("UseCustomOffset", False):
                 # Load from pset
-                custom_offset = pset.get("CustomOffset", 0.0) * unit_scale
+                custom_offset = pset.get("CustomOffset", 0.0)
                 usage_type = tool.Model.get_usage_type(element)
 
                 if usage_type == "LAYER2":
@@ -835,7 +798,7 @@ class Model(bonsai.core.tool.Model):
                 return None
         else:
             # Use current props
-            custom_offset = props.custom_offset
+            custom_offset = props.custom_offset / unit_scale
             if tool.Model.get_usage_type(element) == "LAYER2":
                 custom_offset_reference = props.custom_wall_reference
             elif tool.Model.get_usage_type(element) == "LAYER3":
@@ -846,17 +809,17 @@ class Model(bonsai.core.tool.Model):
         direction_sense = layer_params["direction_sense"]
 
         if direction_sense == "POSITIVE" and custom_offset_reference in {"INTERIOR", "TOP"}:
-            layer_offset = custom_offset - thickness
+            layer_offset = custom_offset - thickness * unit_scale
         if direction_sense == "POSITIVE" and custom_offset_reference in {"CENTER", "MIDDLE"}:
-            layer_offset = custom_offset - (thickness / 2)
+            layer_offset = custom_offset - (thickness / 2) * unit_scale
         if (direction_sense == "POSITIVE" and custom_offset_reference in {"EXTERIOR", "BOTTOM"}) or (
             direction_sense == "NEGATIVE" and custom_offset_reference in {"EXTERIOR", "TOP"}
         ):
             layer_offset = custom_offset
         if direction_sense == "NEGATIVE" and custom_offset_reference in {"CENTER", "MIDDLE"}:
-            layer_offset = custom_offset + (thickness / 2)
+            layer_offset = custom_offset + (thickness / 2) * unit_scale
         if direction_sense == "NEGATIVE" and custom_offset_reference in {"INTERIOR", "BOTTOM"}:
-            layer_offset = custom_offset + thickness
+            layer_offset = custom_offset + thickness * unit_scale
 
         return layer_offset / unit_scale
 
@@ -909,46 +872,6 @@ class Model(bonsai.core.tool.Model):
         """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 strip_underside_booleans(cls, wall: ifcopenshell.entity_instance) -> bool:
-        """Remove slab-trim ``IfcBooleanResult`` items from a wall's body chain.
-
-        Returns ``True`` if any boolean was removed, so the caller knows whether
-        a Blender-side body reload is needed to surface the geometry change.
-
-        Hook for the duplicate path (Shift+D): the source wall's clip booleans
-        don't make sense on a copy pulled away from the slab. Booleans whose
-        ``SecondOperand.is_a("IfcTessellatedFaceSet")`` are removed — same
-        imprecise discriminator the rest of the wall-to-underside machinery
-        uses (manual cuts authored from tessellated meshes would also be
-        stripped, but most manual cuts use ``IfcExtrudedAreaSolid`` / CSG
-        primitives and are unaffected).
-
-        Cannot reuse ``remove_wall_to_underside_booleans`` here because the
-        duplicate's ``BBIM_Boolean.Data`` holds the source wall's stale ids —
-        ``get_manual_booleans`` returns empty on the copy and the helper
-        early-returns. The duplicate hook works directly off the chain.
-        """
-        representation = tool.Geometry.get_body_representation(wall)
-        if not representation:
-            return False
-        chain = cls.get_booleans(wall, representation)
-        to_remove = [b for b in chain if (sec := b.SecondOperand) is not None and sec.is_a("IfcTessellatedFaceSet")]
-        for b in to_remove:
-            tool.Geometry.remove_representation_item(b.SecondOperand, wall)
-        # Sweep the now-stale BBIM_Boolean entries on the copy (their ids point
-        # at booleans that were never in this wall's chain — they survived the
-        # ifcopenshell deep copy as JSON text in the pset payload).
-        pset_data = ifcopenshell.util.element.get_pset(wall, "BBIM_Boolean")
-        if pset_data:
-            representation = tool.Geometry.get_body_representation(wall)
-            chain_ids = {b.id() for b in cls.get_booleans(wall, representation)} if representation else set()
-            stored_ids = set(json.loads(pset_data["Data"]))
-            stale_ids = stored_ids - chain_ids
-            if stale_ids:
-                cls.unmark_manual_booleans(wall, list(stale_ids))
-        return bool(to_remove)
-
     @classmethod
     def remove_wall_to_underside_booleans(cls, wall: ifcopenshell.entity_instance) -> None:
         """Remove all IfcBooleanResult items previously added by extend_walls_to_underside."""
@@ -1244,42 +1167,6 @@ class Model(bonsai.core.tool.Model):
         cls, parent_obj: bpy.types.Object, data: list[dict[str, Any]], array_layers_to_apply: Iterable[int] = tuple()
     ) -> None:
         """`array_layers_to_apply` - list of array layer indices to apply"""
-        with tool.Geometry.batch_host_recut():
-            cls._regenerate_array_body(parent_obj, data, array_layers_to_apply)
-
-    @classmethod
-    def _prune_orphan_array_children(cls, array: dict[str, Any]) -> None:
-        """Drop GUIDs from ``array['children']`` whose IFC entity or Blender
-        object is no longer alive, and cascade-remove the orphan IFC entity
-        if it still exists. Outliner / keyboard delete of a Bonsai-managed
-        object bypasses ``bim.delete``'s cascade, leaving dangling opening
-        and filling references that later confuse regen and crash the
-        ``batch_host_recut`` drain."""
-        live_guids: list[str] = []
-        ifc_file = tool.Ifc.get()
-        for guid in array["children"]:
-            try:
-                element = ifc_file.by_guid(guid)
-            except RuntimeError:
-                continue
-            obj = tool.Ifc.get_object(element)
-            try:
-                is_live = obj is not None and obj.data is not None
-            except ReferenceError:
-                is_live = False
-            if is_live:
-                live_guids.append(guid)
-                continue
-            try:
-                ifcopenshell.api.root.remove_product(ifc_file, product=element)
-            except (RuntimeError, ifcopenshell.Error):
-                pass
-        array["children"] = live_guids
-
-    @classmethod
-    def _regenerate_array_body(
-        cls, parent_obj: bpy.types.Object, data: list[dict[str, Any]], array_layers_to_apply: Iterable[int]
-    ) -> None:
         parent_element = tool.Ifc.get_entity(parent_obj)
 
         if pset := ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array"):
@@ -1291,7 +1178,6 @@ class Model(bonsai.core.tool.Model):
         obj_stack = [parent_obj]
 
         for array_i, array in enumerate(data):
-            cls._prune_orphan_array_children(array)
             child_i = 0
             existing_children = set(array["children"])
             total_existing_children = len(array["children"])
@@ -1305,14 +1191,6 @@ class Model(bonsai.core.tool.Model):
             else:
                 base_offset = Vector([array["x"], array["y"], array["z"]]) * unit_scale
 
-            target_new_in_this_layer = (array["count"] - 1) * len(obj_stack)
-            missing_count = max(0, target_new_in_this_layer - total_existing_children)
-            new_entities_pool: list[ifcopenshell.entity_instance] = []
-            if missing_count > 0:
-                batch_old_to_new = tool.Geometry.duplicate_ifc_object_n_times(parent_obj, missing_count)
-                new_entities_pool = batch_old_to_new.get(parent_element, [])
-            new_entities_iter = iter(new_entities_pool)
-
             for i in range(array["count"]):
                 if i == 0:
                     continue
@@ -1330,13 +1208,8 @@ class Model(bonsai.core.tool.Model):
                         child_obj = tool.Ifc.get_object(child_element)
                         assert child_obj
                     except (IndexError, RuntimeError, AssertionError):
-                        try:
-                            child_element = next(new_entities_iter)
-                        except StopIteration:
-                            # Stale-GUID mid-list left the pool exhausted; fall back
-                            # to a one-off duplicate so the layer can still complete.
-                            old_to_new, _ = tool.Geometry.duplicate_ifc_objects([parent_obj])
-                            child_element = next(iter(old_to_new.values()))[0]
+                        old_to_new, _ = tool.Geometry.duplicate_ifc_objects([parent_obj])
+                        child_element = next(iter(old_to_new.values()))[0]
                         child_obj = tool.Ifc.get_object(child_element)
 
                     # add child pset
@@ -1370,10 +1243,7 @@ class Model(bonsai.core.tool.Model):
             # handle elements unused in the array after regeneration
             removed_children = set(existing_children) - set(array["children"])
             for removed_child in removed_children:
-                try:
-                    element = tool.Ifc.get().by_guid(removed_child)
-                except RuntimeError:
-                    continue
+                element = tool.Ifc.get().by_guid(removed_child)
                 # Strip any wall/slab opening cut by this child before deletion,
                 # so the host's HasOpenings shrinks symmetrically with count.
                 if getattr(element, "FillsVoids", None):
@@ -1404,7 +1274,14 @@ class Model(bonsai.core.tool.Model):
             tool.Ifc.get(), pset=pset, properties={"Data": json_data, "Parent": parent_element.GlobalId}
         )
 
-        tool.Blender.set_object_selection(parent_obj, True)
+        # Post-condition: parent is selected on return. duplicate_ifc_objects
+        # deselects the source on every call inside the regen loop; without
+        # this restore, callers get a deselected parent for arrays with N >= 2.
+        # TODO: batch the per-child duplicate_ifc_objects([parent]) calls into
+        # a single N-way duplicate — N depsgraph churns + N select/deselect
+        # flips is wasteful, and a batched duplicate would also remove the
+        # need for this restore.
+        parent_obj.select_set(True)
 
     @classmethod
     def mirror_parent_void_fillings_to_children(
@@ -1485,7 +1362,9 @@ class Model(bonsai.core.tool.Model):
             representation = tool.Geometry.get_representation_by_context(voided_element, context)
             if representation is None:
                 continue
-            tool.Geometry.recut_host(voided_obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc, tool.Geometry, obj=voided_obj, representation=representation
+            )
 
     @classmethod
     def unshare_opening_representation(cls, filling: ifcopenshell.entity_instance) -> None:
@@ -1677,7 +1556,8 @@ class Model(bonsai.core.tool.Model):
         element = tool.Ifc.get_entity(object)
         if not element:
             return
-        pset_data = ifcopenshell.util.element.get_pset(element, pset_name)
+        psets = ifcopenshell.util.element.get_psets(element)
+        pset_data = psets.get(pset_name, None)
         if not pset_data:
             return
         pset_data["data_dict"] = json.loads(pset_data.get("Data", "[]") or "[]")
@@ -2096,86 +1976,47 @@ class Model(bonsai.core.tool.Model):
         return (vertices, edges, faces)
 
     @classmethod
-    def regenerate_filling_opening_body(cls, filling: ifcopenshell.entity_instance) -> Optional[bpy.types.Object]:
-        """Regenerate only the mapped source used by ``filling``'s opening so
-        it matches ``filling``'s current parametric dimensions.
-
-        Returns the voided host Blender object so the caller can recut it,
-        or ``None`` if ``filling`` has no opening to refresh or the host is
-        an aggregate (no mesh data to recut against)."""
+    def update_simple_openings(cls, element: ifcopenshell.entity_instance) -> None:
         from bonsai.bim.module.model.opening import FilledOpeningGenerator
 
-        if not filling.FillsVoids:
-            return None
-
         ifc_file = tool.Ifc.get()
-        opening = filling.FillsVoids[0].RelatingOpeningElement
-        voided_obj = tool.Ifc.get_object(opening.VoidsElements[0].RelatingBuildingElement)
-        if voided_obj is None or voided_obj.data is None:
-            return None
+        fillings = {e: tool.Ifc.get_object(e) for e in tool.Array.get_parametric_propagation_targets(element)}
 
-        old_representation = tool.Geometry.get_body_representation(opening)
-        if old_representation is None:
-            return voided_obj
-        old_representation = tool.Geometry.resolve_mapped_representation(old_representation)
-
-        ifcopenshell.api.geometry.unassign_representation(ifc_file, product=opening, representation=old_representation)
-
-        filling_obj = tool.Ifc.get_object(filling)
-        new_representation = FilledOpeningGenerator().generate_opening_from_filling(
-            filling, filling_obj, voided_obj.dimensions[1]
-        )
-
-        for inverse in ifc_file.get_inverse(old_representation):
-            ifcopenshell.util.element.replace_attribute(inverse, old_representation, new_representation)
-
-        ifcopenshell.api.geometry.remove_representation(ifc_file, representation=old_representation)
-
-        return voided_obj
-
-    @classmethod
-    def regenerate_simple_opening_bodies(cls, element: ifcopenshell.entity_instance) -> set:
-        """Regenerate every distinct mapped opening source within ``element``'s
-        type-occurrence family so each one matches the family's current
-        parametric dimensions.
-
-        Most occurrences share a single mapped source — refreshing it once
-        propagates to every filling via inverse-substitution. Some families,
-        especially those imported from foreign authoring tools, fragment into
-        several mapped sources for the same type; dedup is by source id so
-        every distinct source gets one refresh. Returns the set of Blender
-        objects whose host representation needs a viewport-level recut
-        (callers handle the recut themselves)."""
-        ifc_file = tool.Ifc.get()
-        fillings = list(tool.Array.get_parametric_propagation_targets(element))
-
-        voided_objs: set = set()
-        seen_source_ids: set[int] = set()
+        voided_objs = set()
+        has_replaced_opening_representation = False
         for filling in fillings:
             if not filling.FillsVoids:
                 continue
 
             opening = filling.FillsVoids[0].RelatingOpeningElement
             voided_obj = tool.Ifc.get_object(opening.VoidsElements[0].RelatingBuildingElement)
-            if voided_obj is not None:
-                voided_objs.add(voided_obj)
+            voided_objs.add(voided_obj)
 
-            body = tool.Geometry.get_body_representation(opening)
-            if body is None:
+            # We assume all occurrences of the same element type (e.g. a window)
+            # will use openings of the same thickness.
+            # Generator we use by default will create a really thick opening representation
+            # to make sure it will fit for walls with different thickness.
+            if has_replaced_opening_representation:
                 continue
-            source = tool.Geometry.resolve_mapped_representation(body)
-            if source.id() in seen_source_ids:
-                continue
-            seen_source_ids.add(source.id())
 
-            cls.regenerate_filling_opening_body(filling)
+            old_representation = ifcopenshell.util.representation.get_representation(
+                opening, "Model", "Body", "MODEL_VIEW"
+            )
+            old_representation = tool.Geometry.resolve_mapped_representation(old_representation)
+            ifcopenshell.api.geometry.unassign_representation(
+                ifc_file, product=opening, representation=old_representation
+            )
 
-        return voided_objs
+            new_representation = FilledOpeningGenerator().generate_opening_from_filling(
+                filling, fillings[filling], voided_obj.dimensions[1]
+            )
 
-    @classmethod
-    def update_simple_openings(cls, element: ifcopenshell.entity_instance) -> None:
-        voided_objs = cls.regenerate_simple_opening_bodies(element)
-        fillings = {e: tool.Ifc.get_object(e) for e in tool.Array.get_parametric_propagation_targets(element)}
+            for inverse in ifc_file.get_inverse(old_representation):
+                ifcopenshell.util.element.replace_attribute(inverse, old_representation, new_representation)
+
+            ifcopenshell.api.geometry.remove_representation(ifc_file, representation=old_representation)
+
+            has_replaced_opening_representation = True
 
         tool.Model.reload_body_representation(voided_objs)
         if fillings:
@@ -3138,9 +2979,6 @@ class Model(bonsai.core.tool.Model):
             regenerate_fillet_corner_wall(element, obj)
             return
         rep = ifcopenshell.api.geometry.regenerate_wall_representation(tool.Ifc.get(), element)
-        if rep is None:
-            # Wall has no IfcMaterialLayerSet — layer-set rebuild not applicable.
-            return
         bonsai.core.geometry.switch_representation(
             tool.Ifc,
             tool.Geometry,
@@ -3155,19 +2993,6 @@ class Model(bonsai.core.tool.Model):
         obj.matrix_world = tool.Loader.apply_blender_offset_to_matrix_world(obj, matrix)
         tool.Geometry.record_object_position(obj)
 
-    @classmethod
-    def regenerate_wall(cls, obj: bpy.types.Object) -> None:
-        """Rebuild a wall's body from current IFC state: extrusion + openings
-        first, then re-clip to any surviving ``IfcRelConnectsElements(TOP)``
-        slab. Safe on walls with no openings and no slab connection — both
-        steps no-op against their preconditions."""
-        element = tool.Ifc.get_entity(obj)
-        if element is None:
-            return
-        cls.recreate_wall(element, obj)
-        if cls.has_underside_connection(element):
-            bonsai.core.model.regenerate_wall_to_underside(tool.Ifc, tool.Geometry, cls, [obj])
-
     @classmethod
     def recalculate_walls(cls, walls: list[bpy.types.Object]) -> None:
         queue: set[tuple[ifcopenshell.entity_instance, bpy.types.Object]] = set()
@@ -3183,26 +3008,6 @@ class Model(bonsai.core.tool.Model):
                 obj = tool.Ifc.get_object(rel.RelatingElement)
                 tool.Geometry.commit_placement_if_moved(obj)
                 queue.add((rel.RelatingElement, obj))
-
-        # Sync filling and opening placements so subsequent wall recuts
-        # operate on the up-to-date opening positions — a filling moved
-        # along the wall's reference line otherwise stays cut at its old
-        # spot.
-        for element, wall in queue:
-            if not wall:
-                continue
-            for rel in getattr(element, "HasOpenings", []) or []:
-                opening = rel.RelatedOpeningElement
-                for fill_rel in getattr(opening, "HasFillings", []) or []:
-                    filling = fill_rel.RelatedBuildingElement
-                    filling_obj = tool.Ifc.get_object(filling)
-                    if filling_obj is None or not tool.Ifc.is_moved(filling_obj):
-                        continue
-                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=filling_obj)
-                    ifcopenshell.api.geometry.edit_object_placement(
-                        tool.Ifc.get(), product=opening, matrix=filling_obj.matrix_world
-                    )
-
         for element, wall in queue:
             if not wall:
                 continue

src/bonsai/bonsai/tool/parametric.py

@@ -81,19 +81,11 @@ class ParametricObject:
     ``_cancel_targets``) and that therefore wire their operators through
     ``build_edit_lifecycle``. Entries with bespoke edit lifecycles (per-attribute
     diff dispatch, layer-stack editing, mid-spline gizmo drag) leave this
-    False and declare their operator classes directly.
-
-    ``has_default_parameters`` marks entries whose ``BIM<Name>Properties``
-    class exposes ``get_general_kwargs`` / ``copy_to`` and a matching
-    ``draw_<name>_properties`` UI helper, so the addon-preferences panel can
-    surface a per-type defaults section and the create operator can seed new
-    instances from the preset. Entries without that machinery leave this False
-    and don't appear in the preferences ``Default Parameters`` panel."""
+    False and declare their operator classes directly."""
 
     name: str
     has_non_editable_path: bool = False
     supports_build_edit_lifecycle: bool = False
-    has_default_parameters: bool = False
 
     def __post_init__(self) -> None:
         if not _VALID_NAME_RE.match(self.name):
@@ -155,23 +147,18 @@ class Parametric(bonsai.core.tool.Parametric):
             self._data.clear()
             self._gen = None
 
+    # FIXME(PR5): pipe_segment / duct_segment land with their finish/cancel
+    # operators in the MEP slice of PR5 (PR5d). Until then they stay out of
+    # EDIT_TYPES so auto-commit-on-save doesn't try to dispatch a
+    # non-existent operator.
     EDIT_TYPES: list[ParametricObject] = [
-        ParametricObject(
-            "door", has_non_editable_path=True, supports_build_edit_lifecycle=True, has_default_parameters=True
-        ),
-        ParametricObject(
-            "window", has_non_editable_path=True, supports_build_edit_lifecycle=True, has_default_parameters=True
-        ),
-        ParametricObject(
-            "stair", has_non_editable_path=True, supports_build_edit_lifecycle=True, has_default_parameters=True
-        ),
-        ParametricObject("railing", supports_build_edit_lifecycle=True, has_default_parameters=True),
-        ParametricObject("roof", supports_build_edit_lifecycle=True, has_default_parameters=True),
+        ParametricObject("door", has_non_editable_path=True, supports_build_edit_lifecycle=True),
+        ParametricObject("window", has_non_editable_path=True, supports_build_edit_lifecycle=True),
+        ParametricObject("stair", has_non_editable_path=True, supports_build_edit_lifecycle=True),
+        ParametricObject("railing", supports_build_edit_lifecycle=True),
+        ParametricObject("roof", supports_build_edit_lifecycle=True),
         ParametricObject("array", supports_build_edit_lifecycle=True),
-        ParametricObject("pipe_segment", supports_build_edit_lifecycle=True),
-        ParametricObject("duct_segment", supports_build_edit_lifecycle=True),
         ParametricObject("wall"),
-        ParametricObject("slab"),
     ]
 
     # Annotations for the uppercase constants populated from ``EDIT_TYPES`` by
@@ -183,10 +170,7 @@ class Parametric(bonsai.core.tool.Parametric):
     RAILING: ClassVar[ParametricObject]
     ROOF: ClassVar[ParametricObject]
     ARRAY: ClassVar[ParametricObject]
-    PIPE_SEGMENT: ClassVar[ParametricObject]
-    DUCT_SEGMENT: ClassVar[ParametricObject]
     WALL: ClassVar[ParametricObject]
-    SLAB: ClassVar[ParametricObject]
 
     _geom_generation: int = 0
 
@@ -475,15 +459,6 @@ class Parametric(bonsai.core.tool.Parametric):
             return False
         return tool.Pset.get_element_pset(element, "BBIM_Stair") is not None
 
-    @classmethod
-    def is_slab(cls, element: entity_instance) -> bool:
-        """``True`` for any ``IfcSlab``. The slab edit lifecycle only gates
-        the connection-disconnect UI — no IFC mutation — so we don't narrow
-        further (e.g. by checking for wall connections). Per-gizmo polls
-        layer the "has wall connections" check on top via
-        ``tool.Wall.iter_slab_wall_connections``."""
-        return element is not None and element.is_a("IfcSlab")
-
     @classmethod
     def is_wall(cls, element: entity_instance) -> bool:
         """A wall is editable by the parametric gizmo if it is an IfcWall with LAYER2 usage.

src/bonsai/bonsai/tool/patch.py

@@ -18,33 +18,18 @@
 
 from __future__ import annotations
 
-import re
 from typing import TYPE_CHECKING, Any
 
 import bpy
 import ifcopenshell
-import ifcopenshell.util.schema
 import ifcpatch
 
 import bonsai.core.tool
-import bonsai.tool
 
 if TYPE_CHECKING:
     from bonsai.bim.module.patch.prop import BIMPatchProperties
 
 
-# Lower index = older schema. Used to detect downgrades vs upgrades.
-_SCHEMA_AGE = {"IFC2X3": 0, "IFC4": 1, "IFC4X3": 2}
-
-# Pretty-printed argument name for the ``Migrate`` recipe's schema parameter
-# (see UpdateIfcPatchArguments.pretty_arg_name in bim/module/patch/operator.py).
-_MIGRATE_SCHEMA_ARG_NAME = "Schema"
-
-# Match a STEP-encoded FILE_SCHEMA header: ``FILE_SCHEMA(('IFC4'));`` and the
-# IFC4X3_ADD2 / IFC2X3_TC1 variants. Captures the bare schema identifier.
-_IFC_FILE_SCHEMA_RE = re.compile(r"FILE_SCHEMA\s*\(\s*\(\s*'([^']+)'", re.IGNORECASE)
-
-
 class Patch(bonsai.core.tool.Patch):
     @classmethod
     def get_patch_props(cls) -> BIMPatchProperties:
@@ -69,63 +54,6 @@ class Patch(bonsai.core.tool.Patch):
             "SplitByBuildingStorey",
         )
 
-    @classmethod
-    def get_preset_subdir(cls) -> str:
-        """Resolve the preset subdirectory for the currently selected recipe.
-
-        Returns a stable string for the ``-`` placeholder so the menu and save
-        operator remain usable when no real recipe has been picked yet."""
-        recipe = cls.get_patch_props().ifc_patch_recipes or "-"
-        return f"bonsai/ifc_patch/{recipe}"
-
-    @classmethod
-    def migration_is_lossy_downgrade(cls) -> bool:
-        """``True`` when the currently configured patch is the ``Migrate``
-        recipe targeting an older schema than the input file. Used to gate
-        the destructive-migration confirmation dialog."""
-        props = cls.get_patch_props()
-        if props.ifc_patch_recipes != "Migrate":
-            return False
-        target_schema = next(
-            (arg.get_value() for arg in props.ifc_patch_args_attr if arg.name == _MIGRATE_SCHEMA_ARG_NAME),
-            None,
-        )
-        if not target_schema:
-            return False
-        source_schema = cls._patch_source_schema()
-        if not source_schema:
-            return False
-        return _SCHEMA_AGE.get(target_schema, -1) < _SCHEMA_AGE.get(source_schema, -1)
-
-    @classmethod
-    def _patch_source_schema(cls) -> str:
-        """Resolve the IFC schema of the configured input without parsing the
-        full file. For loaded-from-memory the schema is in the entity_instance
-        wrapper; for disk paths we read only the STEP file header (first ~2KB)
-        rather than ``ifcopenshell.open`` which parses the whole file."""
-        props = cls.get_patch_props()
-        if props.should_load_from_memory:
-            ifc_file = bonsai.tool.Ifc.get()
-            return ifc_file.schema if ifc_file else ""
-        if not props.ifc_patch_input:
-            return ""
-        try:
-            with open(props.ifc_patch_input, "rb") as f:
-                header = f.read(2048).decode("utf-8", errors="ignore")
-        except OSError:
-            return ""
-        match = _IFC_FILE_SCHEMA_RE.search(header)
-        if not match:
-            return ""
-        # Collapse IFC4X3_ADD2 / IFC2X3_TC1 / IFC4_ADD2 / IFC4X1 etc. to their
-        # base via the canonical normaliser — handles longest-prefix-first
-        # ordering correctly (IFC4X3 before IFC4) so we don't misclassify
-        # IFC4X3 files as IFC4.
-        try:
-            return ifcopenshell.util.schema.get_fallback_schema(match.group(1).upper())
-        except AssertionError:
-            return ""
-
     @classmethod
     def post_process_patch_arguments(cls, recipe: str, args: list[Any]) -> list[Any]:
         if recipe == "ExtractElements":

src/bonsai/bonsai/tool/project.py

@@ -32,7 +32,6 @@ from typing import (
     NotRequired,
     Optional,
     TypedDict,
-    Union,
 )
 
 import bpy
@@ -334,14 +333,6 @@ class Project(bonsai.core.tool.Project):
                 if reference[1]:
                     m = np.fromstring(reference[1], sep=",", dtype=np.float64).reshape(4, 4)
                     link.has_transformation = not np.allclose(m, np.eye(4))
-                # The selector query used at link time is persisted only in the
-                # sidecar cache JSON; restore it so Reload/Load replay the filter.
-                json_filepath = Path(tool.Ifc.resolve_uri(filepath)).with_suffix(".ifc.cache.json")
-                if json_filepath.exists():
-                    try:
-                        link.query = json.loads(json_filepath.read_text()).get("query", "")
-                    except (OSError, json.JSONDecodeError):
-                        pass
 
     @classmethod
     def get_project_library_elements(
@@ -385,31 +376,12 @@ class Project(bonsai.core.tool.Project):
             )
 
     @classmethod
-    def get_parent_library(
-        cls, project_library: ifcopenshell.entity_instance
-    ) -> Union[ifcopenshell.entity_instance, None]:
-        """Return the IfcContext that declares or nests ``project_library``.
-
-        Returns ``None`` when ``project_library`` is itself the root of a
-        library-only file (no IfcRelNests, no IfcRelDeclares).
-        """
+    def get_parent_library(cls, project_library: ifcopenshell.entity_instance) -> ifcopenshell.entity_instance:
         if nests := project_library.Nests:
+            # IfcProjectLibrary.
             return nests[0].RelatingObject
-        if has_context := project_library.HasContext:
-            return has_context[0].RelatingContext
-        return None
-
-    @classmethod
-    def get_root_context(cls, ifc_file: ifcopenshell.file) -> ifcopenshell.entity_instance:
-        """Return the file's root IfcContext.
-
-        Prefers IfcProject if present, otherwise falls back to IfcProjectLibrary —
-        library-only files are valid per IFC4+ and contain no IfcProject. Caller is
-        responsible for the IFC2X3 guard; IfcContext does not exist in that schema.
-        """
-        if projects := ifc_file.by_type("IfcProject"):
-            return projects[0]
-        return ifc_file.by_type("IfcProjectLibrary")[0]
+        # IfcProject.
+        return project_library.HasContext[0].RelatingContext
 
     @classmethod
     def get_project_hierarchy(cls, ifc_file: ifcopenshell.file) -> HiearchyDict:
@@ -429,8 +401,6 @@ class Project(bonsai.core.tool.Project):
             return hierarchy
         for project_library in ifc_file.by_type("IfcProjectLibrary"):
             parent_library = cls.get_parent_library(project_library)
-            if parent_library is None:
-                continue
             hierarchy[parent_library][project_library] = hierarchy[project_library]
         return hierarchy
 

src/bonsai/bonsai/tool/root.py

@@ -373,37 +373,35 @@ class Root(bonsai.core.tool.Root):
                 try:
                     new_aggregate = old_to_new[old_aggregate]
                 except:
-                    for new_entity in new:
-                        bonsai.core.aggregate.unassign_object(
-                            tool.Ifc,
-                            tool.Aggregate,
-                            tool.Collector,
-                            relating_obj=tool.Ifc.get_object(old_aggregate),
-                            related_obj=tool.Ifc.get_object(new_entity),
-                        )
-                    continue
-
-                for new_entity in new:
-                    bonsai.core.aggregate.assign_object(
+                    bonsai.core.aggregate.unassign_object(
                         tool.Ifc,
                         tool.Aggregate,
                         tool.Collector,
-                        relating_obj=tool.Ifc.get_object(new_aggregate[0]),
-                        related_obj=tool.Ifc.get_object(new_entity),
+                        relating_obj=tool.Ifc.get_object(old_aggregate),
+                        related_obj=tool.Ifc.get_object(new[0]),
                     )
+                    continue
 
-                    # Make sure that the array children also get reassigned to the correct aggregate
-                    pset = ifcopenshell.util.element.get_pset(new_entity, "BBIM_Array")
-                    if pset:
-                        array_children = tool.Array.get_all_children_objects(new_entity)
-                        for obj in array_children:
-                            bonsai.core.aggregate.assign_object(
-                                tool.Ifc,
-                                tool.Aggregate,
-                                tool.Collector,
-                                relating_obj=tool.Ifc.get_object(new_aggregate[0]),
-                                related_obj=tool.Ifc.get_object(tool.Ifc.get_entity(obj)),
-                            )
+                bonsai.core.aggregate.assign_object(
+                    tool.Ifc,
+                    tool.Aggregate,
+                    tool.Collector,
+                    relating_obj=tool.Ifc.get_object(new_aggregate[0]),
+                    related_obj=tool.Ifc.get_object(new[0]),
+                )
+
+                # Make sure that the array children also get reassigned to the correct aggregate
+                pset = ifcopenshell.util.element.get_pset(new[0], "BBIM_Array")
+                if pset:
+                    array_children = tool.Array.get_all_children_objects(new[0])
+                    for obj in array_children:
+                        bonsai.core.aggregate.assign_object(
+                            tool.Ifc,
+                            tool.Aggregate,
+                            tool.Collector,
+                            relating_obj=tool.Ifc.get_object(new_aggregate[0]),
+                            related_obj=tool.Ifc.get_object(tool.Ifc.get_entity(obj)),
+                        )
 
         if new_aggregate is None:
             return

src/bonsai/bonsai/tool/spatial.py

@@ -80,7 +80,10 @@ class Spatial(bonsai.core.tool.Spatial):
     def get_root_element(cls, element: ifcopenshell.entity_instance) -> ifcopenshell.entity_instance:
         while True:
             if parent := (
-                ifcopenshell.util.element.get_aggregate(element) or ifcopenshell.util.element.get_nest(element)
+                ifcopenshell.util.element.get_aggregate(element)
+                or ifcopenshell.util.element.get_nest(element)
+                or ifcopenshell.util.element.get_filled_void(element)
+                or ifcopenshell.util.element.get_voided_element(element)
             ):
                 element = parent
             else:

src/bonsai/bonsai/tool/system.py

@@ -357,13 +357,6 @@ class System(bonsai.core.tool.System):
             if not cls.is_mep_element(element):
                 continue
 
-            # Array children inherit port topology from their parent's IFC
-            # entity, but their positions are derived — drawing ports on every
-            # copy of an arrayed segment doubles up markers and misleads the
-            # user into thinking each copy has its own port network.
-            if tool.Array.is_array_child(element):
-                continue
-
             selected_element = element in connected_elements
             verts_pos = []
 
@@ -495,87 +488,6 @@ class System(bonsai.core.tool.System):
     def is_mep_element(cls, element: ifcopenshell.entity_instance) -> bool:
         return element.is_a("IfcFlowSegment") or element.is_a("IfcFlowFitting")
 
-    @classmethod
-    def is_disconnectable_fitting(cls, element: ifcopenshell.entity_instance) -> bool:
-        """A fitting whose deletion is the supported teardown for one of
-        its port connections. ``OBSTRUCTION`` fittings are excluded — they
-        have a dedicated grow/shrink flow (``bim.mep_add_obstruction``
-        with ``mode=REMOVE``) that absorbs the freed segment length."""
-        if not element.is_a("IfcFlowFitting"):
-            return False
-        return getattr(element, "PredefinedType", None) != "OBSTRUCTION"
-
-    @classmethod
-    def neighbours_at_ports(cls, element: ifcopenshell.entity_instance) -> list[ifcopenshell.entity_instance]:
-        """Entities reachable from ``element``'s ports via a single
-        ``IfcRelConnectsPorts`` hop, deduped by IFC id."""
-        neighbours: list[ifcopenshell.entity_instance] = []
-        seen: set[int] = set()
-        for port in cls.get_ports(element):
-            connected_port = cls.get_connected_port(port)
-            if connected_port is None:
-                continue
-            neighbour = ifcopenshell.util.system.get_port_element(connected_port)
-            if neighbour is None or neighbour.id() in seen:
-                continue
-            seen.add(neighbour.id())
-            neighbours.append(neighbour)
-        return neighbours
-
-    @classmethod
-    def find_bridging_fitting(
-        cls,
-        elem_a: ifcopenshell.entity_instance,
-        elem_b: ifcopenshell.entity_instance,
-    ) -> Union[ifcopenshell.entity_instance, None]:
-        """Return the disconnectable ``IfcFlowFitting`` whose removal
-        disconnects ``elem_a`` from ``elem_b``, or ``None``.
-
-        Two topologies are handled. (1) Direct port-to-port between a
-        segment/fitting and a disconnectable fitting: the fitting endpoint
-        is returned. (2) Two segments joined by a single bridging
-        disconnectable fitting: the bridging fitting is returned.
-        ``OBSTRUCTION`` fittings short-circuit to ``None``."""
-        if not (cls.is_mep_element(elem_a) and cls.is_mep_element(elem_b)):
-            return None
-
-        a_neighbours = cls.neighbours_at_ports(elem_a)
-        b_neighbours = cls.neighbours_at_ports(elem_b)
-        elem_a_id = elem_a.id()
-        elem_b_id = elem_b.id()
-
-        if cls.is_disconnectable_fitting(elem_a) and any(n.id() == elem_b_id for n in a_neighbours):
-            return elem_a
-        if cls.is_disconnectable_fitting(elem_b) and any(n.id() == elem_a_id for n in b_neighbours):
-            return elem_b
-
-        a_fittings = [n for n in a_neighbours if cls.is_disconnectable_fitting(n)]
-        if not a_fittings:
-            return None
-        b_fitting_ids = {n.id() for n in b_neighbours if cls.is_disconnectable_fitting(n)}
-        for fitting in a_fittings:
-            if fitting.id() in b_fitting_ids:
-                return fitting
-        return None
-
-    @classmethod
-    def has_parametric_body(cls, element: ifcopenshell.entity_instance) -> bool:
-        """True when the MEP element's body representation is a profile sweep
-        (``IfcExtrudedAreaSolid`` for segments, ``IfcSweptDiskSolid`` for
-        fittings) — the shape the parametric edit + MEP action gizmos can
-        actually mutate. Tessellation- or brep-imported MEP elements return
-        False so their gizmos hide rather than offer edits the geometry
-        kernel can't honour."""
-        import bonsai.tool as tool
-
-        body = tool.Geometry.get_body_representation(element)
-        if body is None:
-            return False
-        for item in tool.Ifc.get().traverse(body):
-            if item.is_a("IfcExtrudedAreaSolid") or item.is_a("IfcSweptDiskSolid"):
-                return True
-        return False
-
     @classmethod
     def walk_connected_mep_elements(
         cls, start_element: ifcopenshell.entity_instance

src/bonsai/bonsai/tool/type.py

@@ -24,7 +24,6 @@ import bpy
 import ifcopenshell
 import ifcopenshell.util.element
 import ifcopenshell.util.representation
-import ifcopenshell.util.type
 
 import bonsai.core.geometry
 import bonsai.core.tool
@@ -97,26 +96,6 @@ class Type(bonsai.core.tool.Type):
     def get_type_occurrences(cls, element_type: ifcopenshell.entity_instance) -> list[ifcopenshell.entity_instance]:
         return ifcopenshell.util.element.get_types(element_type)
 
-    @classmethod
-    def is_relating_type_compatible(
-        cls,
-        occurrence: ifcopenshell.entity_instance,
-        relating_type: ifcopenshell.entity_instance,
-    ) -> bool:
-        # IFC's EXPRESS schema has no WHERE rule pairing IfcRelDefinesByType's
-        # RelatingType / RelatedObjects classes; the one-to-one class pairing
-        # is a buildingSMART implementer agreement, not file-validation.
-        schema = occurrence.file.schema
-        if relating_type.is_a() in ifcopenshell.util.type.get_applicable_types(occurrence.is_a(), schema=schema):
-            return True
-        # The implementer agreement map has no entry for the abstract
-        # IfcTypeProduct, which Bonsai uses for annotation types. The schema
-        # defines IfcTypeProduct.ApplicableOccurrence for exactly this purpose,
-        # so honor it. occurrence.is_a() handles subtypes and unknown tokens.
-        if applicable_occurrence := getattr(relating_type, "ApplicableOccurrence", None):
-            return occurrence.is_a(applicable_occurrence.split("/", 1)[0])
-        return False
-
     @classmethod
     def has_material_usage(cls, element: ifcopenshell.entity_instance) -> bool:
         material = ifcopenshell.util.element.get_material(element)

src/bonsai/bonsai/tool/wall.py

@@ -242,75 +242,6 @@ class Wall(bonsai.core.tool.Wall):
         local_p2 = Vector((p2[0] * unit_scale, p2[1] * unit_scale, 0.0))
         return obj.matrix_world @ local_p1, obj.matrix_world @ local_p2
 
-    @classmethod
-    def iter_wall_slab_connections(cls, wall: ifcopenshell.entity_instance):
-        """Yield ``(slab, rel)`` tuples for every ``IfcRelConnectsElements(TOP)``
-        connecting a slab to this wall — the rel kind ``extend_walls_to_underside``
-        creates. Walks ``wall.ConnectedFrom`` because the slab is the relating
-        side of the TOP rel."""
-        for rel in getattr(wall, "ConnectedFrom", []) or ():
-            if not rel.is_a("IfcRelConnectsElements") or rel.Description != "TOP":
-                continue
-            slab = rel.RelatingElement
-            if slab is None:
-                continue
-            yield slab, rel
-
-    @classmethod
-    def iter_slab_wall_connections(cls, slab: ifcopenshell.entity_instance):
-        """Yield ``(wall, rel)`` tuples for every wall clipped to this slab's
-        underside. Mirror of ``iter_wall_slab_connections`` from the slab side
-        — walks ``slab.ConnectedTo``."""
-        for rel in getattr(slab, "ConnectedTo", []) or ():
-            if not rel.is_a("IfcRelConnectsElements") or rel.Description != "TOP":
-                continue
-            wall = rel.RelatedElement
-            if wall is None:
-                continue
-            yield wall, rel
-
-    @classmethod
-    def find_wall_slab_rel(
-        cls, wall: ifcopenshell.entity_instance, slab: ifcopenshell.entity_instance
-    ) -> ifcopenshell.entity_instance | None:
-        """Return the single ``IfcRelConnectsElements(TOP)`` between ``wall``
-        and ``slab``, or ``None`` if none exists. Used by the disconnect
-        operator to find the specific rel to remove."""
-        for s, rel in cls.iter_wall_slab_connections(wall):
-            if s == slab:
-                return rel
-        return None
-
-    WALL_SLAB_CONNECTION_Z_CLEARANCE = 0.5
-    """Lift above the wall top so the disconnect icon sits above the
-    extend-vertical / slope gizmo and reads as "the thing above the wall =
-    the slab connection"."""
-
-    @classmethod
-    def wall_slab_connection_location_world(
-        cls, wall_obj: bpy.types.Object, slab_obj: bpy.types.Object
-    ) -> Vector | None:
-        """World-space anchor for the wall-slab disconnect icon.
-
-        X / Y come from the wall axis midpoint (so the icon sits in the
-        middle of the wall horizontally); Z is the wall's top in world space
-        plus ``WALL_SLAB_CONNECTION_Z_CLEARANCE`` so the icon perches above
-        the slope gizmo. The slab-side gizmo calls this with the same
-        arguments so both sides of the same connection render a single
-        visual marker. ``slab_obj`` is kept on the signature for the
-        symmetric call shape; the helper's body no longer reads from it.
-        Returns ``None`` when the wall has no reference line."""
-        ref = cls.get_world_reference_line(wall_obj)
-        if ref is None:
-            return None
-        axis_mid_world = (ref[0] + ref[1]) * 0.5
-        if wall_obj.bound_box:
-            wall_top_local_z = max(c[2] for c in wall_obj.bound_box)
-            wall_top_world_z = (wall_obj.matrix_world @ Vector((0.0, 0.0, wall_top_local_z))).z
-        else:
-            wall_top_world_z = axis_mid_world.z
-        return Vector((axis_mid_world.x, axis_mid_world.y, wall_top_world_z + cls.WALL_SLAB_CONNECTION_Z_CLEARANCE))
-
     @classmethod
     def walk_connected_walls(
         cls,

src/bonsai/pytest.ini

@@ -7,11 +7,8 @@ markers =
     boundary
     brick
     bsdd
-    clash
     classification
-    clip_box
     context
-    contract_guard
     cost
     covering
     debug

src/bonsai/test/bim/conftest.py

@@ -1,46 +1,5 @@
 import pytest
 
-
-class _FakePropsBase:
-    """Base for parametric-edit PropertyGroup stand-ins used in lifecycle tests.
-
-    The parametric-edit lifecycle mixins read/write a common contract:
-    ``is_editing`` (bool), ``last_kwargs`` (dict | None — capture of the last
-    data written via ``set_props_kwargs_from_ifc_data``),
-    ``set_props_kwargs_from_ifc_data(data)``, and
-    ``get_general_kwargs(convert_to_project_units=True)``. Per-type stand-ins
-    (door, railing, roof) subclass this and add their own kwargs accessors
-    and per-type fields."""
-
-    def __init__(self, general: dict | None = None):
-        self.is_editing = False
-        self.last_kwargs: dict | None = None
-        self.general = dict(general) if general is not None else {}
-
-    def set_props_kwargs_from_ifc_data(self, data):
-        self.last_kwargs = dict(data)
-
-    def get_general_kwargs(self, convert_to_project_units=True):
-        return dict(self.general)
-
-
-def make_lifecycle_obj(props, *, name="obj"):
-    """Build a ``bpy.types.Object`` stand-in for parametric-lifecycle tests.
-
-    The mixin code under test reads ``obj.props`` (the PropertyGroup
-    stand-in) and ``obj.name`` (used in error reports). ``spec=bpy.types.Object``
-    catches typo'd attribute access at test time. ``bpy`` is imported inside
-    the function so this conftest stays importable when bpy is absent."""
-    from unittest import mock
-
-    import bpy
-
-    obj = mock.Mock(spec=bpy.types.Object, name=name)
-    obj.props = props
-    obj.name = name
-    return obj
-
-
 # pytest by default doesn't print steps and where it failed. Let's fix that.
 
 

src/bonsai/test/bim/feature/cost.feature

@@ -455,7 +455,6 @@ Scenario: Select Cost Schedule Products
     And I press "bim.assign_cost_item_quantity(cost_item={cost_item}, related_object_type='PRODUCT', prop_name='')"
     When I press "bim.select_cost_schedule_products(cost_schedule={cost_schedule})"
     Then nothing happens
-
 Scenario: Load Cost Item Types
     Given an empty IFC project
     And I press "bim.add_cost_schedule"
@@ -466,30 +465,3 @@ Scenario: Load Cost Item Types
     When I press "bim.add_cost_item(cost_item={cost_item})"
     And I press "bim.load_cost_item_types"
     Then nothing happens
-
-Scenario: Import one cost schedule from CSV
-  Given an empty IFC project
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex1-BoQ-without-query.csv')"
-  And the variable "cost_schedule" is "{ifc}.by_type('IfcCostSchedule')[0].id()"
-  And I press "bim.enable_editing_cost_items(cost_schedule={cost_schedule})"
-  And I press "bim.add_summary_cost_item()"
-  And the variable "cost_item" is "{ifc}.by_type('IfcCostItem')[0].id()"
-  And I press "bim.add_cost_item(cost_item={cost_item})"
-  Then nothing happens
-
-Scenario: Import multiple cost schedules from CSV
-  Given an empty IFC project
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex1-BoQ-without-query.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex2-SoR.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex3-BoQ-with-query.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex4-BoQ-with-description.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex5-SoR-with-description.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex6-BoQ-with-categories.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex7-BoQ-with-Rates.csv')"
-  When I press "bim.import_cost_schedule_csv(filepath='{cwd}/test/files/Ex8-BoQ-with-formula.csv')"
-  And the variable "cost_schedule" is "{ifc}.by_type('IfcCostSchedule')[0].id()"
-  And I press "bim.enable_editing_cost_items(cost_schedule={cost_schedule})"
-  And I press "bim.add_summary_cost_item()"
-  And the variable "cost_item" is "{ifc}.by_type('IfcCostItem')[0].id()"
-  And I press "bim.add_cost_item(cost_item={cost_item})"
-  Then nothing happens

src/bonsai/test/bim/module/clash/__init__.py

@@ -1,17 +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/>.

src/bonsai/test/bim/module/clash/test_clash_decorator_handlers_cleared.py

@@ -1,52 +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.
-
-"""Runtime regression: viewport-decorator install / uninstall keeps the
-``handlers`` list empty across repeated cycles.
-
-ClashDecorator is the representative subclass — its lifecycle is now
-inherited from ``tool.Blender.ViewportDecorator``. The contract pinned
-here is the canonical one for every subclass: after each ``uninstall``,
-``cls.handlers`` must be empty and ``cls.is_installed`` must be False."""
-
-import bpy
-import pytest
-
-from bonsai.bim.module.clash.decorator import ClashDecorator
-
-pytestmark = pytest.mark.clash
-
-
-@pytest.fixture(autouse=True)
-def _reset_decorator_state():
-    ClashDecorator.uninstall()
-    yield
-    ClashDecorator.uninstall()
-
-
-def test_clash_decorator_handlers_cleared_across_install_cycles():
-    ctx = bpy.context
-    for _ in range(3):
-        ClashDecorator.install(ctx)
-        assert ClashDecorator.is_installed is True
-        assert len(ClashDecorator.handlers) > 0
-        ClashDecorator.uninstall()
-        assert ClashDecorator.is_installed is False
-        assert ClashDecorator.handlers == []