Bonsai: custom display names for links

Each link row draws an editable display_name (double-click to rename)
with the file path as placeholder while unset, so several links of the
same file can be told apart. The name persists in the same Description
JSON blob as the filter and loaded state (new name key, written at
save time and by reload_link), restores on project open, and plain
legacy strings still decode unchanged. Decode tests updated to the
four-tuple with a name round-trip case.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

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

@@ -0,0 +1,155 @@
+# 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,9 +10,13 @@ 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/**'
@@ -51,7 +55,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
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing psutil
           pip install src/bcf --no-deps
           pip install pytest-xdist==3.8.0
 
@@ -252,13 +256,26 @@ 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
-          pip install mathutils
-          make test-mathutils || ERROR=1
+          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
           if [ $ERROR -ne 0 ]; then
             echo "One or more tests failed";
             exit 1;

.gitignore

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

cmake/CMakeLists.txt

@@ -27,13 +27,14 @@ endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON) # not necessary, but encouraged
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-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()
+# 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}'")
 
 add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
 
@@ -258,10 +259,14 @@ if(WITH_ROCKSDB)
     set(ROCKSDB_LIBRARIES "IFCOPENSHELL_RocksDB")
     target_compile_definitions(IFCOPENSHELL_RocksDB INTERFACE IFOPSH_WITH_ROCKSDB)
     set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_ROCKSDB)
-    # Shared binaries for `rocksdb` only support limited API (only `c.h`), but we use `db.h` API.
-    # So rocksdb supported only as a static library.
     # See https://github.com/facebook/rocksdb/issues/981.
-    target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
+    if(TARGET RocksDB::rocksdb)
+        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
+    elseif(TARGET RocksDB::rocksdb-shared)
+        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb-shared)
+    else()
+        message(FATAL_ERROR "RocksDB found but neither RocksDB::rocksdb nor RocksDB::rocksdb-shared target exists")
+    endif()
 
     if(WITH_ZSTD)
         # @todo do we actually need the zstd include dir or rather just pass
@@ -656,6 +661,11 @@ 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/FindHDF5.cmake

@@ -88,7 +88,15 @@ if(NOT HDF5_INCLUDE_DIR OR NOT HDF5_LIBRARY_DIR)
     mark_as_advanced(HDF5_DIR)
     if(HDF5_DIR)
         message(STATUS "HDF5: found config at '${HDF5_DIR}'.")
-        set(HDF5_LIBRARIES hdf5_cpp-static)
+        if(TARGET hdf5_cpp-static)
+            set(HDF5_LIBRARIES hdf5_cpp-static)
+        elseif(TARGET hdf5_cpp-shared)
+            set(HDF5_LIBRARIES hdf5_cpp-shared)
+        elseif(TARGET hdf5::hdf5_cpp-shared)
+            set(HDF5_LIBRARIES hdf5::hdf5_cpp-shared)
+        else()
+            find_package(HDF5 REQUIRED COMPONENTS CXX)
+        endif()
     else()
         # If it failed, still try to find as a module.
         # E.g. on Ubuntu `libhdf5-dev` doesn't provie hdf5-config.cmake.

cmake/FindIfcOpenShell.cmake

@@ -0,0 +1,131 @@
+# 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,12 +7,26 @@ 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(Boost_USE_STATIC_LIBS ON)
-set(Boost_USE_STATIC_RUNTIME OFF)
-set(Boost_USE_MULTITHREADED ON)
+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_COMPONENTS
     system
     program_options
@@ -43,13 +57,33 @@ if(IFCOPENSHELL_WITH_ROCKSDB)
 endif()
 
 if(IFCOPENSHELL_IFCXML)
-    find_dependency(LibXml2 CONFIG)
+    find_dependency(LibXml2)
 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")

docs/dev-notes/linked-file-features.md

@@ -0,0 +1,400 @@
+<!-- This file was generated with the assistance of an AI coding tool. -->
+
+# Linked file features — queries, styles, transforms, and multi-linking for linked IFC models
+
+> **Living dev note** for the `Linked_File_Features` branch/PR. Read before working
+> on the feature; append decisions and findings as the PR is refined. This is *not* user
+> documentation — at merge it is removed or its durable parts promoted to code comments.
+> See [README.md](README.md) for the convention (introduced on the
+> `opening-template-on-type` branch; not yet on this branch's base).
+
+## Problem
+
+Linked IFC models (`bim.link_ifc`) had several gaps that made them hard to use as a
+"reference in other trades' models" workflow:
+
+- One shared `.ifc.cache.blend` per IFC file meant the **same file could not be linked
+  twice with different selector queries** — both links showed whichever query was cached
+  first in-session, and whichever was cached last after reopening (Blender reuses one
+  library datablock per path).
+- The selector query was not durably stored anywhere in the host IFC, so save → reopen
+  lost or cross-wired the filter; a scripted `bpy.ops.bim.reload_link()` also wiped it.
+- Linked geometry got **flat diffuse-only materials** — external `.blend` styles
+  (`IfcExternallyDefinedSurfaceStyle`) and per-layer materials (layerset slicing) that
+  the normal import applies were ignored.
+- Moving a linked model required an explicit enable-edit → move → save dance on the
+  active link only, with save/cancel buttons in the panel header.
+- The Explore tool's highlight broke (GPU type errors), drew at the link's *original*
+  location when the link had been moved, and `bim.append_inspected_linked_element`
+  placed appended elements at the original location too.
+
+## Key facts established
+
+- **Cache architecture**: `LoadLink.link_ifc` generates a Python script and runs a
+  background Blender subprocess that executes `bim.load_linked_project` and saves a
+  `.ifc.cache.blend`. The host session then *links* (not appends) the `IfcProject/...`
+  collection from that blend and instances it via an empty (the link "handle").
+  Georeferencing metadata lives in a sidecar `.cache.json`; extracted properties in
+  `.cache.sqlite` (whole file, query-independent — deliberately shared across queries).
+- **Blender reuses an in-session library per path.** Loading the same blend path twice
+  yields the same library/collection. This is what broke multi-query linking with a
+  shared cache filename, and why per-query *filenames* (not cache invalidation) are the
+  fix.
+- **Last-used operator properties** are reused on the next *interactive* invocation
+  (UI button), while scripted `bpy.ops` calls always start from defaults. LoadLink's
+  internal `self.query = link.query` fallback assignment was remembered by Blender and
+  leaked into the next button click (`operator_query='IfcWindow'` for the door link).
+  Any `is_property_set()`-based logic is corrupted the same way. Fix: `SKIP_SAVE` on
+  volatile props. **A GUI-only bug like this is invisible to scripted repro** — both
+  headless and windowed `--python` test runs passed while the manual flow failed.
+- **`IfcDocumentReference`** per link: attribute index 1 (`Identification`) already
+  stores the link's 4×4 transformation (existing Bonsai convention). `Description`
+  (IFC4+; **absent in IFC2X3**) now stores the selector query. One
+  `IfcDocumentInformation` (Scope `LINKED_MODEL`) per file, one reference per link.
+- **Geometry iterator materials**: `material.instance_id()` is the STEP id of the
+  `IfcSurfaceStyle` — or of an `IfcMaterial` when the item has a material but no style,
+  hence the `is_a("IfcSurfaceStyle")` guard when resolving external styles.
+- **External styles**: `IfcExternallyDefinedSurfaceStyle.Location` (`.blend`, relative
+  paths resolve against the *linked* IFC, not the host) + `Identification` in
+  `data_block_type/name` form (e.g. `materials/Brick`), same convention as
+  `bim.activate_external_style`.
+- **Chunk pipeline dedups materials by RGBA color** (`np.unique` on a color array), so
+  style identity must ride along as an extra column to survive — added only for styles
+  that actually resolve to an external material, so plain colored styles dedupe exactly
+  as before.
+- **`slice_layerset_mesh` needs a local-space, per-element mesh** (bisect planes are in
+  object space), which the chunk path can't provide (world-space, many elements per
+  mesh) — hence routing multi-layer elements through the instanced path. Its
+  `dissolve_limit` produces **ngons**, which broke the Explore highlight's
+  triangles-from-`polygon.vertices` assumption downstream.
+- **ID properties round-trip as `IDPropertyArray`**, not plain lists (verified in
+  4.5.7: empty list → flat `IDPropertyArray`; nested lists → list of `IDPropertyArray`
+  items), and `GPUIndexBuf` rejects them — selection geometry must be converted to
+  plain tuples on read.
+- **`scene.ray_cast` returns the hit instance's world matrix** (link empty matrix
+  included). For instanced occurrence objects the object's own local matrix is *not*
+  identity, so resolving the instancing empty must compare against
+  `empty.matrix_world @ obj.matrix_world`, not the empty's matrix alone.
+- **Link matrix math**: the handle empty's matrix is `inv(L) @ T @ G` (L = host local
+  matrix from georef props, T = stored transformation, G = linked model's global
+  matrix from the cache json). The world-space displacement of a moved link is
+  therefore `inv(L) @ T @ L` — no json read needed (`calculate_link_delta_matrix`).
+- **Undo consistency of auto-saved moves**: Blender undo of a handle move fires another
+  depsgraph update, so the handler re-saves the reverted matrix — stored state stays
+  consistent without transactions (a handler can't open one).
+
+## Design
+
+### Per-query caches + query persistence (multi-linking)
+
+`tool.Project.get_link_cache_paths(filepath, query)` appends `.md5(query)[:8]` to the
+cache blend/json names; the empty query keeps the legacy un-suffixed names so existing
+caches stay valid. Every cache-path consumer goes through it — `link_ifc` build and
+invalidation, the subprocess json write, model-origin/georef indicator reads,
+`calculate_link_matrix`, `save_link_transformation`, and the per-link
+selectability/wireframe/visibility toggles (which match collections *by library
+filepath* and would otherwise affect every link of the file at once).
+
+The query persists on each link's `IfcDocumentReference.Description` (written by
+`LinkIfc` and `ReloadLink`); `load_linked_models_from_ifc` restores from it, with a
+legacy-JSON fallback that only applies when the file has a **single** link (with
+several links the shared JSON can't say which link it belonged to). IFC2X3 hosts have
+no `Description` — custom queries are not restorable there (accepted).
+
+`LoadLink`/`ReloadLink` volatile properties are `SKIP_SAVE` (see key facts). Cache
+clearing tolerates a missing blend (a reload with a brand-new query points at a
+not-yet-existing filename).
+
+### Include/Exclude filter pair
+
+The selector grammar's only cross-group combiner is `+` (union) and the `parent`
+facet cannot express "not under X" (its `!=`/regex paths also match by GlobalId, so
+negation removes everything with any parent), which makes set differences like
+"group members minus the slabs under aggregate X" structurally inexpressible in one
+query string. Links therefore carry an **Exclude** query beside the include —
+mirroring `EPset_Drawing`'s Include/Exclude pattern: final set = include (or the
+default set when empty) − exclude, applied in `LoadLinkedProject` and per link in
+`create_drawing`.
+
+- **Cache key**: `get_link_cache_paths` hashes `md5(query + "\0" + exclude)` when an
+  exclude exists; include-only filters keep the pre-exclude `md5(query)` so existing
+  caches stay valid; empty filter keeps legacy un-suffixed names. Keying on query
+  alone would let same-include/different-exclude links silently serve each other's
+  geometry.
+- **Persistence**: `encode_link_filter`/`decode_link_filter` — a plain include is
+  stored in `Description` as-is (backwards compatible); an exclude, a `loaded`
+  state or a custom display name promotes the value to
+  `{"include": …, "exclude": …, "loaded": …, "name": …}` JSON. Decode treats
+  non-JSON as a legacy include string. The display name (`Link.display_name`,
+  double-click the list row to rename; file path shows as placeholder while
+  unset) exists to tell apart several links of the same file.
+- Exclude applies on top of the **default** element set too, so
+  "everything except X" needs no explicit include.
+- UI labels are **Include**/**Exclude** (matching the drawing pattern), but the
+  property identifier stays `query` for script (`bpy.ops.bim.link_ifc(query=…)`)
+  and persistence compatibility.
+- Verified headless: `query=""`/`exclude="IfcDoor"` loads only the window;
+  same file with a different filter gets its own cache; both filters survive
+  save → reopen → reload.
+
+### Auto-load on open
+
+Links that were **loaded and visible** at IFC save time auto-load when the project
+is reopened. `ExportIFC` calls `tool.Project.update_linked_models_state()`, which
+rewrites each reference's `Description` with a `loaded` flag
+(`is_loaded and not is_hidden`); `load_linked_models_from_ifc` replays flagged
+links via `load_link` after restoring the list (missing files warn and skip so
+they can't break project open). The flag extends the same JSON blob as the
+exclude — plain legacy strings decode as no-autoload. Trade-off: project open
+pays the link-load cost up front (fast on cache hit; a missing cache rebuilds in
+a background Blender, same as clicking Load). Verified headless: loaded+visible
+auto-loads; unloaded and loaded-but-hidden links stay unloaded.
+
+### Long-term serialization target: STEP Part 21 Edition 3
+
+STEP p21e3 defines the standards-track version of this feature's persistence:
+`ANCHOR`/`REFERENCE` sections (clauses 9–10) let one file import entities from
+another via URI + fragment, and **anchor tags** (`{tagname: value}`) are the
+designated slot for out-of-schema metadata — a cleaner home than the
+`Description` JSON blob (see the review-round discussion). ifcopenshell does not
+implement these sections yet ([#668](https://github.com/IfcOpenShell/IfcOpenShell/issues/668),
+open, unassigned); if it ever does, the migration path is: link →
+`REFERENCE` to the linked file's project anchor, filter/transform/loaded
+metadata → anchor tags. Keeping the blob behind
+`encode_link_filter`/`decode_link_filter` makes that a two-function change.
+
+Two p21e3 design points this branch already conforms to:
+
+- **Identity**: p21e3 distinguishes volatile file-scoped entity numbers
+  (`#100` fragments) from durable anchors/UUIDs — the same lesson behind our
+  STEP-id collision fixes (GUID-based matching, `element.file` guards). Raw
+  STEP ids must never cross a file boundary; IFC GlobalIds map 1:1 onto
+  p21e3 UUID anchors.
+- **Transport** (clause A.4): exchange structures plus referenced resources
+  can ship as one ZIP archive with references resolving inside it. Our posix,
+  optionally relative `Location`s resolved via `resolve_uri` are exactly the
+  invariants a future "package project with links" export would need.
+
+Even full p21e3 support would not cover per-link transforms, filters, or load
+state — a `REFERENCE` imports entities, it does not place a model — so the
+app-level metadata remains; only its container would change.
+
+### External styles + layerset slicing in the linked loader
+
+`LoadLinkedProject.get_external_material(style_id)` resolves a style id → appended
+Blender material from the external `.blend`, cached two ways (per style id; per
+appended data-block, so styles sharing one material don't append duplicates). Appended
+materials get their stale `ifc_definition_id` cleared (the source `.blend` may have
+been authored in a Bonsai session; the id would be misread in the linked file *and*
+in the host once the cache links in). Applied in both loading paths — instanced
+occurrences directly, chunks via the style-id column.
+
+Multi-layer elements (`IfcMaterialLayerSetUsage`, >1 layer) route through the
+instanced path and get `slice_layerset_mesh`, which gained a pluggable
+`style_to_material` resolver (defaults to the old `tool.Ifc.get_object` for the normal
+import) — the linked resolver prefers the external material, falling back to a flat
+diffuse from the style's shading colour. Also fixed there: newly appended layer
+materials are registered in the dedup dict (two layers sharing one style used to
+append it twice).
+
+Trade-off: layered walls become individual instanced objects instead of chunk members;
+meshes shared between elements (same geometry id) bake the slice from the first
+element's layerset usage — same behaviour as the normal importer.
+
+### Reload Link dialog
+
+`bim.reload_link` now exposes File Path (+ browse button), Use Relative Path
+(defaulting to the stored path form), Use Cache (default off = old always-rebuild
+behaviour), the False Origin Mode project props, and Query. A file browser can't open
+from inside a props dialog, so the browse button runs `bim.select_link_filepath`
+(fileselect) which *reopens* the reload dialog with the chosen path, carrying the
+in-progress dialog state through the round trip (op props are baked at draw time).
+Path changes update `link.name`/`filepath` and, with a host IFC, the reference
+`Location` + document name — which is why `ReloadLink` became a `tool.Ifc.Operator`.
+Script calls without arguments preserve all stored link values via `is_property_set`.
+
+`bim.reload_all_links` (refresh button beside Link IFC in the panel header) reloads
+every *loaded* link via argument-less `reload_link` calls — each link's stored
+path/query/exclude replay and its cache rebuilds from disk. Unloaded links are left
+alone. Deliberately expensive: one background cache rebuild per link.
+
+### Per-row lock toggle + auto-saved transforms
+
+Link editing moved from the panel header into each list row as a lock/unlock icon:
+unlock (`bim.enable_editing_link`) frees the handle; **any movement is persisted
+immediately** by a `depsgraph_update_post` handler (lazy — ticks without transform
+updates cost ~nothing); lock (`bim.disable_editing_link`) saves and locks.
+`bim.edit_link` and the explicit save step are **removed**; cancel/restore semantics
+no longer exist (undo or move it back). The save math lives in
+`tool.Project.save_link_transformation`. Enable/disable take a `link_index`
+(default −1 = active link) so several links can be edited at once and script calls
+stay compatible.
+
+### Explore tool + append fixes for moved links
+
+- Highlight triangles come from `mesh.calc_loop_triangles()` filtered to the queried
+  element's polygon range (ngon-safe); edges keep `polygon.edge_keys` (no diagonals).
+- `get_selected_geometry` converts the ID-prop round trip to plain tuples (GPU
+  rejects `IDPropertyArray`); TRIS drawing gated on its own data.
+- `QueryLinkedElement` passes the ray-cast instance matrix through;
+  `find_obj_root` compares it against `empty @ obj_local` and falls back to the
+  collection's only instance when no matrix is available (select-by-GUID flow).
+- `bim.append_inspected_linked_element` pre-multiplies the imported object's matrix by
+  `calculate_link_delta_matrix(link)`, matching the link by the queried instance's
+  root empty first (filepath alone is ambiguous with several links per file). The
+  element's IFC placement syncs to the moved location on save — intended.
+
+### Drawings (`create_drawing`) — moved links and per-link queries
+
+- The linework serializer opened linked IFCs raw, so a moved link's elements were
+  drawn at their *original* coordinates (usually outside the drawing extents —
+  "linked objects disappear from prints after moving the link").
+- The stored link transformation is already the **model-space** delta (that is how
+  `save_link_transformation` derives it), which is exactly the space the serializer
+  works in — so it can be baked straight into the geometry iterator via the existing
+  `model-offset`/`model-rotation` settings. The mapping composes
+  `Trans(model-offset) @ Rot(model-rotation)` (see `mapping.cpp`), matching the
+  `Trans(t) @ Rot(R)` decomposition of the rigid link matrix; `model-rotation` is a
+  quaternion passed as `(x, y, z, w)`. The pre-existing 2mm plan-view Z-offset simply
+  adds onto the translation (translations commute).
+- The serialization loop previously collected files in a dict keyed by filepath, which
+  **collapsed same-file links into one pass** (one transform — the last link's — and
+  no query awareness): with two links of one file, only one showed in the drawing.
+  It now iterates one entry per link (`(path, file, transform, query)` tuples), and
+  intersects each link's drawing elements with
+  `ifcopenshell.util.selector.filter_elements(ifc, link.query)` so the drawing shows
+  what that link actually displays in the viewport.
+- `tool.Project.get_link_transformation_matrix(link)` is the shared accessor for the
+  stored 4×4 (None when identity/absent).
+- Verified headless with the window/door kit: moved window offset in the SVG by
+  exactly 5m × scale; unmoved door at its native position; both links present.
+
+### Drawings — `.cut` styling for linked models (BISECT cut mode)
+
+- The default **BISECT** cut mode deletes the OpenCASCADE serializer's cut linework
+  (`remove_cut_linework`) and regenerates cuts by bisecting **Blender mesh objects**
+  (`generate_bisect_linework` over `context.visible_objects`). Linked models are
+  instanced collections with no mesh objects, so their cuts were deleted and never
+  regenerated — linked elements only ever appeared as `projection`, and the `.cut`
+  CSS rule never applied to them. Long-standing gap, unrelated to moved links
+  (A/B-tested against pre-branch code: identical).
+- Fix: `remove_cut_linework` only removes cut groups whose guid resolves in the
+  **host** file — linked elements keep the serializer's cut geometry, which the
+  merge step then classes as `cut`.
+- **Cross-file STEP-id collision**: `tool.Ifc.get_object(linked_entity)` resolves the
+  entity's STEP id against the *host* session's id map and can return an arbitrary
+  host object (in the test project: the drawing camera, crashing
+  `generate_material_layers` with "expected 'Mesh' found 'Camera'"). Guarded via
+  `element.file is tool.Ifc.get()` in `generate_material_layers` and the merge step.
+- **Paint order**: the projection-under-cut convention was enforced only in
+  OPENCASCADE mode (`move_projection_to_bottom`); BISECT appends its own cut paths
+  last so it never needed it — but the retained serializer cuts of linked models are
+  emitted *before* the projections. BISECT now runs the same pass; `BringToFront`
+  (`move_elements_to_top`) still gets the final say.
+- Known limitation: linked cut paths are raw serializer output — they skip the
+  shapely path-closing/merging and the material-layer hatching pass (both need host
+  Blender objects). Stroke + fill from `.cut` CSS apply; layered hatching inside
+  linked cuts is a candidate follow-up.
+- Debugging note: merged cut groups carry member guids as CSS *classes*, not as the
+  `ifcopenshell:guid` attribute — inspect both when checking cut output.
+
+## Deferred refactors (deliberate)
+
+- **Upstream `exclude=` on `filter_elements`** — the include−exclude set difference
+  is hand-rolled twice (links, drawings) because the selector grammar has no
+  difference operator and `parent` negation is broken by design (its `!=`/regex
+  paths also match GlobalIds, so negation strips everything that has a parent).
+  The right home is an `exclude=` parameter on
+  `ifcopenshell.util.selector.filter_elements`, documented in
+  `selector_syntax.rst` together with the `parent`-negation limitation. Deferred
+  to a separate ifcopenshell-python PR (different review audience; would widen
+  this PR mid-review). Once it lands, both Bonsai call sites collapse.
+- **Core/tool ceremony skipped** — the new `tool.Project` methods have no
+  `core/tool.py` interface declarations and no `bonsai/core` orchestration
+  functions, matching the pre-existing linked-model code (which bypasses the
+  core layer wholesale; `LoadLinkedProject` is flagged "prototyping" upstream).
+  Interfaces nobody calls through wouldn't add testability — the pure helpers
+  (`encode_link_filter`/`decode_link_filter`, `get_link_cache_paths`) are
+  covered directly in `test/tool/test_project.py` instead. Revisit if the
+  linked-model subsystem is ever promoted out of prototype status.
+
+## Review round 1 (PR #8242, falken10vdl) — decisions
+
+- **Path-form mismatch → duplicate documents (confirmed bug, fixed).**
+  `get_linked_models_documents()` keyed documents by the *stored* `Location`, so
+  linking the same file first relative then absolute (or vice versa) created a second
+  `IfcDocumentInformation`. Both sides of the lookup now normalize through
+  `tool.Ifc.resolve_uri()` before matching.
+- **`Description` for the query — kept.** It is implementation metadata in an IFC
+  attribute, but consistent with the existing convention on these same references
+  (`Identification` stores the 4×4 transformation, a bigger stretch). References are
+  Bonsai-managed (`Scope="LINKED_MODEL"`), so user-description collisions are unlikely.
+  A cleaner consolidated convention (query + transform + options in one serialized
+  attribute) is a candidate follow-up, deliberately out of scope here.
+- **`md5(query)[:8]` — kept.** 32 bits ≈ birthday collision at ~65k distinct queries
+  *per file*; and a collision is not silent: the cache JSON stores the full query and
+  `should_clear_cache()` compares it, so a colliding cache is detected and rebuilt
+  (self-healing).
+- **Depsgraph autosave vs save-on-lock — autosave kept.** Save-on-lock alone loses the
+  "what you see is what's saved" guarantee (move + save project without locking =
+  silently dropped move) and loses undo tracking (undo fires a depsgraph update that
+  re-saves the reverted transform). The handler early-outs when no links exist and only
+  works on ticks containing an object-transform update while a link is unlocked.
+
+## Status — implemented (verified in Blender, incl. headless + GUI repro runs)
+
+Six commits on `Linked_File_Features`:
+
+- `0096c0f6a2` reload_link without a query preserves the stored one.
+- `40db55e52d` external styles + layerset slicing for linked models
+  (`project/operator.py`, `tool/loader.py`).
+- `d210d4c814` full Reload Link dialog + `bim.select_link_filepath`.
+- `3dc161f0f2` per-row lock toggle, auto-save handler, `edit_link` removed
+  (`project/operator.py`, `project/ui.py`, `project/__init__.py`, `tool/project.py`).
+- `0571d22855` Explore highlight (ngons, IDPropertyArray), moved-link highlight,
+  append placement (`tool/project.py`, `project/operator.py`, `project/decorator.py`).
+- `c14592ec0a` per-query caches, Description persistence, SKIP_SAVE.
+
+Plus:
+
+- `ee43ed5526` review-round path normalization in `get_linked_models_documents` /
+  `LinkIfc` (see Review round 1).
+- `1669cbcd43` drawing support for moved links and per-link queries in
+  `create_drawing` (`drawing/operator.py`, `tool/project.py`).
+- `.cut` styling for linked models in BISECT cut mode + STEP-id collision guards +
+  paint order (`drawing/operator.py`) — committed together with this note update.
+
+End-to-end verified with a two-links-one-file kit (window/door, distinct queries):
+correct visuals on load, after save → reopen → reload, in both headless and windowed
+Blender.
+
+## Things to test / verify
+
+- **IFC2X3 host**: `Description` doesn't exist — link queries silently not restored on
+  reopen (legacy fallback only for single-link files). Acceptable? Warn?
+- **Relative-path links** (`use_relative_path`) through the whole cycle: cache paths,
+  reference `Location`, reload path change, query restore. The duplicate-document case
+  (same file linked relative then absolute) is fixed — verify one document with two
+  references via `IfcDocumentInformation.HasDocumentReferences`.
+- Same file linked twice, **both moved differently**: Explore highlight and append
+  placement per instance (root-empty matching), per-link visibility toggles.
+- External styles with **image textures**: paths relative to the style's source
+  `.blend` may not resolve from the cache blend's location (shared limitation with the
+  normal import path).
+- Stale cache orphans: per-query filenames accumulate one blend+json pair per distinct
+  query next to the IFC; nothing auto-deletes them. Cleanup on unlink? Document?
+- Mid-drag auto-save writes the IFC reference outside Bonsai's transaction system —
+  confirm no undo-stack weirdness in longer editing sessions.
+- Layerset slicing on meshes shared by elements with *different* usages (offset/sense)
+  bakes the first element's slice — same as normal import, but worth a look with types.
+- `bim.select_link_filepath` round trip when the reload dialog was opened for a
+  non-active link, and dialog-state carry-over after editing the query *then* browsing.
+- **Drawing SVG guid cache vs moved links**: `create_drawing` skips elements whose
+  guids already exist in the drawing's SVG (`cached_linework`, invalidated only for
+  *edited host objects*). Moving a link does not invalidate its elements, so a
+  regenerated drawing keeps their old positions until the SVG is deleted. Candidate
+  fix: subtract a moved link's guids from `cached_linework` (compare stored transform
+  against the one recorded at last generation).
+- Same element appearing in two links of one file (overlapping queries) serializes
+  twice with different transforms; the SVG guid cache keeps whichever came first on
+  regeneration. Degenerate case — probably fine to ignore, but note it.

src/bonsai/Makefile

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

src/bonsai/bonsai/bim/__init__.py

@@ -29,18 +29,6 @@ from bpy_extras.io_utils import ExportHelper, ImportHelper
 
 from . import handler, operator, parametric_lifecycle, prop, ui
 
-
-def _parametric_gizmo_preference_classes() -> list[type]:
-    """Resolves the registry-driven ``GizmoPreferences<X>`` classes for the
-    ``classes`` list below. ``import bonsai.tool`` is kept local to surface
-    the load-order constraint: it relies on ``from . import handler, …``
-    above having primed the
-    ``tool/ifc.py → bim/ifc.py → bim/handler.py → bonsai.tool`` cycle."""
-    import bonsai.tool as tool
-
-    return tool.Parametric.iter_gizmo_preference_classes(ui)
-
-
 try:
     from bonsai.translations import translations_dict
 except ImportError:
@@ -102,6 +90,7 @@ 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,
@@ -171,10 +160,6 @@ classes = [
     ui.BIM_UL_tab_visibilities,
     ui.BIM_UL_panel_visibilities,
     ui.DocPreferences,
-    # Per-parametric-type ``GizmoPreferences<Name>`` classes — must register
-    # before ``ui.GizmoPreferences`` which holds the matching PointerProperty
-    # fields. Driven by ``tool.Parametric.EDIT_TYPES``.
-    *_parametric_gizmo_preference_classes(),
     ui.GizmoPreferences,
     # ui.DefaultParameters and ui.BIM_ADDON_preferences are registered separately after modules (see late_classes below)
     # Tabs panel

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,#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,#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));
 #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,5 +33,7 @@ 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

@@ -41,14 +41,23 @@ from bonsai.bim.decorator_cache import (
 from bonsai.bim.ifc import IfcStore, get_cache_or_detect_lock
 from bonsai.bim.module.aggregate.decorator import AggregateDecorator
 from bonsai.bim.module.georeference.decorator import GeoreferenceDecorator
+from bonsai.bim.module.model.array import (
+    ArrayPreviewDecorator,
+    ArraySelectionHighlightDecorator,
+)
 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.preview_base import discard_pending_previews
+from bonsai.bim.module.model.wall import WallGizmoPreviewDecorator
 from bonsai.bim.module.nest.decorator import NestDecorator
 
 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -116,19 +125,13 @@ def active_object_callback():
 
 
 def update_bim_tool_props():
-    """update BIM Tools props (such as extrusion_depth, length and x_angle) when active object changes"""
-    obj = bpy.context.active_object
-
-    # bunch of checks to see if we're in a valid state
-    if not obj:
-        return
-    mode = bpy.context.mode
-    current_tool = bpy.context.workspace.tools.from_space_view3d_mode(mode)
-    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
-        return
-    element = tool.Ifc.get_entity(obj)
-    if not element:
+    """Selection-driven BIM Tool sync: re-target user-intent enums
+    (ifc_class, relating_type_id) AND refresh header values
+    (extrusion_depth, length, x_angle) for the new active object."""
+    ctx = _resolve_bim_tool_context()
+    if ctx is None:
         return
+    obj, current_tool, element = ctx
 
     props = tool.Model.get_model_props()
     aprops = tool.Drawing.get_annotation_props()
@@ -178,6 +181,48 @@ def update_bim_tool_props():
     if is_annotation_tool:
         return
 
+    _read_headers_into_props(obj, element)
+
+
+def refresh_bim_tool_headers():
+    """Push the active IFC entity's current header float values
+    (extrusion_depth, length, x_angle) into ``BIMModelProperties``.
+    Enum-safe: never writes user-intent enum slots, which are owned by
+    the selection callback."""
+    ctx = _resolve_bim_tool_context()
+    if ctx is None:
+        return
+    obj, current_tool, element = ctx
+    if current_tool.idname not in tool.Blender.get_property_header_tools():
+        return
+    _read_headers_into_props(obj, element)
+
+
+def _resolve_bim_tool_context():
+    """Return ``(obj, current_tool, element)`` when an active BIM workspace
+    tool sees a resolvable IFC element; ``None`` otherwise. Defensive
+    against stripped operator contexts — a missing ``active_object`` /
+    ``mode`` / ``workspace`` short-circuits to ``None`` instead of raising."""
+    obj = tool.Blender.get_active_object()
+    if not obj:
+        return None
+    mode = getattr(bpy.context, "mode", None)
+    workspace = getattr(bpy.context, "workspace", None)
+    if mode is None or workspace is None:
+        return None
+    current_tool = workspace.tools.from_space_view3d_mode(mode)
+    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
+        return None
+    element = tool.Ifc.get_entity(obj)
+    if not element:
+        return None
+    return obj, current_tool, element
+
+
+def _read_headers_into_props(obj, element):
+    """Populate ``BIMModelProperties`` header values from the active
+    object's IFC extrusion. Enum-safe: writes only header floats, never
+    user-intent enum slots, so it is safe to call on the post-commit hook."""
     representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
     if not representation:
         return
@@ -195,6 +240,7 @@ def update_bim_tool_props():
     if not AuthoringData.is_loaded:
         AuthoringData.load()
 
+    props = tool.Model.get_model_props()
     if AuthoringData.data["active_material_usage"] == "LAYER2":
         x_angle = get_x_angle(extrusion)
         axis = tool.Model.get_wall_axis(obj)["reference"]
@@ -393,8 +439,8 @@ def subscribe_to_viewport_shading_changes():
 
 def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
     """Invariants enforced on every load_post: msgbus subscription, IFC owner
-    settings, scene-bound caches, draft-flag healing, multi-instance lock probe,
-    and previews discarded so saved preview state never resurfaces on reopen."""
+    settings, scene-bound caches, load-transient parametric state, and the
+    multi-instance lock probe."""
     global global_subscription_owner
     active_object_key = bpy.types.LayerObjects, "active"
     bpy.msgbus.subscribe_rna(
@@ -405,8 +451,7 @@ def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
     ifcopenshell.api.owner.settings.get_application = get_application
     AuthoringData.type_thumbnails = {}
 
-    tool.Parametric.heal_stale_edit_flags()
-    discard_pending_previews(scene)
+    tool.Parametric.on_load_post(scene)
 
     if tool.Ifc.get() and bpy.data.is_saved:
         props = tool.Blender.get_bim_props()
@@ -470,7 +515,15 @@ 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()
     try:
         if georeference_props.should_visualise:
@@ -483,12 +536,35 @@ 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.
+        ArraySelectionHighlightDecorator.install(bpy.context)
+        # Always-installed: draw() self-polls on props.is_editing — only
+        # paints during an active array edit lifecycle.
+        ArrayPreviewDecorator.install(bpy.context)
     finally:
         install_decorator_cache_handlers()
 

src/bonsai/bonsai/bim/ifc.py

@@ -552,7 +552,7 @@ class IfcStore:
                     BrickStore.end_transaction()
                 IfcStore.end_transaction(operator)
                 bonsai.bim.handler.refresh_ui_data()
-                tool.Parametric.refresh_post_commit()
+                tool.Parametric.refresh_post_commit(operator)
 
                 if method == "MODAL":
                     cls.modal_in_progress = False
@@ -566,6 +566,19 @@ 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,6 +223,7 @@ 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] = {}
@@ -1219,8 +1220,18 @@ class IfcImporter:
                         if element not in elements_to_import:
                             continue
                     for i in range(len(data)):
-                        tool.Blender.Modifier.Array.set_children_lock_state(element, i, True)
-                        tool.Blender.Modifier.Array.constrain_children_to_parent(element)
+                        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)
 
     def update_linked_aggregates(self):
         # TODO Remove this after a while. See commit 17d6b8a

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

@@ -20,7 +20,6 @@ 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
@@ -28,12 +27,6 @@ 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")
@@ -79,26 +72,8 @@ def create_bounding_box(objs):
     return indices, edges
 
 
-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
+class AggregateDecorator(tool.Blender.ViewportDecorator):
+    draw_method = "draw_aggregate"
 
     def dotted_line_shader(self):
         vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
@@ -153,14 +128,6 @@ class AggregateDecorator:
         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()
@@ -191,12 +158,13 @@ class AggregateDecorator:
                 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]
-            else:
+            elif aggregates_list:
                 aggregate = aggregates_list[-1]
             if aggregate:
                 aggregates.append(tool.Ifc.get_object(aggregate))
@@ -225,39 +193,11 @@ class AggregateDecorator:
             self.draw_custom_batch(line, decorator_color_unselected)
 
 
-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)
+class AggregateModeDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_aggregate_name", "POST_PIXEL"),
+        ("draw_aggregate_empty", "POST_VIEW"),
+    )
 
     def draw_aggregate_name(self, context):
         if context.mode == "EDIT_MESH":

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

@@ -56,11 +56,6 @@ 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")
 
@@ -109,7 +104,11 @@ class BoundaryDecorator:
 
         if unselected_edges:
             self.draw_batch("LINES", unselected_vertices, special_elements_color, unselected_edges)
-            self.draw_batch("TRIS", unselected_vertices, transparent_color(special_elements_color), unselected_tris)
+            self.draw_batch(
+                "TRIS", unselected_vertices, tool.Blender.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, transparent_color(selected_elements_color), selected_tris)
+            self.draw_batch(
+                "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), selected_tris
+            )

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

@@ -345,9 +345,17 @@ class CadArcFrom3Points(bpy.types.Operator):
 class CadOffset(bpy.types.Operator):
     bl_idname = "bim.cad_offset"
     bl_label = "CAD Offset"
-    bl_description = "Copy selected mesh geometry at provided offset. Mesh copied based on the current viewport angle."
+    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_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):
@@ -405,6 +413,11 @@ 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 = []
@@ -517,12 +530,15 @@ 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)
 
@@ -531,9 +547,14 @@ class CadOffset(bpy.types.Operator):
 
                 v1 = v2
 
-            [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]))
+            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.verts.index_update()
         bm.edges.index_update()

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

@@ -27,6 +27,11 @@ 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(
@@ -37,6 +42,7 @@ 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,6 +256,8 @@ 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():
@@ -291,7 +293,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)
+        bpy.ops.bim.cad_offset(distance=self.props.distance, copy=self.props.copy)
 
     def hotkey_S_Q(self):
         obj = bpy.context.active_object

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

@@ -18,43 +18,17 @@
 
 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:
-    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)
+class ClashDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_text", "POST_PIXEL"),
+        ("draw_geometry", "POST_VIEW"),
+    )
 
     def draw_text(self, context):
         self.addon_prefs = tool.Blender.get_addon_preferences()

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

@@ -0,0 +1,130 @@
+# 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

@@ -0,0 +1,212 @@
+# 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

@@ -0,0 +1,879 @@
+# 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

@@ -0,0 +1,312 @@
+# 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

@@ -0,0 +1,294 @@
+# 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

@@ -0,0 +1,165 @@
+# 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

@@ -0,0 +1,145 @@
+# 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/__init__.py

@@ -141,6 +141,7 @@ classes = (
     gizmos.GizmoLockOpen,
     gizmos.GizmoLockClosed,
     gizmos.GizmoArc,
+    gizmos.GizmoLinkToggle,
     gizmos.GizmoFillet,
     gizmos.GizmoWallCornerIcon,
     gizmos.GizmoWallTeeIcon,
@@ -153,6 +154,7 @@ classes = (
     gizmos.GizmoArrayParent,
     gizmos.GizmoArrayAll,
     gizmos.GizmoArrayLayerIndicator,
+    gizmos.GizmoCountLabel,
     gizmos.GizmoMerge,
     gizmos.GizmoSplit,
     gizmos.GizmoUnjoin,

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

@@ -35,6 +35,7 @@ __all__ = [  # noqa: RUF022 (unsorted `__all__`)
     "CoordinateSpace",
     "ModalState",
     "DimensionGizmoConfig",
+    "SwingArcConfig",
     "ViewDirection",
     "GizmoModalContext",
     "get_modal_context",
@@ -81,7 +82,7 @@ import math
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, ClassVar, Literal, Protocol, runtime_checkable
+from typing import Any, ClassVar, Literal, Optional, Protocol, runtime_checkable
 
 import blf
 import bpy
@@ -104,16 +105,6 @@ from mathutils.kdtree import KDTree
 import bonsai.tool as tool
 from bonsai.bim.module.drawing.shaders import ExtrusionGuidesShader
 
-# Backward-compat re-exports — these mixins moved to bim.parametric_lifecycle
-# in the gizmos.py framework refactor. PR4 callers (CycleDoorType / CycleWindowType
-# / CycleStairType) still spell gizmo.CycleTypeMixin; the re-export keeps the
-# old access path alive until PR4 rewrites the import. PR5 cleanup drops these.
-from bonsai.bim.parametric_lifecycle import (  # noqa: F401, E402
-    CycleTypeMixin,
-    PickTypeMixin,
-    TypeAccessorBase,
-)
-
 SNAP_POINT_SIZE = 10.0
 SNAP_POINT_COLOR = (1.0, 0.5, 0.0, 1.0)
 SNAP_MAX_RADIUS = 50.0
@@ -143,6 +134,16 @@ DOOR_SWING_ANGLE_MAX = 90.0
 # Default scale factor for billboarded icons (Blender-unit visual size).
 DEFAULT_BILLBOARD_SCALE = 0.5
 
+# Shared gizmo color constants. Re-exported as class attributes on
+# BaseParametricGizmoGroup so callers can use either ``self.COLOR_GREEN``
+# from inside a gizmo group or the module-level constant from a class body
+# (e.g. IconSlot declarations) without a forward-reference issue. Match
+# Blender's axis convention: X=red, Y=green, Z=blue.
+COLOR_RED = (1.0, 0.2, 0.2)
+COLOR_GREEN = (0.1, 0.8, 0.1)
+COLOR_BLUE = (0.3, 0.3, 1.0)
+COLOR_NEUTRAL = (1.0, 1.0, 1.0)
+
 PRECISION_MODE_MULTIPLIER = 0.1
 
 RAY_CAST_DISTANCE = 1000
@@ -158,6 +159,38 @@ _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.
 
@@ -1291,6 +1324,38 @@ class IconActionConfig:
     visibility_condition: Callable[[Any], bool] | None = None
 
 
+@dataclass(slots=True)
+class SwingArcConfig:
+    """Declarative config for one swing-arc panel — a pair of ``GizmoArc``
+    instances representing a single hinged panel's two possible open sides.
+
+    Each entry produces two gizmos at setup time:
+      - ``self.gizmo_swing_arc_<name>``: main arc on the active swing side
+      - ``self.gizmo_swing_arc_<name>_flip``: Y-mirror of the main, on the
+        opposite side of the hinge line
+
+    Both gizmos hide together when ``visibility_condition(props)`` is False.
+    When visible, each arc's ``matrix_basis`` is:
+
+        Translation(hinge_x(props), hinge_y(props), 0)
+            @ Scale(panel_width(props), 4)
+            @ (Scale(-1, X) if x_mirror(props) else Identity)
+            @ (Scale(-1, Y) if this is the flip arc else Identity)
+
+    The arc geometry (``GizmoArc.tris``) is a unit quarter-arc sweeping
+    counterclockwise from +X to +Y with its hinge at the origin, so the
+    transforms above translate the hinge into world position, scale to
+    panel size, and mirror across the hinge line as needed.
+    """
+
+    name: str
+    visibility_condition: Callable[[Any], bool]
+    hinge_x: Callable[[Any], float]
+    hinge_y: Callable[[Any], float]
+    panel_width: Callable[[Any], float]
+    x_mirror: Callable[[Any], bool]
+
+
 class SnapManager:
     """Manages snap point visualization and mesh snapping with caching."""
 
@@ -1458,24 +1523,11 @@ class SnapManager:
         nearby_objects = []
 
         for obj in mesh_objects:
-            bbox_corners = [obj.matrix_world @ Vector(corner) for corner in obj.bound_box]
-            if not bbox_corners:
+            if not obj.bound_box:
                 continue
-
-            bbox_min = Vector(
-                (
-                    min(c.x for c in bbox_corners),
-                    min(c.y for c in bbox_corners),
-                    min(c.z for c in bbox_corners),
-                )
-            )
-            bbox_max = Vector(
-                (
-                    max(c.x for c in bbox_corners),
-                    max(c.y for c in bbox_corners),
-                    max(c.z for c in bbox_corners),
-                )
-            )
+            bbox = tool.Blender.get_object_world_bounding_box(obj)
+            bbox_min = bbox["min_point"]
+            bbox_max = bbox["max_point"]
 
             closest = Vector(
                 (
@@ -1674,6 +1726,33 @@ 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
@@ -1682,6 +1761,33 @@ def get_screen_up(billboard_rot: Matrix) -> Vector:
     return billboard_rot @ Vector((0.0, 1.0, 0.0))
 
 
+# Screen-up distance lifted off floor-plane gizmo anchors in plan view. Matches
+# the inter-icon stack spacing used by wall-corner stacks so single icons and
+# stack bases sit at consistent screen-up positions when multiple groups render
+# around the same wall endpoint.
+DEFAULT_TOP_DOWN_CLEARANCE = 0.4
+
+
+def top_down_clearance(
+    context: bpy.types.Context,
+    billboard_rot: Matrix,
+    distance: float = DEFAULT_TOP_DOWN_CLEARANCE,
+) -> Vector:
+    """Screen-up offset that keeps a floor-plane gizmo anchor visible in plan view.
+
+    In a top-down view the world-Z axis projects to ~zero on screen, so any
+    icon anchored on the floor (wall endpoints, corners, connection points,
+    the projected 3D cursor) sits directly on the click target it represents.
+    Adding this offset before ``billboarded_at`` shifts the icon along the
+    camera's up axis without changing the operator's world-space target.
+
+    Returns a zero vector outside the top-down cone so callers can apply it
+    unconditionally."""
+    if not tool.Blender.is_view_top_down(context):
+        return Vector((0.0, 0.0, 0.0))
+    return get_screen_up(billboard_rot) * distance
+
+
 # Dead-band on the screen-X delta — prevents flicker when the gizmo sits on the
 # element origin.
 EXTEND_FLIP_EPSILON = 1e-4
@@ -3208,11 +3314,124 @@ 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``."""
+    ``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."""
 
     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], ...]:
+    """Two filled dots joined by a horizontal connector. ``broken=False``
+    draws a single continuous bar between the dots' inner edges;
+    ``broken=True`` shears the two halves vertically — the left dot AND
+    its stub slip down as a unit, the right dot AND its stub slip up,
+    with a horizontal gap at the centre.
+
+    Each half moves as a cohesive piece so the stub stays attached to its
+    dot at the same y, reading as a snapped link whose two halves slid
+    apart rather than as bent stubs jutting out of stationary dots."""
+    dot_cx = 0.30
+    dot_r = 0.10
+    bar_half_thickness = 0.04
+    # Inner edge of each dot — the intact bar joins the dot edges, not the
+    # centres, so the dot + bar reads as one continuous shape.
+    bar_inner_x = dot_cx - dot_r
+    segments = 12
+    # Vertical shear applied to each half when broken. Zero in the intact
+    # form keeps both halves on the centerline.
+    half_offset_y = 0.08 if broken else 0.0
+
+    tris: list[tuple[float, float, float]] = []
+    for sign in (-1, 1):
+        cx = sign * dot_cx
+        cy = sign * half_offset_y
+        for i in range(segments):
+            a1 = (2.0 * math.pi) * (i / segments)
+            a2 = (2.0 * math.pi) * ((i + 1) / segments)
+            p1 = (cx + dot_r * math.cos(a1), cy + dot_r * math.sin(a1))
+            p2 = (cx + dot_r * math.cos(a2), cy + dot_r * math.sin(a2))
+            tris.append((cx, cy, 0.0))
+            tris.append((p1[0], p1[1], 0.0))
+            tris.append((p2[0], p2[1], 0.0))
+
+    if broken:
+        # Stubs reach inward into the dot's interior so they read as rooted
+        # in the dot rather than floating off its edge after the slip.
+        stub_outer_x = 0.27
+        stub_inner_x = 0.06
+        tris.extend(
+            rect_tris(
+                -stub_outer_x,
+                -half_offset_y - bar_half_thickness,
+                -stub_inner_x,
+                -half_offset_y + bar_half_thickness,
+            )
+        )
+        tris.extend(
+            rect_tris(
+                stub_inner_x,
+                half_offset_y - bar_half_thickness,
+                stub_outer_x,
+                half_offset_y + bar_half_thickness,
+            )
+        )
+    else:
+        tris.extend(rect_tris(-bar_inner_x, -bar_half_thickness, bar_inner_x, bar_half_thickness))
+
+    return tuple(tris)
+
+
+LINK_TRIS_INTACT = _link_toggle_icon_tris(broken=False)
+LINK_TRIS_BROKEN = _link_toggle_icon_tris(broken=True)
+
+
+class GizmoLinkToggle(StaticTrisGizmoMixin, bpy.types.Gizmo):
+    """Two-state link glyph: default reads as a connected link (two dots +
+    intact connector); hover swaps to a broken link (same dots + severed
+    connector) to signal that a click will sever the underlying connection.
+
+    Single-click gizmo — the target operator is bound via
+    ``target_set_operator`` by the owning group. The hover swap is purely
+    visual; the click target is the same in both states. The glyph is
+    feature-agnostic — any path / link / pair-of-connected-items context can
+    reuse it for a sever-this-connection affordance."""
+
+    bl_idname = "VIEW3D_GT_link_toggle"
+    __slots__ = ("custom_shape",)
+    # Bbox source for the hit shape. The broken form's vertically-sheared
+    # halves give it the larger bbox of the two states, so using it as the
+    # hit-shape source guarantees the clickable area covers either form —
+    # the cursor doesn't lose hover at the offset dots' outer edges.
+    tris = LINK_TRIS_BROKEN
+
+    # Per-class batch cache: one entry per highlight state. The mixin parent
+    # caches one batch per class via ``_get_static_tris_batch``; the per-state
+    # swap needs a second batch, so this class keeps its own cache.
+    _batch_cache: ClassVar[dict[bool, "gpu.types.GPUBatch"]] = {}
+
+    def draw(self, context: bpy.types.Context) -> None:
+        broken = bool(self.is_highlight)
+        batch = type(self)._batch_cache.get(broken)
+        if batch is None:
+            tris = LINK_TRIS_BROKEN if broken else LINK_TRIS_INTACT
+            batch = batch_for_shader(_get_static_tris_shader(), "TRIS", {"pos": tris})
+            type(self)._batch_cache[broken] = batch
+        # Icon body forced fully opaque so the dark outline behind doesn't
+        # bleed through and grey out the glyph.
+        color = (*self.color_highlight, 1.0) if broken else (*self.color, 1.0)
+        draw_tris_with_outline(
+            batch,
+            self.matrix_basis @ self.matrix_offset,
+            color,
+            self.outline_width,
+            self.outline_alpha,
+        )
 
 
 def _fillet_icon_tris() -> tuple[tuple[float, float, float], ...]:
@@ -3271,8 +3490,9 @@ class GizmoFillet(StaticTrisGizmoMixin, bpy.types.Gizmo):
     bl_idname = "VIEW3D_GT_fillet"
     __slots__ = ("custom_shape",)
     tris = FILLET_TRIS_DEFAULT
-    # Stacked at ICON_STACK_OFFSET_Y above join in GizmoWallJoinIntersection;
-    # full-bbox hit overlaps the sibling icons' bboxes and steals their clicks.
+    # Stacked at ICON_STACK_OFFSET_Y above the join icon in the wall-join
+    # gizmo group; full-bbox hit overlaps the sibling icons' bboxes and
+    # steals their clicks.
     hit_uses_bbox = False
 
 
@@ -3663,7 +3883,7 @@ class GizmoArrayAll(StaticTrisGizmoMixin, bpy.types.Gizmo):
             parent_element = tool.Ifc.get().by_guid(parent_guid)
         except RuntimeError:
             return
-        from bonsai.bim.module.model.decorator import draw_array_layer_children_bbox
+        from bonsai.bim.module.model.array import draw_array_layer_children_bbox
 
         draw_array_layer_children_bbox(context, parent_element, layer_index)
 
@@ -3748,11 +3968,49 @@ class GizmoArrayLayerIndicator(bpy.types.Gizmo):
         parent_element = tool.Ifc.get_entity(obj)
         if parent_element is None:
             return
-        from bonsai.bim.module.model.decorator import draw_array_layer_children_bbox
+        from bonsai.bim.module.model.array import draw_array_layer_children_bbox
 
         draw_array_layer_children_bbox(context, parent_element, self._layer_index)
 
 
+class GizmoCountLabel(bpy.types.Gizmo):
+    """``xN`` text label rendered from 7-segment digit triangles.
+
+    Mirrors a caller-supplied integer into a live count badge. No icon
+    glyph; the gizmo is the number alone."""
+
+    bl_idname = "BIM_GT_count_label"
+
+    __slots__ = ("custom_shape", "_count", "_built_count", "_outlined_batch")
+
+    def setup(self) -> None:
+        self._count = 0
+        self._built_count = -1
+        tris = _count_label_tris(self._count, 0.0, 0.0)
+        self.custom_shape = self.new_custom_shape("TRIS", tris)
+        self._outlined_batch = batch_for_shader(_get_static_tris_shader(), "TRIS", {"pos": tris})
+        self._built_count = 0
+
+    def set_count(self, count: int) -> None:
+        self._count = int(count)
+
+    def _ensure_shape(self) -> None:
+        if self._built_count != self._count:
+            tris = _count_label_tris(self._count, 0.0, 0.0)
+            self.custom_shape = self.new_custom_shape("TRIS", tris)
+            self._outlined_batch = batch_for_shader(_get_static_tris_shader(), "TRIS", {"pos": tris})
+            self._built_count = self._count
+
+    def draw(self, context: bpy.types.Context) -> None:
+        self._ensure_shape()
+        color = (*self.color_highlight, 1.0) if self.is_highlight else (*self.color, 1.0)
+        draw_tris_with_outline(self._outlined_batch, self.matrix_basis @ self.matrix_offset, color)
+
+    def draw_select(self, context: bpy.types.Context, select_id: int) -> None:
+        self._ensure_shape()
+        self.draw_custom_shape(self.custom_shape, select_id=select_id)
+
+
 class GizmoMerge(StaticTrisGizmoMixin, bpy.types.Gizmo):
     """Two arrows pointing inward toward each other — conveys joining/merging elements."""
 
@@ -4049,7 +4307,8 @@ def _generate_menu_tris() -> tuple[tuple[float, float, float], ...]:
 class GizmoMenu(StaticTrisGizmoMixin, bpy.types.Gizmo):
     """Hamburger-stack menu icon — 'open a picker to choose from many options'.
 
-    For enums with 5+ values; use ``GizmoCycle`` for 2-4."""
+    For enums with 3+ values; use ``GizmoCycle`` for exactly 2 (where the
+    advance-one-per-click semantic stays predictable)."""
 
     bl_idname = "VIEW3D_GT_menu"
 
@@ -4591,7 +4850,14 @@ class GizmoDimension(GizmoMovable):
 
         self.init_value = click_distance
 
-        if self.initial_snap_state and self.active_obj:
+        # 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:
             build_snap_cache(context, self.active_obj)
             self._snap_cache_built = True
 
@@ -4633,11 +4899,18 @@ class GizmoDimension(GizmoMovable):
         if not region or not rv3d:
             return {"RUNNING_MODAL"}
 
-        tool_settings.use_snap = not self.initial_snap_state if event.ctrl else self.initial_snap_state
+        # 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)
 
-        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 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
 
         current_coord = (event.mouse_region_x, event.mouse_region_y)
 
@@ -4661,7 +4934,7 @@ class GizmoDimension(GizmoMovable):
 
         delta = (current_3d - self.start_location).dot(axis_direction)
 
-        if tool_settings.use_snap and self.active_obj:
+        if snap_supported and 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)
@@ -4803,6 +5076,8 @@ 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(
@@ -4816,12 +5091,130 @@ class BillboardingGizmoGroupMixin:
         """Convenience wrapper over `setup_icon_gizmo` for subclasses."""
         return setup_icon_gizmo(self, gizmo_type, color, highlight_color, operator, alpha)
 
+    def get_decoration_colors(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+        """Standard (default, highlight) color pair for active-state gizmos.
+        Pulls from the addon preferences — same source consumed by every
+        Bonsai decorator. Hover-class gizmos that should not pull focus
+        should use ``get_unselected_decoration_colors`` instead."""
+        prefs = tool.Blender.get_addon_preferences()
+        return prefs.decorations_colour[:3], prefs.decorator_color_selected[:3]
+
+    def get_unselected_decoration_colors(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+        """Lower-priority (unselected default, highlight) pair for gizmos
+        that surface on already-selected geometry and shouldn't compete
+        visually with the selection outline (e.g. array-child navigation)."""
+        prefs = tool.Blender.get_addon_preferences()
+        return prefs.decorator_color_unselected[:3], prefs.decorator_color_selected[:3]
+
     def position_gizmos(self, context: bpy.types.Context) -> None:
         raise NotImplementedError(
             f"{type(self).__name__} must implement position_gizmos(context) when using BillboardingGizmoGroupMixin."
         )
 
 
+@dataclass(frozen=True)
+class IconSlot:
+    """One slot in a parametric edit gizmo's icon toolbar row.
+
+    The slot's X coordinate is COMPUTED from its index in ``feature_slots`` —
+    never set explicitly. Adding an icon is a one-line append; the layout
+    manager resolves the X. Hidden slots STILL CONSUME their X position so
+    toggling a visibility preference doesn't shift the row.
+
+    Fields:
+
+    - ``gizmo_idname`` — for single-icon slots, the full Blender gizmo
+      idname. For multi-variant slots, EITHER a string PREFIX that auto-
+      suffixes ``_<variant>`` per member (the common case — e.g.
+      ``"VIEW3D_GT_lock"`` + variants ``("open", "closed")`` becomes
+      ``VIEW3D_GT_lock_open`` / ``VIEW3D_GT_lock_closed``) OR a tuple of
+      explicit idnames matching the variant count when the variants
+      don't share a prefix. Attributes created on the gizmo group are
+      ``self.<name>_gizmo`` for single slots, ``self.<name>_<variant>_gizmo``
+      for each variant in multi-variant slots.
+    - ``variants`` — variant suffixes, e.g. ``("open", "closed")`` for a
+      lock pair, ``("exterior", "center", "interior")`` for a baseline
+      cycle. Empty tuple = single icon.
+    - ``color`` — RGB tuple. ``None`` falls back to the gizmo group's default
+      decoration color. Use the group's ``COLOR_RED`` / ``COLOR_GREEN`` /
+      ``COLOR_BLUE`` literals for state-coded icons.
+    - ``extra_gap_before`` — extra spacing past the default uniform gap, in
+      meters. Use sparingly — e.g. to visually separate a destructive
+      action (trash) from the routine edit controls.
+    - ``operator_props`` — tuple of (key, value) pairs forwarded to
+      ``target_set_operator``'s return value (e.g. ``increment=1`` for a
+      +/- adjuster, ``property_name="..."`` for a generic toggle).
+    - ``placeholder`` — when ``True``, the slot reserves an X position in
+      the row but no auto-managed gizmo is created. Subclasses look the X
+      up via ``_slot_x_positions()[name]`` to place their own dynamically-
+      built gizmos (e.g. a live count label). ``gizmo_idname`` / ``operator``
+      are unused for placeholders."""
+
+    name: str
+    gizmo_idname: str | tuple[str, ...] = ""
+    operator: str = ""
+    # Matches DEFAULT_BILLBOARD_SCALE — the scale validate/cancel render at,
+    # so slots that don't override land at the same visual size by default.
+    # Helper icons (+/- count adjusters, lock pairs, delete) override with
+    # smaller values (0.20 - 0.35) to signal secondary affordance.
+    scale: float = DEFAULT_BILLBOARD_SCALE
+    color: tuple[float, float, float] | None = None
+    variants: tuple[str, ...] = ()
+    extra_gap_before: float = 0.0
+    operator_props: tuple[tuple[str, Any], ...] = ()
+    placeholder: bool = False
+    # Optional per-frame visibility predicate. Called with the gizmo group
+    # instance as the sole argument; returning False hides this slot's gizmo
+    # while still reserving its X position so the row layout doesn't shift.
+    # Used for idle-row icons whose relevance depends on element state (e.g.
+    # toggle_openings only when the host has openings).
+    visible_when: Optional[Callable[[Any], bool]] = None
+
+    def __post_init__(self) -> None:
+        # Validate shape at class-definition time so a typo doesn't surface
+        # as a runtime error in the gizmo group's setup() three layers deep.
+        if self.placeholder:
+            return
+        if self.variants:
+            if isinstance(self.gizmo_idname, str):
+                pass  # prefix form — idname auto-suffixed per variant
+            elif isinstance(self.gizmo_idname, tuple) and len(self.gizmo_idname) == len(self.variants):
+                pass  # explicit-tuple form
+            else:
+                raise TypeError(
+                    f"IconSlot({self.name!r}): variants={self.variants} requires gizmo_idname "
+                    f"to be either a string prefix (auto-suffixed as <prefix>_<variant>) or a "
+                    f"tuple of {len(self.variants)} explicit idnames, got {self.gizmo_idname!r}"
+                )
+        elif not isinstance(self.gizmo_idname, str) or not self.gizmo_idname:
+            raise TypeError(
+                f"IconSlot({self.name!r}): single-icon slot requires gizmo_idname str, "
+                f"got {self.gizmo_idname!r} (set variants=(...) if you want a multi-variant "
+                f"slot, or placeholder=True for a reserved-position slot)"
+            )
+
+    def variant_idnames(self) -> tuple[str, ...]:
+        """Resolve per-variant gizmo idnames. For prefix form, suffix each
+        variant onto the prefix; for tuple form, return as is. Single-icon
+        slots return a one-element tuple containing the idname."""
+        if not self.variants:
+            assert isinstance(self.gizmo_idname, str)
+            return (self.gizmo_idname,)
+        if isinstance(self.gizmo_idname, str):
+            return tuple(f"{self.gizmo_idname}_{variant}" for variant in self.variants)
+        return self.gizmo_idname
+
+    def gizmo_attrs(self) -> tuple[str, ...]:
+        """Names of every ``self.*`` attribute this slot writes during setup.
+        Returns one for a single slot, N for an N-variant slot, and an empty
+        tuple for placeholder slots (which reserve X without an auto-gizmo)."""
+        if self.placeholder:
+            return ()
+        if self.variants:
+            return tuple(f"{self.name}_{variant}_gizmo" for variant in self.variants)
+        return (f"{self.name}_gizmo",)
+
+
 class BaseParametricGizmoGroup:
     """Base mixin for parametric element gizmo groups (doors, windows, stairs, etc.).
 
@@ -4897,11 +5290,13 @@ class BaseParametricGizmoGroup:
     """
 
     # === Gizmo Colors ===
-    # Match Blender axis convention: X=red, Y=green, Z=blue
-    COLOR_RED = (1.0, 0.2, 0.2)
-    COLOR_GREEN = (0.1, 0.8, 0.1)
-    COLOR_BLUE = (0.3, 0.3, 1.0)
-    COLOR_NEUTRAL = (1.0, 1.0, 1.0)
+    # Aliased to the module-level constants so subclass class bodies can
+    # reference either spelling. Match Blender's axis convention:
+    # X=red, Y=green, Z=blue.
+    COLOR_RED = COLOR_RED
+    COLOR_GREEN = COLOR_GREEN
+    COLOR_BLUE = COLOR_BLUE
+    COLOR_NEUTRAL = COLOR_NEUTRAL
 
     # === Dimension Gizmo Layout (meters) ===
     ARROW_SCALE = 0.25  # Scale factor for arrow gizmos
@@ -4912,6 +5307,13 @@ 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]
@@ -4920,17 +5322,21 @@ class BaseParametricGizmoGroup:
     ICON_VALIDATE_X = 0.0  # X position of validate (checkmark) icon
     ICON_CANCEL_X = 0.5  # X offset from validate for cancel (X) icon
     ICON_CYCLE_X = 0.87  # X offset from validate for cycle (arrow) icon
-    # Rightmost local-X used by feature-specific icons (across both idle and
-    # edit states). Subclasses override when they add icons past the cycle
-    # slot at 0.87 — currently wall (rotate at 1.24) and stair (minus at
-    # 1.98). Drives both the ARRAY button position (this class) AND the
-    # array-layer-icons start position (``GizmoArrayEdition`` runtime lookup),
-    # so non-colliding features get a tight layout while wall / stair shift
-    # the array-related slots outward to avoid stomping on the rotate /
-    # tread-lock / +/- icons.
-    FEATURE_ICON_MAX_X: float = 0.87
-    # Gap between the last feature icon and the ARRAY button (or the first
-    # array layer icon in idle state).
+    # Subclasses append to declare feature icons in the edit-mode toolbar row.
+    # The layout manager assigns each slot an X position from its tuple
+    # index — adding a new icon is a one-line append, no hardcoded X
+    # constant, no "remember to bump the right edge" rule. The trailing
+    # ARRAY button is positioned past the last slot automatically.
+    feature_slots: ClassVar[tuple[IconSlot, ...]] = ()
+    # Idle-mode pen-row extras (e.g. wall's toggle_openings). Each slot is
+    # placed past the pen at uniform ``ICON_ARRAY_GAP`` spacing. Hidden during
+    # edit — the validate/cancel row owns the X positions there. Peer gizmo
+    # groups (e.g. ``GizmoArrayEdition``'s per-layer ARRAY icons) query
+    # ``_idle_row_right_edge()`` to position past these without a hardcoded
+    # per-feature table.
+    idle_slots: ClassVar[tuple[IconSlot, ...]] = ()
+    # Gap between adjacent slots past the leading validate/cancel/cycle
+    # triplet, AND between the last slot and the ARRAY button.
     ICON_ARRAY_GAP: float = 0.37
     ICON_Z_OFFSET = 0.5  # Height above element for icons
     ICON_Y_OFFSET = GIZMO_OFFSET * 2  # Y offset to keep icons clear of geometry
@@ -4952,6 +5358,62 @@ class BaseParametricGizmoGroup:
         super().__init_subclass__(**kwargs)
         BaseParametricGizmoGroup.REGISTRY.append(cls)
 
+    @classmethod
+    def _slot_x_positions(cls) -> dict[str, float]:
+        """Map each ``feature_slot`` name to its X coordinate in the row.
+
+        Slots are laid out from the cycle position onward at uniform
+        ``ICON_ARRAY_GAP`` spacing, plus any per-slot ``extra_gap_before``.
+        When the cycle slot is unused (no ``cycle_type_operator`` /
+        ``pick_type_operator``), the first feature slot collapses into the
+        cycle position so the row stays tight — that's how wall's baseline
+        triplet ends up at X=0.87 without a gap before it. Tuple order is
+        the only thing that controls X; rearranging the tuple rearranges
+        the row."""
+        positions: dict[str, float] = {}
+        has_cycle = bool(cls.cycle_type_operator) or bool(cls.pick_type_operator)
+        next_x = (cls.ICON_CYCLE_X + cls.ICON_ARRAY_GAP) if has_cycle else cls.ICON_CYCLE_X
+        for slot in cls.feature_slots:
+            next_x += slot.extra_gap_before
+            positions[slot.name] = next_x
+            next_x += cls.ICON_ARRAY_GAP
+        return positions
+
+    @classmethod
+    def _feature_row_right_edge(cls) -> float:
+        """Right edge of the feature icon row, fed to the trailing ARRAY
+        button's X. Computed strictly from slot order + gaps; empty
+        ``feature_slots`` collapses to the cycle position."""
+        positions = cls._slot_x_positions()
+        if not positions:
+            return cls.ICON_CYCLE_X
+        return max(positions.values())
+
+    @classmethod
+    def _idle_slot_x_positions(cls) -> dict[str, float]:
+        """Map each ``idle_slot`` name to its X coordinate past the pen.
+
+        First idle slot lands at ``ICON_CANCEL_X`` (the cancel-slot position,
+        unused in idle since validate/cancel are edit-only). Successive slots
+        are spaced by ``ICON_ARRAY_GAP``, plus any per-slot ``extra_gap_before``."""
+        positions: dict[str, float] = {}
+        next_x = cls.ICON_CANCEL_X
+        for slot in cls.idle_slots:
+            next_x += slot.extra_gap_before
+            positions[slot.name] = next_x
+            next_x += cls.ICON_ARRAY_GAP
+        return positions
+
+    @classmethod
+    def _idle_row_right_edge(cls) -> float:
+        """Rightmost local-X reserved by this group's idle row. Returns the
+        pen position (``ICON_VALIDATE_X``) when no idle slots are declared
+        so peer queries always get a meaningful number."""
+        positions = cls._idle_slot_x_positions()
+        if not positions:
+            return cls.ICON_VALIDATE_X
+        return max(positions.values())
+
     @classmethod
     def pick_visible_anchor(cls, context: bpy.types.Context, world_base: Vector, world_top: Vector) -> Vector:
         """Choose between two anchor candidates so vertical separation stays
@@ -5031,27 +5493,13 @@ class BaseParametricGizmoGroup:
         from_neg_y, from_neg_x = self.get_local_view_direction(context, world_matrix)
         return ViewDirection(from_negative_y=from_neg_y, from_negative_x=from_neg_x)
 
-    def update_gizmo_visibility(self, gizmo: bpy.types.Gizmo, is_editing: bool, pref_enabled: bool) -> bool:
-        """Update gizmo visibility based on modal state, editing state, and preference.
-
-        Consolidates the common pattern:
-            if hidden_by_modal:
-                gizmo.hide = True
-            else:
-                gizmo.hide = not is_editing or not pref_enabled
-
-        Args:
-            gizmo: The gizmo to update visibility for
-            is_editing: Whether the element is currently being edited
-            pref_enabled: Whether this gizmo type is enabled in preferences
-
-        Returns:
-            True if the gizmo is now visible (not hidden), False otherwise
-        """
+    def update_gizmo_visibility(self, gizmo: bpy.types.Gizmo, is_editing: bool) -> bool:
+        """Hide ``gizmo`` when not editing or when a modal owns the viewport.
+        Returns True if the gizmo is now visible."""
         if self.is_gizmo_hidden_by_modal(gizmo):
             gizmo.hide = True
             return False
-        gizmo.hide = not is_editing or not pref_enabled
+        gizmo.hide = not is_editing
         return not gizmo.hide
 
     def get_y_position_for_view(
@@ -5291,10 +5739,11 @@ 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()
-            feature_prefs = getattr(prefs.gizmos, cls.gizmo_pref_name, None)
-            if feature_prefs is not None and not getattr(feature_prefs, "enabled", True):
+            if not getattr(prefs.gizmos, cls.gizmo_pref_name, True):
                 return False
         if len(tool.Blender.get_selected_objects()) != 1:
             return False
@@ -5383,8 +5832,9 @@ class BaseParametricGizmoGroup:
         """
         pass
 
-    # Subclass should define these class attributes for metadata-driven dispatch
-    # If not defined, subclass must override get_props() and get_gizmo_prefs()
+    # Subclass should define these class attributes for metadata-driven dispatch.
+    # ``gizmo_pref_name`` matches a flat BoolProperty field on
+    # ``GizmoPreferences`` and gates the whole gizmo group's poll.
     props_getter: Callable[[bpy.types.Object], bpy.types.PropertyGroup] | None = None
     gizmo_pref_name: str | None = None  # e.g., "door"
 
@@ -5419,18 +5869,6 @@ class BaseParametricGizmoGroup:
         prefs = self.get_addon_prefs()
         return prefs.decorations_colour[:3], prefs.decorator_color_selected[:3]
 
-    def get_gizmo_prefs(self) -> Any:
-        """Get gizmo preferences for this element type.
-
-        Subclass can either:
-        1. Define class attribute `gizmo_pref_name` (e.g., "door")
-        2. Override this method directly
-        """
-        if self.gizmo_pref_name:
-            prefs = self.get_addon_prefs()
-            return getattr(prefs.gizmos, self.gizmo_pref_name)
-        raise NotImplementedError("Subclass must define gizmo_pref_name or override get_gizmo_prefs()")
-
     def is_setup_complete(self) -> bool:
         """Check if gizmo setup has been completed.
 
@@ -5654,6 +6092,34 @@ class BaseParametricGizmoGroup:
                 "VIEW3D_GT_menu", default_color, self.pick_type_operator, highlight_color
             )
 
+        # Feature-specific edit-row icons. Subclasses declare them via
+        # ``feature_slots``; multi-variant slots create one gizmo per
+        # variant at the same X (e.g. a lock pair, a baseline triplet) and
+        # the subclass picks which is visible per frame. Placeholder slots
+        # only reserve an X position — the subclass creates its own gizmo
+        # there in ``setup_element_specific_gizmos``.
+        for slot in self.feature_slots:
+            if slot.placeholder:
+                continue
+            slot_color = slot.color if slot.color is not None else default_color
+            kwargs = dict(slot.operator_props)
+            for attr, idname in zip(slot.gizmo_attrs(), slot.variant_idnames()):
+                gz = self.create_icon_gizmo(idname, slot_color, slot.operator, **kwargs)
+                setattr(self, attr, gz)
+
+        # Idle-mode pen-row extras. Same creation path as feature_slots; the
+        # IDLE branch of ``update_editing_gizmos`` positions and visibility-
+        # gates them, the EDIT branch hides them so the validate/cancel row
+        # owns the X positions.
+        for slot in self.idle_slots:
+            if slot.placeholder:
+                continue
+            slot_color = slot.color if slot.color is not None else default_color
+            kwargs = dict(slot.operator_props)
+            for attr, idname in zip(slot.gizmo_attrs(), slot.variant_idnames()):
+                gz = self.create_icon_gizmo(idname, slot_color, slot.operator, **kwargs)
+                setattr(self, attr, gz)
+
         # ARRAY button — visible during the feature edit lifecycle only (positioned by
         # ``update_editing_gizmos``). Click commits the current edit and adds a
         # Blender-vanilla-defaulted array (count=2, X-offset = bbox extent). The
@@ -5916,14 +6382,65 @@ class BaseParametricGizmoGroup:
                     billboard_rot=billboard_rot,
                     scale=0.30,
                 )
-            # Array gizmo integration is in-progress: the icon binds to
-            # bim.add_array_from_feature_edit but the array-from-parametric-draft
-            # operator + per-feature gizmo positioning haven't fully landed.
-            # Force-hide the icon while parametric-item editing is active to
-            # keep the user from triggering a half-wired add-array flow. Drop
-            # this gate when array integration completes.
+            # Feature slots: per-class IconSlot tuples driven by tuple order.
+            # Whole-feature visibility is gated upstream by ``poll()`` against
+            # ``prefs.gizmos.<feature>``; positioning happens unconditionally
+            # whenever the gizmo group polls visible.
+            slot_positions = self._slot_x_positions()
+            for slot in self.feature_slots:
+                if slot.placeholder:
+                    continue
+                slot_x = self.ICON_VALIDATE_X + slot_positions[slot.name]
+                attrs = slot.gizmo_attrs()
+                if slot.variants:
+                    # Multi-variant slot: write matrix on every variant member
+                    # at the same anchor so a state flip never reveals a stale
+                    # pose. The subclass's per-frame hook picks which member
+                    # is visible — this loop doesn't toggle hide flags.
+                    world_pos = mw @ Vector((slot_x, icon_y, icon_z))
+                    matrix = billboarded_at(world_pos, billboard_rot, scale=slot.scale)
+                    for attr in attrs:
+                        gz = getattr(self, attr, None)
+                        if gz is not None:
+                            gz.matrix_basis = matrix
+                    continue
+                gz = getattr(self, attrs[0], None)
+                if gz is None:
+                    continue
+                gz.hide = self.is_gizmo_hidden_by_modal(gz)
+                self.set_icon_gizmo_position(
+                    attrs[0],
+                    mw=mw,
+                    x=slot_x,
+                    y=icon_y,
+                    z=icon_z,
+                    billboard_rot=billboard_rot,
+                    scale=slot.scale,
+                )
+            # ARRAY button sits past the last feature-specific icon. Slot-based
+            # subclasses derive the right edge from the slot count.
             if hasattr(self, "array_gizmo"):
-                self.array_gizmo.hide = True
+                self.array_gizmo.hide = self.is_gizmo_hidden_by_modal(self.array_gizmo)
+                # 30% smaller than the editing-icon-row default (0.50 → 0.35):
+                # the array button is a tertiary affordance compared to the
+                # primary pen / validate / cancel triad, and the smaller
+                # footprint keeps the edit-mode row from sprawling.
+                self.set_icon_gizmo_position(
+                    "array_gizmo",
+                    mw=mw,
+                    x=self.ICON_VALIDATE_X + self._feature_row_right_edge() + self.ICON_ARRAY_GAP,
+                    y=icon_y,
+                    z=icon_z,
+                    billboard_rot=billboard_rot,
+                    scale=0.35,
+                )
+            # Idle-row icons are hidden in edit — validate / cancel sit at
+            # the same X positions, so showing both would stack icons.
+            for slot in self.idle_slots:
+                for attr in slot.gizmo_attrs():
+                    gz = getattr(self, attr, None)
+                    if gz is not None:
+                        gz.hide = True
         else:
             # ``hide_pen_button = True`` keeps the pen permanently hidden — for
             # groups whose edit-mode entry is already provided by another widget
@@ -5942,8 +6459,41 @@ class BaseParametricGizmoGroup:
             self.cancel_gizmo.hide = True
             if self.cycle_type_operator or self.pick_type_operator:
                 self.cycle_gizmo.hide = True
+            for slot in self.feature_slots:
+                for attr in slot.gizmo_attrs():
+                    gz = getattr(self, attr, None)
+                    if gz is not None:
+                        gz.hide = True
             if hasattr(self, "array_gizmo"):
                 self.array_gizmo.hide = True
+            # Idle slots: position past the pen, apply per-slot visible_when
+            # so state-dependent icons (e.g. toggle_openings) only render
+            # when relevant. Hidden slots STILL consume their X position so
+            # the row layout doesn't shift when state flips.
+            idle_positions = self._idle_slot_x_positions()
+            for slot in self.idle_slots:
+                if slot.placeholder:
+                    continue
+                slot_x = self.ICON_VALIDATE_X + idle_positions[slot.name]
+                gate = slot.visible_when
+                visible = True if gate is None else bool(gate(self))
+                for attr in slot.gizmo_attrs():
+                    gz = getattr(self, attr, None)
+                    if gz is None:
+                        continue
+                    if not visible:
+                        gz.hide = True
+                        continue
+                    gz.hide = self.is_gizmo_hidden_by_modal(gz)
+                    self.set_icon_gizmo_position(
+                        attr,
+                        mw=mw,
+                        x=slot_x,
+                        y=icon_y,
+                        z=icon_z,
+                        billboard_rot=billboard_rot,
+                        scale=slot.scale,
+                    )
 
     def draw_prepare(self, context: bpy.types.Context) -> None:
         """Called before drawing - updates gizmos to face camera.
@@ -5955,6 +6505,8 @@ 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
@@ -6022,6 +6574,11 @@ 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
@@ -6161,6 +6718,8 @@ 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
@@ -6567,6 +7126,8 @@ 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,6 +50,9 @@ 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, Vector
+from mathutils import Color, Matrix, Vector
 
 import bonsai.bim.export_ifc
 import bonsai.bim.handler
@@ -602,6 +602,7 @@ class CreateDrawing(bpy.types.Operator):
         context_type: Literal["body", "annotation"],
         drawing_elements: set[ifcopenshell.entity_instance],
         target_view: str,
+        link_transform: Optional[np.ndarray] = None,
     ) -> None:
         drawing_elements = drawing_elements.copy()
         contexts_: list[list[int]] = getattr(contexts, context_type)
@@ -613,9 +614,22 @@ 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)
 
+                offset = np.zeros(3)
                 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, 0.002 if target_view == "PLAN_VIEW" else -0.002))
+                    offset[2] = 0.002 if target_view == "PLAN_VIEW" else -0.002
+                if link_transform is not None:
+                    # Bake a moved link's transformation into the geometry. The
+                    # mapping composes Trans(model-offset) @ Rot(model-rotation),
+                    # matching the Trans(t) @ Rot(R) decomposition of the rigid
+                    # link matrix, so the Z offset above simply adds on.
+                    offset += link_transform[:3, 3]
+                    quaternion = Matrix(link_transform.tolist()).to_quaternion()
+                    geom_settings.set(
+                        "model-rotation", (quaternion.x, quaternion.y, quaternion.z, quaternion.w)
+                    )
+                if offset.any():
+                    geom_settings.set("model-offset", tuple(float(o) for o in offset))
 
                 geom_settings.set("context-ids", context)
                 it = ifcopenshell.geom.iterator(
@@ -668,6 +682,10 @@ class CreateDrawing(bpy.types.Operator):
             if "projection" in el.get("class", "").split():
                 continue
             element = self.get_element_by_guid(el.get("{http://www.ifcopenshell.org/ns}guid"))
+            if element is None or element.file is not tool.Ifc.get():
+                # Linked model element - no Blender object to bisect, and its
+                # STEP id must not be resolved against the host session.
+                continue
             if not (obj := tool.Ifc.get_object(element)):
                 continue
             if not (material := ifcopenshell.util.element.get_material(element)):
@@ -923,11 +941,25 @@ class CreateDrawing(bpy.types.Operator):
 
         bim_props = tool.Blender.get_bim_props()
         prefs = tool.Blender.get_addon_preferences()
-        files = {bim_props.ifc_file: tool.Ifc.get()}
 
         props = tool.Project.get_project_props()
+        # One entry per file *and* per link - the same file can be linked
+        # several times with different queries and transformations, so links
+        # cannot be collapsed into a dict keyed by filepath.
+        # Each entry is (path, file, link transformation or None, link query, link exclude).
+        file_entries: list[tuple[str, ifcopenshell.file, Optional[np.ndarray], str, str]] = [
+            (bim_props.ifc_file, tool.Ifc.get(), None, "", "")
+        ]
         for link in props.get_loaded_links_for_drawings():
-            files[link.filepath] = self.get_linked_file(link)
+            file_entries.append(
+                (
+                    link.filepath,
+                    self.get_linked_file(link),
+                    tool.Project.get_link_transformation_matrix(link),
+                    link.query,
+                    link.exclude,
+                )
+            )
 
         target_view = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]["TargetView"]
         self.setup_serialiser(target_view)
@@ -935,7 +967,13 @@ class CreateDrawing(bpy.types.Operator):
         tree = ifcopenshell.geom.tree()
         tree.enable_face_styles(True)
 
-        for ifc_path, ifc in files.items():
+        # 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_transform, link_query, link_exclude in file_entries:
             # 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()
@@ -943,14 +981,32 @@ class CreateDrawing(bpy.types.Operator):
 
             self.serialiser.setFile(ifc)
             drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element, ifc_file=ifc)
+            if link_query:
+                # Draw only what the link's selector filter loaded in the viewport.
+                drawing_elements &= ifcopenshell.util.selector.filter_elements(ifc, link_query)
+            if link_exclude:
+                drawing_elements -= ifcopenshell.util.selector.filter_elements(ifc, link_exclude)
+
+            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)
-            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view)
+            self.serialize_contexts_elements(
+                ifc, tree, contexts, "body", drawing_elements, target_view, link_transform
+            )
+            self.serialize_contexts_elements(
+                ifc, tree, contexts, "annotation", drawing_elements, target_view, link_transform
+            )
 
             if tool.Ifc.get() == ifc and self.camera_element not in drawing_elements:
                 with profile("Camera element"):
@@ -1005,6 +1061,10 @@ class CreateDrawing(bpy.types.Operator):
             if self.cprops.generate_material_layers:
                 self.generate_material_layers(context, root)
             self.merge_linework_and_add_metadata(root)
+            # Bisect cut linework is appended after the projections, but the
+            # retained serializer cuts of linked models precede them - enforce
+            # the projection-under-cut convention like OPENCASCADE mode does.
+            self.move_projection_to_bottom(root)
             self.move_elements_to_top(root)
         elif self.cprops.cut_mode == "OPENCASCADE":
             self.move_projection_to_bottom(root)
@@ -1017,16 +1077,6 @@ 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"}
             )
@@ -1410,9 +1460,21 @@ class CreateDrawing(bpy.types.Operator):
                     continue
 
     def remove_cut_linework(self, root):
+        """Remove host elements' cut linework so bisecting can regenerate it.
+
+        Linked model elements keep the serializer's cut geometry - bisect
+        linework is generated from Blender mesh objects, and linked models
+        are instanced collections without any.
+        """
+        ifc_file = tool.Ifc.get()
         for el in root.findall(".//{http://www.w3.org/2000/svg}g[@{http://www.ifcopenshell.org/ns}guid]"):
-            if "projection" not in el.get("class", "").split():
-                el.getparent().remove(el)
+            if "projection" in el.get("class", "").split():
+                continue
+            try:
+                ifc_file.by_guid(el.get("{http://www.ifcopenshell.org/ns}guid"))
+            except RuntimeError:
+                continue  # Linked model element.
+            el.getparent().remove(el)
 
     def merge_linework_and_add_metadata(self, root):
         join_criteria = ifcopenshell.util.element.get_pset(self.camera_element, "EPset_Drawing", "JoinCriteria")
@@ -1447,7 +1509,9 @@ class CreateDrawing(bpy.types.Operator):
                 classes.append("cut")
                 el.set("class", " ".join(classes))
 
-            obj = tool.Ifc.get_object(element)
+            # Resolving a linked element's STEP id against the host session
+            # would return an arbitrary host object.
+            obj = tool.Ifc.get_object(element) if element is not None and element.file is tool.Ifc.get() else None
 
             if not obj:  # This is a linked model object. For now, do nothing.
                 continue
@@ -2319,7 +2383,8 @@ 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"
+        + "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"
     )
 
     drawing: bpy.props.IntProperty()
@@ -2335,13 +2400,23 @@ 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:
@@ -2354,6 +2429,18 @@ 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()
 
@@ -2439,7 +2526,8 @@ 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"
+        + "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"
     )
 
 

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

@@ -604,6 +604,7 @@ 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,6 +99,10 @@ 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/data.py

@@ -80,9 +80,9 @@ class ViewportData:
                 modes.append(edit_mode)
             elif element.is_a("IfcGridAxis"):
                 modes.append(edit_mode)
-            elif tool.Blender.Modifier.is_roof(element):
+            elif tool.Parametric.is_roof(element):
                 modes.append(edit_mode)
-            elif tool.Blender.Modifier.is_railing(element):
+            elif tool.Parametric.is_railing(element):
                 modes.append(edit_mode)
             elif item_mode not in modes:
                 modes.append(item_mode)

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

@@ -16,8 +16,6 @@
 # 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
@@ -25,15 +23,16 @@ 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:
-    is_installed = False
-    handlers = []
+class ItemDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_text", "POST_PIXEL"),
+        ("draw", "POST_VIEW"),
+    )
     objs: dict[str, dict[str, list]]
     obj_is_selected: dict[str, bool]
     obj_is_boolean: dict[str, list[ifcopenshell.entity_instance]]
@@ -119,23 +118,6 @@ class ItemDecorator:
             "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
@@ -163,11 +145,6 @@ class ItemDecorator:
         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
@@ -197,15 +174,33 @@ class ItemDecorator:
                     if context.mode != "OBJECT":
                         continue
                     self.draw_batch("LINES", data["verts"], selected_elements_color, data["edges"])
-                    self.draw_batch("TRIS", data["verts"], transparent_color(selected_elements_color), data["tris"])
+                    self.draw_batch(
+                        "TRIS",
+                        data["verts"],
+                        tool.Blender.transparent_color(selected_elements_color, alpha=0.05),
+                        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"], transparent_color(special_elements_color), data["tris"])
+                    self.draw_batch(
+                        "TRIS",
+                        data["verts"],
+                        tool.Blender.transparent_color(special_elements_color, alpha=0.05),
+                        data["tris"],
+                    )
                     self.draw_batch("LINES", data["special_verts"], special_elements_color, data["special_edges"])
                 else:
                     self.draw_batch(
-                        "LINES", data["verts"], transparent_color(unselected_elements_color, alpha=0.2), data["edges"]
+                        "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"],
                     )
-                    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,6 +546,13 @@ 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
@@ -883,6 +890,16 @@ 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):
@@ -924,7 +941,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)
+                tool.Geometry.delete_ifc_object(obj, batch_being_deleted_ids=batch_being_deleted_ids)
             elif tool.Geometry.is_representation_item(obj):
                 tool.Geometry.delete_ifc_item(obj)
             else:
@@ -1023,14 +1040,17 @@ class OverrideDelete(bpy.types.Operator):
             pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
             if not pset:
                 continue
-            array_parents.add(ifc_file.by_guid(pset["Parent"]))
+            try:
+                array_parents.add(ifc_file.by_guid(pset["Parent"]))
+            except RuntimeError:
+                continue
 
         for array_parent in array_parents:
             array_parent_obj = tool.Ifc.get_object(array_parent)
-            data = [(i, data) for i, data in enumerate(tool.Blender.Modifier.Array.get_modifiers_data(array_parent))]
+            data = [(i, data) for i, data in enumerate(tool.Array.get_modifiers_data(array_parent))]
             # NOTE: there is a way to remove arrays more precisely but it's more complex
             for i, modifier_data in reversed(data):
-                children = set(tool.Blender.Modifier.Array.get_children_objects(modifier_data))
+                children = set(tool.Array.get_children_objects(modifier_data))
                 if children.issubset(selected_objects):
                     with context.temp_override(active_object=array_parent_obj):
                         bpy.ops.bim.remove_array(item=i)
@@ -1289,9 +1309,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
                                 all_objects_to_select.add(part_obj)
 
         # Non-IFC duplicates aren't tracked in old_to_new but are left selected by duplicate_ifc_objects
-        all_objects_to_select.update(
-            obj for obj in context.selected_objects if not tool.Ifc.get_entity(obj)
-        )
+        all_objects_to_select.update(obj for obj in context.selected_objects if not tool.Ifc.get_entity(obj))
 
         # Deselect everything first
         bpy.ops.object.select_all(action="DESELECT")
@@ -2497,9 +2515,9 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
                     profile = tool.Ifc.get().by_id(profile_id)
                     if tool.Ifc.get_object(profile):  # We are editing an arbitrary profile
                         bpy.ops.bim.edit_arbitrary_profile()
-                elif tool.Blender.Modifier.is_railing(element):
+                elif tool.Parametric.is_railing(element):
                     bpy.ops.bim.finish_editing_railing_path()
-                elif tool.Blender.Modifier.is_roof(element):
+                elif tool.Parametric.is_roof(element):
                     bpy.ops.bim.finish_editing_roof_path()
                 elif tool.Model.get_usage_type(element) == "PROFILE":
                     bpy.ops.bim.edit_extrusion_axis()
@@ -3168,7 +3186,7 @@ class EnableEditingRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
                 product_reps = element.RepresentationMaps
             item_aspect = {}
             for product_rep in product_reps:
-                for aspect in product_rep.HasShapeAspects:
+                for aspect in getattr(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,7 +21,6 @@ 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
@@ -30,27 +29,11 @@ import bonsai.tool as tool
 from bonsai.bim.module.georeference.data import GeoreferenceData
 
 
-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
+class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_text", "POST_PIXEL"),
+        ("draw_geometry", "POST_VIEW"),
+    )
 
     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):
@@ -197,6 +180,10 @@ class GeoreferenceDecorator:
         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
@@ -335,6 +322,8 @@ class GeoreferenceDecorator:
                 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,44 +20,18 @@
 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:
-    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)
+class SolarDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_text", "POST_PIXEL"),
+        ("draw_geometry", "POST_VIEW"),
+    )
 
     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

@@ -31,7 +31,9 @@ from . import (
     external,
     grid,
     handler,
+    host_add_opening_gizmo,
     mep,
+    mep_bend_preview,
     opening,
     product,
     profile,
@@ -50,19 +52,28 @@ from . import (
 
 classes = (
     array.AddArray,
-    array.DisableEditingArray,
-    array.EditArray,
+    array.CancelEditingArray,
     array.EnableEditingArray,
+    array.FinishEditingArray,
     array.ApplyArray,
     array.RegenerateArray,
     array.RemoveArray,
     array.SelectAllArrayObjects,
     array.SelectArrayParent,
+    array.ArrayParentGizmoClick,
+    array.EditArrayFromChild,
     array.Input3DCursorXArray,
     array.Input3DCursorYArray,
     array.Input3DCursorZArray,
     array.EnableEditingParametric,
     array.AddArrayFromFeatureEdit,
+    array.ArrayGizmoClick,
+    array.ToggleArrayMethod,
+    array.RemoveArrayLayerFromEdit,
+    array.InputArrayCount,
+    array.AdjustArrayCount,
+    array.GizmoArrayEdition,
+    array.GizmoArrayChild,
     product.AddDefaultType,
     product.AddEmptyType,
     product.AddOccurrence,
@@ -74,6 +85,7 @@ classes = (
     product.SetActiveType,
     workspace.Hotkey,
     workspace.BIM_MT_add_representation_item,
+    wall.AddPerpendicularWall,
     wall.AddWallsFromSlab,
     wall.AlignWall,
     wall.CancelEditingWall,
@@ -91,12 +103,18 @@ classes = (
     wall.ExtendWallToCursor,
     wall.FinishEditingWall,
     wall.FlipWall,
-    wall.GizmoWallAddOpening,
+    host_add_opening_gizmo.GizmoHostAddOpening,
+    host_add_opening_gizmo.GizmoHostToggleOpenings,
     wall.GizmoWallEdition,
     wall.GizmoWallExtendVertically,
     wall.GizmoWallFilletPreview,
     wall.GizmoWallFilletReedit,
+    wall.GizmoWallFilletToggleOpenings,
+    wall.GizmoPairDisconnect,
+    wall.GizmoSlabEdition,
+    wall.GizmoSlabUnjoinWalls,
     wall.GizmoWallJoinIntersection,
+    wall.GizmoWallLinkToggle,
     wall.GizmoWallUnjoinSingle,
     wall.JoinWallsIntersection,
     wall.MergeWall,
@@ -105,8 +123,7 @@ classes = (
     wall.RotateWall90,
     wall.SplitWall,
     wall.SplitWallAtCursor,
-    wall.ToggleWallOpenings,
-    wall.UnjoinWallPathConnection,
+    wall.DisconnectElements,
     wall.UnjoinWalls,
     wall.EnableWallFilletPreview,
     wall.FinishWallFilletPreview,
@@ -124,6 +141,7 @@ classes = (
     opening.RemoveBoolean,
     opening.SelectBoolean,
     opening.ShowOpenings,
+    opening.ToggleHostOpenings,
     opening.UpdateOpeningsFocus,
     profile.ChangeCardinalPoint,
     profile.ChangeProfileDepth,
@@ -139,11 +157,14 @@ 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,
@@ -170,11 +191,16 @@ 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,
@@ -198,7 +224,8 @@ classes = (
     stair.ToggleStairProperty,
     stair.AdjustStairTreads,
     stair.SetStairTreads,
-    stair.CycleStairType,
+    stair.InputStairTreads,
+    stair.PickStairType,
     stair.GizmoStairEdition,
     sverchok_modifier.CreateNewSverchokGraph,
     sverchok_modifier.UpdateDataFromSverchok,
@@ -211,7 +238,7 @@ classes = (
     window.FinishEditingWindow,
     window.EnableEditingWindow,
     window.RemoveWindow,
-    window.CycleWindowType,
+    window.PickWindowType,
     window.GizmoWindowEdition,
     door.BIM_OT_add_door,
     door.AddDoor,
@@ -220,15 +247,19 @@ classes = (
     door.EnableEditingDoor,
     door.RemoveDoor,
     door.ToggleDoorSwing,
-    door.CycleDoorType,
+    door.PickDoorType,
     door.GizmoDoorEdition,
     railing.BIM_OT_add_railing,
     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,
@@ -237,16 +268,39 @@ classes = (
     roof.AddRoof,
     roof.CancelEditingRoof,
     roof.CopyRoofParameters,
+    roof.CycleRoofGenerationMethod,
     roof.FinishEditingRoof,
     roof.EnableEditingRoof,
     roof.CancelEditingRoofPath,
     roof.FinishEditingRoofPath,
     roof.EnableEditingRoofPath,
+    roof.GizmoRoofEdition,
     roof.RemoveRoof,
     roof.SetGableRoofEdgeAngle,
     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,
 )
 
@@ -306,6 +360,9 @@ 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)
@@ -320,6 +377,11 @@ 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)
@@ -331,6 +393,7 @@ 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/data.py

@@ -51,6 +51,10 @@ 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/door.py

@@ -37,8 +37,9 @@ 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.wall_offset_gizmos import WALL_OFFSET_GIZMO_CONFIGS
 from bonsai.bim.module.model.window import create_bm_box, create_bm_window
-from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin, PickTypeMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMDoorProperties
@@ -580,7 +581,7 @@ class _DoorEditMixin(FeatureModifierEditMixin):
 
     @classmethod
     def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_door(element)
+        return tool.Parametric.is_door(element)
 
     @classmethod
     def _get_props(cls, obj: bpy.types.Object):
@@ -629,7 +630,7 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
     def remove_door_on_object(self, obj: bpy.types.Object) -> None:
         element = tool.Ifc.get_entity(obj)
         assert element
-        if not tool.Blender.Modifier.is_door(element):
+        if not tool.Parametric.is_door(element):
             return
         props = tool.Model.get_door_props(obj)
         props.is_editing = False
@@ -644,12 +645,8 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
-    """Toggle door swing direction and optionally flip door geometry.
-
-    Shift+Click (when flip_geometry=True): Flip geometry only without changing door direction"""
-
     bl_idname = "bim.toggle_door_swing"
-    bl_label = "Toggle Door Swing"
+    bl_label = "Change Door Swing"
     bl_options = {"REGISTER", "UNDO"}
 
     flip_geometry: bpy.props.BoolProperty(name="Flip Geometry", default=False)
@@ -660,6 +657,15 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         name="Skip Direction Change", default=False, options={"HIDDEN", "SKIP_SAVE"}
     )
 
+    @classmethod
+    def description(cls, context: bpy.types.Context, properties: bpy.types.OperatorProperties) -> str:
+        if properties.flip_geometry:
+            return (
+                "Swing the door from the opposite side of the wall. "
+                "Shift+click: mirror the door without changing which side it opens to"
+            )
+        return "Move the door hinge to the opposite side"
+
     def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
         self.skip_direction_change = event.shift
         return self.execute(context)
@@ -686,7 +692,7 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         if not element:
             return {"CANCELLED"}
 
-        is_door = tool.Blender.Modifier.is_door(element)
+        is_door = tool.Parametric.is_door(element)
 
         if self.flip_geometry:
             tool.Geometry.flip_object(obj, self.flip_local_axes)
@@ -700,11 +706,11 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin):
-    """Cycle through available door types. Shift+click to cycle in reverse."""
+class PickDoorType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
+    """Pick a door type from a popup menu."""
 
-    bl_idname = "bim.cycle_door_type"
-    bl_label = "Cycle Door Type"
+    bl_idname = "bim.pick_door_type"
+    bl_label = "Pick Door Type"
     bl_options = {"REGISTER", "UNDO"}
 
     element_checker = tool.Parametric.is_door
@@ -713,7 +719,7 @@ class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin)
     type_attr = "door_type"
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cycle_type(context)
+        return self._pick_type(context)
 
 
 class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
@@ -726,7 +732,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     enable_editing_operator = "bim.enable_editing_door"
     finish_editing_operator = "bim.finish_editing_door"
     cancel_editing_operator = "bim.cancel_editing_door"
-    cycle_type_operator = "bim.cycle_door_type"
+    pick_type_operator = "bim.pick_door_type"
 
     # Declarative dimension gizmo configuration with visibility and position
     # matrix_position lambdas replace the get_dimension_matrix_* methods
@@ -833,6 +839,36 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
                 p.get_transom_window_center_z(),
             ),
         ),
+        *WALL_OFFSET_GIZMO_CONFIGS,
+    ]
+
+    # Big quarter-arc hit shapes cover much of the door face — without a
+    # negative select_bias they would steal clicks from the small dimension
+    # and edit gizmos drawn on top of them.
+    SWING_ARC_SELECT_BIAS = -1000.0
+    swing_arc_operator = "bim.toggle_door_swing"
+
+    swing_arc_props = [
+        gizmo.SwingArcConfig(
+            name="primary",
+            visibility_condition=lambda p: p.is_editing and "SLIDING" not in p.door_type,
+            hinge_x=lambda p: (
+                p.overall_width if p.door_type.endswith("RIGHT") and "DOUBLE_DOOR" not in p.door_type else 0.0
+            ),
+            hinge_y=lambda p: p.lining_offset,
+            panel_width=lambda p: p.overall_width / 2 if "DOUBLE_DOOR" in p.door_type else p.overall_width,
+            x_mirror=lambda p: p.door_type.endswith("RIGHT") and "DOUBLE_DOOR" not in p.door_type,
+        ),
+        gizmo.SwingArcConfig(
+            name="secondary",
+            visibility_condition=lambda p: p.is_editing
+            and "DOUBLE_DOOR" in p.door_type
+            and "SLIDING" not in p.door_type,
+            hinge_x=lambda p: p.overall_width,
+            hinge_y=lambda p: p.lining_offset,
+            panel_width=lambda p: p.overall_width / 2,
+            x_mirror=lambda _p: True,
+        ),
     ]
 
     props_getter = tool.Model.get_door_props
@@ -840,7 +876,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
 
     @classmethod
     def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Blender.Modifier.is_door(element)
+        return tool.Parametric.is_door(element)
 
     def get_icon_y_extent(self, props: "BIMDoorProperties") -> tuple[float, float]:
         """Get Y extents for door icon positioning.
@@ -858,22 +894,20 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         return (furthest_y, furthest_y)
 
     def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create door-specific swing arc gizmos."""
-        prefs = tool.Blender.get_addon_preferences()
-        inactive_color = prefs.decorator_color_background[:3]
-        special_color = prefs.decorator_color_special[:3]
+        """Create one (main, flip) swing-arc pair per ``swing_arc_props`` entry.
 
-        self.gizmo_door_type = self.create_arc_gizmo(
-            special_color,
-            "bim.toggle_door_swing",
-            flip_geometry=False,
-        )
-        self.gizmo_flip_arc = self.create_arc_gizmo(
-            inactive_color,
-            "bim.toggle_door_swing",
-            flip_geometry=True,
-            flip_local_axes="XY",
-        )
+        Stored as ``self.gizmo_swing_arc_<name>`` and ``self.gizmo_swing_arc_<name>_flip``
+        and pinned to ``SWING_ARC_SELECT_BIAS`` so other door gizmos win selection."""
+        prefs = tool.Blender.get_addon_preferences()
+        main_color = prefs.decorator_color_special[:3]
+        flip_color = prefs.decorator_color_background[:3]
+        for cfg in self.swing_arc_props:
+            main = self.create_arc_gizmo(main_color, self.swing_arc_operator, flip_geometry=False)
+            flip = self.create_arc_gizmo(flip_color, self.swing_arc_operator, flip_geometry=True)
+            for gz in (main, flip):
+                gz.select_bias = self.SWING_ARC_SELECT_BIAS
+            setattr(self, f"gizmo_swing_arc_{cfg.name}", main)
+            setattr(self, f"gizmo_swing_arc_{cfg.name}_flip", flip)
 
     def _refresh_element_specific(
         self, context: bpy.types.Context, mw: Matrix, props: "BIMDoorProperties"  # noqa: ARG002
@@ -892,29 +926,23 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         self._update_view_dependent_dimensions(context, mw, props)
 
     def update_swing_gizmos(self, mw: Matrix, props: "BIMDoorProperties") -> None:
-        """Update swing gizmo position and color based on editing state."""
-        prefs = self.get_addon_prefs()
-        door_gizmo_prefs = prefs.gizmos.door
-
-        door_type_visible = self.update_gizmo_visibility(
-            self.gizmo_door_type, props.is_editing, door_gizmo_prefs.swing_arc
-        )
-        flip_arc_visible = self.update_gizmo_visibility(
-            self.gizmo_flip_arc, props.is_editing, door_gizmo_prefs.flip_arc
-        )
-
-        if not door_type_visible and not flip_arc_visible:
-            return
-
-        swing_x_offset = props.overall_width if "RIGHT" in props.door_type else 0.0
-        base_swing_transform = Matrix.Translation(V_(swing_x_offset, props.lining_offset, 0)) @ Matrix.Scale(
-            props.overall_width, 4
-        )
-
-        if door_type_visible:
-            self.gizmo_door_type.matrix_basis = mw @ base_swing_transform
-            self.gizmo_door_type.color = prefs.decorations_colour[:3]
-
-        if flip_arc_visible:
-            mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
-            self.gizmo_flip_arc.matrix_basis = mw @ base_swing_transform @ mirror_y
+        """Position each declared swing-arc pair per its config + props state."""
+        mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
+        for cfg in self.swing_arc_props:
+            main = getattr(self, f"gizmo_swing_arc_{cfg.name}")
+            flip = getattr(self, f"gizmo_swing_arc_{cfg.name}_flip")
+            show = cfg.visibility_condition(props)
+            main_visible = self.update_gizmo_visibility(main, show)
+            flip_visible = self.update_gizmo_visibility(flip, show)
+            if not (main_visible or flip_visible):
+                continue
+            x_flip = Matrix.Scale(-1, 4, (1, 0, 0)) if cfg.x_mirror(props) else Matrix.Identity(4)
+            transform = (
+                Matrix.Translation(V_(cfg.hinge_x(props), cfg.hinge_y(props), 0))
+                @ Matrix.Scale(cfg.panel_width(props), 4)
+                @ x_flip
+            )
+            if main_visible:
+                main.matrix_basis = mw @ transform
+            if flip_visible:
+                flip.matrix_basis = mw @ transform @ mirror_y

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

@@ -0,0 +1,247 @@
+# 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 single-click "Add Opening" gizmo for hosts (walls, slabs, roofs).
+
+One GizmoGroup serves every IFC host type that exposes ``HasOpenings``:
+parametric LAYER2 walls, any ``IfcSlab``, and any ``IfcRoof``. The poll
+guards host-host pairings so this gizmo never overlaps with the existing
+wall-join / extend-vertically gizmos. The positioner dispatches on element
+type — walls use axis-projection + camera-facing-Y math (which requires the
+parametric layer-set); slabs and roofs use a world-Z face bias driven by
+the void object's elevation against the host's bounding box."""
+
+import bpy
+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,
+    _wall_gizmo_poll_gate,
+    _WallGeomCachedBillboardingMixin,
+)
+
+
+def is_supported_host(element) -> bool:
+    """Total predicate (None → False). Walls accept either a parametric
+    LAYER2 wall OR a fillet-corner wall (both expose a usable axis +
+    layer-set for the anchor math); slabs and roofs only need the bound
+    box so any IfcSlab / IfcRoof qualifies regardless of parametric
+    modifier state."""
+    if element is None:
+        return False
+    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
+    active element on success, ``None`` on any failure — callers chain their
+    feature-specific checks past the early-return."""
+    if not _wall_gizmo_poll_gate(context):
+        return None
+    selected = tool.Blender.get_selected_objects()
+    if len(selected) != n_selected:
+        return None
+    active = context.active_object
+    if active is None or active not in selected:
+        return None
+    element = tool.Ifc.get_entity(active)
+    if not element or not is_supported_host(element):
+        return None
+    return element
+
+
+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).
+
+    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.
+
+    Per-frame positioning keeps the icon facing the camera as the viewport
+    orbits."""
+
+    bl_idname = "OBJECT_GGT_bim_host_add_opening"
+    bl_label = "Host Add Opening Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        if not _wall_gizmo_poll_gate(context):
+            return False
+        selected = list(tool.Blender.get_selected_objects())
+        if len(selected) != 2:
+            return False
+        active = context.active_object
+        if active is None or active not in selected:
+            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)
+
+    def setup(self, context: bpy.types.Context) -> None:
+        default_color, highlight_color = self.get_decoration_colors()
+        self.add_opening_icon = self.setup_icon_gizmo(
+            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.add_opening"
+        )
+
+    def position_gizmos(self, context: bpy.types.Context) -> None:
+        selected = list(tool.Blender.get_selected_objects())
+        if len(selected) != 2:
+            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:
+            return
+
+        if tool.Parametric.is_path_connectable_wall(host_element):
+            world_pos = wall_anchor(context, self, host_obj, other)
+        else:
+            world_pos = layer3_anchor(host_obj, other)
+        if world_pos is None:
+            return
+        self.add_opening_icon.matrix_basis = gizmo.billboarded_at(world_pos, gizmo.get_billboard_rotation(context))
+
+
+def wall_anchor(
+    context: bpy.types.Context, group: bpy.types.GizmoGroup, wall_obj: bpy.types.Object, other: bpy.types.Object
+) -> Vector | None:
+    """World-space anchor for the add-opening icon on a wall host: void origin
+    projected onto the wall reference-line X (clamped to wall extents), lifted to
+    the camera-facing wall-local Y."""
+    geom = _get_wall_geom_cached(group, wall_obj)
+    if not geom:
+        return None
+    mw = wall_obj.matrix_world
+    wall_local = mw.inverted() @ other.matrix_world.translation
+    local_x = max(geom["anchor_x"], min(wall_local.x, geom["anchor_x"] + geom["length"]))
+    icon_y = _wall_camera_facing_icon_y(context, mw, geom)
+    base_world = mw @ Vector((local_x, icon_y, 0.0))
+    top_world = mw @ Vector((local_x, icon_y, geom["height"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET))
+    return gizmo.BaseParametricGizmoGroup.pick_visible_anchor(context, base_world, top_world)
+
+
+def layer3_anchor(host_obj: bpy.types.Object, other: bpy.types.Object) -> Vector:
+    """World-space anchor for the add-opening icon on a LAYER3 host (slab / roof):
+    void's world XY, lifted just above the host's top face. Predictable height
+    regardless of where the void sits vertically — clicking the icon places the
+    opening at the void's XY, and the operator handles the actual cut depth."""
+    bbox = tool.Blender.get_object_world_bounding_box(host_obj)
+    anchor_xy = other.matrix_world.translation.xy
+    top_z = bbox["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
+    return Vector((anchor_xy.x, anchor_xy.y, top_z))
+
+
+def host_toggle_anchor(host_obj: bpy.types.Object) -> Vector:
+    """Object origin XY, lifted just above the topmost mesh vertex. Tracks
+    the parametric origin (useful reference even when the mesh extends
+    asymmetrically) and the visible top face (stays clear of sloped or
+    stepped bodies)."""
+    origin = host_obj.matrix_world.translation
+    top_z = tool.Blender.get_object_world_bounding_box(host_obj)["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
+    return Vector((origin.x, origin.y, top_z))
+
+
+class GizmoHostToggleOpenings(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
+    """Fallback toggle-openings icon for hosts that lack their own
+    parametric-edit toolbar — slabs today, plus any foreign-authored
+    IfcRoof that carries no BBIM_Roof pset (so ``GizmoRoofEdition`` doesn't
+    poll for it). Walls and parametric roofs already render an idle-row
+    toggle next to the pen and are excluded from this poll.
+
+    When slab parametric-edit lands the slab branch will pen-row-handle
+    its own toggle; updating the exclusion predicate here is the only
+    migration step needed."""
+
+    bl_idname = "OBJECT_GGT_bim_host_toggle_openings"
+    bl_label = "Host Toggle Openings Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        element = _resolve_active_host(context, n_selected=1)
+        if element is None:
+            return False
+        if not tool.Geometry.has_openings(element):
+            return False
+        # Skip when a per-feature parametric-edit gizmo already surfaces
+        # an idle-row toggle for this element — walls and parametric roofs
+        # both render their own toggle in the pen row.
+        if tool.Parametric.is_path_connectable_wall(element):
+            return False
+        if tool.Parametric.is_roof(element):
+            return False
+        return True
+
+    def setup(self, context: bpy.types.Context) -> None:
+        default_color, highlight_color = self.get_decoration_colors()
+        self.toggle_openings_icon = self.setup_icon_gizmo(
+            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.toggle_host_openings"
+        )
+
+    def position_gizmos(self, context: bpy.types.Context) -> None:
+        host_obj = context.active_object
+        if not host_obj:
+            return
+        self.toggle_openings_icon.matrix_basis = gizmo.billboarded_at(
+            host_toggle_anchor(host_obj), gizmo.get_billboard_rotation(context)
+        )

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

@@ -0,0 +1,444 @@
+# 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,6 +15,8 @@
 #
 # 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
@@ -207,6 +209,21 @@ 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]
@@ -223,15 +240,30 @@ 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,
         filling_obj: bpy.types.Object,
         voided_obj: bpy.types.Object,
         target: Optional[Vector] = None,
+        preserve_placement: bool = False,
     ) -> Union[None, str]:
         """
         :param target: Target opening position. If ommited, cursor position is used.
+        :param preserve_placement: If True, keep ``filling_obj.matrix_world`` as-is
+            and skip the snap-to-wall-axis / rl1-rl2 Z-default logic. The opening
+            is still created at the filling's current world position. Useful
+            when the caller (e.g. the SHIFT-add-opening gizmo flow) has
+            already positioned the filling intentionally.
         :return: None if there was no errors, otherwise returns a string with error message.
         """
         props = tool.Model.get_model_props()
@@ -253,7 +285,7 @@ class FilledOpeningGenerator:
             should_set_z_level = False
 
         # Sometimes, the voided_obj may be an aggregate, which won't have any representation.
-        if voided_obj.data:
+        if not preserve_placement and voided_obj.data:
             raycast = voided_obj.closest_point_on_mesh(voided_obj.matrix_world.inverted() @ target, distance=0.01)
             if not raycast[0]:
                 target = filling_obj.matrix_world.translation.copy()
@@ -386,18 +418,16 @@ class FilledOpeningGenerator:
                 representation = tool.Geometry.get_representation_by_context(voided_element, context)
                 assert representation
 
-                bonsai.core.geometry.switch_representation(
-                    tool.Ifc,
-                    tool.Geometry,
-                    obj=voided_obj,
-                    representation=representation,
-                )
+                tool.Geometry.recut_host(voided_obj, representation)
 
     def regenerate_from_type(self, usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
         relating_type = settings["relating_type"]
 
-        for related_object in settings["related_objects"]:
-            self._regenerate_from_type(related_object)
+        # 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)
 
     def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
         filling = related_object
@@ -446,12 +476,7 @@ class FilledOpeningGenerator:
             representation = tool.Geometry.get_active_representation(voided_obj)
             if not representation:
                 continue
-            bonsai.core.geometry.switch_representation(
-                tool.Ifc,
-                tool.Geometry,
-                obj=voided_obj,
-                representation=representation,
-            )
+            tool.Geometry.recut_host(voided_obj, representation)
 
     def generate_opening_from_filling(
         self,
@@ -586,6 +611,31 @@ 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:
@@ -614,12 +664,7 @@ 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:
-                        bonsai.core.geometry.switch_representation(
-                            tool.Ifc,
-                            tool.Geometry,
-                            obj=building_obj,
-                            representation=representation,
-                        )
+                        tool.Geometry.recut_host(building_obj, representation)
 
         # Refresh cut decorator
         DecoratorData.cut_cache.clear()
@@ -737,6 +782,29 @@ class AddBoolean(Operator, tool.Ifc.Operator):
         tool.Root.reload_item_decorator()
 
 
+class ToggleHostOpenings(Operator, tool.Ifc.Operator):
+    bl_idname = "bim.toggle_host_openings"
+    bl_label = "Toggle Openings"
+    bl_description = "Show or hide opening fills (doors and windows) in the viewport\n\nHotkey: Alt+O"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Model.has_selected_ifc_objects():
+            cls.poll_message_set("No IFC objects selected.")
+            return False
+        return True
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        # Opening visibility is independent of host geometry — don't commit any
+        # active parametric edit; the user can keep editing the host.
+        if tool.Model.get_model_props().openings:
+            bpy.ops.bim.edit_openings(apply_all=True)
+        else:
+            bpy.ops.bim.show_openings()
+        return {"FINISHED"}
+
+
 class ShowOpenings(Operator, tool.Ifc.Operator):
     bl_idname = "bim.show_openings"
     bl_label = "Show Openings"
@@ -918,27 +986,29 @@ 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:
-                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)
+                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
+                        )
                     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
@@ -976,6 +1046,12 @@ 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
@@ -1005,12 +1081,7 @@ class CloneOpening(Operator, tool.Ifc.Operator):
                 continue
             representation = tool.Geometry.get_active_representation(obj)
             assert representation
-            bonsai.core.geometry.switch_representation(
-                tool.Ifc,
-                tool.Geometry,
-                obj=obj,
-                representation=representation,
-            )
+            tool.Geometry.recut_host(obj, representation)
 
         return {"FINISHED"}
 
@@ -1160,22 +1231,55 @@ class DecorationsHandler:
         shader.uniform_float("color", color)
         batch.draw(shader)
 
-    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:
+    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:
             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")
-        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)
+        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)
         gpu.state.depth_test_set(original_depth_test)
 
     def __call__(self, context):
@@ -1211,7 +1315,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", 2.0)
+            self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
 
             # general shader
             self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
@@ -1249,9 +1353,7 @@ 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)
-                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)
+                tool.Blender.draw_bmesh_face_tris(bm, verts, transparent_color(special_elements_color), self.draw_batch)
             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,6 +163,59 @@ 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,6 +1002,14 @@ 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")
@@ -1157,7 +1165,8 @@ 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_name=profile1["obj"].name, obj2_name=profile2["obj"].name
+                                obj1_guid=tool.Ifc.get_entity(profile1["obj"]).GlobalId,
+                                obj2_guid=tool.Ifc.get_entity(profile2["obj"]).GlobalId,
                             )
 
     def modal(self, context, event):

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

@@ -33,8 +33,10 @@ 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
@@ -103,8 +105,12 @@ def update_type_page(self: "BIMModelProperties", context: bpy.types.Context) ->
 
 
 def update_relating_array_from_object(self: "BIMArrayProperties", context: bpy.types.Context) -> None:
-    bpy.ops.bim.enable_editing_array(item=self.is_editing)
-    return
+    # Skip the cleanup-time clear: Finish/Cancel sets relating_array_object back to None,
+    # which has no source to hydrate from. Only the user-driven pick (None → some array)
+    # should auto-enter edit on the picked source's layer 0.
+    if self.relating_array_object is None:
+        return
+    bpy.ops.bim.enable_editing_array(item=0)
 
 
 def is_object_array_applicable(self: "BIMArrayProperties", obj: bpy.types.Object) -> bool:
@@ -128,6 +134,19 @@ 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)
@@ -224,11 +243,7 @@ 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:
-        # 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)
+        _get_updater("railing", "update_railing_modifier_bmesh")(context)
 
 
 def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
@@ -238,6 +253,20 @@ 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(
@@ -340,6 +369,19 @@ 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")
@@ -387,6 +429,7 @@ 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
@@ -397,8 +440,13 @@ class BIMModelProperties(PropertyGroup):
 
 
 class BIMArrayProperties(PropertyGroup):
-    is_editing: bpy.props.IntProperty(
-        default=-1, description="Currently edited array index. -1 if not in array editing mode."
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while an array layer is in parametric edit mode. The specific layer is in editing_item_index.",
+    )
+    editing_item_index: bpy.props.IntProperty(
+        default=-1,
+        description="Index of the array layer currently being edited; -1 when not in edit mode.",
     )
     count: bpy.props.IntProperty(name="Count", default=0, min=0)
     x: bpy.props.FloatProperty(name="X", default=0, subtype="DISTANCE")
@@ -414,6 +462,15 @@ class BIMArrayProperties(PropertyGroup):
         name="Method",
         default="OFFSET",
     )
+    per_child_opening: bpy.props.BoolProperty(
+        name="Per-Child Opening",
+        description=(
+            "When the array parent fills a wall (or any voidable host), give each array child its own opening + "
+            "filling pair so the host is cut once per child. Disable to leave the host uncut by the children — "
+            "only the parent's original opening remains"
+        ),
+        default=True,
+    )
     relating_array_object: bpy.props.PointerProperty(
         type=bpy.types.Object,
         name="Copy Array Properties",
@@ -422,13 +479,15 @@ class BIMArrayProperties(PropertyGroup):
     )
 
     if TYPE_CHECKING:
-        is_editing: int
+        is_editing: bool
+        editing_item_index: int
         count: int
         x: float
         y: float
         z: float
         use_local_space: bool
         method: Literal["OFFSET", "DISTRIBUTE"]
+        per_child_opening: bool
         sync_children: bool
         relating_array_object: Union[bpy.types.Object, None]
 
@@ -1659,6 +1718,21 @@ 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.
 
@@ -1904,6 +1978,155 @@ 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.
 
@@ -1960,7 +2183,29 @@ 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,6 +18,7 @@
 
 
 import json
+import math
 from typing import Any
 
 import bmesh
@@ -27,14 +28,24 @@ import ifcopenshell.api.geometry
 import ifcopenshell.api.pset
 import ifcopenshell.util.representation
 import ifcopenshell.util.unit
-from mathutils import Vector
+from mathutils import Matrix, 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 PathPreservingEditMixin
+from bonsai.bim.parametric_lifecycle import (
+    CycleTypeMixin,
+    PathPreservingEditMixin,
+    PickTypeMixin,
+)
+from bonsai.tool.cad import WELD_TOLERANCE
+
+V_ = tool.Blender.V_
 
 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRailing.htm
@@ -125,6 +136,56 @@ 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
@@ -140,6 +201,13 @@ 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)
@@ -165,8 +233,6 @@ 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)
@@ -211,7 +277,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=0.0001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=WELD_TOLERANCE)
 
         bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
 
@@ -271,8 +337,8 @@ def get_path_data(obj: bpy.types.Object) -> dict[str, Any]:
             segments.append((i - 1, 0))
             break
 
-        # skip path verts if they just go vertical to avoid errors
-        if (v.co.xy - prev_v.co.xy).length <= 0.0001:
+        # 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:
             continue
 
         points.append(v.co)
@@ -407,15 +473,14 @@ class CopyRailingParameters(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class _RailingEditMixin(PathPreservingEditMixin):
-    """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."""
+    """Single-object (active_object) railing-edit hooks; path_data is preserved
+    through the edit (path editing is a separate operator family)."""
 
     pset_name = "BBIM_Railing"
 
     @classmethod
     def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_railing(element)
+        return tool.Parametric.is_railing(element)
 
     @classmethod
     def _get_props(cls, obj: bpy.types.Object):
@@ -436,7 +501,21 @@ class _RailingEditMixin(PathPreservingEditMixin):
         update_railing_modifier_ifc_data(context)
 
     @classmethod
-    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+    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
         update_railing_modifier_bmesh(context)
 
 
@@ -467,6 +546,554 @@ 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"
@@ -510,6 +1137,16 @@ 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/roof.py

@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 import json
-from math import cos, pi, radians, tan
-from typing import Any, Literal, Union
+from math import atan2, cos, degrees, pi, radians, tan
+from typing import Any, ClassVar, Literal, Union
 
 import bmesh
 import bpy
@@ -32,9 +32,11 @@ from mathutils import Quaternion, Vector
 
 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, IconSlot
 from bonsai.bim.module.model.data import RoofData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
-from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin
+from bonsai.bim.parametric_lifecycle import CycleTypeMixin, PathPreservingEditMixin
 
 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRoof.htm
@@ -211,7 +213,13 @@ def generate_hipped_roof_bmesh(
 
     new_verts = [bm.verts.new(v) for v in verts]
     new_edges = [bm.edges.new([new_verts[vi] for vi in edge]) for edge in edges]
-    new_faces = [bm.faces.new([new_verts[vi] for vi in face]) for face in faces]
+    # Skip degenerate faces. ``bpypolyskel.polygonize`` can emit a face whose
+    # vertex list contains the same index twice on certain footprint /
+    # slope combinations (the straight-skeleton collapses two ridge events
+    # onto the same vertex). ``bm.faces.new`` rejects those with
+    # ``found the same (BMVert) used multiple times``; dropping them keeps
+    # the rest of the roof intact instead of aborting the whole rebuild.
+    new_faces = [bm.faces.new([new_verts[vi] for vi in face]) for face in faces if len(set(face)) == len(face)]
 
     if mode == "HEIGHT":  # Calculate the angle we ended up with.
         new_faces[0].normal_update()
@@ -397,6 +405,11 @@ def generate_hipped_roof_bmesh(
         if is_internal:
             faces_to_delete.add(face)
     bmesh.ops.delete(bm, geom=list(faces_to_delete), context="FACES")
+    # Final pass: ``remove_doubles`` + internal-face deletion above can leave
+    # the bottom slab faces flipped at low slopes, where the kernel's
+    # "outward" inference becomes ambiguous on near-flat geometry. Recompute
+    # once more on the final topology so the eave plane points down.
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
     return bm
 
 
@@ -618,7 +631,7 @@ class _RoofEditMixin(PathPreservingEditMixin):
 
     @classmethod
     def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_roof(element)
+        return tool.Parametric.is_roof(element)
 
     @classmethod
     def _get_props(cls, obj: bpy.types.Object):
@@ -636,32 +649,142 @@ class _RoofEditMixin(PathPreservingEditMixin):
     def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
         update_roof_modifier_bmesh(obj)
 
+    @classmethod
+    def _restore_viewport_after_cancel(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Rebuild the roof bmesh from the just-restored draft props so the
+        viewport reverts to the pre-edit geometry. Same helper the modal
+        edits use, just driven by the cancelled props instead of in-flight
+        drag values."""
+        update_roof_modifier_bmesh(obj)
 
-class EnableEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.enable_editing_roof"
-    bl_label = "Enable Editing Roof"
+
+EnableEditingRoof, FinishEditingRoof, CancelEditingRoof = tool.Parametric.build_edit_lifecycle(
+    "roof",
+    _RoofEditMixin,
+    labels=(
+        ("Enable Editing Roof", ""),
+        ("Finish Editing Roof", ""),
+        ("Cancel Editing Roof", ""),
+    ),
+    module_name=__name__,
+)
+
+
+# Fixed horizontal run for the slope gizmo: the draggable value is the
+# vertical rise at this distance from the anchor, in the rise/run convention.
+_ROOF_SLOPE_REFERENCE_RUN = 1.0
+# One degree shy of vertical; avoids tan() blow-up when the user drags the
+# rise handle past the gizmo's anchor.
+_ROOF_MAX_SLOPE_ANGLE = pi / 2 - 0.001
+
+
+def _roof_has_openings() -> bool:
+    """``visible_when`` predicate for the toggle_openings idle slot. True iff
+    the active object's IFC element exposes a non-empty HasOpenings inverse."""
+    obj = bpy.context.active_object
+    if obj is None:
+        return False
+    element = tool.Ifc.get_entity(obj)
+    if element is None:
+        return False
+    return tool.Geometry.has_openings(element)
+
+
+class CycleRoofGenerationMethod(bpy.types.Operator, tool.Ifc.Operator, CycleTypeMixin):
+    """Cycle the roof generation method (HEIGHT ↔ ANGLE). Shift+click cycles in reverse."""
+
+    bl_idname = "bim.cycle_roof_generation_method"
+    bl_label = "Cycle Roof Generation Method"
     bl_options = {"REGISTER", "UNDO"}
 
-    def _execute(self, context):
-        return self._enable_targets(context)
+    element_checker = tool.Parametric.is_roof
+    props_getter = tool.Model.get_roof_props
+    type_literal = tool.Model.RoofGenerationMethod
+    type_attr = "generation_method"
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        return self._cycle_type(context)
 
 
-class CancelEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.cancel_editing_roof"
-    bl_label = "Cancel Editing Roof"
-    bl_options = {"REGISTER", "UNDO"}
+class GizmoRoofEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
+    bl_idname = "OBJECT_GGT_bim_roof_edition"
+    bl_label = "Roof Editing Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
 
-    def _execute(self, context):
-        return self._cancel_targets(context)
+    enable_editing_operator = "bim.enable_editing_roof"
+    finish_editing_operator = "bim.finish_editing_roof"
+    cancel_editing_operator = "bim.cancel_editing_roof"
+    cycle_type_operator = "bim.cycle_roof_generation_method"
 
+    # Positions for all three dimensions are set per-frame by the position
+    # override below; no static ``matrix_position`` is needed.
+    dimension_gizmo_props = [
+        DimensionGizmoConfig(
+            attr_name="height",
+            axis=(0, 0, 1),
+            min_value=0.01,
+            visibility_condition=lambda p: p.generation_method == "HEIGHT",
+        ),
+        DimensionGizmoConfig(
+            attr_name="angle",
+            axis=(0, 0, 1),
+            prop_name="Slope",
+            min_value=0.0,
+            visibility_condition=lambda p: p.generation_method == "ANGLE",
+            compute_value=lambda p: tan(p.angle) * _ROOF_SLOPE_REFERENCE_RUN,
+            apply_value=lambda p, rise: setattr(
+                p, "angle", min(_ROOF_MAX_SLOPE_ANGLE, max(0.0, atan2(rise, _ROOF_SLOPE_REFERENCE_RUN)))
+            ),
+            text_formatter=lambda p, rise: (f"{tool.Unit.format_distance(rise)} ({degrees(p.angle):.1f}°)"),
+        ),
+        DimensionGizmoConfig(
+            attr_name="roof_thickness",
+            axis=(0, 0, -1),
+            min_value=0.001,
+            # The line shows the perpendicular slab thickness (matching the
+            # pset value and the drag delta); the true vertical span is
+            # ``roof_thickness / cos(angle)``, longer than what is drawn.
+        ),
+    ]
 
-class FinishEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.finish_editing_roof"
-    bl_label = "Finish Editing Roof"
-    bl_options = {"REGISTER", "UNDO"}
+    props_getter = tool.Model.get_roof_props
+    gizmo_pref_name = "roof"
 
-    def _execute(self, context):
-        return self._finish_targets(context)
+    idle_slots: ClassVar[tuple[IconSlot, ...]] = (
+        IconSlot(
+            name="toggle_openings",
+            gizmo_idname="VIEW3D_GT_add_opening",
+            operator="bim.toggle_host_openings",
+            visible_when=lambda gg: _roof_has_openings(),
+        ),
+    )
+
+    @classmethod
+    def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
+        return tool.Parametric.is_roof(element)
+
+    def _update_dimension_gizmo_positions(self, context: bpy.types.Context, mw, props) -> None:  # noqa: ARG002
+        """Anchor every dimension gizmo at the object origin. Each gizmo's
+        declared axis (height/slope along +Z, thickness along -Z) separates
+        them in 3D so they don't visually collide despite sharing a
+        position; the height + slope gizmos themselves are mutually
+        exclusive via ``visibility_condition`` on ``generation_method``."""
+        origin = Vector((0.0, 0.0, 0.0))
+        self.set_dimension_gizmo_position("height", mw, origin, (0, 0, 1))
+        self.set_dimension_gizmo_position("angle", mw, origin, (0, 0, 1))
+        self.set_dimension_gizmo_position("roof_thickness", mw, origin, (0, 0, -1))
+
+    def get_element_height(self, props) -> float:  # noqa: ARG002
+        """Object-local Z of the mesh's topmost vertex, so the pen / validate /
+        cancel / cycle row anchors visibly above sloped or stepped roof
+        bodies rather than at the parametric ``props.height`` which may not
+        match the rendered apex on ANGLE-generation roofs."""
+        obj = bpy.context.active_object
+        if obj is None or not getattr(obj, "bound_box", None):
+            return 1.0
+        return max(c[2] for c in obj.bound_box)
 
 
 class EnableEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):

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 = obj.rotation_euler.x
+                existing_x_angle = tool.Model.get_existing_x_angle(extrusion)
                 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,6 +620,14 @@ 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")
@@ -991,3 +999,74 @@ 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/stair.py

@@ -31,7 +31,13 @@ from mathutils import Matrix, Vector
 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.drawing.gizmos import (
+    COLOR_GREEN,
+    COLOR_RED,
+    DimensionGizmoConfig,
+    IconSlot,
+)
+from bonsai.bim.parametric_lifecycle import IntegerInputDialogMixin, PickTypeMixin
 from bonsai.tool.numeric_input import (
     IntegerInputState,
     run_integer_input_modal,
@@ -39,7 +45,7 @@ from bonsai.tool.numeric_input import (
 )
 
 V_ = tool.Blender.V_
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from bmesh.types import BMVert
 from bpy.props import IntProperty
@@ -378,6 +384,20 @@ class AdjustStairTreads(bpy.types.Operator):
         return {"FINISHED"}
 
 
+class InputStairTreads(IntegerInputDialogMixin, bpy.types.Operator):
+    """Popup-dialog entry point for typing a new ``number_of_treads`` value.
+    Bound to the world-space ``xN`` count label in the stair edit row."""
+
+    bl_idname = "bim.input_stair_treads"
+    bl_label = "Set Number of Treads"
+    bl_description = "Type the number of treads for this stair"
+    bl_options = {"REGISTER", "UNDO"}
+
+    number_of_treads: IntProperty(name="Number of Treads", default=1, min=1)
+    attr_name = "number_of_treads"
+    props_getter = staticmethod(tool.Model.get_stair_props)
+
+
 class SetStairTreads(bpy.types.Operator):
     """Set the number of treads to a specific value."""
 
@@ -423,11 +443,11 @@ class SetStairTreads(bpy.types.Operator):
         return f"Number of Treads: {input_str}_{validity}  |  Enter to confirm, Esc to cancel"
 
 
-class CycleStairType(bpy.types.Operator, gizmo.CycleTypeMixin):
-    """Cycle through stair types. Shift+click to cycle in reverse."""
+class PickStairType(bpy.types.Operator, PickTypeMixin):
+    """Pick a stair type from a popup menu."""
 
-    bl_idname = "bim.cycle_stair_type"
-    bl_label = "Cycle Stair Type"
+    bl_idname = "bim.pick_stair_type"
+    bl_label = "Pick Stair Type"
     bl_options = {"REGISTER", "UNDO"}
 
     props_getter = tool.Model.get_stair_props
@@ -436,7 +456,7 @@ class CycleStairType(bpy.types.Operator, gizmo.CycleTypeMixin):
     skip_element_check = True
 
     def execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cycle_type(context)
+        return self._pick_type(context)
 
 
 # Tread run accessors - callbacks that delegate to BIMStairProperties methods
@@ -462,20 +482,47 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     bl_region_type = "WINDOW"
     bl_options = {"3D", "PERSISTENT"}
 
-    # === Stair-Specific Icon Layout (meters) ===
-    # Additional icons for stair editing, positioned after standard icons:
-    #   [Validate] [Cancel] [Cycle] [TreadLock] [Plus] [Minus]
-    ICON_TREAD_LOCK_X = 1.24  # X position for tread lock toggle icon
-    ICON_PLUS_X = 1.61  # X position for add tread (+) icon
-    ICON_MINUS_X = 1.98  # X position for remove tread (-) icon
+    # === Stair-Specific Icon Layout ===
+    # Row order: [Validate] [Cancel] [Cycle] [TreadLock] [xN] [Plus] [Minus]
+    # The base class assigns X positions from ``feature_slots`` tuple order —
+    # adding an icon is a one-line append, no hardcoded X constant.
     ICON_PLUS_MINUS_SCALE = 0.24  # Scale for plus/minus icons (slightly larger)
     ICON_CYCLE_SCALE = 0.3  # Scale for cycle type icon
+    ICON_COUNT_LABEL_SCALE = 0.36  # Scale for the xN tread-count label
     ICON_Z_OFFSET = 0.5  # Z offset above geometry for editing icons
 
+    feature_slots: ClassVar[tuple[IconSlot, ...]] = (
+        IconSlot(
+            name="tread_lock",
+            gizmo_idname="VIEW3D_GT_lock",
+            variants=("open", "closed"),
+            operator="bim.toggle_stair_property",
+            color=(1.0, 1.0, 1.0),
+            operator_props=(("property_name", "custom_tread_lock"),),
+        ),
+        IconSlot(name="tread_count_label", placeholder=True),
+        IconSlot(
+            name="plus",
+            gizmo_idname="VIEW3D_GT_plus",
+            operator="bim.adjust_stair_treads",
+            scale=ICON_PLUS_MINUS_SCALE,
+            color=COLOR_GREEN,
+            operator_props=(("increment", 1),),
+        ),
+        IconSlot(
+            name="minus",
+            gizmo_idname="VIEW3D_GT_minus",
+            operator="bim.adjust_stair_treads",
+            scale=ICON_PLUS_MINUS_SCALE,
+            color=COLOR_RED,
+            operator_props=(("increment", -1),),
+        ),
+    )
+
     enable_editing_operator = "bim.enable_editing_stair"
     finish_editing_operator = "bim.finish_editing_stair"
     cancel_editing_operator = "bim.cancel_editing_stair"
-    cycle_type_operator = "bim.cycle_stair_type"
+    pick_type_operator = "bim.pick_stair_type"
 
     def get_icon_y_extent(self, props: "BIMStairProperties") -> tuple[float, float]:
         """Get Y extents for stair icon positioning.
@@ -585,28 +632,31 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
 
     @classmethod
     def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Blender.Modifier.is_stair(element)
+        return tool.Parametric.is_stair(element)
 
     def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create stair-specific icon gizmos (lock, plus, minus)."""
-        self.lock_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_lock",
-            self.COLOR_BLUE,
+        """Create the total-length lock as an open/closed pair plus the
+        ``xN`` tread-count label. Lock click toggles
+        ``props.total_length_lock``; the per-frame update hook picks which
+        member is visible. Anchored to the stair's far X end (not the edit
+        row) so it's positioned by ``_update_lock_gizmo_position`` rather
+        than the toolbar slot system.
+
+        The count label binds to ``bim.input_stair_treads`` (popup dialog)
+        for click-to-type input and sits at the X reserved by the
+        ``tread_count_label`` placeholder slot in ``feature_slots``."""
+        self.total_length_lock_open_gizmo, self.total_length_lock_closed_gizmo = self.create_icon_gizmo_lock_pair(
             "bim.toggle_stair_property",
+            self.COLOR_BLUE,
             property_name="total_length_lock",
         )
-        self.tread_lock_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_lock",
-            (1.0, 1.0, 1.0),
-            "bim.toggle_stair_property",
-            property_name="custom_tread_lock",
-        )
-        self.plus_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_plus", self.COLOR_GREEN, "bim.adjust_stair_treads", increment=1
-        )
-        self.minus_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_minus", self.COLOR_RED, "bim.adjust_stair_treads", increment=-1
-        )
+        default_color, highlight_color = self.get_decoration_colors()
+        self.tread_count_label_gizmo = self.gizmos.new("BIM_GT_count_label")
+        self.tread_count_label_gizmo.use_draw_scale = False
+        self.tread_count_label_gizmo.color = default_color
+        self.tread_count_label_gizmo.color_highlight = highlight_color
+        self.tread_count_label_gizmo.alpha = 0.8
+        self.tread_count_label_gizmo.target_set_operator("bim.input_stair_treads")
 
     def _refresh_element_specific(
         self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"  # noqa: ARG002
@@ -618,30 +668,43 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         self.update_tread_count_gizmos(props)
 
     def update_lock_gizmo(self, props: "BIMStairProperties") -> None:
-        """Update lock gizmo color and visibility. Positioning is handled
-        per-frame by the dimension-positioning hook."""
-        gizmo_prefs = self.get_gizmo_prefs()
-        if not self.update_gizmo_visibility(self.lock_gizmo, props.is_editing, gizmo_prefs.lock):
-            return  # Hidden, skip color update
-        self.lock_gizmo.color = self.COLOR_RED if props.total_length_lock else self.COLOR_GREEN
+        """Show the open/closed total-length lock variant matching
+        ``props.total_length_lock``. Positioning is handled per-frame by
+        the dimension-positioning hook."""
+        if not hasattr(self, "total_length_lock_open_gizmo"):
+            return
+        if not props.is_editing:
+            self.total_length_lock_open_gizmo.hide = True
+            self.total_length_lock_closed_gizmo.hide = True
+            return
+        self.total_length_lock_open_gizmo.hide = props.total_length_lock
+        self.total_length_lock_closed_gizmo.hide = not props.total_length_lock
 
     def update_tread_lock_gizmo(self, props: "BIMStairProperties") -> None:
-        """Update visibility of tread lock gizmo. Positioning is handled in _update_editing_icon_positions."""
-        if not hasattr(self, "tread_lock_gizmo"):
+        """Show the open/closed lock variant matching ``props.custom_tread_lock``.
+
+        Both pair members share an X position (set by the base's slot
+        positioning); this picks which one is visible per frame so a state
+        flip can't reveal both at once."""
+        if not hasattr(self, "tread_lock_open_gizmo"):
             return
-        gizmo_prefs = self.get_gizmo_prefs()
-        self.update_gizmo_visibility(self.tread_lock_gizmo, props.is_editing, gizmo_prefs.lock)
+        if not props.is_editing:
+            self.tread_lock_open_gizmo.hide = True
+            self.tread_lock_closed_gizmo.hide = True
+            return
+        self.tread_lock_open_gizmo.hide = props.custom_tread_lock
+        self.tread_lock_closed_gizmo.hide = not props.custom_tread_lock
 
     def update_tread_count_gizmos(self, props: "BIMStairProperties") -> None:
-        """Update visibility of +/- tread count gizmos. Positioning is handled in _update_editing_icon_positions."""
+        """Update visibility of the +/- tread count gizmos and the ``xN``
+        label. Positioning is handled in ``_update_editing_icon_positions``."""
         if not hasattr(self, "plus_gizmo") or not hasattr(self, "minus_gizmo"):
             return
-        gizmo_prefs = self.get_gizmo_prefs()
-        self.update_gizmo_visibility(self.plus_gizmo, props.is_editing, gizmo_prefs.plus)
+        self.update_gizmo_visibility(self.plus_gizmo, props.is_editing)
         # Minus has additional condition: number_of_treads > 1
-        self.update_gizmo_visibility(
-            self.minus_gizmo, props.is_editing and props.number_of_treads > 1, gizmo_prefs.minus
-        )
+        self.update_gizmo_visibility(self.minus_gizmo, props.is_editing and props.number_of_treads > 1)
+        if hasattr(self, "tread_count_label_gizmo"):
+            self.update_gizmo_visibility(self.tread_count_label_gizmo, props.is_editing)
 
     def _update_dimension_gizmo_positions(
         self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"  # noqa: ARG002
@@ -719,10 +782,12 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         billboard_rot: Matrix,
         total_run: float,
     ) -> None:
-        """Update lock gizmo position based on Y view direction."""
+        """Update lock gizmo pair position based on Y view direction. Writes
+        the matrix on both members so a state flip can't reveal a stale pose."""
         y_pos = self.get_y_position_for_view(props, viewing_from_negative_y, use_offset=True)
-        self.set_icon_gizmo_position(
-            "lock_gizmo",
+        self.set_icon_gizmo_pair_position(
+            "total_length_lock_open_gizmo",
+            "total_length_lock_closed_gizmo",
             mw,
             total_run + self.ICON_Z_OFFSET,
             y_pos,
@@ -734,30 +799,47 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     def _update_editing_icon_positions(
         self, mw: Matrix, props: "BIMStairProperties", viewing_from_negative_y: bool, billboard_rot: Matrix
     ) -> None:
-        """Update editing icon positions, flipping Y based on viewing angle."""
+        """Reposition the editing icons at stair's view-dependent Y. The base
+        class's update_editing_gizmos already placed them at the default
+        ``get_icon_y_offset`` Y — this overrides with the stair-specific
+        ``get_icon_y_for_view`` flip so the icons land on the side the
+        camera is looking from."""
         if not props.is_editing:
             return
 
         icon_z = props.height + self.ICON_Z_OFFSET
         y_pos = self.get_icon_y_for_view(props, viewing_from_negative_y)
+        slot_x = self._slot_x_positions()
 
         self.set_icon_gizmo_position("validate_gizmo", mw, 0, y_pos, icon_z, billboard_rot)
         self.set_icon_gizmo_position("cancel_gizmo", mw, self.ICON_CANCEL_X, y_pos, icon_z, billboard_rot)
         self.set_icon_gizmo_position(
             "cycle_gizmo", mw, self.ICON_CYCLE_X, y_pos, icon_z, billboard_rot, scale=self.ICON_CYCLE_SCALE
         )
-        self.set_icon_gizmo_position(
-            "tread_lock_gizmo",
+        self.set_icon_gizmo_pair_position(
+            "tread_lock_open_gizmo",
+            "tread_lock_closed_gizmo",
             mw,
-            self.ICON_TREAD_LOCK_X,
+            slot_x["tread_lock"],
             y_pos,
             icon_z - self.EDITING_ICON_SCALE / 2,
             billboard_rot,
             scale=self.EDITING_ICON_SCALE,
         )
         self.set_icon_gizmo_position(
-            "plus_gizmo", mw, self.ICON_PLUS_X, y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
+            "plus_gizmo", mw, slot_x["plus"], y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
         )
         self.set_icon_gizmo_position(
-            "minus_gizmo", mw, self.ICON_MINUS_X, y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
+            "minus_gizmo", mw, slot_x["minus"], y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
         )
+        if hasattr(self, "tread_count_label_gizmo"):
+            self.tread_count_label_gizmo.set_count(int(props.number_of_treads))
+            self.set_icon_gizmo_position(
+                "tread_count_label_gizmo",
+                mw,
+                slot_x["tread_count_label"],
+                y_pos,
+                icon_z,
+                billboard_rot,
+                scale=self.ICON_COUNT_LABEL_SCALE,
+            )

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
@@ -238,11 +238,11 @@ class BIM_PT_array(bpy.types.Panel):
 
             for i, array in enumerate(ArrayData.data["parameters"]["data_dict"]):
                 box = self.layout.box()
-                if props.is_editing == i:
+                if props.editing_item_index == i:
                     row = box.row(align=True)
                     row.prop(props, "count", icon="MOD_ARRAY")
-                    row.operator("bim.edit_array", icon="CHECKMARK", text="").item = i
-                    row.operator("bim.disable_editing_array", icon="CANCEL", text="")
+                    row.operator("bim.finish_editing_array", icon="CHECKMARK", text="")
+                    row.operator("bim.cancel_editing_array", icon="CANCEL", text="")
                     row = box.row(align=True)
                     row.prop(props, "method")
                     row = box.row(align=True)
@@ -365,7 +365,7 @@ class BIM_PT_wall(bpy.types.Panel):
         if not obj:
             return False
         element = tool.Ifc.get_entity(obj)
-        return bool(element) and tool.Blender.Modifier.is_wall(element)
+        return bool(element) and tool.Parametric.is_wall(element)
 
     def draw(self, context):
         obj = context.active_object

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

@@ -0,0 +1,279 @@
+# 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.
+
+"""Four wall-offset dimension gizmos (left / right / top / bottom) shared by door and
+window edit gizmo groups — both fillings sit in a LAYER2 wall and the offset math is
+identical.
+
+The compute side returns a *signed* value on the X axis (negative when the filling
+is 180°-flipped onto the wall's opposite face) so the gizmo framework auto-flips
+the rendered arrow; the apply side takes ``abs(value)`` because the user-facing
+offset is always positive. Z-axis values are unsigned in both directions.
+
+Fillings are assumed to align with the wall's local X axis to within ±90° — the
+parametric door/window construction path enforces this, and the X-sign math
+falls back to +1 if ``col[0].x`` lands on the ambiguous zero (filling rotated
+exactly 90° in the wall plane).
+
+Every public entry point falls back to a safe no-op when the host-wall chain
+cannot be resolved: reads return 0.0, writes do nothing, and gizmo anchors
+return a filling-relative position. This keeps the gizmos non-crashing when a
+filling momentarily loses its host (e.g. mid-edit, partially-loaded files).
+
+``_GEOM_CACHE`` is module-scoped and persists across tests — tests must call
+``clear_caches()`` between cases."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, NamedTuple, Protocol
+
+from mathutils import Vector
+
+import bonsai.tool as tool
+from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+
+if TYPE_CHECKING:
+    import bpy
+
+
+class FillingProps(Protocol):
+    """Structural subset of door/window props this module touches."""
+
+    id_data: bpy.types.Object
+    overall_width: float
+    overall_height: float
+
+
+# Wall-local frame axis indices. Y (depth) is unused — fillings sit on the wall's centreline.
+_AXIS_X = 0
+_AXIS_Z = 2
+
+
+class _HostWallGeom(NamedTuple):
+    """Cached host-wall geometry in SI metres, wall-local frame. ``height`` is
+    the vertical projection (already accounts for slanted extrusions)."""
+
+    wall_obj: bpy.types.Object
+    height: float
+    axis_min_x: float
+    axis_max_x: float
+
+
+class _AxisExtent(NamedTuple):
+    """``[low, high]`` interval on one wall-local axis; low = near end.
+
+    ``x_sign`` is +1 / -1 for an X-axis filling extent only (carries the
+    180° auto-flip); always 1.0 elsewhere."""
+
+    low: float
+    high: float
+    x_sign: float = 1.0
+
+
+class _Edge(NamedTuple):
+    """Wall edge a gizmo measures to. ``is_max_end=True`` picks right/top, else left/bottom."""
+
+    axis_index: int
+    is_max_end: bool
+
+
+_LEFT = _Edge(axis_index=_AXIS_X, is_max_end=False)
+_RIGHT = _Edge(axis_index=_AXIS_X, is_max_end=True)
+_BOTTOM = _Edge(axis_index=_AXIS_Z, is_max_end=False)
+_TOP = _Edge(axis_index=_AXIS_Z, is_max_end=True)
+
+
+# Avoids repeating the host-wall chain walk + LAYER2 geometry read per gizmo per frame.
+_GEOM_CACHE = tool.Parametric.GenerationKeyedCache()
+
+
+def clear_caches() -> None:
+    _GEOM_CACHE.clear()
+
+
+def _host_wall_geom(filling_obj: bpy.types.Object) -> _HostWallGeom | None:
+    """Cached host-wall geometry for a filling, or ``None`` if any link in
+    filling → opening → wall → LAYER2 extrusion → scene-object resolution breaks."""
+    return _GEOM_CACHE.get_or_compute(filling_obj.name, lambda: _compute_host_wall_geom(filling_obj))
+
+
+def _compute_host_wall_geom(filling_obj: bpy.types.Object) -> _HostWallGeom | None:
+    element = tool.Ifc.get_entity(filling_obj)
+    if not element:
+        return None
+    host_wall = tool.Spatial.get_host_wall(element)
+    if not host_wall:
+        return None
+    wall_obj = tool.Ifc.get_object(host_wall)
+    length_height = tool.Wall.get_length_and_height(host_wall)
+    axis_extent = tool.Wall.get_axis_local_extent(host_wall)
+    # x_angle is None for non-LAYER2 walls — gates entry; the value itself is unused.
+    if not (wall_obj and length_height and axis_extent and tool.Wall.get_x_angle(host_wall) is not None):
+        return None
+    _, height = length_height
+    axis_min_x, axis_max_x = axis_extent
+    return _HostWallGeom(wall_obj=wall_obj, height=height, axis_min_x=axis_min_x, axis_max_x=axis_max_x)
+
+
+def _filling_axis_extent(props: FillingProps, host_wall_obj: bpy.types.Object, axis_index: int) -> _AxisExtent:
+    """Filling footprint on the wall's local axis.
+
+    X-axis extent carries the filling's orientation sign (180° flip onto
+    the opposite face) in ``x_sign``."""
+    filling_in_wall = host_wall_obj.matrix_world.inverted() @ props.id_data.matrix_world
+    origin = filling_in_wall.translation[axis_index]
+    if axis_index == _AXIS_X:
+        # col[0].x is the X-component of the filling's local X axis in the wall-local frame:
+        # +1 when filling's +X aligns with wall's +X, -1 after a 180° Z-flip.
+        x_sign = 1.0 if filling_in_wall.col[0].x >= 0.0 else -1.0
+        signed_width = x_sign * props.overall_width
+        return _AxisExtent(origin + min(0.0, signed_width), origin + max(0.0, signed_width), x_sign)
+    return _AxisExtent(origin, origin + props.overall_height)
+
+
+def _wall_axis_extent(geom: _HostWallGeom, axis_index: int) -> _AxisExtent:
+    """Wall span on one local axis: X = IFC axis-line endpoints (not mesh bound-box,
+    which drifts on trimmed walls); Z = 0 → wall height."""
+    if axis_index == _AXIS_X:
+        return _AxisExtent(geom.axis_min_x, geom.axis_max_x)
+    return _AxisExtent(0.0, geom.height)
+
+
+def _offset_from_extents(filling: _AxisExtent, wall: _AxisExtent, is_max_end: bool) -> float:
+    """Distance from the wall edge to the filling's matching edge on the same axis."""
+    if is_max_end:
+        return wall.high - filling.high
+    return filling.low - wall.low
+
+
+def _translate_along_wall_axis(
+    props: FillingProps, host_wall_obj: bpy.types.Object, delta: float, axis_index: int
+) -> None:
+    """Shift the filling by ``delta`` SI metres along the wall's local axis. Drag
+    operates in the filling's intent frame, not Blender's world frame, so a rotated
+    host wall still tracks correctly."""
+    if delta == 0.0:
+        return
+    direction_world = host_wall_obj.matrix_world.to_3x3().col[axis_index].normalized()
+    props.id_data.matrix_world.translation = props.id_data.matrix_world.translation + direction_world * delta
+
+
+def _get_offset(props: FillingProps, edge: _Edge) -> float:
+    """SI distance from the wall edge to the filling's matching edge on the same axis."""
+    geom = _host_wall_geom(props.id_data)
+    if not geom:
+        return 0.0
+    filling = _filling_axis_extent(props, geom.wall_obj, edge.axis_index)
+    wall = _wall_axis_extent(geom, edge.axis_index)
+    return _offset_from_extents(filling, wall, edge.is_max_end)
+
+
+def _set_offset(props: FillingProps, edge: _Edge, value: float) -> None:
+    """Translate the filling so its offset to ``edge`` becomes ``max(0, value)`` SI metres.
+    Max-end edges (right/top) translate in the opposite direction of near-end edges."""
+    geom = _host_wall_geom(props.id_data)
+    if not geom:
+        return
+    current = _get_offset(props, edge)
+    target = max(0.0, value)
+    delta = (current - target) if edge.is_max_end else (target - current)
+    _translate_along_wall_axis(props, geom.wall_obj, delta, edge.axis_index)
+
+
+def has_host_wall(props: FillingProps) -> bool:
+    """True when the filling resolves to a LAYER2 host wall present in the scene."""
+    return _host_wall_geom(props.id_data) is not None
+
+
+def _edge_position(props: FillingProps, edge: _Edge) -> Vector:
+    """Gizmo anchor in filling-local space, at the wall edge, pointing toward the filling."""
+    geom = _host_wall_geom(props.id_data)
+    if not geom:
+        if edge.axis_index == _AXIS_X:
+            return Vector((0.0, 0.0, props.overall_height / 2))
+        return Vector((props.overall_width / 2, 0.0, props.overall_height if edge.is_max_end else 0.0))
+    wall = _wall_axis_extent(geom, edge.axis_index)
+    edge_value = wall.high if edge.is_max_end else wall.low
+    if edge.axis_index == _AXIS_X:
+        wall_edge_world = geom.wall_obj.matrix_world @ Vector((edge_value, 0.0, 0.0))
+        pos = props.id_data.matrix_world.inverted() @ wall_edge_world
+        return Vector((pos.x, 0.0, props.overall_height / 2))
+    # LAYER2 wall matrix_world is upright, so wall-local Z and filling-local Z differ
+    # only by the filling's Z origin in the wall frame.
+    filling_z_in_wall = _filling_axis_extent(props, geom.wall_obj, axis_index=_AXIS_Z).low
+    return Vector((props.overall_width / 2, 0.0, edge_value - filling_z_in_wall))
+
+
+def _compute_value(props: FillingProps, edge: _Edge) -> float:
+    """Renderer-side value. X-axis edges return a signed value so the gizmo's
+    auto-flip kicks in for fillings on the wall's opposite face; Z-axis returns unsigned."""
+    geom = _host_wall_geom(props.id_data)
+    if not geom:
+        return 0.0
+    filling = _filling_axis_extent(props, geom.wall_obj, edge.axis_index)
+    wall = _wall_axis_extent(geom, edge.axis_index)
+    return filling.x_sign * _offset_from_extents(filling, wall, edge.is_max_end)
+
+
+def _apply_value(props: FillingProps, edge: _Edge, value: float) -> None:
+    """Drag-end commit; X-axis takes ``abs(value)`` since the negative sign in compute
+    is a rendering hint only (user-facing offset is always positive)."""
+    if edge.axis_index == _AXIS_X:
+        _set_offset(props, edge, abs(value))
+    else:
+        _set_offset(props, edge, value)
+
+
+# attr_name identifies the gizmo within its group; values flow through
+# compute/apply, not via a registered property.
+WALL_OFFSET_GIZMO_CONFIGS: list[DimensionGizmoConfig] = [
+    DimensionGizmoConfig(
+        attr_name="host_wall_offset_left",
+        axis=(1, 0, 0),
+        visibility_condition=has_host_wall,
+        compute_value=lambda p: _compute_value(p, _LEFT),
+        apply_value=lambda p, v: _apply_value(p, _LEFT, v),
+        matrix_position=lambda p: _edge_position(p, _LEFT),
+    ),
+    DimensionGizmoConfig(
+        attr_name="host_wall_offset_right",
+        axis=(-1, 0, 0),
+        visibility_condition=has_host_wall,
+        compute_value=lambda p: _compute_value(p, _RIGHT),
+        apply_value=lambda p, v: _apply_value(p, _RIGHT, v),
+        matrix_position=lambda p: _edge_position(p, _RIGHT),
+    ),
+    DimensionGizmoConfig(
+        attr_name="host_wall_offset_bottom",
+        axis=(0, 0, 1),
+        visibility_condition=has_host_wall,
+        compute_value=lambda p: _compute_value(p, _BOTTOM),
+        apply_value=lambda p, v: _apply_value(p, _BOTTOM, v),
+        matrix_position=lambda p: _edge_position(p, _BOTTOM),
+    ),
+    DimensionGizmoConfig(
+        attr_name="host_wall_offset_top",
+        axis=(0, 0, -1),
+        visibility_condition=has_host_wall,
+        compute_value=lambda p: _compute_value(p, _TOP),
+        apply_value=lambda p, v: _apply_value(p, _TOP, v),
+        matrix_position=lambda p: _edge_position(p, _TOP),
+    ),
+]

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

@@ -39,7 +39,8 @@ 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.parametric_lifecycle import FeatureModifierEditMixin
+from bonsai.bim.module.model.wall_offset_gizmos import WALL_OFFSET_GIZMO_CONFIGS
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin, PickTypeMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMWindowProperties
@@ -491,7 +492,7 @@ class _WindowEditMixin(FeatureModifierEditMixin):
 
     @classmethod
     def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_window(element)
+        return tool.Parametric.is_window(element)
 
     @classmethod
     def _get_props(cls, obj: bpy.types.Object):
@@ -551,11 +552,11 @@ class RemoveWindow(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class CycleWindowType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin):
-    """Cycle through available window types. Shift+click to cycle in reverse."""
+class PickWindowType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
+    """Pick a window type from a popup menu."""
 
-    bl_idname = "bim.cycle_window_type"
-    bl_label = "Cycle Window Type"
+    bl_idname = "bim.pick_window_type"
+    bl_label = "Pick Window Type"
     bl_options = {"REGISTER", "UNDO"}
 
     element_checker = tool.Parametric.is_window
@@ -564,7 +565,7 @@ class CycleWindowType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixi
     type_attr = "window_type"
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cycle_type(context)
+        return self._pick_type(context)
 
 
 # Frame accessor factory - creates callbacks that delegate to BIMWindowProperties methods
@@ -602,7 +603,7 @@ class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     enable_editing_operator = "bim.enable_editing_window"
     finish_editing_operator = "bim.finish_editing_window"
     cancel_editing_operator = "bim.cancel_editing_window"
-    cycle_type_operator = "bim.cycle_window_type"
+    pick_type_operator = "bim.pick_window_type"
 
     # matrix_position lambdas replace the get_dimension_matrix_* methods
     dimension_gizmo_props = [
@@ -743,6 +744,7 @@ class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         ),
         # lining_offset is handled specially in _update_dimension_gizmo_positions due to negative value support
         DimensionGizmoConfig(attr_name="lining_offset", axis=(0, 1, 0), min_value=-10.0),
+        *WALL_OFFSET_GIZMO_CONFIGS,
     ]
 
     props_getter = tool.Model.get_window_props
@@ -750,7 +752,7 @@ class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
 
     @classmethod
     def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Blender.Modifier.is_window(element)
+        return tool.Parametric.is_window(element)
 
     def get_icon_y_extent(self, props: "BIMWindowProperties") -> tuple[float, float]:
         """Get Y extents for window icon positioning.

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

@@ -963,13 +963,19 @@ class EditObjectUI:
 
     @classmethod
     def draw_regen_operations(cls, row, ui_context):
-        if AuthoringData.data["is_regenable_element"]:
+        # ``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"):
             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)
 
         if PortData.data["total_ports"] > 0:
             row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
-            add_layout_hotkey_operator(row, "Regen", "S_G", bpy.ops.bim.regenerate_distribution_element.__doc__, ui_context)
+            add_layout_hotkey_operator(
+                row, "Regen", "S_G", bpy.ops.bim.regenerate_distribution_element.__doc__, ui_context
+            )
 
     @classmethod
     def draw_void(cls, context, row):
@@ -1315,7 +1321,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):
@@ -1442,10 +1448,7 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             bpy.ops.bim.enable_editing_extrusion_axis()
 
     def hotkey_A_O(self):
-        if tool.Model.get_model_props().openings:
-            bpy.ops.bim.edit_openings(apply_all=True)
-        else:
-            bpy.ops.bim.show_openings()
+        bpy.ops.bim.toggle_host_openings()
 
     def hotkey_C_E(self):
         if not bpy.context.selected_objects:

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

@@ -20,7 +20,6 @@ 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
@@ -28,12 +27,6 @@ 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")
@@ -79,26 +72,8 @@ def create_bounding_box(objs):
     return indices, edges
 
 
-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
+class NestDecorator(tool.Blender.ViewportDecorator):
+    draw_method = "draw_nest"
 
     def dotted_line_shader(self):
         vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
@@ -154,14 +129,6 @@ class NestDecorator:
         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:
@@ -226,35 +193,11 @@ class NestDecorator:
             self.draw_custom_batch(line, decorator_color_unselected)
 
 
-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)
+class NestModeDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_nest_name", "POST_PIXEL"),
+        ("draw_nest_empty", "POST_VIEW"),
+    )
 
     def draw_nest_name(self, context):
         if context.mode == "EDIT_MESH":

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

@@ -21,6 +21,7 @@ import bpy
 from . import operator, prop, ui
 
 classes = (
+    operator.AddIfcPatchPreset,
     operator.ExecuteIfcPatch,
     operator.ExtractSelectedElements,
     operator.RunMigratePatch,
@@ -28,6 +29,7 @@ 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,6 +23,7 @@ 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
@@ -77,6 +78,27 @@ 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
@@ -224,3 +246,38 @@ 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,6 +71,15 @@ 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,6 +29,20 @@ 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"
@@ -66,6 +80,11 @@ 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,6 +28,12 @@ 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,
@@ -39,7 +45,6 @@ classes = (
     operator.DisableEditingHeader,
     operator.DisableEditingLink,
     operator.EditHeader,
-    operator.EditLink,
     operator.EditProjectLibrary,
     operator.EnableCulling,
     operator.EnableEditingHeader,
@@ -61,6 +66,7 @@ classes = (
     operator.QueryLinkedElement,
     operator.RefreshClippingPlanes,
     operator.RefreshLibrary,
+    operator.ReloadAllLinks,
     operator.ReloadLink,
     operator.RemoveProjectLibrary,
     operator.RevertProject,
@@ -68,6 +74,7 @@ classes = (
     operator.SaveLibraryFile,
     operator.SelectLibraryFile,
     operator.SelectLinkedModelElement,
+    operator.SelectLinkFilepath,
     operator.SelectLinkHandle,
     operator.ToggleFilterCategories,
     operator.ToggleLinkSelectability,
@@ -82,6 +89,8 @@ classes = (
     prop.FilterCategory,
     prop.Link,
     prop.EditedObj,
+    prop.PendingArrayRepair,
+    prop.PendingOpeningRecut,
     prop.BIMProjectProperties,
     prop.MeasureToolSettings,
     ui.BIM_MT_new_project,
@@ -101,12 +110,45 @@ classes = (
 addon_keymaps = []
 
 
+@bpy.app.handlers.persistent
+def _autosave_link_transforms(scene, depsgraph):
+    """Persist link transformations whenever an editing link's handle is moved.
+
+    Deliberate exemption from the transaction rule in
+    docs/guides/development/undo_system.rst: a handler cannot run inside
+    execute_ifc_operator, so this IFC write is not undo-tracked. It stays
+    consistent anyway because undoing the move fires another depsgraph
+    update, which re-saves the reverted matrix.
+    """
+    import bonsai.tool as tool
+
+    props = tool.Project.get_project_props()
+    if not props.links:
+        return
+    handles = None
+    for update in depsgraph.updates:
+        if not update.is_updated_transform or not isinstance(update.id, bpy.types.Object):
+            continue
+        if handles is None:
+            # Built lazily so ticks without transform updates stay cheap.
+            handles = {}
+            for link in props.links:
+                if link.is_loaded and link.is_editing and (handle := tool.Project.get_link_empty_handle(link)):
+                    handles[handle] = link
+            if not handles:
+                return
+        if link := handles.get(update.id.original):
+            tool.Project.save_link_transformation(link)
+
+
 def register():
     if not bpy.app.background:
         bpy.utils.register_tool(workspace.ExploreTool, after={"builtin.transform"}, separator=True, group=False)
     bpy.types.Scene.BIMProjectProperties = bpy.props.PointerProperty(type=prop.BIMProjectProperties)
     bpy.types.Scene.MeasureToolSettings = bpy.props.PointerProperty(type=prop.MeasureToolSettings)
     bpy.app.handlers.load_post.append(decorator.toggle_decorations_on_load)
+    if _autosave_link_transforms not in bpy.app.handlers.depsgraph_update_post:
+        bpy.app.handlers.depsgraph_update_post.append(_autosave_link_transforms)
     bpy.types.TOPBAR_MT_file_import.append(ui.file_import_menu)
     bpy.types.TOPBAR_MT_file.prepend(ui.file_menu)
     bpy.types.TOPBAR_MT_file_context_menu.prepend(ui.file_menu)
@@ -131,6 +173,8 @@ def unregister():
     del bpy.types.Scene.BIMProjectProperties
     del bpy.types.Scene.MeasureToolSettings
     bpy.app.handlers.load_post.remove(decorator.toggle_decorations_on_load)
+    if _autosave_link_transforms in bpy.app.handlers.depsgraph_update_post:
+        bpy.app.handlers.depsgraph_update_post.remove(_autosave_link_transforms)
     bpy.types.TOPBAR_MT_file.remove(ui.file_menu)
     bpy.types.TOPBAR_MT_file_context_menu.remove(ui.file_menu)
 

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
-        project = library_file.by_type("IfcProject")[0]
-        results.append((str(project.id()), f"IfcProject {project.Name or 'Unnamed'}", project.Description or ""))
+        root = tool.Project.get_root_context(library_file)
+        results.append((str(root.id()), f"{root.is_a()} {root.Name or 'Unnamed'}", root.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,12 +42,6 @@ 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
 
@@ -80,11 +74,6 @@ 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")
 
@@ -110,7 +99,10 @@ class ProjectDecorator:
 
         if geom.selected_edges:
             self.draw_batch("LINES", selected_vertices, selected_elements_color, geom.selected_edges)
-            self.draw_batch("TRIS", selected_vertices, transparent_color(selected_elements_color), geom.selected_tris)
+        if geom.selected_tris:
+            self.draw_batch(
+                "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), geom.selected_tris
+            )
 
 
 class ClippingPlaneDecorator:
@@ -145,11 +137,6 @@ 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")
 
@@ -210,37 +197,21 @@ class ClippingPlaneDecorator:
 
             if unselected_edges:
                 self.draw_batch("LINES", unselected_vertices, special_elements_color, unselected_edges)
-                self.draw_batch("TRIS", unselected_vertices, transparent_color(special_elements_color), unselected_tris)
+                self.draw_batch(
+                    "TRIS", unselected_vertices, tool.Blender.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, transparent_color(selected_elements_color), selected_tris)
+                self.draw_batch(
+                    "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), selected_tris
+                )
 
 
-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
+class MeasureDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_measurements_text", "POST_PIXEL"),
+        ("draw_measurements_poly", "POST_VIEW"),
+    )
 
     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)
 
-        ifc_project = library_file.by_type("IfcProject")[0]
+        root_context = tool.Project.get_root_context(library_file)
         hierarchy = tool.Project.get_project_hierarchy(library_file)
-        tool.Project.load_project_libraries_to_ui(ifc_project, hierarchy)
+        tool.Project.load_project_libraries_to_ui(root_context, hierarchy)
         return {"FINISHED"}
 
 
@@ -763,7 +763,10 @@ 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_a("IfcProject"):
+            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"):
                 # Then new one is IfcProjectLibrary.
                 ifcopenshell.api.nest.assign_object(library_file, [project_library], new_parent_library)
             else:  # Previous is IfcProjectLibrary.
@@ -804,9 +807,12 @@ class AddProjectLibrary(bpy.types.Operator):
         props = tool.Project.get_project_props()
         library_file = IfcStore.library_file
         assert library_file
-        project = library_file.by_type("IfcProject")[0]
+        root_context = tool.Project.get_root_context(library_file)
         project_library = ifcopenshell.api.root.create_entity(library_file, "IfcProjectLibrary")
-        ifcopenshell.api.project.assign_declaration(library_file, [project_library], project)
+        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)
         ProjectLibraryData.load()  # Update enum.
         props.selected_project_library = str(project_library.id())
         props.is_editing_project_library = True
@@ -1113,6 +1119,14 @@ 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"))
@@ -1223,6 +1237,30 @@ 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()
@@ -1256,6 +1294,11 @@ 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)
@@ -1317,10 +1360,18 @@ class LinkIfc(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
     )
     use_cache: bpy.props.BoolProperty(name="Use Cache", default=True)
     query: bpy.props.StringProperty(
-        name="Query",
+        name="Include",
         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."
+            "Selector query for the elements to load from the linked model. E.g. 'IfcElement'.\n\n"
+            "Default when empty - IfcElement, but excluding IfcProxy, IfcSpatialStructureElement, IfcSpatialElement, IfcFeatureElement."
+        ),
+    )
+    exclude: bpy.props.StringProperty(
+        name="Exclude",
+        description=(
+            "Selector query whose matches are excluded from the loaded elements.\n\n"
+            "Applied on top of the query (or the default set), providing the set "
+            "difference a single query cannot express. E.g. 'IfcSlab, parent=\"X\"'."
         ),
     )
 
@@ -1334,6 +1385,7 @@ class LinkIfc(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
         use_relative_path: bool
         use_cache: bool
         query: str
+        exclude: str
 
     def draw(self, context):
         assert self.layout
@@ -1352,6 +1404,7 @@ class LinkIfc(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
             row = self.layout.row()
             row.prop(pprops, "project_north")
         self.layout.prop(self, "query", placeholder="IfcElement")
+        self.layout.prop(self, "exclude", placeholder='IfcSlab, parent="..."')
 
     def _execute(self, context):
         start = time.time()
@@ -1374,17 +1427,26 @@ class LinkIfc(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
 
             new = props.links.add()
             if tool.Ifc.get():
-                if not (document := existing_links.get(filepath)):
+                # Look up by resolved absolute path so a file already linked
+                # with a relative Location (or vice versa) reuses its document.
+                resolved_filepath = Path(tool.Ifc.resolve_uri(filepath)).as_posix()
+                if not (document := existing_links.get(resolved_filepath)):
                     document = ifcopenshell.api.document.add_information(tool.Ifc.get())
                     document.Name = Path(filepath).name
                     document.Scope = "LINKED_MODEL"
                 reference = ifcopenshell.api.document.add_reference(tool.Ifc.get(), information=document)
                 reference[1] = ",".join([str(o) for o in np.eye(4).flatten().tolist()])
                 reference.Location = filepath.replace("\\", "/")
+                # Persist the filter per reference (Description is IFC4+ only).
+                description = tool.Project.encode_link_filter(self.query, self.exclude, loaded=True)
+                if description and hasattr(reference, "Description"):
+                    reference.Description = description
                 new.ifc_definition_id = reference.id()
             new.name = filepath
             new.filepath = filepath
-            bpy.ops.bim.load_link(link_index=-1, use_cache=self.use_cache, query=self.query)
+            new.query = self.query
+            new.exclude = self.exclude
+            bpy.ops.bim.load_link(link_index=-1, use_cache=self.use_cache, query=self.query, exclude=self.exclude)
 
 
 class UnlinkIfc(bpy.types.Operator, tool.Ifc.Operator):
@@ -1443,17 +1505,28 @@ class LoadLink(bpy.types.Operator, tool.Ifc.Operator):
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Load the selected file"
 
+    # SKIP_SAVE: Blender reuses an operator's last-used property values on the
+    # next interactive invocation, which would leak one link's query/cache
+    # settings into another link's load.
     link_index: bpy.props.IntProperty(name="Link Index")
-    use_cache: bpy.props.BoolProperty(name="Use Cache", default=True)
-    query: bpy.props.StringProperty()
+    use_cache: bpy.props.BoolProperty(name="Use Cache", default=True, options={"SKIP_SAVE"})
+    query: bpy.props.StringProperty(options={"SKIP_SAVE"})
+    exclude: bpy.props.StringProperty(options={"SKIP_SAVE"})
 
     if TYPE_CHECKING:
         link_index: int
         use_cache: bool
         query: str
+        exclude: str
 
     def _execute(self, context):
         self.link = tool.Project.get_project_props().links[self.link_index]
+        # Fall back to the Link's stored filter 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
+        if not self.exclude and self.link.exclude:
+            self.exclude = self.link.exclude
         filepath = Path(tool.Ifc.resolve_uri(self.link.filepath))
         if not filepath.exists():
             self.report({"ERROR"}, f"File does not exist: '{filepath}'")
@@ -1490,22 +1563,21 @@ class LoadLink(bpy.types.Operator, tool.Ifc.Operator):
             self.link.is_loaded = False
 
     def link_ifc(self) -> Union[set[str], None]:
-        blend_filepath = self.filepath_.with_suffix(".ifc.cache.blend")
-        h5_filepath = self.filepath_.with_suffix(".ifc.cache.h5")
-        json_filepath = self.filepath_.with_suffix(".ifc.cache.json")
+        blend_filepath, json_filepath = tool.Project.get_link_cache_paths(self.filepath_, self.query, self.exclude)
 
         def should_clear_cache() -> bool:
             if not self.use_cache:
                 return True
             if not blend_filepath.exists():
                 return False
+            if not json_filepath.exists():
+                return True
             data = json.loads(json_filepath.read_text())
             # Empty 'query' - model loaded without custom query.
             # Missing 'query' - model was loaded before custom queries were introduced in Bonsai.
-            query = data.get("query", "")
-            return query != self.query
+            return data.get("query", "") != self.query or data.get("exclude", "") != self.exclude
 
-        if should_clear_cache():
+        if should_clear_cache() and blend_filepath.exists():
             os.remove(blend_filepath)
 
         if not blend_filepath.exists():
@@ -1533,7 +1605,7 @@ def run():
     pprops.project_north = "{pprops.project_north}"
     # Use absolute path to be safe from cwd changes.
     try:
-        bpy.ops.bim.load_linked_project(filepath=r"{str(self.filepath_)}", query={repr(self.query)})
+        bpy.ops.bim.load_linked_project(filepath=r"{str(self.filepath_)}", query={repr(self.query)}, exclude={repr(self.exclude)})
     except RuntimeError as e:
         # Operator failed (returned CANCELLED with error report)
         print(f"Failed to load linked project: {{e}}")
@@ -1582,7 +1654,7 @@ except Exception as e:
         if len(tool.Project.get_project_props().links) > 1:
             return  # Only the first link sets the origin
 
-        json_filepath = self.filepath_.with_suffix(".ifc.cache.json")
+        json_filepath = tool.Project.get_link_cache_paths(self.filepath_, self.query, self.exclude)[1]
         if not json_filepath.exists():
             return
 
@@ -1601,8 +1673,7 @@ except Exception as e:
         if not (crs_name := (ifcopenshell.util.geolocation.get_crs(tool.Ifc.get()) or {}).get("Name", "")):
             self.link.georeferenced = "NONE"
             return
-        reference = tool.Ifc.get().by_id(self.link.ifc_definition_id)
-        json_filepath = Path(reference.Location).with_suffix(".ifc.cache.json")
+        json_filepath = tool.Project.get_link_cache_paths(self.filepath_, self.query, self.exclude)[1]
         if not json_filepath.exists():
             self.link.georeferenced = "NONE"
             return
@@ -1614,20 +1685,211 @@ except Exception as e:
             self.link.georeferenced = "FULL_COMPATIBLE" if crs_name == data["model_crs"] else "NOT_COMPATIBLE"
 
 
-class ReloadLink(bpy.types.Operator):
+class ReloadLink(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.reload_link"
     bl_label = "Reload Link"
     bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Reload the selected file"
+    bl_description = "Reload the selected file, optionally changing its file path and load options"
 
+    # SKIP_SAVE: this operator distinguishes "provided" from "unset" properties
+    # via is_property_set, so last-used property retention between interactive
+    # invocations would leak one link's settings into another's reload.
     link_index: bpy.props.IntProperty(name="Link Index")
+    filepath: bpy.props.StringProperty(
+        name="File Path",
+        description="Path to the linked IFC file",
+        options={"SKIP_SAVE"},
+    )
+    use_relative_path: bpy.props.BoolProperty(
+        name="Use Relative Path",
+        description="Whether to store linked model path relative to the currently opened IFC file.",
+        default=False,
+        options={"SKIP_SAVE"},
+    )
+    use_cache: bpy.props.BoolProperty(
+        name="Use Cache",
+        description="Reuse the cached geometry if it's still valid instead of reprocessing the IFC",
+        default=False,
+        options={"SKIP_SAVE"},
+    )
+    query: bpy.props.StringProperty(
+        name="Include",
+        description=(
+            "Selector query for the elements to load from the linked model. E.g. 'IfcElement'.\n\n"
+            "Default when empty - IfcElement, but excluding IfcProxy, IfcSpatialStructureElement, IfcSpatialElement, IfcFeatureElement."
+        ),
+        options={"SKIP_SAVE"},
+    )
+    exclude: bpy.props.StringProperty(
+        name="Exclude",
+        description=(
+            "Selector query whose matches are excluded from the loaded elements.\n\n"
+            "Applied on top of the query (or the default set), providing the set "
+            "difference a single query cannot express. E.g. 'IfcSlab, parent=\"X\"'."
+        ),
+        options={"SKIP_SAVE"},
+    )
 
     if TYPE_CHECKING:
         link_index: int
+        filepath: str
+        use_relative_path: bool
+        use_cache: bool
+        query: str
+        exclude: str
+
+    def invoke(self, context, event):
+        link = tool.Project.get_project_props().links[self.link_index]
+        # Properties may arrive pre-set when the dialog is reopened
+        # by bim.select_link_filepath - don't clobber them.
+        if not self.properties.is_property_set("filepath"):
+            self.filepath = link.filepath
+        if not self.properties.is_property_set("use_relative_path"):
+            self.use_relative_path = not Path(link.filepath).is_absolute()
+        if not self.properties.is_property_set("query"):
+            self.query = link.query
+        if not self.properties.is_property_set("exclude"):
+            self.exclude = link.exclude
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context):
+        assert self.layout
+        pprops = tool.Project.get_project_props()
+        row = self.layout.row(align=True)
+        row.prop(self, "filepath")
+        op = row.operator("bim.select_link_filepath", text="", icon="FILEBROWSER")
+        op.link_index = self.link_index
+        # Carry the current dialog state through the file browser round-trip.
+        op.use_relative_path = self.use_relative_path
+        op.use_cache = self.use_cache
+        op.query = self.query
+        op.exclude = self.exclude
+        row = self.layout.row()
+        row.prop(self, "use_relative_path")
+        row = self.layout.row()
+        row.prop(self, "use_cache")
+        row = self.layout.row()
+        row.label(text="False Origin Mode:")
+        row = self.layout.row()
+        row.prop(pprops, "false_origin_mode", text="")
+        if pprops.false_origin_mode == "MANUAL":
+            row = self.layout.row()
+            row.prop(pprops, "false_origin")
+            row = self.layout.row()
+            row.prop(pprops, "project_north")
+        self.layout.prop(self, "query", placeholder="IfcElement")
+        self.layout.prop(self, "exclude", placeholder='IfcSlab, parent="..."')
+
+    def _execute(self, context):
+        link = tool.Project.get_project_props().links[self.link_index]
+        # Unset properties mean the operator was called without the dialog
+        # (e.g. from a script) - preserve the link's stored values instead
+        # of overwriting them with the defaults.
+        if self.properties.is_property_set("query"):
+            link.query = self.query
+        if self.properties.is_property_set("exclude"):
+            link.exclude = self.exclude
+
+        filepath = self.filepath if self.properties.is_property_set("filepath") else link.filepath
+        if self.properties.is_property_set("use_relative_path"):
+            use_relative_path = self.use_relative_path
+        else:
+            use_relative_path = not Path(link.filepath).is_absolute()
+
+        abs_filepath = Path(tool.Ifc.resolve_uri(filepath))
+        if not abs_filepath.exists():
+            self.report({"ERROR"}, f"File does not exist: '{abs_filepath}'")
+            return {"CANCELLED"}
+        filepath = tool.Ifc.get_uri(abs_filepath, use_relative_path=use_relative_path)
+        if filepath != link.filepath:
+            link.name = filepath
+            link.filepath = filepath
+            if tool.Ifc.get() and link.ifc_definition_id:
+                reference = tool.Ifc.get().by_id(link.ifc_definition_id)
+                reference.Location = filepath.replace("\\", "/")
+                if document := tool.Document.get_reference_document(reference):
+                    document.Name = Path(filepath).name
+        if tool.Ifc.get() and link.ifc_definition_id:
+            reference = tool.Ifc.get().by_id(link.ifc_definition_id)
+            if hasattr(reference, "Description"):
+                reference.Description = tool.Project.encode_link_filter(
+                    link.query, link.exclude, loaded=True, display_name=link.display_name
+                )
+
+        bpy.ops.bim.unload_link(link_index=self.link_index)
+        return bpy.ops.bim.load_link(
+            link_index=self.link_index, use_cache=self.use_cache, query=link.query, exclude=link.exclude
+        ) or {"FINISHED"}
+
+
+class ReloadAllLinks(bpy.types.Operator):
+    bl_idname = "bim.reload_all_links"
+    bl_label = "Reload All Links"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Reload all loaded linked models from disk, rebuilding their caches"
+
+    @classmethod
+    def poll(cls, context):
+        if not any(link.is_loaded for link in tool.Project.get_project_props().links):
+            cls.poll_message_set("No loaded links to reload.")
+            return False
+        return True
 
     def execute(self, context):
-        bpy.ops.bim.unload_link(link_index=self.link_index)
-        return bpy.ops.bim.load_link(link_index=self.link_index, use_cache=False) or {"FINISHED"}
+        props = tool.Project.get_project_props()
+        reloaded = 0
+        for i, link in enumerate(props.links):
+            if not link.is_loaded:
+                continue
+            # Called without filter properties, reload_link preserves each
+            # link's stored path, query and exclude.
+            bpy.ops.bim.reload_link(link_index=i)
+            reloaded += 1
+        self.report({"INFO"}, f"Reloaded {reloaded} linked model(s).")
+        return {"FINISHED"}
+
+
+class SelectLinkFilepath(bpy.types.Operator):
+    bl_idname = "bim.select_link_filepath"
+    bl_label = "Select Link File Path"
+    bl_options = {"REGISTER", "UNDO", "INTERNAL"}
+    bl_description = "Select a new file path for the linked model and return to the reload dialog"
+
+    link_index: bpy.props.IntProperty(name="Link Index")
+    filepath: bpy.props.StringProperty(subtype="FILE_PATH", options={"SKIP_SAVE", "HIDDEN"})
+    filter_glob: bpy.props.StringProperty(default="*.ifc", options={"HIDDEN"})
+    # Reload dialog state carried through the file browser round-trip.
+    use_relative_path: bpy.props.BoolProperty(options={"HIDDEN"})
+    use_cache: bpy.props.BoolProperty(options={"HIDDEN"})
+    query: bpy.props.StringProperty(options={"HIDDEN"})
+    exclude: bpy.props.StringProperty(options={"HIDDEN"})
+
+    if TYPE_CHECKING:
+        link_index: int
+        filepath: str
+        filter_glob: str
+        use_relative_path: bool
+        use_cache: bool
+        query: str
+        exclude: str
+
+    def invoke(self, context, event):
+        link = tool.Project.get_project_props().links[self.link_index]
+        self.filepath = tool.Ifc.resolve_uri(link.filepath)
+        context.window_manager.fileselect_add(self)
+        return {"RUNNING_MODAL"}
+
+    def execute(self, context):
+        bpy.ops.bim.reload_link(
+            "INVOKE_DEFAULT",
+            link_index=self.link_index,
+            filepath=self.filepath,
+            use_relative_path=self.use_relative_path,
+            use_cache=self.use_cache,
+            query=self.query,
+            exclude=self.exclude,
+        )
+        return {"FINISHED"}
 
 
 class ToggleLinkSelectability(bpy.types.Operator):
@@ -1645,7 +1907,7 @@ class ToggleLinkSelectability(bpy.types.Operator):
         props = tool.Project.get_project_props()
         link = props.links[self.link_index]
         self.library_filepath = tool.Blender.ensure_blender_path_is_abs(
-            Path(link.filepath).with_suffix(".ifc.cache.blend")
+            tool.Project.get_link_cache_paths(link.filepath, link.query, link.exclude)[0]
         )
         link.is_selectable = (is_selectable := not link.is_selectable)
         for collection in self.get_linked_collections():
@@ -1682,7 +1944,7 @@ class ToggleLinkVisibility(bpy.types.Operator):
         props = tool.Project.get_project_props()
         link = props.links[self.link_index]
         self.library_filepath = tool.Blender.ensure_blender_path_is_abs(
-            Path(link.filepath).with_suffix(".ifc.cache.blend")
+            tool.Project.get_link_cache_paths(link.filepath, link.query, link.exclude)[0]
         )
         if self.mode == "WIREFRAME":
             self.toggle_wireframe(link)
@@ -1724,10 +1986,16 @@ class EnableEditingLink(bpy.types.Operator):
     bl_idname = "bim.enable_editing_link"
     bl_label = "Enable Editing Link"
     bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Enable editing link location"
+    bl_description = "Unlock the link's position for editing. Any movement is saved automatically"
+
+    link_index: bpy.props.IntProperty(name="Link Index", default=-1)
+
+    if TYPE_CHECKING:
+        link_index: int
 
     def execute(self, context):
-        link = tool.Project.get_project_props().active_link
+        props = tool.Project.get_project_props()
+        link = props.active_link if self.link_index == -1 else props.links[self.link_index]
         assert link
         link.is_editing = True
         obj = tool.Project.get_link_empty_handle(link)
@@ -1736,70 +2004,25 @@ class EnableEditingLink(bpy.types.Operator):
         return {"FINISHED"}
 
 
-class DisableEditingLink(bpy.types.Operator):
+class DisableEditingLink(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.disable_editing_link"
     bl_label = "Disable Editing Link"
     bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Disable editing link and restore to previously saved location"
+    bl_description = "Lock the link at its current location"
 
-    def execute(self, context):
-        link = tool.Project.get_project_props().active_link
-        assert link
-        link.is_editing = False
-        obj = tool.Project.get_link_empty_handle(link)
-        assert obj
-        obj.matrix_world = tool.Project.calculate_link_matrix(link)
-        tool.Geometry.lock_object(obj)
-        return {"FINISHED"}
+    link_index: bpy.props.IntProperty(name="Link Index", default=-1)
 
-
-class EditLink(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.edit_link"
-    bl_label = "Edit Link"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Disable editing link and restore to previously saved location"
+    if TYPE_CHECKING:
+        link_index: int
 
     def _execute(self, context):
-        link = tool.Project.get_project_props().active_link
+        props = tool.Project.get_project_props()
+        link = props.active_link if self.link_index == -1 else props.links[self.link_index]
         assert link
         link.is_editing = False
         obj = tool.Project.get_link_empty_handle(link)
         assert obj
-        new_obj_matrix = obj.matrix_world
-
-        filepath = Path(tool.Ifc.resolve_uri(link.filepath))
-        with open(filepath.with_suffix(".ifc.cache.json"), "r") as f:
-            metadata = json.load(f)
-
-        rot = ifcopenshell.util.shape_builder.np_rotation_matrix(
-            radians(-float(metadata["model_project_north"])), 4, "Z"
-        )
-        global_matrix = rot @ np.eye(4)
-        global_matrix[:, 3][:3] = [float(o) for o in metadata["model_origin_si"].split(",")]
-
-        gprops = tool.Georeference.get_georeference_props()
-        rot = ifcopenshell.util.shape_builder.np_rotation_matrix(radians(-float(gprops.model_project_north)), 4, "Z")
-        local_matrix = rot @ np.eye(4)
-        local_matrix[:, 3][:3] = [float(o) for o in gprops.model_origin_si.split(",")]
-
-        # obj_matrix is typically calculated as:
-        # obj_matrix = np.linalg.inv(local_matrix) @ transformation @ global_matrix
-        identity_blender_matrix = np.linalg.inv(local_matrix) @ global_matrix
-        if np.allclose(np.array(new_obj_matrix), identity_blender_matrix, atol=1e-5):
-            link.has_transformation = False
-            transformation = ",".join(map(str, np.eye(4).reshape(-1)))
-        else:
-            transformed_global_matrix = local_matrix @ np.array(new_obj_matrix)
-            transformation = transformed_global_matrix @ np.linalg.inv(global_matrix)
-            link.has_transformation = True
-            transformation = ",".join(map(str, transformation.reshape(-1)))
-
-        if tool.Ifc.get():
-            reference = tool.Ifc.get().by_id(link.ifc_definition_id)
-            reference[1] = transformation
-        else:
-            link.transformation = transformation
-
+        tool.Project.save_link_transformation(link)
         obj.matrix_world = tool.Project.calculate_link_matrix(link)
         tool.Geometry.lock_object(obj)
 
@@ -1941,6 +2164,8 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         # gizmo polls gate on each preview's is_active flag, and a stuck flag
         # persisted through the save would silently hide them on reload.
         preview_base.discard_pending_previews(context.scene)
+        # Links loaded and visible right now auto-load on the next open.
+        tool.Project.update_linked_models_state()
         # Suffix is appended to the IFC save-success report below so the auto-commit
         # info isn't immediately overwritten by the success message in Blender's
         # status bar (only the latest self.report({"INFO"}, ...) sticks).
@@ -2048,14 +2273,23 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
 
     query: bpy.props.StringProperty()
     """See ``bim.link_ifc``."""
+    exclude: bpy.props.StringProperty()
+    """See ``bim.link_ifc``."""
 
     if TYPE_CHECKING:
         query: str
+        exclude: str
 
     file: ifcopenshell.file
     meshes: dict[str, bpy.types.Mesh]
     # Material names is derived from diffuse as in 'r-g-b-a'.
     blender_mats: dict[str, bpy.types.Material]
+    # Materials appended from external .blend styles, keyed by style id.
+    # None means the style has no loadable external .blend style.
+    external_style_mats: dict[int, Union[bpy.types.Material, None]]
+    # Appended data-blocks keyed by (filepath, data_block_type, name)
+    # so styles sharing the same external material don't append duplicates.
+    appended_external_blocks: dict[tuple[str, str, str], Union[bpy.types.Material, None]]
 
     def invoke(self, context, event):
         # Invoke is for debugging purposes, users are not intended to use this method really.
@@ -2112,6 +2346,9 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
             else:
                 self.elements |= set(self.file.by_type("IfcSpatialElement"))
             self.elements -= set(self.file.by_type("IfcFeatureElement"))
+        if self.exclude:
+            # The set difference a single selector query cannot express.
+            self.elements -= ifcopenshell.util.selector.filter_elements(self.file, self.exclude)
 
         if tool.Loader.settings.false_origin_mode == "MANUAL" and tool.Loader.settings.false_origin:
             tool.Loader.set_manual_blender_offset(self.file)
@@ -2119,7 +2356,7 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
             tool.Loader.guess_false_origin(self.file)
 
         tool.Georeference.set_model_origin()
-        self.json_filepath = self.filepath + ".cache.json"
+        self.json_filepath = str(tool.Project.get_link_cache_paths(self.filepath, self.query, self.exclude)[1])
         data = {
             "model_is_georeferenced": gprops.model_is_georeferenced,
             "model_crs": gprops.model_crs,
@@ -2137,10 +2374,14 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
             "false_origin": pprops.false_origin,
             "project_north": pprops.project_north,
             "query": self.query,
+            "exclude": self.exclude,
         }
         with open(self.json_filepath, "w") as f:
             json.dump(data, f)
 
+        self.external_style_mats = {}
+        self.appended_external_blocks = {}
+
         for settings in tool.Loader.settings.context_settings:
             if not self.elements:
                 break
@@ -2180,8 +2421,10 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
                     mat = tuple(mat)
                     blender_mat = blender_mats.get(mat, None)
                     if not blender_mat:
-                        blender_mat = bpy.data.materials.new("Chunk")
-                        blender_mat.diffuse_color = mat
+                        blender_mat = self.get_external_material(int(mat[4]))
+                        if not blender_mat:
+                            blender_mat = bpy.data.materials.new("Chunk")
+                            blender_mat.diffuse_color = mat[:4]
                         blender_mats[mat] = blender_mat
                     mat_results.append(blender_mat)
 
@@ -2199,11 +2442,16 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
                 while True:  # Main loop.
                     shape = iterator.get()
                     assert isinstance(shape, W.TriangulationElement)
-                    results.add(self.file.by_id(shape.id))
+                    element = self.file.by_id(shape.id)
+                    results.add(element)
                     geometry = shape.geometry
 
-                    # Elements with a lot of geometry benefit from instancing to save memory
-                    if ifcopenshell.util.shape.get_faces(geometry).shape[0] > 333:  # 333 tris
+                    # Elements with a lot of geometry benefit from instancing to save memory.
+                    # Multi-layer elements also take this path as they need their own
+                    # local-space mesh to be sliced into per-layer materials.
+                    if ifcopenshell.util.shape.get_faces(geometry).shape[0] > 333 or self.is_multilayer_element(
+                        element
+                    ):  # 333 tris
                         self.process_occurrence(shape)
                         if not iterator.next():
                             if not chunked_verts:
@@ -2220,9 +2468,15 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
 
                     ms = np.vstack([default_mat, ifcopenshell.util.shape.get_material_colors(shape.geometry)])
                     mi = ifcopenshell.util.shape.get_faces_material_style_ids(shape.geometry)
+                    # Style ids ride along as a 5th column so styles with
+                    # external .blend materials survive the per-color dedup.
+                    style_ids = np.zeros((len(ms), 1))
                     for geom_material_idx, geom_material in enumerate(shape.geometry.materials):
                         if not geom_material.instance_id():
                             ms[geom_material_idx + 1] = (0.8, 0.8, 0.8, 1)
+                        elif self.get_external_material(geom_material.instance_id()):
+                            style_ids[geom_material_idx + 1] = geom_material.instance_id()
+                    ms = np.hstack((ms, style_ids))
                     chunked_materials.append(ms)
                     chunked_material_ids.append(mi + material_offset + 1)
                     material_offset += len(ms)
@@ -2309,12 +2563,14 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
                     diffuse = (material.diffuse.r(), material.diffuse.g(), material.diffuse.b(), alpha)
                 else:
                     diffuse = (0.8, 0.8, 0.8, 1)  # Blender's default material
-                material_name = f"{diffuse[0]}-{diffuse[1]}-{diffuse[2]}-{diffuse[3]}"
-                blender_mat = self.blender_mats.get(material_name, None)
+                blender_mat = self.get_external_material(material.instance_id())
                 if not blender_mat:
-                    blender_mat = bpy.data.materials.new(material_name)
-                    blender_mat.diffuse_color = diffuse
-                    self.blender_mats[material_name] = blender_mat
+                    material_name = f"{diffuse[0]}-{diffuse[1]}-{diffuse[2]}-{diffuse[3]}"
+                    blender_mat = self.blender_mats.get(material_name, None)
+                    if not blender_mat:
+                        blender_mat = bpy.data.materials.new(material_name)
+                        blender_mat.diffuse_color = diffuse
+                        self.blender_mats[material_name] = blender_mat
                 slot_index = mesh.materials.find(material.name)
                 if slot_index == -1:
                     mesh.materials.append(blender_mat)
@@ -2327,6 +2583,8 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
             mesh.polygons.foreach_set("material_index", material_index)
             mesh.update()
 
+            mesh = tool.Loader.slice_layerset_mesh(element, mesh, style_to_material=self.get_style_material)
+
             self.meshes[geometry.id] = mesh
 
         obj = bpy.data.objects.new(tool.Loader.get_name(element), mesh)
@@ -2339,6 +2597,88 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
 
         self.collection.objects.link(obj)
 
+    def get_external_material(self, style_id: int) -> Union[bpy.types.Material, None]:
+        """Get the Blender material referenced by a style's external .blend style, if it has one.
+
+        The material is appended from the external .blend file on first use and
+        cached, so it ends up saved inside the link's .cache.blend.
+        """
+        if not style_id:
+            return None
+        if style_id in self.external_style_mats:
+            return self.external_style_mats[style_id]
+
+        material = None
+        # instance_id may also refer to an IfcMaterial when the item has
+        # a material but no style, hence the class check.
+        style = self.file.by_id(style_id)
+        external = None
+        if style.is_a("IfcSurfaceStyle"):
+            external = next((s for s in style.Styles if s.is_a("IfcExternallyDefinedSurfaceStyle")), None)
+
+        if (
+            external
+            and external.Location
+            and external.Location.endswith(".blend")
+            and external.Identification
+            and "/" in external.Identification
+        ):
+            location = Path(external.Location)
+            if not location.is_absolute():
+                # Relative locations are relative to the linked IFC, not the host.
+                location = Path(self.filepath).parent / location
+            data_block_type, data_block = external.Identification.split("/", 1)
+            key = (str(location), data_block_type, data_block)
+            if key in self.appended_external_blocks:
+                material = self.appended_external_blocks[key]
+            elif not location.exists():
+                print(f"WARNING. External style file not found for {style}: '{location}'")
+                self.appended_external_blocks[key] = None
+            else:
+                db = tool.Blender.append_data_block(str(location), data_block_type, data_block)
+                material = db["data_block"]
+                if not isinstance(material, bpy.types.Material):
+                    print(f"WARNING. Failed to load external style for {style}: {db['msg'] or 'not a material'}")
+                    material = None
+                else:
+                    # The source .blend may have been authored in a Bonsai session -
+                    # unlink any stale IFC id so it's not misinterpreted here or in the host.
+                    tool.Style.get_material_style_props(material).ifc_definition_id = 0
+                self.appended_external_blocks[key] = material
+
+        self.external_style_mats[style_id] = material
+        return material
+
+    def is_multilayer_element(self, element: ifcopenshell.entity_instance) -> bool:
+        material = ifcopenshell.util.element.get_material(element)
+        return bool(
+            material and material.is_a("IfcMaterialLayerSetUsage") and len(material.ForLayerSet.MaterialLayers) > 1
+        )
+
+    def get_style_material(self, style: ifcopenshell.entity_instance) -> Union[bpy.types.Material, None]:
+        """Resolve a style to a Blender material for slice_layerset_mesh.
+
+        Prefers the style's external .blend material, falling back to a flat
+        diffuse material as used for the rest of the linked geometry.
+        """
+        if material := self.get_external_material(style.id()):
+            return material
+        # IfcSurfaceStyleRendering is a subclass of IfcSurfaceStyleShading.
+        shading = next((s for s in style.Styles if s.is_a("IfcSurfaceStyleShading")), None)
+        if shading:
+            colour = shading.SurfaceColour
+            alpha = 1.0 - (getattr(shading, "Transparency", None) or 0.0)
+            diffuse = (colour.Red, colour.Green, colour.Blue, alpha)
+        else:
+            diffuse = (0.8, 0.8, 0.8, 1.0)
+        material_name = f"{diffuse[0]}-{diffuse[1]}-{diffuse[2]}-{diffuse[3]}"
+        material = self.blender_mats.get(material_name, None)
+        if not material:
+            material = bpy.data.materials.new(material_name)
+            material.diffuse_color = diffuse
+            self.blender_mats[material_name] = material
+        return material
+
     def create_object(
         self,
         verts: np.ndarray,
@@ -2412,7 +2752,7 @@ class QueryLinkedElement(bpy.types.Operator):
 
         guid = tool.Project.Link.get_guid_by_face_index(obj, face_index)
         assert guid is not None
-        tool.Project.Link.select_linked_element(context, obj, guid)
+        tool.Project.Link.select_linked_element(context, obj, guid, instance_matrix)
 
         self.report({"INFO"}, f"Loaded data for {guid}")
         ProjectDecorator.install(bpy.context)
@@ -2537,6 +2877,27 @@ class AppendInspectedLinkedElement(AppendLibraryElement):
         if element_type and tool.Ifc.get_object(element_type) is None:
             self.import_type_from_ifc(element_type, context)
 
+        # If the link was moved, place the appended element where the link
+        # is displayed rather than at its original coordinates.
+        obj = tool.Ifc.get_object(element)
+        if isinstance(obj, bpy.types.Object):
+            # Prefer matching the link by the queried instance's root empty -
+            # the same file may be linked several times (different queries)
+            # and moved to different locations.
+            root = props.queried_obj_root
+            linked_filepath = Path(queried_obj["ifc_filepath"])
+            link_match = None
+            for link in props.links:
+                if root is not None and tool.Project.get_link_empty_handle(link) == root:
+                    link_match = link
+                    break
+                if link_match is None and Path(tool.Ifc.resolve_uri(link.filepath)) == linked_filepath:
+                    link_match = link
+            if link_match:
+                delta = tool.Project.calculate_link_delta_matrix(link_match)
+                if not delta.is_identity:
+                    obj.matrix_world = delta @ obj.matrix_world
+
         return {"FINISHED"}
 
 
@@ -3421,3 +3782,149 @@ 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,7 +98,8 @@ 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)
-        self.parent_library = str(tool.Project.get_parent_library(project_library).id())
+        if parent_library := tool.Project.get_parent_library(project_library):
+            self.parent_library = str(parent_library.id())
         ProjectLibraryData.load()  # Show edit icon in enum.
         return
 
@@ -259,6 +260,24 @@ 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="Include",
+        description="Selector query for the elements to load from the linked model",
+        default="",
+    )
+    exclude: StringProperty(
+        name="Exclude",
+        description="Selector query whose matches are excluded when loading the linked model",
+        default="",
+    )
+    display_name: StringProperty(
+        name="Name",
+        description=(
+            "Optional display name to tell links apart (e.g. when the same file "
+            "is linked several times). Shows the file path when empty"
+        ),
+        default="",
+    )
 
     if TYPE_CHECKING:
         name: str
@@ -274,6 +293,9 @@ class Link(PropertyGroup):
         include_in_drawings: bool
         empty_handle: Union[bpy.types.Object, None]
         ifc_definition_id: int
+        query: str
+        exclude: str
+        display_name: str
 
 
 class EditedObj(PropertyGroup):
@@ -295,6 +317,28 @@ 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)
@@ -360,6 +404,8 @@ 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,
@@ -525,6 +571,8 @@ 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/project/ui.py

@@ -492,17 +492,13 @@ class BIM_PT_links(Panel):
 
         row = self.layout.row(align=True)
         row.operator("bim.link_ifc")
+        row.operator("bim.reload_all_links", text="", icon="FILE_REFRESH")
         if self.props.links:
             if self.props.active_link:
                 row = self.layout.row(align=True)
                 row.alignment = "RIGHT"
                 index = self.props.active_link_index
                 if self.props.active_link.is_loaded:
-                    if self.props.active_link.is_editing:
-                        row.operator("bim.edit_link", text="", icon="CHECKMARK")
-                        row.operator("bim.disable_editing_link", text="", icon="CANCEL")
-                    else:
-                        row.operator("bim.enable_editing_link", text="", icon="GREASEPENCIL")
                     row.operator("bim.select_linked_model_element", icon="VIEWZOOM", text="")
                     row.operator("bim.select_link_handle", text="", icon="OBJECT_DATA").link_index = index
                     row.operator("bim.unload_link", text="", icon="UNLINKED").link_index = index
@@ -643,7 +639,12 @@ class BIM_UL_links(UIList):
             if item.has_transformation:
                 row.label(text="", icon="OBJECT_ORIGIN")
 
-            row.label(text=item.filepath)
+            # Double-click to rename; shows the file path while unset.
+            row.prop(item, "display_name", text="", emboss=False, placeholder=item.filepath)
+            if item.is_editing:
+                row.operator("bim.disable_editing_link", text="", icon="UNLOCKED", emboss=False).link_index = index
+            else:
+                row.operator("bim.enable_editing_link", text="", icon="LOCKED", emboss=False).link_index = index
             icon = "RESTRICT_SELECT_OFF" if item.is_selectable else "RESTRICT_SELECT_ON"
             row.operator("bim.toggle_link_selectability", text="", icon=icon, emboss=False).link_index = index
             icon = "CUBE" if item.is_wireframe else "MESH_CUBE"
@@ -655,7 +656,7 @@ class BIM_UL_links(UIList):
             op.link_index = index
             op.mode = "VISIBLE"
         else:
-            row.label(text=item.filepath)
+            row.prop(item, "display_name", text="", emboss=False, placeholder=item.filepath)
 
 
 class BIM_PT_purge(Panel):

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

@@ -18,43 +18,17 @@
 
 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:
-    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)
+class GridDecorator(tool.Blender.ViewportDecorator):
+    draw_methods = (
+        ("draw_text", "POST_PIXEL"),
+        ("draw", "POST_VIEW"),
+    )
 
     def draw_text(self, context):
         if not tool.Blender.is_addon_enabled():

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

@@ -31,11 +31,17 @@ import bonsai.tool as tool
 from bonsai.bim.module.structural.load_decoration_data import ShaderInfo
 
 
-class LoadsDecorator:
+class LoadsDecorator(tool.Blender.ViewportDecorator):
     """Decorator to show structural loads in 3D"""
 
-    is_installed = False
-    handlers = []
+    # 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"),
+    )
     decoration_data = None
     text_info = []
     shader_info = []
@@ -54,15 +60,6 @@ class LoadsDecorator:
         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
+                assert attributes is not None
                 color = attributes.add()
                 assert isinstance(color, ColourRgb)
                 color.name = attribute_name
@@ -782,34 +782,40 @@ 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
 
-        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)
+        try:
+            style_elements = tool.Style.get_style_elements(self.style)
 
-        if self.surface_style:
-            result = self.edit_existing_style()
-        else:
-            result = self.add_new_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)
 
-        if result:
-            return result
+            if self.surface_style:
+                result = self.edit_existing_style()
+            else:
+                result = self.add_new_style()
 
-        tool.Style.disable_editing()
-        core.load_styles(tool.Style, style_type=self.props.style_type)
+            if result:
+                return result
 
-        # 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
+            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
 
     def edit_existing_style(self) -> None:
         ifc_file = tool.Ifc.get()
@@ -1231,4 +1237,5 @@ 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,6 +185,13 @@ 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,8 +176,30 @@ 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="Supported reflectance methods are:")
-            self.layout.label(text="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",
+            )
 
         row = self.layout.row(align=True)
         row.label(text="Emissive" if self.props.reflectance_method == "FLAT" else "Diffuse")
@@ -232,6 +254,8 @@ 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)
@@ -244,6 +268,22 @@ 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")
@@ -252,10 +292,17 @@ 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,9 +15,10 @@
 #
 # 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
@@ -30,12 +31,6 @@ 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()
@@ -78,15 +73,9 @@ class SystemDecorator:
         batch.draw(shader)
 
     def draw_faces(self, bm, vertices_coords):
-        """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)
+        """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)
 
     def __call__(self, context, get_custom_bmesh=None, draw_faces=False, exit_edit_mode_callback=None):
         self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -133,13 +122,15 @@ class SystemDecorator:
         self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
         self.shader.bind()
 
-        self.draw_batch("LINES", all_vertices, transparent_color(unselected_elements_color), unselected_edges)
+        self.draw_batch(
+            "LINES", all_vertices, tool.Blender.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, transparent_color(unselected_elements_color, 0.5))
+        self.draw_batch("POINTS", unselected_vertices, tool.Blender.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,13 +317,23 @@ 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_name: bpy.props.StringProperty(name="Object 1")
-    obj2_name: bpy.props.StringProperty(name="Object 2")
+    obj1_guid: bpy.props.StringProperty(name="Object 1 GlobalId")
+    obj2_guid: bpy.props.StringProperty(name="Object 2 GlobalId")
 
     def _execute(self, context):
-        if self.obj1_name and self.obj2_name:
-            obj1 = bpy.data.objects.get(self.obj1_name)
-            obj2 = bpy.data.objects.get(self.obj2_name)
+        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"}
         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,10 +65,28 @@ 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
@@ -376,12 +394,22 @@ 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 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 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 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
+from bonsai.bim.module.model.opening import FilledOpeningGenerator, is_filling_supported
 
 
 class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
@@ -34,11 +34,21 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
     bl_label = "Apply Opening"
     bl_options = {"REGISTER", "UNDO"}
     bl_description = (
-        "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."
+        "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."
     )
 
+    # Toggled by ``invoke`` when the user holds SHIFT during a gizmo / hotkey
+    # click. The filling-opening generator gates its snap-to-wall-axis block
+    # on this flag. HIDDEN + SKIP_SAVE so the flag doesn't surface in the F6
+    # redo panel or persist into saved keymaps.
+    preserve_placement: bpy.props.BoolProperty(default=False, options={"HIDDEN", "SKIP_SAVE"})
+
     @classmethod
     def poll(cls, context):
         if len(context.selected_objects) < 2:
@@ -46,7 +56,17 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
             return False
         return True
 
+    def invoke(self, context, event):
+        self.preserve_placement = bool(event.shift)
+        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]
 
@@ -66,9 +86,20 @@ 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 element1.is_a("IfcWindow") or element1.is_a("IfcDoor"):  # Add a fill to an element.
+                    if is_filling_supported(element1):  # Add a fill to an element.
                         obj1, obj2 = obj2, obj1
-                    FilledOpeningGenerator().generate(obj2, obj1, target=obj2.matrix_world.translation)
+                    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,
+                        target=obj2.matrix_world.translation,
+                        preserve_placement=self.preserve_placement,
+                    )
                     continue
                 elif element1.is_a("IfcOpeningElement") or element2.is_a("IfcOpeningElement"):
                     if element1.is_a("IfcOpeningElement"):  # Reassign an opening to another element.
@@ -148,7 +179,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:
-                            bpy.ops.bim.update_representation(obj=voided_obj.name)
+                            tool.Geometry.update_host_representation(voided_obj)
 
                     if tool.Ifc.is_moved(voided_obj):
                         bonsai.core.geometry.edit_object_placement(
@@ -157,12 +188,7 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
 
                     representation = tool.Geometry.get_active_representation(voided_obj)
                     assert representation
-                    bonsai.core.geometry.switch_representation(
-                        tool.Ifc,
-                        tool.Geometry,
-                        obj=voided_obj,
-                        representation=representation,
-                    )
+                    tool.Geometry.recut_host(voided_obj, representation)
                 tool.Geometry.lock_scale(voided_obj)
 
             if not has_visible_openings:
@@ -200,12 +226,7 @@ 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
-                bonsai.core.geometry.switch_representation(
-                    tool.Ifc,
-                    tool.Geometry,
-                    obj=building_obj,
-                    representation=representation,
-                )
+                tool.Geometry.recut_host(building_obj, representation)
         tool.Geometry.unlock_scale_object_with_openings(obj)
         tool.Geometry.clear_cache(element)
         return {"FINISHED"}

src/bonsai/bonsai/bim/parametric_lifecycle.py

@@ -61,7 +61,7 @@ Pattern selection (which approach a new feature should adopt):
     The authoritative list of registered parametric types — and which use
     `build_edit_lifecycle` vs. standalone operators — lives in
     `tool/parametric.py`'s `EDIT_TYPES` and is enforced by the registry
-    contract tests in `test/bim/test_parametric_registry.py`.
+    contract tests.
 
 This module hosts operator-side mixins that import ``bonsai.tool`` freely.
 The lightweight parametric registry consumed at addon-enable time must stay
@@ -528,6 +528,51 @@ class PickTypeMixin(TypeAccessorBase):
         return {"FINISHED"}
 
 
+class IntegerInputDialogMixin:
+    """Operator mixin that mirrors a per-feature ``IntProperty`` on the
+    operator into a draft attribute on the active object's parametric props,
+    via Blender's ``invoke_props_dialog`` popup.
+
+    Subclasses declare:
+
+    - ``attr_name`` — name of the IntProperty on the subclass AND of the
+      attribute on the resolved props (same name on both sides).
+    - ``props_getter`` — ``staticmethod(tool.Model.get_<feature>_props)``.
+    - ``requires_editing`` — True iff the operator must no-op outside an
+      active edit lifecycle. Default False.
+    - ``value_min`` — minimum value to clamp to. Default 1."""
+
+    attr_name: ClassVar[str] = ""
+    props_getter: ClassVar[Callable[[bpy.types.Object], bpy.types.PropertyGroup]]
+    requires_editing: ClassVar[bool] = False
+    value_min: ClassVar[int] = 1
+
+    def _resolve_props(self, context: bpy.types.Context) -> bpy.types.PropertyGroup | None:
+        """Return the active object's parametric props if the operator is
+        allowed to fire, ``None`` otherwise (caller bails with ``CANCELLED``)."""
+        obj = context.active_object
+        if not obj:
+            return None
+        props = self.props_getter(obj)
+        if self.requires_editing and not props.is_editing:
+            return None
+        return props
+
+    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:  # noqa: ARG002
+        props = self._resolve_props(context)
+        if props is None:
+            return {"CANCELLED"}
+        setattr(self, self.attr_name, max(self.value_min, getattr(props, self.attr_name)))
+        return context.window_manager.invoke_props_dialog(self)
+
+    def execute(self, context: bpy.types.Context) -> set[str]:
+        props = self._resolve_props(context)
+        if props is None:
+            return {"CANCELLED"}
+        setattr(props, self.attr_name, max(self.value_min, getattr(self, self.attr_name)))
+        return {"FINISHED"}
+
+
 # --- Undo-resync registry ----------------------------------------------------
 #
 # Per-type regenerators called from ``resync_parametric_drafts_after_undo``

src/bonsai/bonsai/bim/ui.py

@@ -39,21 +39,10 @@ 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.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.model import prop as _model_prop
+from bonsai.bim.module.model import ui as _model_ui
 from bonsai.bim.module.pset.prop import IfcProperty
 from bonsai.bim.prop import Attribute
 
@@ -275,202 +264,32 @@ class BIM_UL_panel_visibilities(bpy.types.UIList):
         row.prop(item, "is_bookmarked", text="", icon="SOLO_ON" if item.is_bookmarked else "SOLO_OFF", emboss=False)
 
 
-class GizmoPreferencesDoor(bpy.types.PropertyGroup):
-    """Property group for door gizmo visibility settings."""
-
-    overall_height: BoolProperty(name="Overall Height", default=True)
-    overall_width: BoolProperty(name="Overall Width", default=True)
-    threshold_thickness: BoolProperty(name="Threshold Thickness", default=True)
-    threshold_depth: BoolProperty(name="Threshold Depth", default=True)
-    threshold_offset: BoolProperty(name="Threshold Offset", default=True)
-    lining_offset: BoolProperty(name="Lining Offset", default=True)
-    lining_depth: BoolProperty(name="Lining Depth", default=True)
-    lining_thickness: BoolProperty(name="Lining Thickness", default=True)
-    transom_offset: BoolProperty(name="Transom Offset", default=True)
-    transom_thickness: BoolProperty(name="Transom Thickness", default=True)
-    casing_thickness: BoolProperty(name="Casing Thickness", default=True)
-    casing_depth: BoolProperty(name="Casing Depth", default=True)
-    swing_arc: BoolProperty(name="Swing Arc", default=True, description="Show door swing direction arc")
-    flip_arc: BoolProperty(name="Flip Arc", default=True, description="Show flip door orientation arc")
-
-    if TYPE_CHECKING:
-        overall_height: bool
-        overall_width: bool
-        threshold_thickness: bool
-        threshold_depth: bool
-        threshold_offset: bool
-        lining_offset: bool
-        lining_depth: bool
-        lining_thickness: bool
-        transom_offset: bool
-        transom_thickness: bool
-        casing_thickness: bool
-        casing_depth: bool
-        swing_arc: bool
-        flip_arc: bool
-
-
-class GizmoPreferencesWindow(bpy.types.PropertyGroup):
-    """Property group for window gizmo visibility settings."""
-
-    overall_height: BoolProperty(name="Overall Height", default=True)
-    overall_width: BoolProperty(name="Overall Width", default=True)
-    lining_offset: BoolProperty(name="Lining Offset", default=True)
-    lining_depth: BoolProperty(name="Lining Depth", default=True)
-    lining_thickness: BoolProperty(name="Lining Thickness", default=True)
-    lining_to_panel_offset_x: BoolProperty(name="Lining to Panel Offset X", default=True)
-    lining_to_panel_offset_y: BoolProperty(name="Lining to Panel Offset Y", default=True)
-    frame_depth: BoolProperty(name="Frame Depth", default=True)
-    frame_thickness: BoolProperty(name="Frame Thickness", default=True)
-    mullion_thickness: BoolProperty(name="Mullion Thickness", default=True)
-    first_mullion_offset: BoolProperty(name="First Mullion Offset", default=True)
-    second_mullion_offset: BoolProperty(name="Second Mullion Offset", default=True)
-    transom_thickness: BoolProperty(name="Transom Thickness", default=True)
-    first_transom_offset: BoolProperty(name="First Transom Offset", default=True)
-    second_transom_offset: BoolProperty(name="Second Transom Offset", default=True)
-
-    if TYPE_CHECKING:
-        overall_height: bool
-        overall_width: bool
-        lining_offset: bool
-        lining_depth: bool
-        lining_thickness: bool
-        lining_to_panel_offset_x: bool
-        lining_to_panel_offset_y: bool
-        frame_depth: bool
-        frame_thickness: bool
-        mullion_thickness: bool
-        first_mullion_offset: bool
-        second_mullion_offset: bool
-        transom_thickness: bool
-        first_transom_offset: bool
-        second_transom_offset: bool
-
-
-class GizmoPreferencesStair(bpy.types.PropertyGroup):
-    """Property group for stair gizmo visibility settings."""
-
-    width: BoolProperty(name="Width", default=True)
-    height: BoolProperty(name="Height", default=True)
-    tread_run: BoolProperty(name="Tread Run", default=True)
-    tread_depth: BoolProperty(name="Tread Depth", default=True)
-    riser_height: BoolProperty(name="Riser Height", default=True)
-    nosing_length: BoolProperty(name="Nosing Length", default=True)
-    nosing_depth: BoolProperty(name="Nosing Depth", default=True)
-    total_length_target: BoolProperty(name="Total Length Target", default=True)
-    base_slab_depth: BoolProperty(name="Base Slab Depth", default=True)
-    top_slab_depth: BoolProperty(name="Top Slab Depth", default=True)
-    lock: BoolProperty(name="Total Length Lock", default=True)
-    plus: BoolProperty(name="Add Tread (+)", default=True)
-    minus: BoolProperty(name="Remove Tread (-)", default=True)
-    cycle: BoolProperty(name="Cycle Stair Type", default=True)
-
-    if TYPE_CHECKING:
-        width: bool
-        height: bool
-        tread_run: bool
-        tread_depth: bool
-        riser_height: bool
-        nosing_length: bool
-        nosing_depth: bool
-        total_length_target: bool
-        base_slab_depth: bool
-        top_slab_depth: bool
-        lock: bool
-        plus: bool
-        minus: bool
-        cycle: bool
-
-
-class GizmoPreferencesWall(bpy.types.PropertyGroup):
-    """Property group for wall gizmo visibility settings."""
-
-    length: BoolProperty(
-        name="Length",
-        default=True,
-        description="Show the length dimension gizmo along the wall axis.",
-    )
-    height: BoolProperty(
-        name="Height",
-        default=True,
-        description="Show the height dimension gizmo at the wall's start endpoint.",
-    )
-    height_end: BoolProperty(
-        name="Height (far end, walls > 5m)",
-        default=True,
-        description=(
-            "Show a second height gizmo at the wall's far end so long walls don't "
-            "require panning to reach the handle."
-        ),
-    )
-    x_angle: BoolProperty(
-        name="Slope",
-        default=True,
-        description="Show the slope gizmo at the wall top measuring horizontal displacement of the top face.",
-    )
-    cycle: BoolProperty(
-        name="Cycle Offset Baseline",
-        default=True,
-        description="Show the baseline-state icon (Exterior / Centreline / Interior) in the editing icon row.",
-    )
-    scissors: BoolProperty(
-        name="Split at cursor",
-        default=True,
-        description="Show the split icon at the 3D cursor when it lies within the wall's length range.",
-    )
-    extend: BoolProperty(
-        name="Extend length to cursor X",
-        default=True,
-        description="Show the extend-length icon at the 3D cursor's projected wall-axis X.",
-    )
-    extend_height: BoolProperty(
-        name="Extend height to cursor Z",
-        default=True,
-        description="Show the extend-height icon at the 3D cursor's Z, on the wall axis.",
-    )
-    rotate: BoolProperty(
-        name="Rotate 90°",
-        default=True,
-        description="Show the rotate-90 icon in the editing icon row (rotates the wall around its Z axis).",
-    )
-    toggle_openings: BoolProperty(
-        name="Toggle Openings",
-        default=True,
-        description="Show the toggle-openings icon next to the pen (toggles opening fill visibility in the viewport).",
-    )
-
-    if TYPE_CHECKING:
-        length: bool
-        height: bool
-        height_end: bool
-        x_angle: bool
-        cycle: bool
-        scissors: bool
-        extend: bool
-        extend_height: bool
-        rotate: bool
-        toggle_openings: bool
-
-
 class GizmoPreferences(bpy.types.PropertyGroup):
-    """Property group for all gizmo visibility settings."""
+    """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."""
 
     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: bpy.props.PointerProperty(type=GizmoPreferencesDoor)
-    window: bpy.props.PointerProperty(type=GizmoPreferencesWindow)
-    stair: bpy.props.PointerProperty(type=GizmoPreferencesStair)
-    wall: bpy.props.PointerProperty(type=GizmoPreferencesWall)
 
     if TYPE_CHECKING:
         draw_gizmos_in_3d_viewport: bool
-        door: GizmoPreferencesDoor
-        window: GizmoPreferencesWindow
-        stair: GizmoPreferencesStair
-        wall: GizmoPreferencesWall
+
+
+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
 
 
 class DocPreferences(bpy.types.PropertyGroup):
@@ -566,11 +385,22 @@ class DocPreferences(bpy.types.PropertyGroup):
 
 
 class DefaultParameters(bpy.types.PropertyGroup):
-    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)
+    """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
 
 
 class BIM_ADDON_preferences(bpy.types.AddonPreferences):
@@ -682,6 +512,15 @@ 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",
@@ -918,61 +757,13 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
             )
 
     def draw_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        """Render one enabled-toggle per parametric feature."""
         layout.label(text="Toggle visibility of gizmos in editing mode")
         box = layout.box()
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Door", self.draw_door_gizmo_parameters)
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Window", self.draw_window_gizmo_parameters)
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Stair", self.draw_stair_gizmo_parameters)
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Wall", self.draw_wall_gizmo_parameters)
-
-    def _draw_parametric_gizmo_parameters(
-        self,
-        layout: bpy.types.UILayout,
-        gizmo_pg: bpy.types.PropertyGroup,
-        dimension_gizmo_class: type,
-        special_gizmo_names: frozenset[str] = frozenset(),
-    ) -> None:
-        """Draw the per-element gizmo visibility toggles. Surfaces every annotation
-        on ``gizmo_pg`` that either maps to one of ``dimension_gizmo_class``'s
-        dimension gizmos or is named in ``special_gizmo_names`` (non-dimension icons
-        like baseline cycle, scissors, rotate, …)."""
-        visible_names = {p.attr_name for p in dimension_gizmo_class.dimension_gizmo_props} | special_gizmo_names
-        try:
-            annotations = gizmo_pg.__annotations__
-        except AttributeError:
-            annotations = type(gizmo_pg).__annotations__
-        for prop in annotations:
-            if prop in visible_names:
-                layout.prop(gizmo_pg, prop)
-
-    def draw_door_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.door import GizmoDoorEdition
-
-        self._draw_parametric_gizmo_parameters(
-            layout, self.gizmos.door, GizmoDoorEdition, frozenset({"swing_arc", "flip_arc"})
-        )
-
-    def draw_window_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.window import GizmoWindowEdition
-
-        self._draw_parametric_gizmo_parameters(layout, self.gizmos.window, GizmoWindowEdition)
-
-    def draw_stair_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.stair import GizmoStairEdition
-
-        self._draw_parametric_gizmo_parameters(
-            layout, self.gizmos.stair, GizmoStairEdition, frozenset({"lock", "plus", "minus", "cycle"})
-        )
-
-    def draw_wall_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.wall import GizmoWallEdition
-
-        self._draw_parametric_gizmo_parameters(
-            layout,
-            self.gizmos.wall,
-            GizmoWallEdition,
-            frozenset({"cycle", "scissors", "extend", "extend_height", "rotate", "toggle_openings"}),
-        )
+        annotations = type(self.gizmos).__annotations__
+        for feature in tool.Parametric.EDIT_TYPES:
+            if feature.name in annotations:
+                box.prop(self.gizmos, feature.name)
 
     def draw_model_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "occurrence_name_style")
@@ -1019,39 +810,29 @@ 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()
-        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),
-        )
+        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),
+            )
 
     def draw_other_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "opening_focus_opacity")
@@ -1169,6 +950,50 @@ 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"):
@@ -2120,6 +1945,7 @@ 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()
@@ -2137,10 +1963,20 @@ 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

@@ -0,0 +1,113 @@
+# 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,9 +302,23 @@ 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":
@@ -335,7 +349,22 @@ def add_drawing(
         },
     )
     drawing.setup_shading_styles_path(shading_styles_path)
-    information = ifc.run("document.add_information")
+
+    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)
     uri = drawing.get_default_drawing_path(drawing_name)
     reference = ifc.run("document.add_reference", information=information)
     if ifc.get_schema() == "IFC2X3":
@@ -363,9 +392,21 @@ 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]
@@ -381,7 +422,21 @@ def duplicate_drawing(
     old_reference = drawing_tool.get_drawing_document(new_drawing)
     ifc.run("document.unassign_document", products=[new_drawing], document=old_reference)
 
-    information = ifc.run("document.add_information")
+    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)
     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,12 +167,22 @@ 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."""
+    """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.
+    """
     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)
@@ -185,8 +195,9 @@ def regenerate_wall_to_underside(
             if clip:
                 model.clip_wall_to_slab(wall, clip)
         clipped_objs.append(obj)
-    if clipped_objs:
-        model.reload_body_representation(clipped_objs)
+    refresh_objs = clipped_objs + reverted_objs
+    if refresh_objs:
+        model.reload_body_representation(refresh_objs)
 
 
 def extend_wall_to_slab(

src/bonsai/bonsai/core/root.py

@@ -20,8 +20,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional
 
-import ifcopenshell.util.element
-
 if TYPE_CHECKING:
     import bpy
     import ifcopenshell
@@ -58,31 +56,12 @@ def copy_class(
             geometry.change_object_data(obj, data, is_global=True)
             geometry.rename_object(data, geometry.get_representation_name(ifc.get_entity(data)))
         # Only assign styles if element doesn't get them from material
-        if not _has_material_styles(ifc, new):
+        if not root.has_material_styles(new):
             root.assign_body_styles(new, obj)
     collector.assign(obj)
     return new
 
 
-def _has_material_styles(ifc: type[tool.Ifc], element: ifcopenshell.entity_instance) -> bool:
-    """Check if element has styles defined through its material.
-
-    Returns True if any constituent material has a style representation,
-    which means styles should NOT be applied directly to the geometry.
-    """
-    materials = ifcopenshell.util.element.get_materials(element)
-
-    if not materials:
-        return False
-
-    # Check if any of the constituent materials have styles
-    for material in materials:
-        if hasattr(material, "HasRepresentation") and material.HasRepresentation:
-            return True
-
-    return False
-
-
 def assign_class(
     ifc: type[tool.Ifc],
     collector: type[tool.Collector],

src/bonsai/bonsai/core/spatial.py

@@ -64,7 +64,7 @@ def assign_container(
         spatial.disable_editing(obj)
         all_elements.add(root_element)
         all_elements.update(spatial.get_decomposition(root_element))
-    if products := [e for e in root_elements if spatial.can_contain(container, root_element)]:
+    if products := [e for e in root_elements if spatial.can_contain(container, e)]:
         ifc.run("spatial.assign_container", products=products, relating_structure=container)
     for element in all_elements:
         if obj := ifc.get_object(element):

src/bonsai/bonsai/core/tool.py

@@ -195,6 +195,14 @@ 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
@@ -459,7 +467,6 @@ class Geometry:
     def has_axis_representation(cls, element): pass
     def has_data_users(cls, data): pass
     def has_material_style_override(cls, obj): pass
-    def has_material_styles(cls, element): pass
     def import_representation_parameters(cls, data): pass
     def is_body_representation(cls, representation): pass
     def is_box_representation(cls, representation): pass
@@ -695,11 +702,13 @@ 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
 
 
@@ -796,7 +805,7 @@ class Profile:
 @interface
 class Parametric:
     def get_geom_generation(cls) -> int: pass
-    def refresh_post_commit(cls) -> None: pass
+    def refresh_post_commit(cls, operator) -> None: pass
 
 
 @interface
@@ -888,6 +897,7 @@ class Root:
     def get_object_name(cls, obj): pass
     def get_object_representation(cls, obj): pass
     def get_representation_context(cls, representation): pass
+    def has_material_styles(cls, element): pass
     def is_containable(cls, element): pass
     def is_drawing_annotation(cls, element): pass
     def is_element_a(cls, element, ifc_class): pass
@@ -1198,6 +1208,7 @@ 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,7 +30,9 @@ 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,6 +178,25 @@ 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,6 +22,7 @@ from __future__ import annotations
 
 import contextlib
 import importlib
+import math
 import os
 import platform
 import subprocess
@@ -29,7 +30,15 @@ import sys
 import tempfile
 import traceback
 import types
-from collections.abc import Callable, Generator, Iterable, Mapping, Sequence, Sized
+from collections.abc import (
+    Callable,
+    Generator,
+    Iterable,
+    Iterator,
+    Mapping,
+    Sequence,
+    Sized,
+)
 from datetime import datetime
 from functools import cache, lru_cache
 from pathlib import Path
@@ -46,9 +55,11 @@ 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
 
@@ -229,15 +240,22 @@ class Blender(bonsai.core.tool.Blender):
 
     @classmethod
     def get_active_object(cls, is_selected: bool = False) -> Union[bpy.types.Object, None]:
-        """Gets the active object
+        """Return the active object, or ``None`` when the current context
+        exposes neither ``active_object`` nor a ``view_layer`` (stripped
+        operator contexts).
 
         :param is_selected: If true, the active object also needs to be selected.
         """
-        if obj := (getattr(bpy.context, "active_object", None) or bpy.context.view_layer.objects.active):
-            if not is_selected:
-                return obj
-            if obj.select_get():
-                return obj
+        obj = getattr(bpy.context, "active_object", None)
+        if obj is None:
+            view_layer = getattr(bpy.context, "view_layer", None)
+            if view_layer is not None:
+                obj = view_layer.objects.active
+        if obj is None:
+            return None
+        if is_selected and not obj.select_get():
+            return None
+        return obj
 
     @classmethod
     def get_selected_objects(cls, include_active: bool = True) -> set[bpy.types.Object]:
@@ -520,6 +538,19 @@ 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
@@ -567,6 +598,120 @@ 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.
@@ -880,19 +1025,57 @@ class Blender(bonsai.core.tool.Blender):
         #     ( 1.0,  1.0, -1.0),        # 7
         # ]
         bound_box = obj.bound_box
+        min_pt = Vector(bound_box[0])
+        max_pt = Vector(bound_box[6])
         bbox_dict = {
-            "min_x": bound_box[0][0],
-            "max_x": bound_box[6][0],
-            "min_y": bound_box[0][1],
-            "max_y": bound_box[6][1],
-            "min_z": bound_box[0][2],
-            "max_z": bound_box[6][2],
-            "min_point": Vector(bound_box[0]),
-            "max_point": Vector(bound_box[6]),
-            "center": (Vector(bound_box[6]) + Vector(bound_box[0])) / 2,
+            "min_x": min_pt.x,
+            "max_x": max_pt.x,
+            "min_y": min_pt.y,
+            "max_y": max_pt.y,
+            "min_z": min_pt.z,
+            "max_z": max_pt.z,
+            "min_point": min_pt,
+            "max_point": max_pt,
+            "center": (max_pt + min_pt) / 2,
+            # Intrinsic per-axis size in object-local space. Distinct from
+            # ``obj.dimensions``, which folds object-level scale into its
+            # output; this is the raw mesh bbox extent.
+            "dimensions": (max_pt.x - min_pt.x, max_pt.y - min_pt.y, max_pt.z - min_pt.z),
         }
         return bbox_dict
 
+    @classmethod
+    def get_object_world_bounding_box(cls, obj: bpy.types.Object) -> dict[str, Union[float, Vector]]:
+        """Same shape as ``get_object_bounding_box`` but with ``matrix_world``
+        applied — extents are computed across the 8 transformed corners, so
+        a rotated or scaled object reports its actual world-axis AABB rather
+        than the misleading transform of the local-space corners.
+
+        ``bound_box[0]`` / ``bound_box[6]`` are the local min/max corners but
+        do NOT correspond to the world AABB extremes once the object is
+        rotated, so min/max must be taken per-axis across all 8 corners."""
+        corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
+        xs = [c.x for c in corners]
+        ys = [c.y for c in corners]
+        zs = [c.z for c in corners]
+        min_point = Vector((min(xs), min(ys), min(zs)))
+        max_point = Vector((max(xs), max(ys), max(zs)))
+        return {
+            "min_x": min_point.x,
+            "max_x": max_point.x,
+            "min_y": min_point.y,
+            "max_y": max_point.y,
+            "min_z": min_point.z,
+            "max_z": max_point.z,
+            "min_point": min_point,
+            "max_point": max_point,
+            "center": (min_point + max_point) / 2,
+            # World-axis-aligned per-axis size. For rotated objects this is
+            # the AABB extent, not the intrinsic mesh size (use the local
+            # variant for that).
+            "dimensions": (max_point.x - min_point.x, max_point.y - min_point.y, max_point.z - min_point.z),
+        }
+
     @classmethod
     def select_and_activate_single_object(cls, context: bpy.types.Context, active_object: bpy.types.Object) -> None:
         for obj in context.selected_objects:
@@ -1228,7 +1411,10 @@ class Blender(bonsai.core.tool.Blender):
 
     @classmethod
     def get_object_from_guid(cls, guid: str) -> Union[bpy.types.Object, None]:
-        element = tool.Ifc.get().by_guid(guid)
+        try:
+            element = tool.Ifc.get().by_guid(guid)
+        except RuntimeError:
+            return None
         obj = tool.Ifc.get_object(element)
         if obj:
             return obj
@@ -1332,74 +1518,6 @@ class Blender(bonsai.core.tool.Blender):
         return True
 
     class Modifier:
-        # ----------------------------------------------------------------------
-        # FIXME(PR5): backward-compat shims for callers still using the
-        # pre-refactor API. The is_<type> predicates now live on tool.Parametric;
-        # the Array helper bag now lives on tool.Array. PR4 migrates each caller;
-        # this whole shim block is removed in PR5's cleanup.
-        # ----------------------------------------------------------------------
-
-        @classmethod
-        def is_door(cls, element: entity_instance) -> bool:
-            return tool.Parametric.is_door(element)
-
-        @classmethod
-        def is_railing(cls, element: entity_instance) -> bool:
-            return tool.Parametric.is_railing(element)
-
-        @classmethod
-        def is_roof(cls, element: entity_instance) -> bool:
-            return tool.Parametric.is_roof(element)
-
-        @classmethod
-        def is_stair(cls, element: entity_instance) -> bool:
-            return tool.Parametric.is_stair(element)
-
-        @classmethod
-        def is_wall(cls, element: entity_instance) -> bool:
-            return tool.Parametric.is_wall(element)
-
-        @classmethod
-        def is_window(cls, element: entity_instance) -> bool:
-            return tool.Parametric.is_window(element)
-
-        class Array:
-            @classmethod
-            def bake_children_transform(cls, parent_element: ifcopenshell.entity_instance, item: int) -> None:
-                tool.Array.bake_children_transform(parent_element, item)
-
-            @classmethod
-            def constrain_children_to_parent(cls, parent_element: ifcopenshell.entity_instance) -> None:
-                tool.Array.constrain_children_to_parent(parent_element)
-
-            @classmethod
-            def get_all_children_objects(cls, parent_element: ifcopenshell.entity_instance) -> list:
-                return tool.Array.get_all_children_objects(parent_element)
-
-            @classmethod
-            def get_all_objects(cls, parent_element: ifcopenshell.entity_instance) -> list:
-                return tool.Array.get_all_objects(parent_element)
-
-            @classmethod
-            def get_children_objects(cls, modifier_data: dict) -> list:
-                return tool.Array.get_children_objects(modifier_data)
-
-            @classmethod
-            def get_modifiers_data(cls, parent_element: ifcopenshell.entity_instance):
-                return tool.Array.get_modifiers_data(parent_element)
-
-            @classmethod
-            def remove_constraints(cls, parent_element: ifcopenshell.entity_instance) -> None:
-                tool.Array.remove_constraints(parent_element)
-
-            @classmethod
-            def set_children_lock_state(
-                cls, parent_element: ifcopenshell.entity_instance, item: int, lock: bool
-            ) -> None:
-                tool.Array.set_children_lock_state(parent_element, item, lock)
-
-        # ----------------------------------------------------------------------
-
         @classmethod
         def try_applying_edit_mode(cls, obj: bpy.types.Object, element: entity_instance) -> bool:
             """Tries to validate the current BIM modifier parameters for the active object
@@ -1419,6 +1537,10 @@ 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
@@ -1481,6 +1603,38 @@ 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
@@ -2018,6 +2172,18 @@ class Blender(bonsai.core.tool.Blender):
         dct = {cls.bl_idname: cls.ifc_element_type for cls in (BimTool.__subclasses__())}
         return types.MappingProxyType(dct)
 
+    @classmethod
+    @lru_cache
+    def get_property_header_tools(cls) -> frozenset[str]:
+        """``BimTool`` plus its parametric subclasses — the workspace
+        tools whose 3D-view / N-panel header surfaces BIM Tool property
+        floats (extrusion_depth, length, x_angle). ``AnnotationTool``
+        and the non-``BimTool`` workspace tools (spatial / structural /
+        cad / covering) are excluded by construction."""
+        from bonsai.bim.module.model.workspace import BimTool
+
+        return frozenset(cls.bl_idname for cls in (BimTool.__subclasses__() + [BimTool]))
+
     @classmethod
     def get_object_constraint_props(cls, obj: bpy.types.Object) -> BIMObjectConstraintProperties:
         return obj.BIMObjectConstraintProperties  # pyright: ignore[reportAttributeAccessIssue]
@@ -2238,6 +2404,149 @@ 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.
@@ -2388,7 +2697,7 @@ class Blender(bonsai.core.tool.Blender):
 
         See https://projects.blender.org/blender/blender/issues/149283
         """
-        if len(bytedata) == (n * 2):
+        if len(bytedata) == (n * 8):  # float64 has 8 bytes per element
             return np.frombuffer(bytedata, dtype=np.float64).astype(np.float32)
         return np.frombuffer(bytedata, dtype=np.float32)
 

src/bonsai/bonsai/tool/cad.py

@@ -177,6 +177,14 @@ 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"""
@@ -198,6 +206,237 @@ 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

@@ -0,0 +1,168 @@
+# 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,6 +78,7 @@ 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")
@@ -453,6 +454,41 @@ 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
@@ -1009,6 +1045,8 @@ 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:
@@ -1044,6 +1082,10 @@ 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
 
@@ -2267,14 +2309,19 @@ 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"""
-        if ifc_file is None:
+        param_was_none = ifc_file is None
+        if param_was_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)
@@ -2286,7 +2333,16 @@ 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:
@@ -2384,13 +2440,13 @@ class Drawing(bonsai.core.tool.Drawing):
     @classmethod
     def is_drawing_active(cls) -> bool:
         camera = bpy.context.scene.camera
-        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
-        )
+        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
 
     @classmethod
     def is_camera_orthographic(cls) -> bool:
@@ -2521,10 +2577,19 @@ 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:
+                if element in filtered_elements or obj in linked_handles:
                     visible_objects.append(obj)
             else:
                 if obj.hide_get() is False:

src/bonsai/bonsai/tool/duplicate.py

@@ -248,32 +248,30 @@ class Duplicate(bonsai.core.tool.Duplicate):
         old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
     ) -> None:
         for element, data in relationship.items():
-            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,
-            )
+            new_relating_elements = old_to_new.get(data.relating_element) or []
+            new_related_elements = old_to_new.get(data.related_element) or []
             # 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
-            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}"
-                    )
+            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}"
+                        )
 
     @classmethod
     def recreate_port_connections(
@@ -283,46 +281,43 @@ 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
-                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
+                new_relateds = old_to_new.get(related_element) or []
                 expected_related = snapshot.port_counts.get(related_element)
-                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
+                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)
 
-                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}")
+                    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}")

src/bonsai/bonsai/tool/geometry.py

@@ -24,6 +24,7 @@ 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,
@@ -65,6 +66,7 @@ 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
@@ -129,6 +131,85 @@ 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
@@ -156,6 +237,112 @@ 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.
@@ -271,12 +458,38 @@ class Geometry(bonsai.core.tool.Geometry):
         bpy.data.objects.remove(obj)
 
     @classmethod
-    def delete_ifc_object(cls, obj: bpy.types.Object) -> None:
+    def delete_ifc_object(
+        cls,
+        obj: bpy.types.Object,
+        batch_being_deleted_ids: Optional[set[int]] = None,
+    ) -> None:
         ifc_file = tool.Ifc.get()
         element = tool.Ifc.get_entity(obj)
         if not element:
             return
-        elif element.is_a("IfcAnnotation"):
+        # 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"):
             if element.ObjectType == "DRAWING":
                 return bonsai.core.drawing.remove_drawing(tool.Ifc, tool.Drawing, drawing=element)
             elif tool.Drawing.is_auto_annotation(element):
@@ -641,7 +854,13 @@ 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)
         ):
-            return tool.Ifc.get().by_id(ifc_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
 
     @classmethod
     def get_data_representation(cls, data: bpy.types.ID) -> ifcopenshell.entity_instance | None:
@@ -849,15 +1068,6 @@ class Geometry(bonsai.core.tool.Geometry):
                 return True
         return False
 
-    @classmethod
-    def has_material_styles(cls, element: ifcopenshell.entity_instance) -> bool:
-        """True when any of ``element``'s materials exposes an
-        ``IfcSurfaceStyle``. Gate body-style assignment to avoid double-styling."""
-        return any(
-            tool.Material.get_style(material) is not None
-            for material in ifcopenshell.util.element.get_materials(element)
-        )
-
     @classmethod
     def reimport_element_representations(
         cls, obj: bpy.types.Object, representation: ifcopenshell.entity_instance, apply_openings: bool = True
@@ -2279,84 +2489,16 @@ class Geometry(bonsai.core.tool.Geometry):
         old_obj_name_to_new_obj_name: dict[str, str] = {}
 
         for obj in objects_to_duplicate:
-            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)
+            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
 
         # Remap Blender parent relationships for duplicated objects
         for old_obj_name, new_obj_name in old_obj_name_to_new_obj_name.items():
@@ -2384,10 +2526,211 @@ 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()
@@ -2439,7 +2782,10 @@ class Geometry(bonsai.core.tool.Geometry):
             pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
             if not pset:
                 continue
-            array_parents.add(tool.Ifc.get().by_guid(pset["Parent"]))
+            try:
+                array_parents.add(tool.Ifc.get().by_guid(pset["Parent"]))
+            except RuntimeError:
+                continue
 
         for array_parent in array_parents:
             array_parent_obj = tool.Ifc.get_object(array_parent)

src/bonsai/bonsai/tool/loader.py

@@ -23,7 +23,7 @@ import os
 import re
 from math import atan, radians
 from pathlib import Path
-from typing import Any, Optional, Union, cast
+from typing import Any, Callable, Optional, Union, cast
 
 import bmesh
 import bpy
@@ -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 "Generated"
+        surface_texture["uv_mode"] = uv_mode or "UV"
         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)
+                    return bpy.data.images.load(image_url, check_existing=True)
 
                 elif texture["type"] == "IfcBlobTexture":
                     # https://blender.stackexchange.com/questions/173206/how-to-efficiently-convert-a-pil-image-to-bpy-types-image
@@ -472,12 +472,23 @@ 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
 
-                # 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)
+                # 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)
 
                 node = blender_material.node_tree.nodes.new(type="ShaderNodeTexImage")
                 node.location = bsdf.location - Vector((200, 250))
@@ -1062,7 +1073,19 @@ class Loader(bonsai.core.tool.Loader):
         return mesh
 
     @classmethod
-    def slice_layerset_mesh(cls, element: ifcopenshell.entity_instance, mesh: bpy.types.Mesh) -> bpy.types.Mesh:
+    def slice_layerset_mesh(
+        cls,
+        element: ifcopenshell.entity_instance,
+        mesh: bpy.types.Mesh,
+        style_to_material: Optional[Callable[[ifcopenshell.entity_instance], Union[bpy.types.Material, None]]] = None,
+    ) -> bpy.types.Mesh:
+        """Bisect a layerset element's mesh at layer boundaries and assign each layer its material style.
+
+        :param style_to_material: Callback resolving an IfcSurfaceStyle to a Blender material.
+            Defaults to the IFC-linked material, which only works for the actively edited project.
+        """
+        if style_to_material is None:
+            style_to_material = tool.Ifc.get_object
         if not (material := ifcopenshell.util.element.get_material(element)):
             return mesh
         elif material.is_a("IfcMaterialLayerSetUsage"):
@@ -1110,7 +1133,8 @@ class Loader(bonsai.core.tool.Loader):
                 continue
             if (material_index := styles.get(style, None)) is None:
                 material_index = len(mesh.materials)
-                mesh.materials.append(tool.Ifc.get_object(style))
+                mesh.materials.append(style_to_material(style))
+                styles[style] = material_index
             if i == last_i:
                 for face in bisect_geom["geom"]:
                     if isinstance(face, bmesh.types.BMFace):
@@ -1216,7 +1240,7 @@ class Loader(bonsai.core.tool.Loader):
     ) -> bool:
         items = [i["item"] for i in ifcopenshell.util.representation.resolve_items(representation)]
         if len(items) == 1 and items[0].is_a("IfcSweptDiskSolid"):
-            if tool.Blender.Modifier.is_railing(element):
+            if tool.Parametric.is_railing(element):
                 return False
             return True
         elif len(items) and (  # See #2508 why we accommodate for invalid IFCs here
@@ -1224,7 +1248,7 @@ class Loader(bonsai.core.tool.Loader):
             and len({i.is_a() for i in items}) == 1
             and len({i.Radius for i in items}) == 1
         ):
-            if tool.Blender.Modifier.is_railing(element):
+            if tool.Parametric.is_railing(element):
                 return False
             return True
         return False

src/bonsai/bonsai/tool/misc.py

@@ -227,10 +227,8 @@ class Misc(bonsai.core.tool.Misc):
 
     @classmethod
     def set_object_origin_to_bottom(cls, obj: bpy.types.Object) -> None:
-        absolute_bound_box = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
-        min_z = min([c[2] for c in absolute_bound_box])
         new_origin = obj.matrix_world.translation.copy()
-        new_origin[2] = min_z
+        new_origin[2] = tool.Blender.get_object_world_bounding_box(obj)["min_z"]
         assert isinstance(obj.data, bpy.types.Mesh)
         obj.data.transform(
             Matrix.Translation(
@@ -249,11 +247,8 @@ class Misc(bonsai.core.tool.Misc):
 
     @classmethod
     def scale_object_to_height(cls, obj: bpy.types.Object, height: float) -> None:
-        absolute_bound_box = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
-        max_z = max([c[2] for c in absolute_bound_box])
-        min_z = min([c[2] for c in absolute_bound_box])
-        current_absolute_height = max_z - min_z
-        scale_factor = height / current_absolute_height
+        bbox = tool.Blender.get_object_world_bounding_box(obj)
+        scale_factor = height / (bbox["max_z"] - bbox["min_z"])
         obj.matrix_world @= Matrix.Scale(
             scale_factor, 4, obj.matrix_world.inverted().to_quaternion() @ Vector((0, 0, 1))
         )

src/bonsai/bonsai/tool/model.py

@@ -75,11 +75,14 @@ if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import (
         BIMArrayProperties,
         BIMDoorProperties,
+        BIMDuctSegmentProperties,
         BIMExternalParametricGeometryProperties,
         BIMModelProperties,
+        BIMPipeSegmentProperties,
         BIMPolylineProperties,
         BIMRailingProperties,
         BIMRoofProperties,
+        BIMSlabProperties,
         BIMStairProperties,
         BIMSverchokProperties,
         BIMWallProperties,
@@ -116,6 +119,18 @@ 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]
@@ -362,6 +377,28 @@ 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]]
@@ -777,7 +814,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"] / unit_scale
+        thickness = layer_params["thickness"]
         props = tool.Material.get_object_material_props(obj)
 
         # Try to load from pset if not already in props
@@ -785,7 +822,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)
+                custom_offset = pset.get("CustomOffset", 0.0) * unit_scale
                 usage_type = tool.Model.get_usage_type(element)
 
                 if usage_type == "LAYER2":
@@ -798,7 +835,7 @@ class Model(bonsai.core.tool.Model):
                 return None
         else:
             # Use current props
-            custom_offset = props.custom_offset / unit_scale
+            custom_offset = props.custom_offset
             if tool.Model.get_usage_type(element) == "LAYER2":
                 custom_offset_reference = props.custom_wall_reference
             elif tool.Model.get_usage_type(element) == "LAYER3":
@@ -809,17 +846,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 * unit_scale
+            layer_offset = custom_offset - thickness
         if direction_sense == "POSITIVE" and custom_offset_reference in {"CENTER", "MIDDLE"}:
-            layer_offset = custom_offset - (thickness / 2) * unit_scale
+            layer_offset = custom_offset - (thickness / 2)
         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) * unit_scale
+            layer_offset = custom_offset + (thickness / 2)
         if direction_sense == "NEGATIVE" and custom_offset_reference in {"INTERIOR", "BOTTOM"}:
-            layer_offset = custom_offset + thickness * unit_scale
+            layer_offset = custom_offset + thickness
 
         return layer_offset / unit_scale
 
@@ -872,6 +909,46 @@ 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."""
@@ -1167,6 +1244,42 @@ 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"):
@@ -1178,6 +1291,7 @@ 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"])
@@ -1191,6 +1305,14 @@ 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
@@ -1208,8 +1330,13 @@ class Model(bonsai.core.tool.Model):
                         child_obj = tool.Ifc.get_object(child_element)
                         assert child_obj
                     except (IndexError, RuntimeError, AssertionError):
-                        old_to_new, _ = tool.Geometry.duplicate_ifc_objects([parent_obj])
-                        child_element = next(iter(old_to_new.values()))[0]
+                        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]
                         child_obj = tool.Ifc.get_object(child_element)
 
                     # add child pset
@@ -1243,7 +1370,10 @@ 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:
-                element = tool.Ifc.get().by_guid(removed_child)
+                try:
+                    element = tool.Ifc.get().by_guid(removed_child)
+                except RuntimeError:
+                    continue
                 # 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):
@@ -1274,14 +1404,7 @@ class Model(bonsai.core.tool.Model):
             tool.Ifc.get(), pset=pset, properties={"Data": json_data, "Parent": parent_element.GlobalId}
         )
 
-        # 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)
+        tool.Blender.set_object_selection(parent_obj, True)
 
     @classmethod
     def mirror_parent_void_fillings_to_children(
@@ -1362,9 +1485,7 @@ class Model(bonsai.core.tool.Model):
             representation = tool.Geometry.get_representation_by_context(voided_element, context)
             if representation is None:
                 continue
-            bonsai.core.geometry.switch_representation(
-                tool.Ifc, tool.Geometry, obj=voided_obj, representation=representation
-            )
+            tool.Geometry.recut_host(voided_obj, representation)
 
     @classmethod
     def unshare_opening_representation(cls, filling: ifcopenshell.entity_instance) -> None:
@@ -1556,8 +1677,7 @@ class Model(bonsai.core.tool.Model):
         element = tool.Ifc.get_entity(object)
         if not element:
             return
-        psets = ifcopenshell.util.element.get_psets(element)
-        pset_data = psets.get(pset_name, None)
+        pset_data = ifcopenshell.util.element.get_pset(element, pset_name)
         if not pset_data:
             return
         pset_data["data_dict"] = json.loads(pset_data.get("Data", "[]") or "[]")
@@ -1976,47 +2096,86 @@ class Model(bonsai.core.tool.Model):
         return (vertices, edges, faces)
 
     @classmethod
-    def update_simple_openings(cls, element: ifcopenshell.entity_instance) -> None:
+    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)."""
         from bonsai.bim.module.model.opening import FilledOpeningGenerator
 
-        ifc_file = tool.Ifc.get()
-        fillings = {e: tool.Ifc.get_object(e) for e in tool.Array.get_parametric_propagation_targets(element)}
+        if not filling.FillsVoids:
+            return None
 
-        voided_objs = set()
-        has_replaced_opening_representation = False
+        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
+
+        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()
         for filling in fillings:
             if not filling.FillsVoids:
                 continue
 
             opening = filling.FillsVoids[0].RelatingOpeningElement
             voided_obj = tool.Ifc.get_object(opening.VoidsElements[0].RelatingBuildingElement)
-            voided_objs.add(voided_obj)
+            if voided_obj is not None:
+                voided_objs.add(voided_obj)
 
-            # 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:
+            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())
 
-            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
-            )
+            cls.regenerate_filling_opening_body(filling)
 
-            new_representation = FilledOpeningGenerator().generate_opening_from_filling(
-                filling, fillings[filling], voided_obj.dimensions[1]
-            )
+        return voided_objs
 
-            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
+    @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)}
 
         tool.Model.reload_body_representation(voided_objs)
         if fillings:
@@ -2943,7 +3102,7 @@ class Model(bonsai.core.tool.Model):
     def offset_wall(cls, wall: bpy.types.Object, baseline: Literal["EXTERIOR", "INTERIOR", "CENTER"]) -> None:
         element = tool.Ifc.get_entity(wall)
         usage = ifcopenshell.util.element.get_material(element)
-        if not usage.is_a("IfcMaterialLayerSetUsage"):
+        if usage is None or not usage.is_a("IfcMaterialLayerSetUsage"):
             return
         layer_set = usage.ForLayerSet
         if baseline == "CENTER":
@@ -2979,6 +3138,9 @@ 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,
@@ -2993,6 +3155,19 @@ 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()
@@ -3008,6 +3183,26 @@ 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