Add import hashlib and formatted with black

Enables images for IfcImageTexture to be loaded from remote sources
2026-08-06 16:01:36 +00:00 · 2026-04-20 07:26:40 -07:00 · 2026-04-18 06:49:53 -07:00
691 changed files with 7663 additions and 62607 deletions
@@ -53,7 +53,7 @@ jobs:
          python ../nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
        with:
          key: mac-${{ matrix.arch }}

@@ -29,7 +29,7 @@ jobs:
          python ../IfcOpenShell/nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
        with:
          key: ubuntu-22.04-${{ runner.arch }}

@@ -10,7 +10,7 @@ jobs:

    steps:
      - name: Set up uv
-        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57 # v8.0.0

      - name: Install Python
        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
@@ -54,7 +54,7 @@ jobs:
          uv run ../nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
        with:
          key: ubuntu-22.04-${{ runner.arch }}-rockylinux9

@@ -10,7 +10,7 @@ jobs:

    steps:
      - name: Set up uv
-        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57 # v8.0.0

      - name: Install Python
        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
@@ -54,7 +54,7 @@ jobs:
          uv run ../nix/cache_dependencies.py unpack

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
        with:
          key: ubuntu-22.04-${{ runner.arch }}-rockylinux9

@@ -52,7 +52,7 @@ jobs:
          }

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
        with:
          key: win-${{ matrix.arch }}
          # Windows ccache needs ~1GB
@@ -109,7 +109,7 @@ jobs:
          # Ensure Bonsai and ifcsverchok enable/disable works before uploading to extensions repo.

          # Download Blender.
-          wget -q -O blender.tar.xz https://download.blender.org/release/Blender5.2/blender-5.2.0-linux-x64.tar.xz
+          wget -q -O blender.tar.xz https://download.blender.org/release/Blender5.1/blender-5.1.0-linux-x64.tar.xz
          tar -xf blender.tar.xz

          # Setup Blender.
@@ -179,7 +179,8 @@ jobs:
          blender --online-mode --command extension install --enable --sync sun_position

          cd IfcOpenShell/src/bonsai
-          pip install -r requirements-dev.txt
+          pip install pytest-blender
+          pip install pytest-bdd
          blender --background --python scripts/setup_pytest.py
          blender --python-expr "import bonsai; print(bonsai.bbim_semver); import ifcopenshell; print(ifcopenshell.version)" --background
          make test
@@ -35,7 +35,7 @@ jobs:

    -
      name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.23
+      uses: hendrikmuhs/ccache-action@v1.2.22

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

      # black doesn't catch all syntax errors, so we check them explicitly.
      - name: Check syntax errors
@@ -55,17 +58,11 @@ jobs:
          black --diff --check . | black-codeclimate | python .github/workflows/black_to_github_annotations.py
        continue-on-error: true

-      - name: ty check (venv setup)
-        run: poe ty-venv
-
-      - name: ty check (bonsai)
-        id: ty-bonsai
-        run: poe ty-bonsai
-        continue-on-error: true
-
-      - name: ty check (ios)
-        id: ty-ios
-        run: poe ty-ios
+      - name: ty check
+        id: ty
+        run: |
+          poe ty-venv
+          poe ty
        continue-on-error: true

      - name: Ruff check
@@ -115,10 +112,7 @@ jobs:
          if [ "${{ steps.ruff.outcome }}" != "success" ]; then
            echo "::error::Ruff check failed, see Summary or 'ruff' step for the details." && ERROR=1
          fi
-          if [ "${{ steps.ty-bonsai.outcome }}" != "success" ]; then
-            echo "::error::ty check (bonsai) failed, see 'ty check (bonsai)' step for the details." && ERROR=1
-          fi
-          if [ "${{ steps.ty-ios.outcome }}" != "success" ]; then
-            echo "::error::ty check (ios) failed, see 'ty check (ios)' step for the details." && ERROR=1
+          if [ "${{ steps.ty.outcome }}" != "success" ]; then
+            echo "::error::ty check failed, see 'ty check' step for the details." && ERROR=1
          fi
          exit $ERROR
@@ -10,13 +10,9 @@ on:
      - 'src/ifcgeomserver/**'
      - 'src/ifcjni/**'
      - 'src/ifcmax/**'
-      - 'src/ifc5d/**'
-      - 'src/ifcedit/**'
-      - 'src/ifcmcp/**'
      - 'src/ifcopenshell-python/**'
      - '!src/ifcopenshell-python/docs/**'
      - 'src/ifcparse/**'
-      - 'src/ifcquery/**'
      - 'src/ifcwrap/**'
      - 'src/qtviewer/**'
      - 'src/svgfill/**'
@@ -55,7 +51,7 @@ jobs:
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
-          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing psutil
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely
          pip install src/bcf --no-deps
          pip install pytest-xdist==3.8.0

@@ -83,7 +79,7 @@ jobs:
          libhdf5-dev libcgal-dev libeigen3-dev
          
      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
        with:
          key: ubuntu-22.04-${{ runner.arch }}

@@ -256,26 +252,13 @@ jobs:
          pip install deepdiff
          cd ../ifcdiff && make test || ERROR=1
          cd ../ifcpatch && make test || ERROR=1
-          pip install -e ../ifc5d --no-deps
-          pip install odfpy xlsxwriter
-          cd ../ifc5d && make test || ERROR=1
-          pip install -e ../ifcquery --no-deps
-          cd ../ifcquery && make test || ERROR=1
-          pip install -e ../ifcedit --no-deps
-          cd ../ifcedit && make test || ERROR=1
-          pip install mcp
-          pip install -e ../ifcmcp --no-deps
-          cd ../ifcmcp && make test || ERROR=1
          pip install -e ../ifctester --no-deps
          cd ../ifctester && make test || ERROR=1
          make build-ids-docs || ERROR=1
          # Run mathutils related tests at the end to ensure no other code is relying on mathutils.
-          # mathutils only has pre-built wheels for Python 3.13+; skip on older versions.
          cd ../ifcopenshell-python
-          if python -c "import sys; sys.exit(0 if sys.version_info >= (3, 13) else 1)"; then
-            pip install mathutils
-            make test-mathutils || ERROR=1
-          fi
+          pip install mathutils
+          make test-mathutils || ERROR=1
          if [ $ERROR -ne 0 ]; then
            echo "One or more tests failed";
            exit 1;
@@ -7,9 +7,9 @@ jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4

-      - uses: astral-sh/setup-uv@v7
+      - uses: astral-sh/setup-uv@v3

      - run: uv run .github/scripts/publish-bonsai-releases.py
        env:
@@ -4,8 +4,6 @@
 /_deps-vs*-x*-installed/
 /_installed-vs*-x*/
 /build/
-/build.log
-/output/
 /src/examples/build/
 # ifctester docs output
 /src/ifctester/test/build/
@@ -24,14 +22,12 @@
 __pycache__
 *.py.bak
 venv
-uv.lock

 # Visual Studio Code files
 .vscode
 !.vscode/launch.json
 !.vscode/tasks.json
 .vs
-/*.code-workspace

 # PyCharm files
 .idea
@@ -130,7 +126,5 @@ src/ifcopenshell-python/ifcopenshell/express/*.exp.cache.dat

 # temp files from AI coding tools
 *.claude
-CLAUDE.local.md
 *.py.tmp*
 *.json.tmp*
-
@@ -18,7 +18,7 @@ and many other libraries, CLI apps, and more. Support is also provided for auxil

 For more information, see:

-* [IfcOpenShell Website](https://ifcopenshell.org)
+* [IfcOpenShell Website](http://ifcopenshell.org)
 * [IfcOpenShell Documentation](https://docs.ifcopenshell.org)
  * [IfcOpenShell C++ Installation](https://docs.ifcopenshell.org/ifcopenshell/installation.html)
  * [IfcOpenShell Python Installation](https://docs.ifcopenshell.org/ifcopenshell-python/installation.html)
@@ -27,14 +27,13 @@ endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON) # not necessary, but encouraged
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

-# The VERSION file in the repository root is the single source of truth for the
-# release version. Read it unconditionally so a plain source build reports the
-# real version through buildinfo.cpp instead of the stale hardcoded 0.8.0
-# fallback (see #8164). VERSION_OVERRIDE still controls the branch name used
-# when ADD_COMMIT_SHA embeds a commit sha.
-file(READ "../VERSION" "RELEASE_VERSION_")
-string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
-message(STATUS "Detected version '${RELEASE_VERSION}'")
+if(VERSION_OVERRIDE)
+    file(READ "../VERSION" "RELEASE_VERSION_")
+    string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
+    message(STATUS "Detected version '${RELEASE_VERSION}'")
+else()
+    set(RELEASE_VERSION "0.8.0")
+endif()

 add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)

@@ -259,14 +258,10 @@ 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.
-    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()
+    target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)

    if(WITH_ZSTD)
        # @todo do we actually need the zstd include dir or rather just pass
@@ -314,12 +309,8 @@ if(WASM_BUILD)
 else()
    # @todo review this, shouldn't this be all possible header-only now?
    # ... or rewritten using C++17 features?
-    # Boost.System has been header-only since 1.69 and its compiled stub library
-    # was dropped in newer Boost, so requesting it as a component makes
-    # find_package fail on Boost 1.70 and up (for example Boost 1.90). It is
-    # still pulled in transitively by thread / iostreams where needed, so do not
-    # request it explicitly.
    set(BOOST_COMPONENTS
+        system
        program_options
        regex
        thread
@@ -563,8 +554,8 @@ if(COMPILE_SCHEMA)
    # Bootstrap the parser
    message(STATUS "Compiling schema, this will take a while...")
    execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py
-        WORKING_DIRECTORY ../src/ifcopenshell-python/ifcopenshell/express
+        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf
+        WORKING_DIRECTORY ../src/ifcexpressparser
        OUTPUT_FILE express_parser.py
        RESULT_VARIABLE SUCCESS
    )
@@ -575,7 +566,7 @@ if(COMPILE_SCHEMA)

    # Generate code
    execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} ../ifcopenshell-python/ifcopenshell/express/express_parser.py ../../${COMPILE_SCHEMA}
+        COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
        WORKING_DIRECTORY ../src/ifcparse
        OUTPUT_VARIABLE COMPILED_SCHEMA_NAME
    )
@@ -665,11 +656,6 @@ if(ADD_COMMIT_SHA)
    endif()
 endif(ADD_COMMIT_SHA)

-# Always expose the release version (from the VERSION file) to buildinfo.cpp so
-# that a build without commit-sha info reports the correct version instead of a
-# stale hardcoded fallback. See #8164.
-target_compile_definitions(IfcParse PRIVATE IFCOPENSHELL_VERSION_STRING=${RELEASE_VERSION})
-
 if(MSVC)
    # @todo still needs to be understood better, but the cgal and cgal-simple kernel cause multiply defined boost lambda placeholders _1 ... _3
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /FORCE:MULTIPLE")
@@ -88,15 +88,7 @@ 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}'.")
-        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()
+        set(HDF5_LIBRARIES hdf5_cpp-static)
    else()
        # If it failed, still try to find as a module.
        # E.g. on Ubuntu `libhdf5-dev` doesn't provie hdf5-config.cmake.
@@ -1,131 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-################################################################################
-#                                                                              #
-# This file is part of IfcOpenShell.                                           #
-#                                                                              #
-# IfcOpenShell is free software: you can redistribute it and/or modify         #
-# it under the terms of the Lesser GNU General Public License as published by  #
-# the Free Software Foundation, either version 3.0 of the License, or          #
-# (at your option) any later version.                                          #
-#                                                                              #
-# IfcOpenShell is distributed in the hope that it will be useful,              #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 #
-# Lesser GNU General Public License for more details.                          #
-#                                                                              #
-# You should have received a copy of the Lesser GNU General Public License     #
-# along with this program. If not, see <http://www.gnu.org/licenses/>.         #
-#                                                                              #
-################################################################################
-
-include("${CMAKE_CURRENT_LIST_DIR}/utilities.cmake" OPTIONAL)
-
-set(_IfcOpenShell_find_args)
-if(IfcOpenShell_FIND_VERSION)
-    list(APPEND _IfcOpenShell_find_args "${IfcOpenShell_FIND_VERSION}")
-    if(IfcOpenShell_FIND_VERSION_EXACT)
-        list(APPEND _IfcOpenShell_find_args EXACT)
-    endif()
-endif()
-list(APPEND _IfcOpenShell_find_args CONFIG QUIET)
-if(IfcOpenShell_FIND_COMPONENTS)
-    list(APPEND _IfcOpenShell_find_args COMPONENTS ${IfcOpenShell_FIND_COMPONENTS})
-endif()
-
-set(_IfcOpenShell_saved_module_path "${CMAKE_MODULE_PATH}")
-list(REMOVE_ITEM CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
-find_package(IfcOpenShell ${_IfcOpenShell_find_args})
-set(CMAKE_MODULE_PATH "${_IfcOpenShell_saved_module_path}")
-
-if(NOT IfcOpenShell_FOUND)
-    set(_IfcOpenShell_error "Could not find an IfcOpenShell CMake config package. Set IfcOpenShell_DIR or CMAKE_PREFIX_PATH.")
-    if(IfcOpenShell_FIND_REQUIRED)
-        message(FATAL_ERROR "${_IfcOpenShell_error}")
-    elseif(NOT IfcOpenShell_FIND_QUIETLY)
-        message(STATUS "${_IfcOpenShell_error}")
-    endif()
-    return()
-endif()
-
-set(_IfcOpenShell_required_targets IfcOpenShell::IfcParse IfcOpenShell::IfcGeom)
-set(_IfcOpenShell_missing_targets "")
-foreach(_IfcOpenShell_target IN LISTS _IfcOpenShell_required_targets)
-    if(NOT TARGET ${_IfcOpenShell_target})
-        list(APPEND _IfcOpenShell_missing_targets ${_IfcOpenShell_target})
-    endif()
-endforeach()
-
-if(_IfcOpenShell_missing_targets)
-    set(IfcOpenShell_FOUND FALSE)
-    string(REPLACE ";" ", " _IfcOpenShell_missing_targets_text "${_IfcOpenShell_missing_targets}")
-    set(_IfcOpenShell_error "IfcOpenShell config was found, but required targets are missing: ${_IfcOpenShell_missing_targets_text}.")
-    if(IfcOpenShell_FIND_REQUIRED)
-        message(FATAL_ERROR "${_IfcOpenShell_error}")
-    elseif(NOT IfcOpenShell_FIND_QUIETLY)
-        message(STATUS "${_IfcOpenShell_error}")
-    endif()
-    return()
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_WITH_OPENCASCADE)
-    set(IFCOPENSHELL_WITH_OPENCASCADE OFF)
-    if(TARGET IfcOpenShell::geometry_kernel_opencascade)
-        set(IFCOPENSHELL_WITH_OPENCASCADE ON)
-    endif()
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_WITH_CGAL)
-    set(IFCOPENSHELL_WITH_CGAL OFF)
-    if(TARGET IfcOpenShell::IFCOPENSHELL_CGAL)
-        set(IFCOPENSHELL_WITH_CGAL ON)
-    endif()
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_IFCXML)
-    set(IFCOPENSHELL_IFCXML OFF)
-endif()
-
-if(NOT DEFINED IFCOPENSHELL_WITH_ROCKSDB)
-    set(IFCOPENSHELL_WITH_ROCKSDB OFF)
-endif()
-
-set(IFCOPENSHELL_LIBRARIES IfcOpenShell::IfcParse)
-foreach(_IfcOpenShell_target IN ITEMS IfcOpenShell::geometry_serializer IfcOpenShell::Serializers)
-    if(TARGET ${_IfcOpenShell_target})
-        list(APPEND IFCOPENSHELL_LIBRARIES ${_IfcOpenShell_target})
-    endif()
-endforeach()
-
-set(IFCOPENSHELL_KERNEL_LIBRARIES "")
-foreach(_IfcOpenShell_target IN ITEMS
-    IfcOpenShell::geometry_kernel_opencascade
-    IfcOpenShell::geometry_kernel_cgal
-    IfcOpenShell::geometry_kernel_cgal_simple
-)
-    if(TARGET ${_IfcOpenShell_target})
-        list(APPEND IFCOPENSHELL_KERNEL_LIBRARIES ${_IfcOpenShell_target})
-    endif()
-endforeach()
-
-set(IFCOPENSHELL_GEOMETRY_LIBRARIES IfcOpenShell::IfcGeom ${IFCOPENSHELL_KERNEL_LIBRARIES})
-
-if(TARGET IfcOpenShell::OpenCASCADE_INTERFACE)
-    set(OpenCASCADE_LIBRARIES IfcOpenShell::OpenCASCADE_INTERFACE)
-endif()
-
-if(TARGET IfcOpenShell::IFCOPENSHELL_CGAL)
-    set(CGAL_LIBRARIES IfcOpenShell::IFCOPENSHELL_CGAL)
-endif()
-
-if(TARGET IfcOpenShell::svgfill)
-    set(IFCOPENSHELL_SVGFILL_LIBRARY IfcOpenShell::svgfill)
-endif()
-
-mark_as_advanced(IfcOpenShell_DIR)
-
-unset(_IfcOpenShell_error)
-unset(_IfcOpenShell_find_args)
-unset(_IfcOpenShell_missing_targets)
-unset(_IfcOpenShell_missing_targets_text)
-unset(_IfcOpenShell_required_targets)
-unset(_IfcOpenShell_target)
@@ -7,26 +7,12 @@ set(IFCOPENSHELL_WITH_OPENCASCADE @WITH_OPENCASCADE@)
 set(IFCOPENSHELL_WITH_CGAL @WITH_CGAL@)
 set(IFCOPENSHELL_IFCXML @IFCXML_SUPPORT@)
 set(IFCOPENSHELL_WITH_ROCKSDB @WITH_ROCKSDB@)
-set(IFCOPENSHELL_COLLADA_SUPPORT @COLLADA_SUPPORT@)
-set(IFCOPENSHELL_GLTF_SUPPORT @GLTF_SUPPORT@)
-set(IFCOPENSHELL_HDF5_SUPPORT @HDF5_SUPPORT@)
-set(IFCOPENSHELL_WITH_PROJ @WITH_PROJ@)
-set(IFCOPENSHELL_USD_SUPPORT @USD_SUPPORT@)

 include(CMakeFindDependencyMacro)

-set(IFCOPENSHELL_BOOST_USE_STATIC_LIBS "@Boost_USE_STATIC_LIBS@")
-set(IFCOPENSHELL_BOOST_USE_STATIC_RUNTIME "@Boost_USE_STATIC_RUNTIME@")
-set(IFCOPENSHELL_BOOST_USE_MULTITHREADED "@Boost_USE_MULTITHREADED@")
-if(NOT "${IFCOPENSHELL_BOOST_USE_STATIC_LIBS}" STREQUAL "")
-    set(Boost_USE_STATIC_LIBS ${IFCOPENSHELL_BOOST_USE_STATIC_LIBS})
-endif()
-if(NOT "${IFCOPENSHELL_BOOST_USE_STATIC_RUNTIME}" STREQUAL "")
-    set(Boost_USE_STATIC_RUNTIME ${IFCOPENSHELL_BOOST_USE_STATIC_RUNTIME})
-endif()
-if(NOT "${IFCOPENSHELL_BOOST_USE_MULTITHREADED}" STREQUAL "")
-    set(Boost_USE_MULTITHREADED ${IFCOPENSHELL_BOOST_USE_MULTITHREADED})
-endif()
+set(Boost_USE_STATIC_LIBS ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+set(Boost_USE_MULTITHREADED ON)
 set(Boost_COMPONENTS
    system
    program_options
@@ -57,33 +43,13 @@ if(IFCOPENSHELL_WITH_ROCKSDB)
 endif()

 if(IFCOPENSHELL_IFCXML)
-    find_dependency(LibXml2)
+    find_dependency(LibXml2 CONFIG)
 endif()

 if(IFCOPENSHELL_WITH_CGAL)
    find_dependency(CGAL CONFIG)
 endif()

-if(IFCOPENSHELL_COLLADA_SUPPORT)
-    find_dependency(OpenCOLLADA)
-endif()
-
-if(IFCOPENSHELL_GLTF_SUPPORT)
-    find_dependency(nlohmann_json CONFIG)
-endif()
-
-if(IFCOPENSHELL_HDF5_SUPPORT)
-    find_dependency(HDF5 COMPONENTS C CXX)
-endif()
-
-if(IFCOPENSHELL_WITH_PROJ)
-    find_dependency(PROJ)
-endif()
-
-if(IFCOPENSHELL_USD_SUPPORT)
-    find_dependency(USD)
-endif()
-
 if(IFCOPENSHELL_WITH_OPENCASCADE)
    find_dependency(OpenCASCADE CONFIG)
    if(OpenCASCADE_VERSION VERSION_LESS "7.7.0")
@@ -1,3 +0,0 @@
-.env
-*.pyc
-__pycache__
@@ -1,3 +0,0 @@
-.env
-*.pyc
-__pycache__
@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# .ifcos_env
-# register autocompletes. just source the file in your shell, i.e. 
-# source .ifcos_env
-
-.ifcos_env() {
-    local cur prev opts
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    prev="${COMP_WORDS[COMP_CWORD-1]}"
-
-    opts="create update up down restart build attach logs ps config remove help"
-
-    # Basic static completion
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-
-    return 0
-}
-
-# Register the completion for the command "ifcos_env"
-complete -F .ifcos_env ./ifcos_env
@@ -1,67 +0,0 @@
-FROM rockylinux:9
-
-# Update system, enable CRB (needed by some EPEL packages) and install EPEL,
-# then install required packages + some common tools for a bit of command
-# line comfort. Combined into one layer so a later `create` always installs
-# against packages from the same dnf update, rather than layering fresh
-# installs on top of a stale cached "update" layer.
-RUN dnf update -y && \
-    dnf install -y epel-release && \
-    dnf config-manager --set-enabled crb && \
-    dnf install -y --allowerasing --setopt=install_weak_deps=False --setopt=tsflags=nodocs \
-                   bash-completion vim git curl wget which tree htop sudo   \
-                   gcc gcc-c++ autoconf automake bison make zip cmake      \
-                   python3 python3-pip                                    \
-                   bzip2 patch mesa-libGL-devel libffi-devel fontconfig-devel \
-                   sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel \
-                   readline-devel ncurses-devel libuuid-devel git-lfs      \
-                   findutils xz byacc ccache && \
-    git lfs install --system && \
-    dnf clean all && \
-    rm -rf /var/cache/dnf
-
-# Trust bind-mounted repos regardless of which user (root or builder) or host
-# UID owns them, rather than a per-user config that only one of them sees.
-RUN git config --system --add safe.directory '*'
-
-# Configure ccache. CCACHE_MAXSIZE (not `ccache -M`) because /ccache is a
-# volume mount point at runtime - anything `ccache -M` writes to a config
-# file under it during this build gets shadowed once the real volume is
-# mounted, so the size cap only actually takes effect via the env var.
-# 2G is generous: a full build (IfcParse+IfcGeom+IfcConvert+wrapper, one
-# Python version) measures ~300MB, and the volume is now shared across all
-# checkouts (see compose.yaml), so this covers several diverging branches.
-ENV CCACHE_DIR=/ccache
-ENV CCACHE_MAXSIZE=2G
-ENV PATH="/usr/lib/ccache:$PATH"
-
-# Non-root user matching the host UID/GID that bind-mounts the repo (default
-# 1000:1000, the common single-user-Linux-box case), so files the build
-# creates under the mount keep sane, non-root ownership on the host side.
-# Override with --build-arg USER_UID=$(id -u) --build-arg USER_GID=$(id -g)
-# if your host user has a different UID/GID.
-ARG USER_UID=1000
-ARG USER_GID=1000
-# groupadd fails outright if USER_GID is already taken by an existing
-# system group - which happens whenever a host's primary GID collides with
-# one baked into the rockylinux9 base image. The main real-world case is
-# macOS, where the default user's primary group is "staff" at GID 20, and
-# GID 20 is "games" on RHEL-family images. Only create the "builder" group
-# when that GID is actually free; otherwise useradd just attaches to
-# whichever group already owns it. Either way the builder user ends up
-# with the right GID for bind-mount ownership, which is all that matters.
-RUN (getent group "${USER_GID}" >/dev/null || groupadd -g "${USER_GID}" builder) \
-    && useradd -m -u "${USER_UID}" -g "${USER_GID}" -s /bin/bash builder \
-    && echo "builder ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/builder
-
-# Copied while still root: /bin is not writable by the builder user.
-COPY --from=ghcr.io/astral-sh/uv:0.11.27 /uv /uvx /bin/
-
-USER builder
-WORKDIR /__w/IfcOpenShell/IfcOpenShell
-
-# Installed as builder so managed Python interpreters land under builder's
-# $HOME, matching the user that actually runs the build.
-RUN uv python install
-
-CMD ["sleep", "infinity"]
@@ -1,78 +0,0 @@
-Docker build environment
-========================
-
-This is a small utility to make it easy to compile a perfect `_ifcopenshell_wrapper.cpython-*-x86_64-linux-gnu.so`
-files.
-
-The reason for this tool is that I was trying to follow the web page directions, and my build was behaving differently
-to the release builds. Eventually I concluded that the differences between toolchains on the RHEL based rocky9 image
-and Ubuntu were just too great. Getting the build setup was already a lot of trial and error, so I thought I'd spend
-more time trying to reuse the github actions that perform the build, using a utility called `act`. I learnt a lot, in
-particular how much time, energy, and bandwidth Github waste. I also realised I was most of the way to a regular docker
-setup anyway, so I might as well just do that. So I've deconstructed all the github action steps, and turned it into
-a local docker build environment that uses the exact same base, tools, libraries, and build command/flags etc.
-
-Right now a Github action will:
- launch the rocky9 base
- upgrade all the packages
- install a bunch of extra tools
- do a recursive checkout of your repo
- checkout the build repository
- unpack dependencies
- run the build script, making all python versions (5? right now I think)
- create the .zip release files
-
-And it does _all_ of that _every_ time. This is not a fault of the action writers - it's just how Github seems to work.
-
-These dockers tools do the following differently, and it's actually a bit more powerful too:
- build the base image once.
- update the packages once.
- install the extra tools once.
- the repository is the one on your host, that gets bind mounted in the container as the working directory.
- by adding an environment variable to .env, restricts to compiling for just a single python version.
- when the build is finished the created files are right there under your local repositry (but not added to git) for
-  ease of access
- each repository can have it's own build environment container.
- the image is shared between those environments.
- the containers share the ccache, so additional envs should get a helping hand.
- it has a simple set of user friendly commands to drive it all.
-
-For example:
-``` bash
-# To see the commands (a superset of docker compose commands)
-./ifcos_env
-
-# Enable autocomplete of commands
-source .ifcos_env
-
-# First time commands
-./ifcos_env create
-./ifcos_env up
-./ifcos_env build
-
-# install and test library
-# find an issue
-# edit code
-./ifcos_env build
-
-# and so on. When done stop and optionally delete the container
-./ifcos_env stop
-./ifcos_env remove
-```
-
-To limit the build to one python version just add
-``` bash
-PY_TGT=py-311
-```
-or whichever version your Blender requires.
-
-You might see UNIQUE_ID in the .env file too. This keeps containers for separate folders, separate.
-
-System requirements
-1. Linux-x64 only at this time.
-2. Docker and docker-compose need to be installed.
-3. Have a good amount of disk space. (image is in /var (typically the root partition) and will be about 1.7 GB)
-4. The build action will create about 10GB in your repository folder. Make sure this partition is spacious
-   particularly if you intent on having multiple clones building.
-5. ... I think that covers most of it.
-
@@ -1,186 +0,0 @@
---
-name: ifcopenshell-docker-build
-description: >-
-  Build a real ifcopenshell_wrapper (.so + .py) and IfcConvert locally via
-  the docker/ifcos_env toolchain, then wire them into a checkout for
-  running C++-dependent parts of the test suite (geometry, the SWIG
-  wrapper stub, the C++ parser). Use whenever a task needs to compile
-  IfcOpenShell's C++ core rather than just read/patch source - e.g.
-  reproducing or fixing a bug in src/ifcgeom, src/ifcparse, src/ifcwrap,
-  or validating util/scripts/validate_stub.py against the actual
-  generated wrapper.
---
-
-# Building IfcOpenShell locally with docker/ifcos_env
-
-`docker/` mirrors the project's GitHub Actions build environment locally,
-in a persistent, non-root container with ccache so repeat builds are fast.
-See `docker/README.md` for the design rationale. Pure-Python changes don't
-need any of this - only reach for it when you need a real compiled
-`_ifcopenshell_wrapper*.so` or `IfcConvert` binary.
-
-## Placement
-
-This `docker/` folder must live as a direct child of the repo root you want
-to build (sibling of `src/`, `cmake/`, etc.) - `compose.yaml` and
-`ifcos_env` resolve the repo via `../` relative to wherever `docker/`
-itself sits, and bind-mount it into the container. If you're setting this
-up in a fresh clone, copy the whole `docker/` directory there first.
-
-## Setup
-
-```bash
-cd docker
-./ifcos_env create   # build the image (shared by name across all your clones/checkouts, so usually instant after the first time anywhere)
-./ifcos_env up        # create + start the container, clone/unpack the third-party dependency cache (~10GB, one-time per container)
-./ifcos_env build     # full build: all deps + IfcParse + IfcGeom + IfcConvert + the Python wrapper, for one Python version
-```
-
-`PY_TGT` and `UNIQUE_ID` live in `docker/.env` - `PY_TGT` (e.g. `py-311`)
-restricts the build to one Python version instead of building five;
-`UNIQUE_ID` is a hash of the folder path, recalculated on every `up`, so
-each checkout gets its own container/volumes automatically.
-
-A full first build takes ~1.5 hours (mostly compiling IfcOpenShell's own
-C++, not the cached third-party deps). After that, ccache makes incremental
-rebuilds of a couple of touched `.cpp` files **under a minute**.
-
-## Container lifecycle
-
-The container is long-lived (`sleep infinity`) so exec'd commands and
-ccache state persist between builds. Commands map directly onto Docker
-Compose's own container-vs-image distinction:
-
-```bash
-./ifcos_env up         # create the container if it doesn't exist, then start it (runs ready_repo too)
-./ifcos_env stop       # stop the container, keep it around
-./ifcos_env start      # start it back up (same container, same filesystem layer)
-./ifcos_env restart    # stop, then start
-./ifcos_env down       # remove the container (and its network) entirely
-./ifcos_env recreate   # down, then up - a fresh container
-```
-
-Named volumes (`ccache`) and the bind-mounted repo/`build/` are unaffected
-by `down`/`recreate` - only the container itself goes away, and `up`
-recreates it from the image.
-
-## Fast iteration
-
-Pass a target to `build` to skip the parts you don't need:
-
-```bash
-./ifcos_env build IfcConvert           # only the executables (IfcConvert, IfcGeomServer) - skips the Python wrapper entirely
-./ifcos_env build IfcOpenShell-Python  # only the SWIG Python wrapper - skips executables entirely
-./ifcos_env build                      # no target = everything (needed the first time, or after touching shared headers)
-```
-
-Use this to keep the edit -> rebuild -> test loop fast when debugging: if
-you're only touching `src/ifcgeom/`, build `IfcConvert`; if you're only
-exercising the Python API, build `IfcOpenShell-Python`.
-
-## Where the artifacts land
-
-Build output goes to `<repo_root>/build/Linux/x86_64/install/` on the host
-(bind-mounted, not just inside the container), owned by you (see
-"Container user" below):
-
- `ifcopenshell/bin/IfcConvert` - the CLI binary
- `python-<version>/lib/python<X.Y>/site-packages/ifcopenshell/_ifcopenshell_wrapper*.so`
-  and `ifcopenshell_wrapper.py` - the compiled wrapper + its generated
-  Python glue
-
-## Testing against a checkout (automated / AI-driven)
-
-`_ifcopenshell_wrapper*.so` and `ifcopenshell_wrapper.py` are already
-gitignored under `src/ifcopenshell-python/ifcopenshell/`, which is exactly
-where a normal in-tree build would put them - copy the two files there:
-
-```bash
-SRC=build/Linux/x86_64/install/python-3.11.8/lib/python3.11/site-packages/ifcopenshell
-cp "$SRC/_ifcopenshell_wrapper.cpython-311-x86_64-linux-gnu.so" src/ifcopenshell-python/ifcopenshell/
-cp "$SRC/ifcopenshell_wrapper.py" src/ifcopenshell-python/ifcopenshell/
-```
-
-Then, to run the test suite against it:
-
-```bash
-export PATH="$PWD/build/Linux/x86_64/install/ifcopenshell/bin:$PATH"   # for IfcConvert-dependent tests
-cd src/ifcopenshell-python/test
-PYTHONPATH="$PWD/.." python3.11 -m pytest -p no:pytest-blender .
-```
-
-(`-p no:pytest-blender` avoids the pytest-blender plugin trying to find a
-`blender` executable and failing collection entirely, even for non-Blender
-tests.) You'll need the matching Python version's `pip install`s too
-(numpy, shapely, isodate, lark, tabulate, pytest, ... - whatever the
-modules under test import) since this is a bare interpreter, not the
-project's pixi env.
-
-**This is the pattern to use for automated or AI-driven verification.**
-Don't use `try` (below) for that - it overwrites files in a real, live
-Blender installation, which isn't something an automated/AI workflow
-should ever do without the human explicitly asking for it in the moment.
-
-## Testing in Blender itself (human only)
-
-`try` copies the built wrapper straight into your actual Blender/Bonsai
-extension install, for manual in-Blender testing:
-
-```bash
-./ifcos_env try
-```
-
-It reads `BLENDER_USER_RESOURCE` from `.env` - set this to wherever
-Blender's user resource folder for the Bonsai extension actually lives on
-your system, which depends on your own Blender setup:
-
-```bash
-# in docker/.env
-BLENDER_USER_RESOURCE=~/.config/blender/bonsai/
-```
-
-`try` figures out the built Python version from `build/.../install/`
-(disambiguating with `PY_TGT` if more than one version was built) and
-copies the wrapper to
-`$BLENDER_USER_RESOURCE/extensions/.local/lib/python<X.Y>/site-packages/ifcopenshell/`.
-
-## Container user
-
-The image runs as a non-root `builder` user, UID/GID matching your host
-account (passed as `--build-arg` by `create` from `id -u`/`id -g`, so it
-adjusts automatically - no manual flag needed even if you're not 1000:1000).
-Files the build creates under the bind mount come out owned by you, not
-root. Passwordless `sudo` is available inside the container (e.g. via
-`attach`) for the rare case you need root for something ad hoc.
-
-If you're picking up an existing checkout that was previously built with
-an older, root-based image, you may hit `Permission denied` the first time
-you run `up`/`build` under the new image - `build/`, `.git/modules/`, the
-`ccache` volume, `output/`, and `build.log` can all be left root-owned from
-before. Fix it once via the container's own root (no host `sudo` needed):
-
-```bash
-docker exec -u root -w /__w/IfcOpenShell/IfcOpenShell <container-name> \
-    chown -R "$(id -u)":"$(id -g)" .git/modules build output build.log /ccache
-```
-
-(`<container-name>` is `ifcopenshell-<UNIQUE_ID>` - see `docker ps -a`.)
-
-## Other things worth knowing
-
- **Linux x64 only.** `compose.yaml` pins `platform: linux/amd64`; on an
-  ARM host (e.g. Apple Silicon) this build isn't available.
- **The final "Package .zip archives" step of `build()` has a pre-existing
-  bash syntax error**, unrelated to compilation - the actual build already
-  succeeded by that point (look for `Built IfcOpenShell...` in the output),
-  so this is safe to ignore if you only need the raw artifacts under
-  `build/.../install/`, not packaged release zips.
- **`test_mmaped_stream` and similar `USE_MMAP`-dependent tests will fail**
-  against this build - `nix/build-all.py` is invoked with `USE_MMAP=OFF`
-  here. Not a bug in your code if you see it fail.
- Only the bind-mounted `<repo>/build` lives on the host filesystem your
-  repo is checked out on. Anything the container writes *outside* that
-  mount lives in the container's own writable layer under Docker's data
-  root (commonly `/var/lib/docker`, i.e. usually your root partition) -
-  keep an eye on `df -h /` if you're running several of these containers
-  at once.
@@ -1,15 +0,0 @@
-name: ifcopenshell-${UNIQUE_ID}
-services:
-  ifcopenshell:
-    container_name: ifcopenshell-${UNIQUE_ID}
-    image: ifcopenshell-build-env:updated
-    platform: linux/amd64
-    volumes:
-      - type: bind
-        source: ../
-        target: /__w/IfcOpenShell/IfcOpenShell
-      - ccache:/ccache
-
-volumes:
-  ccache:
-    name: ifcopenshell-ccache-shared
@@ -1,339 +0,0 @@
-#!/bin/bash
-
-# ================== CONFIG ==================
-SCRIPT_NAME=$(basename "$0")
-ENV_FILE=".env"
-WORKDIR="/__w/IfcOpenShell/IfcOpenShell"
-NAMEPREFIX=ifcopenshell
-
-function set_env() {
-    # Load .env file if it exists
-    if [[ -f "$ENV_FILE" ]]; then
-        set -a
-        source "$ENV_FILE"
-        set +a
-        echo "✅ Loaded environment variables from $ENV_FILE"
-    else
-        echo "⚠️  No $ENV_FILE found, proceeding without it."
-    fi
-}
-
-set_env
-
-# ================ FUNCTIONS =================
-
-function create() {
-    echo "⭐ Creating image: ifcopenshell-build-env"
-    docker build -f Dockerfile \
-        --build-arg USER_UID="$(id -u)" --build-arg USER_GID="$(id -g)" \
-        -t ifcopenshell-build-env:updated .
-}
-
-function update() {
-    # The Dockerfile always builds FROM a clean rockylinux:9 and does
-    # `dnf update -y` as its first step, so re-running create() is enough
-    # to get fresh packages.
-    echo "⚡ Updating image: ifcopenshell-build-env"
-    create
-}
-
-function up() {
-    # Creates the container if it doesn't exist yet (and starts it either
-    # way) - this is the one that needs ready_repo, since a freshly created
-    # container has no submodules/dependency cache in place yet.
-    echo "🚀 Creating/starting stack: ifcopenshell-${UNIQUE_ID}"
-    unique          # Update UNIQUE_ID first
-    docker compose up -d "$@"   # Container must exist before ready_repo can exec into it.
-    ready_repo      # Ensure repo is recursive, and the build repo is in place.
-}
-
-function down() {
-    # Removes the container (and its network) entirely. Named volumes
-    # (ccache) and the bind-mounted repo/build/ survive; up() will recreate
-    # the container from scratch next time.
-    echo "🔥 Removing stack: ifcopenshell-${UNIQUE_ID}"
-    docker compose down "$@"
-}
-
-function stop() {
-    # Stops the existing container without removing it - the container,
-    # its filesystem layer, and its exec history all remain intact.
-    echo "🛑 Stopping stack: ifcopenshell-${UNIQUE_ID}"
-    docker compose stop "$@"
-}
-
-function start() {
-    # Starts a previously-stopped container back up. Does nothing (and
-    # won't create anything) if the container doesn't exist - use up() for
-    # that.
-    echo "▶️  Starting stack: ifcopenshell-${UNIQUE_ID}"
-    docker compose start "$@"
-}
-
-function restart() {
-    echo "🔄 Restarting stack (stop, then start)..."
-    stop
-    start
-}
-
-function recreate() {
-    echo "♻️  Recreating stack (down, then up)..."
-    down
-    up
-}
-
-function logs() {
-    echo "📜 Showing logs..."
-    docker compose logs -f "$@"
-}
-
-function ps() {
-    docker compose ps
-}
-
-function config() {
-    echo "🔍 Validated compose configuration:"
-    docker compose config
-}
-
-function remove() {
-    # Lower-level than down(): removes already-stopped containers without
-    # touching the compose network. Mostly useful after a plain stop().
-    echo "🗑️  Removing stopped containers: ifcopenshell-${UNIQUE_ID}"
-    docker compose rm "$@"
-}
-
-function unique() {
-    echo "🔧 Making stack name folder specific..."
-
-    REGEX="^UNIQUE_ID="
-
-    if [[ ! -f "$ENV_FILE" ]] || ! grep -qE "$REGEX" "$ENV_FILE"; then
-        echo -e "\nUNIQUE_ID=dummy\n" >> "$ENV_FILE"
-    fi
-
-    export UNIQUE_ID="$(pwd | sha256sum | cut -c -8)"
-
-    # `sed -i` takes incompatible syntax between GNU sed (Linux) and BSD sed
-    # (macOS) - `-si` is GNU-only and errors as "illegal option -- s" under
-    # BSD/macOS sed. Avoid -i altogether and do the in-place edit via a temp
-    # file + mv instead, which behaves identically with either sed.
-    local tmp_file
-    tmp_file="$(mktemp "${ENV_FILE}.XXXXXX")"
-    sed "s/^UNIQUE_ID=.*$/UNIQUE_ID=${UNIQUE_ID}/" "$ENV_FILE" > "$tmp_file"
-    mv "$tmp_file" "$ENV_FILE"
-
-    set_env
-}
-
-function ready_repo() {
-    echo "👍 Getting the repo ready to build..."
-    docker exec -i -w "${WORKDIR}" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        set -euo pipefail   # Recommended for robustness
-
-        git submodule update --init --recursive
-
-        if [[ ! -d "build" ]]; then
-            git clone -b rockylinux9-x64 https://github.com/IfcOpenShell/build-outputs.git build
-        else
-            cd build
-            git pull
-            cd ..
-        fi
-
-        if [[ ! -d "build/Linux/x86_64/install/boost-1.86.0/" ]]; then
-            cd build
-            uv run ../nix/cache_dependencies.py unpack
-            cd ..
-        fi
-    '
-}
-
-function build() {
-    echo "☕ Execute the build, go make yourself a cuppa... I'll be a while"
-    local BUILD_TARGET="$1"
-    
-    docker exec -i -w "${WORKDIR}" -e PY_TGT="${PY_TGT}" -e BUILD_TARGET="${BUILD_TARGET}" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        set -o pipefail
-        CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v ${PY_TGT:+-$PY_TGT} --diskcleanup ${BUILD_TARGET} 2>&1 | tee build.log
-    '
-    echo "🎒 Pack Dependencies"
-    docker exec -i -w "${WORKDIR}" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        cd build
-        uv run ../nix/cache_dependencies.py pack
-    '
-
-    echo "🎁 Package .zip archives"
-    docker exec -i -w "${WORKDIR}" -e GITHUB_SHA="$(git rev-parse HEAD)" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        OUTPUT_DIR=${PWD}/output
-        VERSION=v`cat VERSION`
-        mkdir -p ${OUTPUT_DIR}
-        cd ./build/`uname`/*/install/ifcopenshell
-
-        ls -d python-* | while read py_version; do
-            postfix=`echo ${py_version: -1} | sed s/[0-9]//`
-            numbers=`echo $py_version | grep -oE "[0-9]+\.[0-9]+" | tr -d "."`
-            py_version_major=python-${numbers}$postfix
-            pushd . > /dev/null
-            cd $py_version
-            if [ ! -d ifcopenshell ]; then
-                mkdir ../ifcopenshell_
-                mv * ../ifcopenshell_
-                mv ../ifcopenshell_ ifcopenshell
-            fi
-            [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
-            find ifcopenshell -name "*.pyc" -delete
-            zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip ifcopenshell/*
-            mv *.zip ${OUTPUT_DIR}/
-            popd > /dev/null
-        done
-
-        cd bin
-        if compgen -G "./*.zip" > /dev/null; then
-            rm *.zip 2>&1 >/dev/null || true
-        ls | while read exe; do
-            zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip $exe
-        done
-        mv *.zip ${OUTPUT_DIR}/
-        cd ..
-      '
-}
-
-function attach() {
-    echo "🔦 Connect to interactive shell"
-    docker exec -it  -w "${WORKDIR}" "${NAMEPREFIX}-${UNIQUE_ID}" /bin/bash
-}
-
-function try() {
-    # Copies the freshly built wrapper into your actual Blender/Bonsai
-    # installation for manual, in-Blender testing. This is a human-only
-    # convenience: it overwrites files in your live Blender setup, so it's
-    # not something that should run unattended as part of an automated or
-    # AI-driven build/test loop (which should instead copy the wrapper into
-    # the repo's own src/ifcopenshell-python/ifcopenshell/ - see SKILL.md).
-    echo "🚴 Copying build artifacts into your Blender resource folder for testing"
-
-    if [[ -z "${BLENDER_USER_RESOURCE:-}" ]]; then
-        echo "❌ BLENDER_USER_RESOURCE is not set in .env."
-        echo "   Add a line pointing at wherever Blender's user resource folder for"
-        echo "   the Bonsai extension actually is on your system, e.g.:"
-        echo "     BLENDER_USER_RESOURCE=~/.config/blender/bonsai/"
-        return 1
-    fi
-
-    # Normalise: expand a leading ~ (in case it was quoted in .env and so
-    # never went through shell tilde-expansion when set_env sourced it),
-    # then resolve to an absolute, symlink-free path.
-    local resource="${BLENDER_USER_RESOURCE/#\~/$HOME}"
-    resource="$(realpath -m "$resource")"
-
-    local install_dir="../build/Linux/x86_64/install"
-    local py_dirs=("$install_dir"/python-*)
-    if [[ ${#py_dirs[@]} -gt 1 && -n "${PY_TGT:-}" ]]; then
-        # PY_TGT is compact (py-311); the install dirs are dotted
-        # (python-3.11.8) - reinsert the dot (assumes a single-digit major
-        # version, true for the Python 3.x line) before matching.
-        local py_tgt_digits="${PY_TGT#py-}"
-        local py_tgt_dotted="${py_tgt_digits:0:1}.${py_tgt_digits:1}"
-        local filtered=() d
-        for d in "${py_dirs[@]}"; do
-            [[ "$(basename "$d")" == "python-${py_tgt_dotted}."* ]] && filtered+=("$d")
-        done
-        [[ ${#filtered[@]} -gt 0 ]] && py_dirs=("${filtered[@]}")
-    fi
-    if [[ ${#py_dirs[@]} -ne 1 || ! -d "${py_dirs[0]}" ]]; then
-        echo "❌ Expected exactly one built python-* dir under $install_dir, found ${#py_dirs[@]}."
-        echo "   Run 'build' first, or set PY_TGT in .env to disambiguate a multi-version build."
-        return 1
-    fi
-
-    local py_minor
-    py_minor="$(basename "${py_dirs[0]}" | grep -oE '[0-9]+\.[0-9]+')"
-    local wrapper_dir="${py_dirs[0]}/lib/python${py_minor}/site-packages/ifcopenshell"
-    if [[ ! -f "$wrapper_dir/ifcopenshell_wrapper.py" ]]; then
-        echo "❌ Built wrapper not found at $wrapper_dir - run 'build' first."
-        return 1
-    fi
-
-    local target="$resource/extensions/.local/lib/python${py_minor}/site-packages/ifcopenshell"
-    mkdir -p "$target"
-    cp "$wrapper_dir"/_ifcopenshell_wrapper*.so "$target/"
-    cp "$wrapper_dir"/ifcopenshell_wrapper.py "$target/"
-    echo "✅ Copied wrapper into $target"
-}
-
-function clean() {
-    # Host-side only - doesn't touch the container, image, or ccache volume.
-    echo "💎 Clean the build and output folder up"
-    if [[ -d "../build" ]]; then
-        rm -rf ../build
-    fi
-    if [[ -d "../output" ]]; then
-        rm -rf ../output
-    fi
-}
-
-
-function help() {
-    cat <<EOF
-Usage: ./$SCRIPT_NAME <command>
-
-Available commands:
-  create      Build the rocky9-based image
-  update      Rebuild the image fresh, picking up OS package updates
-  up          Create the container if it doesn't exist yet, and start it
-  down        Remove the container entirely (docker compose down)
-  stop        Stop the container without removing it
-  start       Start a previously-stopped container
-  restart     stop, then start (same container, no recreation)
-  recreate    down, then up (fresh container)
-  build       Execute the IfcOpenShell build
-  attach      Connect to an interactive shell in the container
-  try         Copy the built wrapper into your Blender resource folder
-              (human-only - see BLENDER_USER_RESOURCE below, and SKILL.md
-              for the AI/automated-testing equivalent)
-  clean       Remove the build and output folders
-  logs        Follow container logs
-  ps          Show running containers
-  config      Validate and show compose config
-  remove      Remove stopped containers (docker compose rm)
-  help        Show this help
-
-Environment variables from .env are automatically loaded, including:
-  PY_TGT                  Restrict the build to one Python version, e.g. py-311
-  UNIQUE_ID               Recalculated automatically on every 'up', don't set by hand
-  BLENDER_USER_RESOURCE   Where 'try' copies the wrapper for manual testing, e.g.
-                          ~/.config/blender/bonsai/
-EOF
-}
-
-# ================= MAIN =================
-
-case "$1" in
-    create)         create ;;
-    update)         update ;;
-    up)             up "${@:2}" ;;
-    down)           down "${@:2}" ;;
-    stop)           stop "${@:2}" ;;
-    start)          start "${@:2}" ;;
-    restart)        restart ;;
-    recreate)       recreate ;;
-    build)          build "${@:2}" ;;
-    attach)         attach ;;
-    try)            try ;;
-    clean)          clean ;;
-    logs)           logs "${@:2}" ;;
-    ps)             ps ;;
-    config)         config ;;
-    remove)         remove ;;
-    help|-h|--help) help ;;
-    "")
-        echo "❌ No command provided."
-        help
-        ;;
-    *)
-        echo "❌ Unknown command: $1"
-        echo "Type './$SCRIPT_NAME help' for available commands."
-        exit 1
-        ;;
-esac
@@ -50,7 +50,7 @@ Used environment variables:
    - ``NO_CLEAN`` - do not clean `ifcopenshell` build directories but continue working on current build
    (installed dependencies are never cleared).
    By default option is disabled, to enable pass any value from `1`, `on`, `true`.
-    - ``IFCOS_SCHEMAS`` - schemas to be built; defaults to cmake default (8 schemas), to be supplied as `2x3;4;4x3_add2`
+    - ``IFCOS_SCHEMAS`` - schemas to be built; defaults to cmake default (IFC2X3; IFC4; IFC4X3_ADD2) - to be supplied as `2x3;4`
    - ``USE_OCCT`` - whether to use official Open CASCADE instead of Community Edition
    (`true` by default, any other value is considered `false`)
    - ``WASM_PYTHON_PATH`` - path to WASM Python installation,
@@ -126,9 +126,10 @@ ssl._create_default_https_context = ssl._create_unverified_context
 import time
 from collections.abc import Generator, Sequence
 from pathlib import Path
-from typing import Literal, Union
 from urllib.request import urlretrieve

+from typing import Literal, Union
+
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 ch = logging.StreamHandler()
@@ -155,7 +156,7 @@ MPFR_VERSION = "3.1.6"  # latest is 4.1.0
 CGAL_VERSION = "v5.6.3"
 USD_VERSION = "23.05"
 TBB_VERSION = "2021.9.0"
-ROCKSDB_VERSION = "10.4.2"
+ROCKSDB_VERSION = "9.11.2"
 ZSTD_VERSION = "1.5.7"
 # binaries
 cp = "cp"
@@ -627,10 +628,9 @@ def build_dependency(
    build_tool_args: "list[str]",
    download_url: str,
    download_name: str,
-    *,
    download_tool: Literal["py", "git"] = download_tool_default,
    revision: "Union[str, None]" = None,
-    patch: list[str] | None = None,
+    patch: "Union[str, list[str], None]" = None,
    shell=None,
    pre_compile_subs: "Sequence[tuple[str, str, str]]" = (),
    additional_files: "Union[dict[str, str], None]" = None,
@@ -715,6 +715,8 @@ def build_dependency(
                urlretrieve(url, os.path.join(extract_dir, path))

    if patch is not None:
+        if isinstance(patch, str):
+            patch = [patch]
        for p in patch:
            patch_abs = (SCRIPT_PATH / p).absolute().__str__()
            if os.path.exists(patch_abs):
@@ -723,8 +725,6 @@ def build_dependency(
                except Exception as e:
                    # Assert that the patch has already been applied
                    run(["patch", "-p1", "--batch", "--reverse", "--dry-run", "-i", patch_abs], cwd=extract_dir)
-            else:
-                raise FileNotFoundError(patch_abs)

    if shell is not None:
        sp.run(shell, shell=True, check=True, cwd=extract_dir)
@@ -1172,14 +1172,6 @@ if "cgal" in targets:
        os.environ["CC"] = MAC_CROSS_COMPILE_INTEL_CC
        gmp_args.extend(MAC_CROSS_COMPILE_INTEL_AUTOCONF_HOST_ARGS)

-    # Fixes configure failing to find a working compiler under GCC 15's default -std=gnu23.
-    # Issue presumably will be resolved in any next gmp version, but currently the last one is 6.3.0.
-    # Patch is just applying fix from upstream meantion below:
-    # https://gmplib.org/list-archives/gmp-bugs/2025-February/005561.html
-    gmp_patches = ["./patches/gmp/001-fix-std23.patch"]
-    if GMP_VERSION != "6.3.0":
-        raise Exception(f"GMP_VERSION changed to {GMP_VERSION}, check whether {gmp_patches} is still needed.")
-
    build_dependency(
        name=f"gmp-{GMP_VERSION}",
        mode="autoconf",
@@ -1187,7 +1179,6 @@ if "cgal" in targets:
        pre_compile_subs=(
            [("build/config.h", "HAVE_OBSTACK_VPRINTF 1", "HAVE_OBSTACK_VPRINTF 0")] if "wasm" in flags else []
        ),
-        patch=gmp_patches,
        # Sometimes ftp.gnu.org is very slow, use ftpmirror.gnu.org as a workaround.
        download_url="https://ftpmirror.gnu.org/gnu/gmp/",
        download_name=f"gmp-{GMP_VERSION}.tar.bz2",
@@ -68,7 +68,6 @@ def unpack_dependencies(install_dir: Path) -> None:


 if __name__ == "__main__":
-    action = None
    if len(sys.argv) != 2 or (action := sys.argv[1].lower()) not in ("pack", "unpack"):
        print(__doc__)
        sys.exit(1)
@@ -1,27 +0,0 @@
-Fixes configure failing to find a working compiler under GCC 15's default
-std=gnu23 (upstream fix: https://gmplib.org/repo/gmp/rev/8e7bb4ae7a18).
-
-Upstream fix is patching `acinclude.m4`, but since in the release tarball
-all macros are already expanded to `configure` script, so we're patching
-all occurrences of that macro.
-
--- a/configure
-+++ b/configure
-@@ -6568,7 +6568,7 @@
-
- #if defined (__GNUC__) && ! defined (__cplusplus)
- typedef unsigned long long t1;typedef t1*t2;
-void g(){}
-+void g(int,t1 const*,t1,t2,t1 const*,int){}
- void h(){}
- static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
- {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}
-@@ -8187,7 +8187,7 @@
-
- #if defined (__GNUC__) && ! defined (__cplusplus)
- typedef unsigned long long t1;typedef t1*t2;
-void g(){}
-+void g(int,t1 const*,t1,t2,t1 const*,int){}
- void h(){}
- static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
- {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}
@@ -0,0 +1,32 @@
+http://git.dev.opencascade.org/gitweb/?p=occt.git;a=commitdiff;h=0ab4e621833f4eae945a3762c9a29ee12e2eec53#patch1
+diff --git a/src/HLRBRep/HLRBRep_InternalAlgo.cxx b/src/HLRBRep/HLRBRep_InternalAlgo.cxx
+index ca885ca..c13cb06 100644 (file)
+--- a/src/HLRBRep/HLRBRep_InternalAlgo.cxx
+++ b/src/HLRBRep/HLRBRep_InternalAlgo.cxx
+@@ -165,7 +165,7 @@ void HLRBRep_InternalAlgo::Update ()
+       SB.Bounds(v1,v2,e1,e2,f1,f2);
+ 
+       for (Standard_Integer e = e1; e <= e2; e++) {
+-        HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
+        HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
+         HLRAlgo::DecodeMinMax(ed.MinMax(), TheMin, TheMax);
+        if (FirstTime) {
+          FirstTime = Standard_False;
+@@ -307,7 +307,7 @@ void HLRBRep_InternalAlgo::InitEdgeStatus ()
+   Standard_Integer nf = myDS->NbFaces();
+ 
+   for (Standard_Integer e = 1; e <= ne; e++) {
+-    HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
+    HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
+     if (ed.Selected()) ed.Status().ShowAll();
+   }
+ //  for (Standard_Integer f = 1; f <= nf; f++) {
+@@ -368,7 +368,7 @@ void HLRBRep_InternalAlgo::Select ()
+     Standard_Integer nf = myDS->NbFaces();
+     
+     for (Standard_Integer e = 1; e <= ne; e++) {
+-      HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
+      HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
+       ed.Selected(Standard_True);
+     }
+     
@@ -0,0 +1,22 @@
+From a0deb4ce8b43cf3c8b8c0a4225c6be5296446dbd Mon Sep 17 00:00:00 2001
+From: Adam Eri <adam.eri@blackmirror.media>
+Date: Tue, 3 Sep 2019 23:30:20 +0200
+Subject: [PATCH] Resolves compile error on macOS
+
+Resolves "no member named 'isnan' in namespace 'std'" on macOS
+---
+ GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp b/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+index 1f9a3eef..dd6f5c59 100644
+--- a/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+++ b/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+@@ -10,6 +10,7 @@
+ 
+ #include "GeneratedSaxParserUtils.h"
+ #include <math.h>
+#include <cmath>
+ #include <memory>
+ #include <string.h>
+ #include <limits>
@@ -1,11 +1,6 @@
 #!/usr/bin/bash
 set -ex

-PYODIDE_VERSION=0.29.3
-PYODIDE_BUILD_VERSION=0.33.0
-PYODIDE_XBUILDENV_ROOT="${HOME}/.cache/.pyodide-xbuildenv-${PYODIDE_BUILD_VERSION}"
-PYODIDE_XBUILDENV="${PYODIDE_XBUILDENV_ROOT}/${PYODIDE_VERSION}"
-
 # Script is assuming that it will be possible to execute it multiple times
 # therefore we're clearing venv each time and ignoring existing 'emsdk' folder.

@@ -16,15 +11,14 @@ source .venv/bin/activate

 # Install pyodide cross build environment.
 # Instructions: https://pyodide.org/en/stable/development/building-packages.html
-uv pip install "pyodide-build==${PYODIDE_BUILD_VERSION}"
+uv pip install pyodide-build
 # `uv run` is required, so xbuildenv would skip using `pip`.
-uv run pyodide xbuildenv install "${PYODIDE_VERSION}"
+uv run pyodide xbuildenv install
 uv run pyodide xbuildenv install-emscripten

-EMSDK_ROOT="${PYODIDE_XBUILDENV}/emsdk"
-source "${EMSDK_ROOT}/emsdk_env.sh"
+EMSDK_ROOT=$(pyodide config get emscripten_dir)
+source ${EMSDK_ROOT}/emsdk_env.sh
 which emcc
-emcc --version

 mkdir -p packages/ifcopenshell
 VERSION=`cat IfcOpenShell/VERSION`
@@ -1,8 +1,13 @@
 [project]
 name = "IfcOpenShell"
 version = "0.0.0"
-# Don't provide requires-python explicitly
-# allowing pyprojects to set their own (e.g. bonsai and general ifcopenshell version differ).
+dependencies = [
+    "black==26.3.1",
+    "ruff==0.15.10",
+    "poethepoet",
+    "ty==0.0.29",
+    "gersemi==0.26.1",
+]

 [tool.black]
 line-length = 120
@@ -38,7 +43,6 @@ exclude = [
 # then they will be inherited by projects' .toml files.
 # This allows using assuming different Python version for different projects.
 [tool.ruff]
-line-length = 120
 exclude = [
    # Submodules.
    "src/ifcopenshell-python/ifcopenshell/express",
@@ -79,36 +83,92 @@ ignore = [
 ]

 [tool.ty.rules]
-all = "error"
+all = "ignore"

 # Structural rules (no deep type inference needed, easier to adapt).
-# Maybe later, requires to specify element types for all generics.
-missing-type-argument = "ignore"
-# Conflicts with `bpy` props defined using annotations.
-invalid-type-form = "ignore"
+abstract-method-in-final-class = "error"
+ambiguous-protocol-member = "error"
+conflicting-declarations = "error"
+conflicting-metaclass = "error"
+cyclic-class-definition = "error"
+cyclic-type-alias-definition = "error"
+dataclass-field-order = "error"
+duplicate-base = "error"
+duplicate-kw-only = "error"
+empty-body = "error"
+escape-character-in-forward-annotation = "error"
+final-on-non-method = "error"
+final-without-value = "error"
+ignore-comment-unknown-rule = "error"
+implicit-concatenated-string-type-annotation = "error"
+inconsistent-mro = "error"
+ineffective-final = "error"
+instance-layout-conflict = "error"
+invalid-dataclass = "error"
+invalid-dataclass-override = "error"
+invalid-enum-member-annotation = "error"
+invalid-explicit-override = "error"
+invalid-frozen-dataclass-subclass = "error"
+invalid-generic-class = "error"
+invalid-generic-enum = "error"
+invalid-ignore-comment = "error"
+invalid-legacy-positional-parameter = "error"
+invalid-legacy-type-variable = "error"
+invalid-named-tuple = "error"
+invalid-newtype = "error"
+invalid-overload = "error"
+invalid-paramspec = "error"
+invalid-protocol = "error"
+invalid-syntax-in-forward-annotation = "error"
+invalid-total-ordering = "error"
+invalid-type-alias-type = "error"
+invalid-type-checking-constant = "error"
+invalid-type-guard-definition = "error"
+invalid-type-variable-bound = "error"
+invalid-type-variable-constraints = "error"
+invalid-typed-dict-header = "error"
+invalid-typed-dict-statement = "error"
+override-of-final-method = "error"
+override-of-final-variable = "error"
+possibly-missing-import = "error"
+possibly-missing-submodule = "error"
+# Has false positives due to ty walrus operator bug.
+# possibly-unresolved-reference = "error"
+raw-string-type-annotation = "error"
+redundant-final-classvar = "error"
+shadowed-type-variable = "error"
+subclass-of-final-class = "error"
+super-call-in-named-tuple-method = "error"
+unavailable-implicit-super-arguments = "error"
+unbound-type-variable = "error"
+undefined-reveal = "error"
+unresolved-global = "error"
+unresolved-import = "error"
+unresolved-reference = "error"
+unused-ignore-comment = "error"
+unused-type-ignore-comment = "error"
+useless-overload-body = "error"

 # Non-structural rules:
+deprecated = "error"
+zero-stepsize-in-slice = "error"
+possibly-missing-implicit-call = "error"
+unused-awaitable = "error"
+
+# Function argument rules:
 # Conflicts with `ifcopenshell.api.geometry.add_representation` type of callables we have, confusing them with a module.
-call-non-callable = "ignore"
-# bpy is missing some context manager implementations.
-invalid-context-manager = "ignore"
-# Doesn't go well with `bpy.ops.xxx.yyy`.
-unresolved-attribute = "ignore"
+# call-non-callable = "error"
+conflicting-argument-forms = "error"
 # Too many false positives.
-invalid-argument-type = "ignore"
-invalid-method-override = "ignore"
-invalid-assignment = "ignore"
-invalid-parameter-default = "ignore"
-missing-override-decorator = "ignore"
-invalid-yield = "ignore"
-invalid-return-type = "ignore"
-non-callable-init-subclass = "ignore"
-not-iterable = "ignore"
-possibly-missing-attribute = "ignore"
-no-matching-overload = "ignore"
-not-subscriptable = "ignore"
-unsupported-dynamic-base = "ignore"
-unsupported-operator = "ignore"
+# invalid-argument-type = "error"
+missing-argument = "error"
+parameter-already-assigned = "error"
+positional-only-parameter-as-kwarg = "error"
+too-many-positional-arguments = "error"
+unknown-argument = "error"
+# Has a lot of warnings due to current ty walrus operator issues.
+# index-out-of-bounds = "error"
+# unresolved-attribute = "error"

 [tool.ty.environment]
 extra-paths = [
@@ -155,18 +215,6 @@ exclude = [

 [tool.poe.tasks]

-dev-setup.sequence = [
-    {cmd = "uv sync"},
-    {cmd = "uv pip install -e ./src/bsdd/"},
-    {cmd = "uv pip install -e ./src/ifcopenshell-python/[advanced,dev]"},
-    {cmd = "uv pip install -e ./src/ifcedit/"},
-    {cmd = "uv pip install -e ./src/ifcpatch/"},
-    {cmd = "uv pip install -e ./src/ifcquery/"},
-    {cmd = "uv pip install -e './src/ifcmcp/[mcp]'"},
-    {cmd = "uv pip install -r src/bonsai/requirements-dev.txt"},
-]
-dev-setup.help = "Install repo packages in editable mode"
-
 ruff = "ruff check"

 black = "black ."
@@ -192,9 +240,9 @@ format.sequence = ["black", "ruff"]
 cmake-format = "gersemi . --in-place"

 [tool.poe.tasks.ty-ios]
+# --ignore unresolved-reference: walrus operator false positives in ty.
 cmd = """
    ty check
-    nix/
    src/bcf
    src/bsdd
    src/ifc2ca
@@ -209,6 +257,7 @@ cmd = """
    src/ifcpatch
    src/ifctester
    --python=src/ifcopenshell-python/.venv
+    --ignore unresolved-reference
 """

 [tool.poe.tasks.bonsai-deps]
@@ -1,5 +0,0 @@
-black==26.3.1
-ruff==0.15.22
-poethepoet
-ty==0.0.61
-gersemi==0.26.1
@@ -188,8 +188,6 @@ class BcfClient:
                response.raise_for_status()
            return response.status_code, response.text
        except requests.exceptions.HTTPError as errh:
-            response = errh.response
-            assert response is not None
            print(f"message: {response.reason}'  '{response.status_code}, {errh}")
            return response.status_code, response.reason

@@ -208,8 +206,6 @@ class BcfClient:
                response.raise_for_status()
            return response.status_code, response.text
        except requests.exceptions.HTTPError as errh:
-            response = errh.response
-            assert response is not None
            print(f"message: {response.reason}'  '{response.status_code}, {errh}")
            return response.status_code, response.reason

@@ -226,8 +222,6 @@ class BcfClient:
                response.raise_for_status()
            return response.status_code, response.text
        except requests.exceptions.HTTPError as errh:
-            response = errh.response
-            assert response is not None
            print(f"message: {response.reason}'  '{response.status_code}, {errh}")
            return response.status_code, response.reason

@@ -106,7 +106,7 @@ endif
 endif # def PLATFORM

 # Current build commit hash.
-OLD:=3e7b739
+OLD:=1c5b825
 .PHONY: bump
 bump:
 ifndef NEW
@@ -192,11 +192,7 @@ endif
 	# Provides networkx graph analysis for project dependency calculations
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download networkx --dest=./wheels
 	# Required by IFCDiff
-	# Pinned <9.1: deepdiff 9.1.0 adds cachebox<6,>=5.2 which only ships macOS x86_64
-	# wheels for macosx_10_12+ and is incompatible with our macos py311 --platform
-	# macosx_10_10_x86_64 target. Revisit once the macos py311 platform tag is bumped
-	# to 10_13 (matching py312/py313).
-	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download "deepdiff<9.1" --dest=./wheels
+	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download deepdiff --dest=./wheels
 	# Required by IFCCSV and ifcopenshell.util.selector
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download lark --dest=./wheels
 	# Required by IFC4D
@@ -360,10 +356,6 @@ else
 	pytest test/tool/test_$(MODULE).py --maxfail=1
 endif

-.PHONY: test-modal
-test-modal:
-	blender --enable-event-simulate --python test/modal/test_modal.py --window-maximized
-
 # Reregistering test is not added to the standard test suite because during unregister
 # Blender removes all Bonsai dependencies breaking dev-environment symlinks.
 .PHONY: test-reregister
@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.

 import importlib
 import os
@@ -27,7 +25,7 @@ import bpy
 import bpy.utils.previews
 from bpy_extras.io_utils import ExportHelper, ImportHelper

-from . import handler, operator, parametric_lifecycle, prop, ui
+from . import handler, operator, prop, ui

 try:
    from bonsai.translations import translations_dict
@@ -90,7 +88,6 @@ modules = {
    "web": None,
    "light": None,
    "alignment": None,
-    "clip_box": None,
    # Uncomment this line to enable loading of the demo module. Happy hacking!
    # The name "demo" must correlate to a folder name in `bim/module/`.
    # "demo": None,
@@ -160,6 +157,9 @@ classes = [
    ui.BIM_UL_tab_visibilities,
    ui.BIM_UL_panel_visibilities,
    ui.DocPreferences,
+    ui.GizmoPreferencesDoor,  # Register before GizmoPreferences
+    ui.GizmoPreferencesWindow,  # Register before GizmoPreferences
+    ui.GizmoPreferencesStair,  # Register before GizmoPreferences
    ui.GizmoPreferences,
    # ui.DefaultParameters and ui.BIM_ADDON_preferences are registered separately after modules (see late_classes below)
    # Tabs panel
@@ -268,8 +268,6 @@ def register():
    bpy.app.handlers.depsgraph_update_post.append(on_register)
    bpy.app.handlers.undo_post.append(handler.undo_post)
    bpy.app.handlers.redo_post.append(handler.redo_post)
-    # Must follow the two appends above so regenerators see restored IFC state.
-    parametric_lifecycle.install_parametric_lifecycle_handlers()
    bpy.app.handlers.load_post.append(handler.load_post)
    bpy.app.handlers.load_post.append(handler.loadIfcStore)
    bpy.types.Scene.BIMProperties = bpy.props.PointerProperty(type=prop.BIMProperties)
@@ -327,7 +325,6 @@ def unregister():

    unregister_classes(classes)

-    parametric_lifecycle.uninstall_parametric_lifecycle_handlers()
    bpy.app.handlers.load_post.remove(handler.load_post)
    bpy.app.handlers.load_post.remove(handler.loadIfcStore)
    del bpy.types.Scene.BIMProperties
@@ -24,28 +24,10 @@ a text, a tspan {  fill: blue !important;  text-decoration: underline;}
 a:hover { cursor: pointer; }
 .cut { fill: black; stroke: black; stroke-linecap: 'round'; stroke-width: 0.35; fill-rule: evenodd; }
 .projection { fill: white; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
-/* SVG edge classification (issue #3668): see edge-classification.md. These select directly on
-   the <path> element (each classified projection edge carries its own class), so they win over
-   the inherited .projection rule above regardless of specificity. */
-path.outline { stroke: black; stroke-width: 0.35; stroke-opacity: 1; }
-path.boundary { stroke: black; stroke-width: 0.3; stroke-opacity: 0.9; }
-path.crease { stroke: black; stroke-width: 0.25; stroke-opacity: 0.85; }
-path.sharp { stroke: black; stroke-width: 0.18; stroke-opacity: 0.7; }
-path.flush { stroke: black; stroke-width: 0.1; stroke-opacity: 0.4; }
-
-/* Debug CSS for troubleshooting edge classification */
-/*
-path.outline { stroke: black; stroke-width: 0.35; stroke-opacity: 1; }
-path.boundary { stroke: orange; stroke-width: 0.3; stroke-opacity: 0.9; }
-path.crease { stroke: green; stroke-width: 0.25; stroke-opacity: 0.85; }
-path.sharp { stroke: red; stroke-width: 0.18; stroke-opacity: 0.7; }
-path.flush { stroke: blue; stroke-width: 0.1; stroke-opacity: 0.4; }
-*/
-
-.surface {fill: white; stroke-width: 0.1;}
-.annotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.3; }
-.IfcAnnotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.3; }
-/* .IfcGeographicElement { fill: none; stroke: rgb(150, 150, 150); stroke-linecap: 'round'; stroke-dasharray: 1, 2;} */
+.surface { stroke: none; fill: #fff; fill-rule: evenodd; }
+.annotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
+.IfcAnnotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
+.IfcGeographicElement { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 1; }
 .PredefinedType-LINEWORK { stroke: black; stroke-width: 0.25; }
 .PredefinedType-LINEWORK.dashed { stroke-dasharray: 3, 2; }
 .PredefinedType-LINEWORK.fine { stroke-width: 0.18; stroke: #777777; }
@@ -1,96 +0,0 @@
-Copyright (c) 2011-2012, Nikita Volchenkov (<nikitavolchenkov@gmail.com>),
-with Reserved Font Name OpenGost Type B.
-
-Copyright (c) 2012, Valek Filippov (<frob@gnome.org>).
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-
-----------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',$,$,'EPset_Drawing','EPset_D
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#23,#22,#27,#24,#29,#30,#19,#12,#26,#9,#8,#7,#6,#4,#18,#11,#5,#20,#25,#14,#10,#17,#28,#16,#3,#21,#13,#15,#2,#31,#32,#33,#34,#35,#36,#37));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#23,#22,#27,#24,#19,#12,#26,#9,#8,#7,#6,#4,#18,#11,#5,#20,#25,#14,#10,#17,#28,#16,#3,#21,#13,#15,#2));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','The scale of this drawing represented as a numerator and denominator, such as 1/100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','The scale of this drawing in human readable format, such as 1:100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -33,14 +33,5 @@ DATA;
 #26=IFCSIMPLEPROPERTYTEMPLATE('2iwERDOW55Pf4hCbuFRe1Q',$,'FillMode','Method to fill areas seen in projection',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #27=IFCSIMPLEPROPERTYTEMPLATE('1YF$qLzBzF19Io8aB2N8cE',$,'CutMode','Method for cutting geometry',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #28=IFCSIMPLEPROPERTYTEMPLATE('1YSnFzurrEyRNtoLdmmddP',$,'BringToFront','The objects with these SVG classes will render in front of all other objects.Ex: IfcBeam, IfcColumn',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
-#29=IFCSIMPLEPROPERTYTEMPLATE('0lP6Y8q9v2QhDnR4sT7uVx',$,'PerspectiveShiftX','Horizontal perspective camera shift stored as drawing metadata using Blender camera shift units.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
-#30=IFCSIMPLEPROPERTYTEMPLATE('2mR8b1NcW5EoFyG7hJ9kLp',$,'PerspectiveShiftY','Vertical perspective camera shift stored as drawing metadata using Blender camera shift units.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
-#31=IFCSIMPLEPROPERTYTEMPLATE('1cFVJnqT13m8ItkMHaI1tp',$,'UseEdgeClassification','Enable the boundary/outline/sharp/crease/flush SVG edge classification scheme (issue #3668). When false, drawings use the original unclassified linework.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#32=IFCSIMPLEPROPERTYTEMPLATE('2kB$mxBgnBUvhjh0Ti0c4P',$,'RenderCreases','Whether to render ''crease'' (concave) edges. Only relevant when UseEdgeClassification is enabled.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#33=IFCSIMPLEPROPERTYTEMPLATE('3MSIJNW$T8r9Hl12kk0BY$',$,'ValleyAngleMinDegrees','Minimum concave dihedral deviation from flat, in degrees, for a projection edge to be classified as ''crease'' rather than ''flush''.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
-#34=IFCSIMPLEPROPERTYTEMPLATE('2epSGfC4bFM9gb1X7zBIp4',$,'RenderSharp','Whether to render ''sharp'' (convex) edges. Only relevant when UseEdgeClassification is enabled.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#35=IFCSIMPLEPROPERTYTEMPLATE('3TZwsEjkr5WRDKcgrYzSIA',$,'RidgeAngleMinDegrees','Minimum convex dihedral deviation from flat, in degrees, for a projection edge to be classified as ''sharp'' rather than ''flush''.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
-#36=IFCSIMPLEPROPERTYTEMPLATE('2Jua$lO754vgZOkBoHM2gA',$,'RenderFlush','Whether to render ''flush'' edges (dihedral deviation below both ridge/valley thresholds). Only relevant when UseEdgeClassification is enabled.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#37=IFCSIMPLEPROPERTYTEMPLATE('1zM9sia2L8RQDnWZxgUwlZ',$,'JoinClasses','Comma separated list of IFC classes whose cut linework will be joined together when they meet (e.g. mitred at a corner).\X2\000A\X0\Defaults to ''IfcWall,IfcSlab'' if not set. Override to also join other classes, such as ''IfcWall,IfcSlab,IfcCovering''.',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;
@@ -244,7 +244,7 @@ function addGanttElement(blenderId, tasks, workSched, filename) {
      vShowTaskInfoLink: 1, // Show link in tool tip (0/1)
      vShowEndWeekDate: 0, // Show/Hide the date for the last day of the week in header for daily
      vUseSingleCell: 10000, // Set the threshold cell per table row (Helps performance for large data.
-      vFormatArr: ["Hour", "Day", "Week", "Month", "Quarter"], // vUseSingleCell keeps Hour usable on large charts.
+      vFormatArr: ["Day", "Week", "Month", "Quarter"], // Even with setUseSingleCell using Hour format on such a large chart can cause issues in some browsers,
      vShowRes: true, // Disable the resource column.
      vShowComp: false, // Disable the completion column.
      vShowDur: false, // Disable the duration column, because jsgantt doesn't calculate durations the way we want.
@@ -1,119 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Shared structural-change cache token for POST_VIEW decorators.
-
-Decorators include the token in their cache key and rebuild on bump."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any, Generic, TypeVar
-
-import bpy
-
-T = TypeVar("T")
-
-_DECORATOR_CACHE_TOKEN = 0
-
-
-def get_decorator_cache_token() -> int:
-    return _DECORATOR_CACHE_TOKEN
-
-
-def reset_for_test() -> None:
-    """Test-only: reset the cache token to 0 so bump-count assertions are stable."""
-    global _DECORATOR_CACHE_TOKEN
-    _DECORATOR_CACHE_TOKEN = 0
-
-
-@bpy.app.handlers.persistent
-def _bump_decorator_cache_token(*args: Any) -> None:
-    """depsgraph_update_post fires every animation frame and every driver
-    evaluation, even when no IFC-relevant ID block changed. Unconditional
-    bumping defeats the cache: an animated scene rebuilds every decorator
-    every viewport tick. Gate the depsgraph path on Object geometry or
-    transform updates; undo / redo / load have no depsgraph and always
-    invalidate.
-
-    Coverage assumption: ``TokenCache`` consumers key on Object identity
-    (depsgraph updates whose ``id`` is a ``bpy.types.Object``). Mesh /
-    Material / NodeTree updates that don't surface as an Object change
-    do NOT invalidate the token — a decorator that caches material- or
-    mesh-data-derived state must gate on a separate signal."""
-    global _DECORATOR_CACHE_TOKEN
-    if len(args) >= 2:
-        depsgraph = args[1]
-        if depsgraph is not None and hasattr(depsgraph, "updates"):
-            if not any(
-                (getattr(u, "is_updated_geometry", False) or getattr(u, "is_updated_transform", False))
-                and hasattr(u, "id")
-                and isinstance(u.id, bpy.types.Object)
-                for u in depsgraph.updates
-            ):
-                return
-    _DECORATOR_CACHE_TOKEN += 1
-
-
-def _hooks() -> tuple[Any, ...]:
-    return (
-        bpy.app.handlers.depsgraph_update_post,
-        bpy.app.handlers.undo_post,
-        bpy.app.handlers.redo_post,
-        bpy.app.handlers.load_post,
-    )
-
-
-def install_decorator_cache_handlers() -> None:
-    """Append the bump handler to each hook; idempotent."""
-    for hook in _hooks():
-        if _bump_decorator_cache_token not in hook:
-            hook.append(_bump_decorator_cache_token)
-
-
-def uninstall_decorator_cache_handlers() -> None:
-    for hook in _hooks():
-        try:
-            hook.remove(_bump_decorator_cache_token)
-        except ValueError:
-            pass
-
-
-class TokenCache(Generic[T]):
-    """Memoise a single value keyed on ``(caller_key, get_decorator_cache_token())``.
-
-    The token component invalidates the cache on depsgraph / undo / redo / load,
-    so cached ``bpy.types.Object`` references can't outlive the underlying ID
-    blocks. Holds exactly one entry — last key wins."""
-
-    __slots__ = ("_key", "_value")
-
-    def __init__(self) -> None:
-        self._key: tuple[Any, int] | None = None
-        self._value: T | None = None
-
-    def get_or_compute(self, key: Any, compute: Callable[[], T]) -> T:
-        token_key = (key, _DECORATOR_CACHE_TOKEN)
-        if token_key == self._key:
-            return self._value  # type: ignore[return-value]
-        value = compute()
-        self._key = token_key
-        self._value = value
-        return value
@@ -15,12 +15,11 @@
 #
 # 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 os
 import weakref
 from collections.abc import Callable
+from math import cos
 from typing import Union

 import bpy
@@ -32,32 +31,16 @@ from bpy.app.handlers import persistent
 from mathutils import Vector

 import bonsai.bim
-import bonsai.core.model as core_model
 import bonsai.tool as tool
-from bonsai.bim.decorator_cache import (
-    install_decorator_cache_handlers,
-    uninstall_decorator_cache_handlers,
-)
-from bonsai.bim.ifc import IfcStore, get_cache_or_detect_lock
+from bonsai.bim.ifc import IfcStore
 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.wall import WallGizmoPreviewDecorator
 from bonsai.bim.module.nest.decorator import NestDecorator

 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -125,13 +108,19 @@ def active_object_callback():


 def update_bim_tool_props():
-    """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:
+    """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:
        return
-    obj, current_tool, element = ctx

    props = tool.Model.get_model_props()
    aprops = tool.Drawing.get_annotation_props()
@@ -144,85 +133,18 @@ def update_bim_tool_props():

            if is_annotation_tool and (object_type := tool.Drawing.get_annotation_type_object_type(element_type)):
                aprops.object_type = object_type
-                try:
-                    aprops.relating_type_id = str(element_type.id())
-                except TypeError:
-                    # EnumProperty items are rebuilt asynchronously when ifc_class changes;
-                    # this assignment can race a stale item list. Skipping is harmless —
-                    # the UI will resync on the next active_object_callback.
-                    pass
+                aprops.relating_type_id = str(element_type.id())
                return

            if is_bim_tool:
-                try:
-                    props.ifc_class = element_type.is_a()
-                except TypeError:
-                    # ifc_class only lists element/space types present in the model, so an
-                    # unsupported type (e.g. a raw IfcTypeProduct) or a stale item list mid-
-                    # rebuild raises `enum "<class>" not found`. Skip rather than crash the
-                    # handler — it re-fires on the next selection and the panel resyncs.
-                    pass
+                props.ifc_class = element_type.is_a()

-            # Only assign when the target enum is the one that lists this type — otherwise
-            # we hit `enum "<id>" not found in (...)` if the user selects an element of a
-            # different class than the workspace tool was built for (e.g. selecting a wall
-            # while the door tool is active).
-            tool_class_match = TOOLS_TO_CLASSES_MAP.get(current_tool.idname) == element_type.is_a()
-            bim_tool_class_match = is_bim_tool and props.ifc_class == element_type.is_a()
-            if bim_tool_class_match or tool_class_match:
-                try:
-                    props.relating_type_id = str(element_type.id())
-                except TypeError:
-                    # Defensive: the enum item list can lag behind ifc_class assignment
-                    # above. Skipping leaves the panel briefly out of sync rather than
-                    # crashing the handler (which Blender re-fires on every selection).
-                    pass
+            if is_bim_tool or TOOLS_TO_CLASSES_MAP.get(current_tool.idname) == element_type.is_a():
+                props.relating_type_id = str(element_type.id())

    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
@@ -240,13 +162,10 @@ def _read_headers_into_props(obj, element):
    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"]
-        props.extrusion_depth = core_model.vertical_height_from_extrusion_depth(
-            extrusion.Depth * si_conversion, x_angle
-        )
+        props.extrusion_depth = abs(extrusion.Depth * si_conversion * cos(x_angle))
        props.length = (axis[1] - axis[0]).length
        props.x_angle = x_angle

@@ -320,11 +239,9 @@ def loadIfcStore(scene: bpy.types.Scene) -> None:
    IfcStore.purge()
    refresh_ui_data()
    if not tool.Ifc.get():
-        tool.Autosave.cancel_timer()
        return
    tool.Ifc.schema()
    IfcStore.relink_all_objects()
-    tool.Autosave.reset_timer()


@persistent
@@ -439,10 +356,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, load-transient parametric state, and the
-    multi-instance lock probe."""
+@persistent
+def load_post(scene):
    global global_subscription_owner
    active_object_key = bpy.types.LayerObjects, "active"
    bpy.msgbus.subscribe_rna(
@@ -453,23 +368,6 @@ def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
    ifcopenshell.api.owner.settings.get_application = get_application
    AuthoringData.type_thumbnails = {}

-    tool.Parametric.on_load_post(scene)
-
-    if tool.Ifc.get() and bpy.data.is_saved:
-        props = tool.Blender.get_bim_props()
-        props.has_blend_warning = True
-
-    # Probe the H5 cooked-geometry cache so the multi-instance warning surfaces
-    # right after .blend load. Without this, the lock is only detected when a
-    # mutation triggers ``clear_cache`` — by which time the user has already
-    # made changes that may now conflict with the other Blender instance.
-    if tool.Ifc.get():
-        get_cache_or_detect_lock()
-
-
-def _apply_user_preferences() -> None:
-    """User-preference-driven UI setup: toolbar, BIM workspace, viewport shading
-    subscription, scene-panel hijack, tab layout, snap defaults."""
    preferences = tool.Blender.get_addon_preferences()
    if not preferences.should_setup_toolbar:
        tool.Blender.unregister_toolbar()
@@ -493,21 +391,11 @@ def _apply_user_preferences() -> None:
        tool.Blender.override_scene_panel(panel)
    tool.Blender.setup_tabs()

-    if preferences.should_use_snap and (scene := bpy.context.scene):
-        # Snapping is off by default in Blender, but in BIM, it's more useful to be on
-        scene.tool_settings.use_snap = True
-        # Match default Bonsai snaps
-        scene.tool_settings.snap_elements_base = {"EDGE", "EDGE_PERPENDICULAR", "VERTEX", "EDGE_MIDPOINT", "FACE"}
+    if tool.Ifc.get() and bpy.data.is_saved:
+        props = tool.Blender.get_bim_props()
+        props.has_blend_warning = True

-    tool.Blender.sync_old_preferences()
-
-
-def _install_viewport_overlays() -> None:
-    """Sync every Bonsai viewport decorator to its enabled state.
-
-    Wrapped in uninstall/install of the decorator-cache bump handlers so a
-    decorator's own install path doesn't double-bind to depsgraph_update_post
-    via ``TokenCache`` instances created during their own ``install()``."""
+    # Bonsai overlays
    georeference_props = tool.Georeference.get_georeference_props()
    aggregate_props = tool.Aggregate.get_aggregate_props()
    nest_props = tool.Nest.get_nest_props()
@@ -517,62 +405,23 @@ 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:
-            GeoreferenceDecorator.install(bpy.context)
-        if aggregate_props.aggregate_decorator:
-            AggregateDecorator.install(bpy.context)
-        if nest_props.nest_decorator:
-            NestDecorator.install(bpy.context)
-        if model_props.show_wall_axis:
-            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()
+    if georeference_props.should_visualise:
+        GeoreferenceDecorator.install(bpy.context)
+    if aggregate_props.aggregate_decorator:
+        AggregateDecorator.install(bpy.context)
+    if nest_props.nest_decorator:
+        NestDecorator.install(bpy.context)
+    if model_props.show_wall_axis:
+        WallAxisDecorator.install(bpy.context)
+    if model_props.show_slab_direction:
+        SlabDirectionDecorator.install(bpy.context)
+    if model_props.show_bounding_box:
+        BoundingBoxDecorator.install(bpy.context)

+    if preferences.should_use_snap and (scene := bpy.context.scene):
+        # Snapping is off by default in Blender, but in BIM, it's more useful to be on
+        scene.tool_settings.use_snap = True
+        # Match default Bonsai snaps
+        scene.tool_settings.snap_elements_base = {"EDGE", "EDGE_PERPENDICULAR", "VERTEX", "EDGE_MIDPOINT", "FACE"}

-@persistent
-def load_post(scene):
-    _apply_save_file_invariants(scene)
-    _apply_user_preferences()
-    _install_viewport_overlays()
+    tool.Blender.sync_old_preferences()
@@ -46,7 +46,7 @@ IFC_CONNECTED_TYPE = Union[bpy.types.Material, bpy.types.Object]
 class OperationData(TypedDict):
    id: int
    guid: NotRequired[str]
-    obj: NotRequired[str]
+    obj: str


 class EditObjectOperationData(TypedDict):
@@ -64,44 +64,6 @@ class TransactionStep(TypedDict):
    operations: list[Operation]


-# Set when ``IfcStore.get_cache`` observes an external lock on the HDF5 cache —
-# signal that another Blender process has the same IFC file open. Project panel
-# polls ``is_cache_locked_by_other_process`` to warn the user. The dismissed
-# flag is sticky per-session so the warning doesn't re-nag once the user has
-# acknowledged it.
-_cache_locked_by_other_process: bool = False
-_multi_instance_warning_dismissed: bool = False
-
-
-def is_cache_locked_by_other_process() -> bool:
-    return _cache_locked_by_other_process and not _multi_instance_warning_dismissed
-
-
-def dismiss_multi_instance_warning() -> None:
-    global _multi_instance_warning_dismissed
-    _multi_instance_warning_dismissed = True
-
-
-def get_cache_or_detect_lock() -> ifcopenshell.geom.serializers.hdf5 | None:
-    """Like ``IfcStore.get_cache`` but tracks the multi-instance lock flag — sets
-    it on ``PermissionError``, clears it (along with the dismiss flag) when a
-    subsequent call succeeds. Returns ``None`` on lock; other exceptions
-    propagate. Callers that don't need the warning side effect can use
-    ``IfcStore.get_cache`` directly."""
-    global _cache_locked_by_other_process, _multi_instance_warning_dismissed
-    try:
-        cache = IfcStore.get_cache()
-    except PermissionError:
-        _cache_locked_by_other_process = True
-        return None
-    if _cache_locked_by_other_process:
-        # Lock released — clear both flags so a future re-locking re-surfaces
-        # the warning rather than staying suppressed by the previous dismiss.
-        _cache_locked_by_other_process = False
-        _multi_instance_warning_dismissed = False
-    return cache
-
-
 class IfcStore:
    path: str = ""
    """Should be set only using ``tool.Ifc.set_path``."""
@@ -234,7 +196,7 @@ class IfcStore:
                shutil.copy2(IfcStore.cache_path, new_cache_path)
            except PermissionError:
                pass  # Well we tried. No cache for you!
-        get_cache_or_detect_lock()
+        IfcStore.get_cache()

    @staticmethod
    def load_file(path: str) -> None:
@@ -552,7 +514,6 @@ class IfcStore:
                    BrickStore.end_transaction()
                IfcStore.end_transaction(operator)
                bonsai.bim.handler.refresh_ui_data()
-                tool.Parametric.refresh_post_commit(operator)

                if method == "MODAL":
                    cls.modal_in_progress = False
@@ -566,19 +527,6 @@ class IfcStore:
                result = getattr(operator, "_modal")(context, event)
        except:
            bonsai.last_error = traceback.format_exc()
-            # An operator that mutated IFC then raised leaves the IFC graph captured
-            # by the transaction but the Blender side stale. Blender does not push an
-            # undo step for a raised operator (mirror of the CANCELLED-modal gap
-            # handled below), so we push one here so Ctrl+Z actually rewinds the
-            # partial mutation, then surface the recovery path to the user.
-            ifc_file = tool.Ifc.get()
-            if ifc_file and ifc_file.transaction and ifc_file.transaction.operations:
-                bpy.ops.ed.undo_push(message=f"Recover {operator.bl_idname}")
-                operator.report(
-                    {"WARNING"},
-                    "Operation partially completed (IFC changed, Blender state may be stale). "
-                    "Press Ctrl+Z to restore the previous state.",
-                )
            # Try to ensure undo will work since Blender undo does work in case of errors.
            # As error come unexpectedly, it's important that user might have a chance to save the file
            # before they got the error and not to lose the work they've done.
@@ -223,7 +223,6 @@ class IfcImporter:
        self.elements: set[ifcopenshell.entity_instance] = set()
        self.annotations: set[ifcopenshell.entity_instance] = set()
        self.gross_elements: set[ifcopenshell.entity_instance] = set()
-        self.broken_arrays: set[ifcopenshell.entity_instance] = set()
        self.element_types: set[ifcopenshell.entity_instance] = set()
        self.spatial_elements: set[ifcopenshell.entity_instance] = set()
        self.meshes: dict[str, OBJECT_DATA_TYPE] = {}
@@ -980,13 +979,8 @@ class IfcImporter:
                    if unit.Name == "METRE":
                        if not unit.Prefix:
                            bpy.context.scene.unit_settings.length_unit = "METERS"
-                        elif f"{unit.Prefix}METERS" in ("KILOMETERS", "CENTIMETERS", "MILLIMETERS", "MICROMETERS"):
-                            bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
                        else:
-                            # Blender's length_unit enum has no entry for other
-                            # SI prefixes (e.g. DECIMETERS), so fall back to
-                            # adaptive display instead of failing to open.
-                            bpy.context.scene.unit_settings.length_unit = "ADAPTIVE"
+                            bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
                else:
                    bpy.context.scene.unit_settings.system = "IMPERIAL"
                    name = unit.Name.lower()
@@ -1103,14 +1097,12 @@ class IfcImporter:
        vertices = [[v[i], v[i + 1], v[i + 2], 1] for i in range(0, len(v), 3)]
        edges = [[e[i], e[i + 1]] for i in range(0, len(e), 2)]
        v2 = None
-        polyline = None
        for edge in edges:
            v1 = vertices[edge[0]]
            if v1 != v2:
                polyline = curve.splines.new("POLY")
                polyline.points[-1].co = mathutils.Vector(v1)
            v2 = vertices[edge[1]]
-            assert polyline is not None
            polyline.points.add(1)
            polyline.points[-1].co = mathutils.Vector(v2)
        edges_item_ids = ifcopenshell.util.shape.get_edges_representation_item_ids(geometry).tolist()
@@ -1227,18 +1219,8 @@ class IfcImporter:
                        if element not in elements_to_import:
                            continue
                    for i in range(len(data)):
-                        tool.Array.set_children_lock_state(element, i, True)
-                    tool.Array.constrain_children_to_parent(element)
-                    for layer in data:
-                        for child_guid in layer.get("children", ()):
-                            try:
-                                self.file.by_guid(child_guid)
-                            except RuntimeError:
-                                print(
-                                    f"setup_arrays: array parent {element.GlobalId} references missing "
-                                    f"child GUID {child_guid!r}."
-                                )
-                                self.broken_arrays.add(element)
+                        tool.Blender.Modifier.Array.set_children_lock_state(element, i, True)
+                        tool.Blender.Modifier.Array.constrain_children_to_parent(element)

    def update_linked_aggregates(self):
        # TODO Remove this after a while. See commit 17d6b8a
@@ -20,6 +20,7 @@ import blf
 import bpy
 import gpu
 import ifcopenshell.util.element
+from bpy.types import SpaceView3D
 from bpy_extras import view3d_utils
 from gpu_extras.batch import batch_for_shader
 from mathutils import Vector
@@ -27,6 +28,12 @@ from mathutils import Vector
 import bonsai.tool as tool


+def transparent_color(color, alpha=0.1):
+    color = [i for i in color]
+    color[3] = alpha
+    return color
+
+
 def create_bounding_box(objs):
    # Initialize the bounding box coordinates
    min_x, min_y, min_z = float("inf"), float("inf"), float("inf")
@@ -72,8 +79,26 @@ def create_bounding_box(objs):
    return indices, edges


-class AggregateDecorator(tool.Blender.ViewportDecorator):
-    draw_method = "draw_aggregate"
+class AggregateDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_aggregate, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False

    def dotted_line_shader(self):
        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
@@ -128,6 +153,14 @@ class AggregateDecorator(tool.Blender.ViewportDecorator):
        shader.uniform_float("u_Scale", 25)
        batch.draw(shader)

+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
    def draw_aggregate(self, context):
        props = tool.Aggregate.get_aggregate_props()
        self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -158,13 +191,12 @@ class AggregateDecorator(tool.Blender.ViewportDecorator):
                aggregates.append(obj)
                continue

-            aggregate = None
            aggregates_list = tool.Aggregate.get_aggregates_recursively(element)
            if props.in_aggregate_mode and props.editing_aggregate:
                index = aggregates_list.index(tool.Ifc.get_entity(props.editing_aggregate))
                if index > 0:
                    aggregate = aggregates_list[index - 1]
-            elif aggregates_list:
+            else:
                aggregate = aggregates_list[-1]
            if aggregate:
                aggregates.append(tool.Ifc.get_object(aggregate))
@@ -193,11 +225,39 @@ class AggregateDecorator(tool.Blender.ViewportDecorator):
            self.draw_custom_batch(line, decorator_color_unselected)


-class AggregateModeDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_aggregate_name", "POST_PIXEL"),
-        ("draw_aggregate_empty", "POST_VIEW"),
-    )
+class AggregateModeDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(
+            SpaceView3D.draw_handler_add(handler.draw_aggregate_name, (context,), "WINDOW", "POST_PIXEL")
+        )
+        cls.handlers.append(
+            SpaceView3D.draw_handler_add(handler.draw_aggregate_empty, (context,), "WINDOW", "POST_VIEW")
+        )
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)

    def draw_aggregate_name(self, context):
        if context.mode == "EDIT_MESH":
@@ -139,7 +139,6 @@ class BIMAggregateProperties(PropertyGroup):
    previous_editing_aggregate: PointerProperty(name="Editing Aggregate", type=bpy.types.Object)
    editing_objects: CollectionProperty(type=Objects)
    not_editing_objects: CollectionProperty(type=Objects)
-    previously_selected_objects: CollectionProperty(type=Objects)
    aggregate_decorator: BoolProperty(
        name="Display Aggregate",
        default=False,
@@ -156,6 +155,5 @@ class BIMAggregateProperties(PropertyGroup):
        previous_editing_aggregate: Union[bpy.types.Object, None]
        editing_objects: bpy.types.bpy_prop_collection_idprop[Objects]
        not_editing_objects: bpy.types.bpy_prop_collection_idprop[Objects]
-        previously_selected_objects: bpy.types.bpy_prop_collection_idprop[Objects]
        aggregate_decorator: bool
        previous_state: bool
@@ -48,14 +48,12 @@ def draw_ui(context: bpy.types.Context, layout: bpy.types.UILayout, attributes)
        row = layout.row()
        op = row.operator("bim.enable_editing_attributes", icon="GREASEPENCIL", text="Edit")

-        element = tool.Ifc.get_entity(obj)
-        key_prefix = "type." if (element and element.is_a("IfcTypeObject")) else ""
        for attribute in attributes:
            row = layout.row(align=True)
            row.label(text=attribute["name"])
            value = bonsai.bim.helper.get_display_value(attribute["value"])
            op = row.operator("bim.select_similar", text=value, icon="NONE", emboss=False)
-            op.key = key_prefix + attribute["name"]
+            op.key = attribute["name"]

    # TODO: reimplement, see #1222
    # if "IfcSite/" in context.active_object.name or "IfcBuilding/" in context.active_object.name:
@@ -56,6 +56,11 @@ class BoundaryDecorator:
        unselected_elements_color = self.addon_prefs.decorator_color_unselected
        special_elements_color = self.addon_prefs.decorator_color_special

+        def transparent_color(color, alpha=0.1):
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
        gpu.state.point_size_set(6)
        gpu.state.blend_set("ALPHA")

@@ -104,11 +109,7 @@ class BoundaryDecorator:

        if unselected_edges:
            self.draw_batch("LINES", unselected_vertices, special_elements_color, unselected_edges)
-            self.draw_batch(
-                "TRIS", unselected_vertices, tool.Blender.transparent_color(special_elements_color), unselected_tris
-            )
+            self.draw_batch("TRIS", unselected_vertices, transparent_color(special_elements_color), unselected_tris)
        if selected_edges:
            self.draw_batch("LINES", selected_vertices, selected_elements_color, selected_edges)
-            self.draw_batch(
-                "TRIS", selected_vertices, tool.Blender.transparent_color(selected_elements_color), selected_tris
-            )
+            self.draw_batch("TRIS", selected_vertices, transparent_color(selected_elements_color), selected_tris)
@@ -843,6 +843,7 @@ class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
                        settings = ifcopenshell.geom.settings()
                        shape = ifcopenshell.geom.create_shape(settings, opening)
                        mat = Matrix(ifcopenshell.util.shape.get_shape_matrix(shape))
+                        mat.translation = (0, 0, 0)
                        opening_bm = bmesh.new()
                        verts = ifcopenshell.util.shape.get_vertices(shape.geometry)
                        for vert in verts:
@@ -1059,7 +1060,6 @@ class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
        return tool.Ifc.get().createIfcConnectionSurfaceGeometry(surface)

    def export_surface(self, polygon, target_face_matrix):
-        ifc_file = tool.Ifc.get()
        x_axis = target_face_matrix.col[0][:3]
        z_axis = target_face_matrix.col[2][:3]
        p1 = target_face_matrix.translation
@@ -1072,20 +1072,18 @@ class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
        placement = builder.create_axis2_placement_3d([o / self.unit_scale for o in p1], z_axis, x_axis)
        surface.BasisSurface = tool.Ifc.get().create_entity("IfcPlane", placement)

-        schema = ifc_file.schema
-        if schema != "IFC2X3":
+        if tool.Ifc.get().schema != "IFC2X3":
            points = [tool.Model.convert_si_to_unit(list(co)) for co in polygon.exterior.coords]
            point_list = tool.Ifc.get().createIfcCartesianPointList2D(points)
            outer_boundary = tool.Ifc.get().createIfcIndexedPolyCurve(point_list, None, False)

-            inner_boundaries: list[ifcopenshell.entity_instance] = []
+            inner_boundaries = []
            for interior in polygon.interiors:
                points = [tool.Model.convert_si_to_unit(list(co)) for co in interior.coords]
                point_list = tool.Ifc.get().createIfcCartesianPointList2D(points)
                inner_boundaries.append(tool.Ifc.get().createIfcIndexedPolyCurve(point_list, None, False))
        else:
-            # TODO:
-            raise NotImplementedError(schema)
+            pass  # TODO

        surface.OuterBoundary = outer_boundary
        surface.InnerBoundaries = inner_boundaries
@@ -156,13 +156,16 @@ class BrickschemaReferencesData:
        for rel in getattr(tool.Ifc.get_entity(bpy.context.active_object), "HasAssociations", []):
            if rel.is_a("IfcRelAssociatesLibrary"):
                reference = rel.RelatingLibrary
-                identification = tool.Document.get_external_reference_id(reference)
-                if not identification or "#" not in identification:
+                if tool.Ifc.get_schema() == "IFC2X3" and "#" not in reference.ItemReference:
+                    continue
+                if tool.Ifc.get_schema() != "IFC2X3" and "#" not in reference.Identification:
                    continue
                results.append(
                    {
                        "id": reference.id(),
-                        "identification": identification,
+                        "identification": (
+                            reference.ItemReference if tool.Ifc.get_schema() == "IFC2X3" else reference.Identification
+                        ),
                        "name": reference.Name or "Unnamed",
                    }
                )
@@ -345,17 +345,9 @@ class CadArcFrom3Points(bpy.types.Operator):
 class CadOffset(bpy.types.Operator):
    bl_idname = "bim.cad_offset"
    bl_label = "CAD Offset"
-    bl_description = (
-        "Offset selected mesh geometry at provided distance, based on the current viewport angle. "
-        "Creates a copy by default, or moves the existing edges if Copy is disabled."
-    )
+    bl_description = "Copy selected mesh geometry at provided offset. Mesh copied based on the current viewport angle."
    bl_options = {"REGISTER", "UNDO"}
    distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
-    copy: bpy.props.BoolProperty(
-        name="Copy",
-        description="Create a new offset copy of the geometry. If disabled, move the existing edges to the offset location",
-        default=True,
-    )

    @classmethod
    def poll(cls, context):
@@ -400,7 +392,6 @@ class CadOffset(bpy.types.Operator):
        [verts.update(e.verts) for e in edges]

        # Use the viewport angle to determine the offset direction
-        wp = None
        for area in bpy.context.screen.areas:
            if area.type == "VIEW_3D":
                # Don't ask me, I don't know.
@@ -410,16 +401,10 @@ class CadOffset(bpy.types.Operator):
                z = area.spaces.active.region_3d.view_rotation @ Vector((0, 0, 1))
                wp = Matrix([x, y, z, Vector((0, 0, 0))]).to_4x4().transposed()
                break
-        assert wp is not None

        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 = []
@@ -532,15 +517,12 @@ class CadOffset(bpy.types.Operator):
                    offset_length = self.distance / sqrt((1 + normals[0].dot(normals[1])) / 2)
                    offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ (new_normal * offset_length).to_3d())
                    new_vert = v1.co + offset
+                    new_verts.append(bm.verts.new(new_vert))
                else:
                    normal = (normals[0] * self.distance).to_3d()
                    offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ normal)
                    new_vert = v1.co + offset
-
-                if self.copy:
                    new_verts.append(bm.verts.new(new_vert))
-                else:
-                    moved_verts.append((v1, new_vert))

                processed_verts.add(v1.index)

@@ -549,14 +531,9 @@ class CadOffset(bpy.types.Operator):

                v1 = v2

-            if self.copy:
-                [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
-                if is_closed:
-                    bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))
-
-        # Move the existing edges to the offset location.
-        for vert, new_co in moved_verts:
-            vert.co = new_co
+            [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
+            if is_closed:
+                bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))

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

        elif self.hotkey == "S_R":
            if tool.Geometry.is_profile_object_active():
@@ -293,7 +291,7 @@ class CadHotkey(bpy.types.Operator):
            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius)

    def hotkey_S_O(self):
-        bpy.ops.bim.cad_offset(distance=self.props.distance, copy=self.props.copy)
+        bpy.ops.bim.cad_offset(distance=self.props.distance)

    def hotkey_S_Q(self):
        obj = bpy.context.active_object
@@ -18,17 +18,43 @@

 import blf
 import gpu
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Vector

 import bonsai.tool as tool


-class ClashDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw_geometry", "POST_VIEW"),
-    )
+class ClashDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)

    def draw_text(self, context):
        self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -478,7 +478,6 @@ class ChangeClassificationLevel(bpy.types.Operator):
    def execute(self, context):
        props = tool.Classification.get_classification_props()
        props.available_library_references.clear()
-        reference = None
        for reference in IfcStore.classification_file.by_id(self.parent_id).HasReferences:
            new = props.available_library_references.add()
            new.identification = reference.Identification or ""
@@ -486,7 +485,6 @@ class ChangeClassificationLevel(bpy.types.Operator):
            new.ifc_definition_id = reference.id()
            new.has_references = bool(reference.HasReferences)
            new.referenced_source
-        assert reference
        if reference.ReferencedSource.is_a("IfcClassificationReference"):
            props.active_library_referenced_source = reference.ReferencedSource.ReferencedSource.id()
        else:
@@ -1,130 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-import bpy
-from bpy.app.handlers import persistent
-
-import bonsai.tool as tool
-
-from . import face_quad, gizmos, operator, prop, ui
-
-classes = (
-    operator.BIM_OT_add_clip_box,
-    operator.BIM_OT_add_clip_box_for_source,
-    operator.BIM_OT_align_view_to_clip_face,
-    operator.BIM_OT_duplicate_clip_box,
-    operator.BIM_OT_remove_clip_box,
-    operator.BIM_OT_set_active_clip_box,
-    operator.BIM_OT_toggle_clip_box_enabled,
-    prop.BIMClipBoxProperties,
-    prop.BIMSceneClipBoxProperties,
-    face_quad.BIM_GT_box_face_quad,
-    face_quad.BIM_GT_box_face_outline,
-    gizmos.OBJECT_GGT_bim_clip_box,
-    ui.BIM_MT_clip_box_add_for_source,
-    ui.BIM_MT_clip_box_info,
-    ui.BIM_MT_clip_box_settings,
-    ui.BIM_UL_clip_box,
-    ui.BIM_PT_clip_box,
-)
-
-
-@persistent
-def _on_depsgraph_update(scene, depsgraph):
-    tool.ClipBox.on_depsgraph_update(scene, depsgraph)
-    tool.ClipBox.on_depsgraph_update_caps(scene, depsgraph)
-
-
-@persistent
-def _on_load_pre(filepath):
-    # Tear down any in-flight clip-box timers before Blender frees the
-    # WM / screens / areas / regions for the loading file. A refresh timer
-    # that survives the teardown fires against the new file's freshly-
-    # allocated regions before their GPU state is wired, CTD-ing inside
-    # GPU_matrix_ortho_set. The gate also blocks the depsgraph IFC-reload
-    # branch and is held closed until on_pre_view fires for the first time
-    # on the new file (first paint = GPU contexts wired).
-    tool.ClipBox._file_loading = True
-    tool.ClipBox._post_load_paint_pending = True
-    tool.ClipBox._cancel_pending_refresh()
-    tool.ClipBox._cancel_pending_cap_rebuild()
-
-
-@persistent
-def _on_load_post(filepath):
-    # The _file_loading gate is NOT cleared here: load_post fires before
-    # the new file's first paint, so GPU contexts may still be uninitialised.
-    # on_pre_view consumes _post_load_paint_pending to open the gate at the
-    # safe moment and kick the post-load re-arm.
-    # Restore the per-scene clip-box list from the project's BBIM_ClipBoxes
-    # pset. Runs after the standard load_post that creates Blender objects.
-    tool.ClipBox._last_seen_object_matrices.clear()
-    tool.ClipBox.load_from_project_pset()
-
-
-_draw_handler_pre = None
-_draw_handler_post = None
-
-
-def register():
-    global _draw_handler_pre, _draw_handler_post
-    bpy.types.Object.BIMClipBoxProperties = bpy.props.PointerProperty(type=prop.BIMClipBoxProperties)
-    bpy.types.Scene.BIMSceneClipBoxProperties = bpy.props.PointerProperty(type=prop.BIMSceneClipBoxProperties)
-    tool.ClipBox.reset_ownership()
-    if _on_depsgraph_update not in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.append(_on_depsgraph_update)
-    if _on_load_pre not in bpy.app.handlers.load_pre:
-        bpy.app.handlers.load_pre.append(_on_load_pre)
-    if _on_load_post not in bpy.app.handlers.load_post:
-        bpy.app.handlers.load_post.append(_on_load_post)
-    if _draw_handler_pre is None:
-        _draw_handler_pre = bpy.types.SpaceView3D.draw_handler_add(tool.ClipBox.on_pre_view, (), "WINDOW", "PRE_VIEW")
-    if _draw_handler_post is None:
-        _draw_handler_post = bpy.types.SpaceView3D.draw_handler_add(
-            tool.ClipBox.on_post_view_caps, (), "WINDOW", "POST_VIEW"
-        )
-
-
-def unregister():
-    global _draw_handler_pre, _draw_handler_post
-    if _draw_handler_post is not None:
-        try:
-            bpy.types.SpaceView3D.draw_handler_remove(_draw_handler_post, "WINDOW")
-        except ValueError:
-            pass
-        _draw_handler_post = None
-    if _draw_handler_pre is not None:
-        try:
-            bpy.types.SpaceView3D.draw_handler_remove(_draw_handler_pre, "WINDOW")
-        except ValueError:
-            pass
-        _draw_handler_pre = None
-    if _on_load_post in bpy.app.handlers.load_post:
-        bpy.app.handlers.load_post.remove(_on_load_post)
-    if _on_load_pre in bpy.app.handlers.load_pre:
-        bpy.app.handlers.load_pre.remove(_on_load_pre)
-    if _on_depsgraph_update in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.remove(_on_depsgraph_update)
-    tool.ClipBox._cancel_pending_refresh()
-    tool.ClipBox._cancel_pending_cap_rebuild()
-    tool.ClipBox._last_seen_object_matrices.clear()
-    tool.ClipBox.clear_clip_planes()
-    del bpy.types.Object.BIMClipBoxProperties
-    del bpy.types.Scene.BIMSceneClipBoxProperties
@@ -1,212 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""EnumProperty ``items=`` callbacks for the source-based clip-box picker.
-
-Each callback returns ``[(id_str, label, description)]`` where ``id_str`` is
-an IFC entity id stringified for entity-driven kinds, an IFC class name for
-``CLASS``, or a fixed status name for ``STATUS``. The clip-box operator
-turns the picked id into a ``matrix_world`` via the source-preset helper.
-"""
-
-from __future__ import annotations
-
-import bonsai.tool as tool
-
-EnumItems = list[tuple[str, str, str]]
-
-# Module-level cache. Blender's EnumProperty stores raw char pointers from the
-# tuples a callback returns, so the Python strings must outlive the draw call.
-# Stashing the latest result per kind keeps them alive across callback firings.
-_items_cache: dict[str, EnumItems] = {}
-
-# Sentinel id used for the "no options available" placeholder. The operator
-# treats this as an invalid pick and surfaces an ERROR.
-NO_OPTIONS_ID = "__none__"
-
-
-def _cache(kind: str, items: EnumItems) -> EnumItems:
-    _items_cache[kind] = items
-    return items
-
-
-def _no_options(label: str) -> EnumItems:
-    # Blender refuses to draw an EnumProperty with zero entries — show a
-    # placeholder so the dialog renders and the user sees the empty state.
-    return [(NO_OPTIONS_ID, label, "")]
-
-
-def _label(entity, ifc_class: str | None = None) -> str:
-    name = (getattr(entity, "Name", None) or "Unnamed").strip() or "Unnamed"
-    return f"{ifc_class}: {name}" if ifc_class else name
-
-
-def _build_items(kind: str, empty_label: str, build_fn) -> EnumItems:
-    """Shared shape for the IFC-driven enum callbacks.
-
-    Returns the no-IFC placeholder if no file is loaded, then runs
-    ``build_fn(ifc_file)``, sorts the result alphabetically by label, and
-    returns the empty-result placeholder if nothing matched. The output is
-    always routed through the module cache.
-    """
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return _cache(kind, _no_options("No IFC loaded"))
-    items = build_fn(ifc)
-    items.sort(key=lambda t: t[1].lower())
-    if not items:
-        return _cache(kind, _no_options(empty_label))
-    return _cache(kind, items)
-
-
-# Top-down spatial hierarchy so the picker reads in the order an architect
-# already thinks in, rather than a flat alphabetical mix. IfcSpace is excluded
-# — spaces are typically empty volumes used for room metadata, so clipping to
-# one rarely matches the user intent of "show me what's in this container".
-SPATIAL_CLASSES: tuple[str, ...] = (
-    "IfcProject",
-    "IfcSite",
-    "IfcBuilding",
-    "IfcBuildingStorey",
-)
-
-
-def spatial_items(self, context) -> EnumItems:
-    # Special-case: per-class sort within the hierarchy order rather than a
-    # flat alphabetical sort, so the dropdown reads project → site → building.
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return _cache("SPATIAL", _no_options("No IFC loaded"))
-    items: EnumItems = []
-    for ifc_class in SPATIAL_CLASSES:
-        try:
-            entities = ifc.by_type(ifc_class, include_subtypes=False)
-        except RuntimeError:
-            continue
-        for entity in sorted(entities, key=lambda e: (e.Name or "").lower()):
-            items.append((str(entity.id()), _label(entity, ifc_class), ""))
-    if not items:
-        return _cache("SPATIAL", _no_options("No spatial containers"))
-    return _cache("SPATIAL", items)
-
-
-def class_items(self, context) -> EnumItems:
-    # Special-case: the picker value IS the IFC class name, not an entity id,
-    # so the build shape differs from the other entity-driven callbacks.
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return _cache("CLASS", _no_options("No IFC loaded"))
-    # List only IFC classes ACTUALLY present in the file (not the whole
-    # schema), so the user picks from classes that can produce a non-empty
-    # clip volume. ``e.is_a()`` returns the most specific class per element.
-    present = sorted({e.is_a() for e in ifc.by_type("IfcProduct")})
-    if not present:
-        return _cache("CLASS", _no_options("No products"))
-    return _cache("CLASS", [(cls, cls, "") for cls in present])
-
-
-def type_items(self, context) -> EnumItems:
-    return _build_items(
-        "TYPE",
-        "No types defined",
-        lambda ifc: [(str(e.id()), _label(e, e.is_a()), "") for e in ifc.by_type("IfcTypeProduct")],
-    )
-
-
-def material_items(self, context) -> EnumItems:
-    return _build_items(
-        "MATERIAL",
-        "No materials defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcMaterial")],
-    )
-
-
-def profile_items(self, context) -> EnumItems:
-    # ProfileName is optional. Skip unnamed profiles — they can't be
-    # meaningfully picked from a flat list.
-    return _build_items(
-        "PROFILE",
-        "No named profiles",
-        lambda ifc: [
-            (str(e.id()), f"{e.is_a()}: {e.ProfileName}", "")
-            for e in ifc.by_type("IfcProfileDef")
-            if getattr(e, "ProfileName", None)
-        ],
-    )
-
-
-def drawing_items(self, context) -> EnumItems:
-    return _build_items(
-        "DRAWING",
-        "No drawings defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcAnnotation") if e.ObjectType == "DRAWING"],
-    )
-
-
-# Display labels for each status value. The id strings on the left are the
-# canonical Pset_*Common.Status enum values accepted by Bonsai's status query.
-STATUS_LABELS: tuple[tuple[str, str], ...] = (
-    ("No Status", "No Status"),
-    ("NEW", "New"),
-    ("EXISTING", "Existing"),
-    ("DEMOLISH", "Demolish"),
-    ("TEMPORARY", "Temporary"),
-    ("OTHER", "Other"),
-    ("NOTKNOWN", "Not Known"),
-    ("UNSET", "Unset"),
-)
-
-
-def status_items(self, context) -> EnumItems:
-    # Fixed enum; no IFC needed. Still routed through the cache to share the
-    # same string-lifetime guarantee as the other callbacks.
-    return _cache("STATUS", [(value, label, "") for value, label in STATUS_LABELS])
-
-
-def system_items(self, context) -> EnumItems:
-    # IfcStructuralAnalysisModel is a structural-grouping container, not a
-    # distribution system — excluded to match Bonsai's other system pickers.
-    return _build_items(
-        "SYSTEM",
-        "No systems defined",
-        lambda ifc: [
-            (str(e.id()), _label(e, e.is_a()), "")
-            for e in ifc.by_type("IfcSystem")
-            if not e.is_a("IfcStructuralAnalysisModel")
-        ],
-    )
-
-
-def group_items(self, context) -> EnumItems:
-    # include_subtypes=False so IfcSystem and IfcZone instances don't appear
-    # under Group as well — those get their own picker entries.
-    return _build_items(
-        "GROUP",
-        "No groups defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcGroup", include_subtypes=False)],
-    )
-
-
-def zone_items(self, context) -> EnumItems:
-    return _build_items(
-        "ZONE",
-        "No zones defined",
-        lambda ifc: [(str(e.id()), _label(e), "") for e in ifc.by_type("IfcZone")],
-    )
@@ -1,879 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Generic face-quad resize gizmos for any axis-aligned local box.
-
-This module contains the box-agnostic core of the interactive
-face-resize gizmos: two Gizmo classes (a near-invisible click target
-welded to each face, and a thin colored edge outline), a per-redraw
-orchestrator that places six of each on a box, and the pure one-sided
-resize arithmetic. None of it knows about IFC, clip boxes, or
-``BIMSceneClipBoxProperties`` — a future camera-view-box adapter can
-reuse the same classes and helpers.
-
-Consumer contract — the adapter group must:
-
-1. Create six ``BIM_GT_box_face_quad`` and six ``BIM_GT_box_face_outline``
-   instances at ``setup()`` time, in :data:`FACE_ROUTES` order, and bind
-   each quad's ``move_get_cb`` / ``move_set_cb`` to closures that read
-   and mutate the box's host (e.g. an Empty's ``location`` / ``scale``).
-2. Call :func:`apply_face_quad_layout` from ``refresh()`` /
-   ``draw_prepare()`` with the box's local-frame ``bmin`` / ``bmax``,
-   the host's ``matrix_world``, the OBB rotation as a 4x4
-   (``Matrix.Identity(4)`` when the rotation rides in ``matrix_world``),
-   and the current ``region`` / ``rv3d``.
-3. Implement ``_lock_for(active_gz)`` / ``_unlock_all()`` on the group
-   for drag mutual exclusion; the quad's ``invoke`` / ``exit`` call them.
-
-The resize arithmetic in :func:`compute_face_resize` is pure: feed it
-the modal scalar plus drag-start snapshots and it returns the host's
-new scale-on-axis and new origin location.
-"""
-
-from __future__ import annotations
-
-import math
-from collections.abc import Sequence
-from typing import Any
-
-import bpy
-from bpy_extras.view3d_utils import location_3d_to_region_2d, region_2d_to_location_3d
-from mathutils import Matrix, Vector
-
-# ---------------------------------------------------------------------------
-# Public iteration order
-# ---------------------------------------------------------------------------
-
-# (axis, is_max) pairs. The adapter group's ``setup()`` MUST create its
-# six face-quad gizmos in this order so positional indexing into the
-# layout helper stays correct.
-FACE_ROUTES: tuple[tuple[int, bool], ...] = (
-    (0, False),
-    (0, True),
-    (1, False),
-    (1, True),
-    (2, False),
-    (2, True),
-)
-
-
-# ---------------------------------------------------------------------------
-# Public visual constants (adapter reads these in setup())
-# ---------------------------------------------------------------------------
-
-# Standard XYZ axis colors (Blender convention).
-AXIS_COLOR: dict[int, tuple[float, float, float]] = {
-    0: (1.0, 0.2, 0.2),
-    1: (0.2, 1.0, 0.2),
-    2: (0.2, 0.4, 1.0),
-}
-
-# Documented "selectable but unpainted" trick: the GPU still writes the
-# selection buffer at this alpha so clicks register, but no visible
-# pixels are produced.
-FACE_QUAD_ALPHA: float = 0.001
-
-# Very faint hover tint — just enough to confirm "you're aiming at this
-# face" without painting visibly over geometry behind it.
-FACE_QUAD_ALPHA_HIGHLIGHT: float = 0.04
-
-# Setup-time default for ``select_bias``; the layout helper overwrites
-# it per frame to the front-facing or halo value below. Kept below the
-# canonical arrow bias so a bailed frame can't let a front quad steal
-# clicks meant for a hidden control.
-FACE_QUAD_SELECT_BIAS: float = 0.5
-
-
-# ---------------------------------------------------------------------------
-# Internal constants
-# ---------------------------------------------------------------------------
-
-# Unit quad in the local XY plane spanning [-0.5, 0.5]^2 at z=0. Two
-# CCW triangles viewed from +Z. matrix_basis stretches it onto the
-# face's perpendicular extents.
-_QUAD_TRIS: list[tuple[float, float, float]] = [
-    (-0.5, -0.5, 0.0),
-    (0.5, -0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (-0.5, -0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (-0.5, 0.5, 0.0),
-]
-
-# Unit-quad outline as 4 line segments in the local XY plane at z=0.
-_QUAD_OUTLINE_LINES: list[tuple[float, float, float]] = [
-    (-0.5, -0.5, 0.0),
-    (0.5, -0.5, 0.0),
-    (0.5, -0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (0.5, 0.5, 0.0),
-    (-0.5, 0.5, 0.0),
-    (-0.5, 0.5, 0.0),
-    (-0.5, -0.5, 0.0),
-]
-
-# Degenerate zero-area triangle for hidden back-facing quads with no
-# visible-adjacent neighbours (rare orientation). Blender tolerates
-# this; the gizmo is hidden anyway so nothing renders.
-_EMPTY_TRIS: list[tuple[float, float, float]] = [
-    (0.0, 0.0, 0.0),
-    (0.0, 0.0, 0.0),
-    (0.0, 0.0, 0.0),
-]
-
-# Rotates the gizmo's local +Z onto the outward face normal in the
-# box's local frame. Right-hand rotation around the named axis.
-_AXIS_ORIENT: dict[tuple[int, bool], Matrix] = {
-    (0, False): Matrix.Rotation(-math.pi / 2, 4, "Y"),
-    (0, True): Matrix.Rotation(math.pi / 2, 4, "Y"),
-    (1, False): Matrix.Rotation(math.pi / 2, 4, "X"),
-    (1, True): Matrix.Rotation(-math.pi / 2, 4, "X"),
-    (2, False): Matrix.Rotation(math.pi, 4, "X"),
-    (2, True): Matrix.Identity(4),
-}
-
-# Per-face mapping from face-quad local axes to local box axes for the
-# perpendicular-extent scale. ``(w_axis, h_axis)`` — the box-local axis
-# indices the quad's local X and Y span after the orientation rotation.
-_QUAD_PERP_AXES: dict[tuple[int, bool], tuple[int, int]] = {
-    (0, False): (2, 1),
-    (0, True): (2, 1),
-    (1, False): (0, 2),
-    (1, True): (0, 2),
-    (2, False): (0, 1),
-    (2, True): (0, 1),
-}
-
-# Front-facing quad sits ABOVE the halo strips so the cursor on the
-# visible face area always grabs the visible face, never accidentally
-# routes to a back-face halo strip in an adjacent screen region.
-_FACE_QUAD_FRONT_FACING_SELECT_BIAS: float = 1.5
-_FACE_QUAD_HALO_FRAME_SELECT_BIAS: float = 1.0
-
-# Target halo-strip thickness in screen pixels. The world-space margin
-# is recomputed per frame so the rim stays a roughly constant on-screen
-# size regardless of viewport zoom.
-_FACE_QUAD_HALO_TARGET_PIXELS: float = 20.0
-
-# Minimum world half-extent a face resize may shrink to. Stops a drag
-# from collapsing the host to zero or negative scale.
-_MIN_HALF_EXTENT: float = 1e-4
-
-
-# ---------------------------------------------------------------------------
-# Pure predicates (testable without Blender)
-# ---------------------------------------------------------------------------
-
-Vec3 = tuple[float, float, float]
-
-
-def face_outward_axis_local(axis: int, is_max: bool) -> Vec3:
-    """Un-rotated outward face normal in the box's local AABB coords.
-
-    For ``(axis=0, is_max=True)`` returns ``(+1, 0, 0)``; for the −X
-    face ``(-1, 0, 0)``; etc. The rotated world normal is obtained by
-    applying the host's rotation and the OBB rotation:
-    ``mw_rot @ cage_rotation @ this``.
-    """
-    sign = 1.0 if is_max else -1.0
-    out = [0.0, 0.0, 0.0]
-    out[axis] = sign
-    return (out[0], out[1], out[2])
-
-
-def front_facing_face_mask(
-    face_normals_world: Sequence[Vec3],
-    view_dir_world: Vec3,
-    eps: float = 1e-6,
-) -> tuple[bool, ...]:
-    """Which of the 6 box faces point toward the camera.
-
-    A face is front-facing iff its outward normal points AGAINST the
-    view direction (``dot(normal, view_dir) < -eps``). The ``-eps``
-    margin prevents flicker at grazing angles.
-
-    ``face_normals_world`` must be in :data:`FACE_ROUTES` order; returns
-    a 6-tuple of bool parallel to that order.
-    """
-    if len(face_normals_world) != 6:
-        msg = f"expected 6 face normals, got {len(face_normals_world)}"
-        raise ValueError(msg)
-    vx, vy, vz = view_dir_world
-    return tuple((n[0] * vx + n[1] * vy + n[2] * vz) < -eps for n in face_normals_world)
-
-
-def view_axis_parallel_face_mask(
-    face_normals_world: Sequence[Vec3],
-    view_dir_world: Vec3,
-    threshold: float = 0.95,
-) -> tuple[bool, ...]:
-    """Which faces have normals (anti-)parallel to the view direction.
-
-    True iff ``abs(dot(normal, view_dir)) >= threshold`` — i.e. the
-    face is nearly perpendicular to the screen plane. Provided as a
-    pure predicate for callers that want to detect degenerate-drag
-    conditions; the layout helper itself no longer gates on it.
-    """
-    if len(face_normals_world) != 6:
-        msg = f"expected 6 face normals, got {len(face_normals_world)}"
-        raise ValueError(msg)
-    vx, vy, vz = view_dir_world
-    return tuple(abs(n[0] * vx + n[1] * vy + n[2] * vz) >= threshold for n in face_normals_world)
-
-
-# ---------------------------------------------------------------------------
-# Pure resize arithmetic
-# ---------------------------------------------------------------------------
-
-
-def compute_face_resize(
-    *,
-    value: float,
-    init_world_half: float,
-    init_location: tuple[float, float, float],
-    world_axis: tuple[float, float, float],
-    display_size: float,
-) -> tuple[float, tuple[float, float, float]]:
-    """Pure one-sided face-resize arithmetic.
-
-    Returns ``(new_scale_axis, new_location)`` — the host's new scale
-    on the dragged axis and its new world origin — such that the
-    dragged face moves by the modal's outward delta while the OPPOSITE
-    face stays put.
-
-    ``value`` is ``init + delta``, where ``init`` is the unsigned
-    drag-start world half-extent and ``delta`` is the cursor projection
-    onto the face's OUTWARD world normal. Realized half-extent is
-    clamped to a small floor; the location shift uses the realized
-    (post-clamp) delta so the opposite face stays fixed even at the
-    clamp.
-    """
-    face_delta = value - init_world_half
-    new_world_half = init_world_half + 0.5 * face_delta
-    if new_world_half < _MIN_HALF_EXTENT:
-        new_world_half = _MIN_HALF_EXTENT
-    realized_delta = 2.0 * (new_world_half - init_world_half)
-
-    ds = display_size if display_size != 0.0 else 1.0
-    new_scale_axis = new_world_half / ds
-    shift = 0.5 * realized_delta
-    new_location = (
-        init_location[0] + shift * world_axis[0],
-        init_location[1] + shift * world_axis[1],
-        init_location[2] + shift * world_axis[2],
-    )
-    return new_scale_axis, new_location
-
-
-# ---------------------------------------------------------------------------
-# Internal geometry helpers
-# ---------------------------------------------------------------------------
-
-
-def _compute_face_quad_scale(bmin: Any, bmax: Any, axis: int, is_max: bool) -> tuple[float, float]:
-    """Return ``(w, h)`` for the face quad's scale matrix."""
-    w_axis, h_axis = _QUAD_PERP_AXES[(axis, is_max)]
-    w = float(bmax[w_axis] - bmin[w_axis])
-    h = float(bmax[h_axis] - bmin[h_axis])
-    return w, h
-
-
-def _shared_edge_corner_keys(
-    axis_a: int, is_max_a: bool, axis_b: int, is_max_b: bool
-) -> tuple[tuple[int, int, int], tuple[int, int, int]] | None:
-    """Return the 2 corner-bit triples shared by two adjacent faces.
-
-    Corner keys are 3-tuples of bits (0 = bmin, 1 = bmax). The two
-    returned corners are ordered with the free-axis bit ascending.
-    """
-    if axis_a == axis_b:
-        return None
-    free_axis = 3 - axis_a - axis_b
-    bit_a = 1 if is_max_a else 0
-    bit_b = 1 if is_max_b else 0
-    corner_lo = [0, 0, 0]
-    corner_hi = [0, 0, 0]
-    corner_lo[axis_a] = bit_a
-    corner_hi[axis_a] = bit_a
-    corner_lo[axis_b] = bit_b
-    corner_hi[axis_b] = bit_b
-    corner_lo[free_axis] = 0
-    corner_hi[free_axis] = 1
-    return (
-        (corner_lo[0], corner_lo[1], corner_lo[2]),
-        (corner_hi[0], corner_hi[1], corner_hi[2]),
-    )
-
-
-def _face_corner_keys(axis: int, is_max: bool) -> tuple[
-    tuple[int, int, int],
-    tuple[int, int, int],
-    tuple[int, int, int],
-    tuple[int, int, int],
-]:
-    """Return the 4 corner-bit triples of a face in CCW order.
-
-    Triangulation as ``[(0,1,2), (0,2,3)]`` covers the whole face with
-    two non-overlapping triangles.
-    """
-    fixed_bit = 1 if is_max else 0
-    free_axes = [a for a in (0, 1, 2) if a != axis]
-    fa0, fa1 = free_axes
-    corners = []
-    for ka, kb in ((0, 0), (1, 0), (1, 1), (0, 1)):
-        key = [0, 0, 0]
-        key[axis] = fixed_bit
-        key[fa0] = ka
-        key[fa1] = kb
-        corners.append((key[0], key[1], key[2]))
-    return (corners[0], corners[1], corners[2], corners[3])
-
-
-def _build_strip_tris_relative(
-    edge_p0_local: tuple[float, float, float],
-    edge_p1_local: tuple[float, float, float],
-    extrusion_local: tuple[float, float, float],
-) -> list[tuple[float, float, float]]:
-    """Build two CCW triangles (6 vertices) for a thin halo strip.
-
-    All inputs are in coords relative to the gizmo's ``matrix_basis``
-    anchor. The strip runs along ``[edge_p0_local, edge_p1_local]`` and
-    extrudes by ``extrusion_local`` perpendicular to the edge.
-    """
-    p0x, p0y, p0z = edge_p0_local
-    p1x, p1y, p1z = edge_p1_local
-    ex, ey, ez = extrusion_local
-    p0e = (p0x + ex, p0y + ey, p0z + ez)
-    p1e = (p1x + ex, p1y + ey, p1z + ez)
-    return [
-        (p0x, p0y, p0z),
-        p0e,
-        p1e,
-        (p0x, p0y, p0z),
-        p1e,
-        (p1x, p1y, p1z),
-    ]
-
-
-def _strips_geometry_changed(quad_gz, face_quad_local, all_tris) -> bool:
-    """True if the back-face quad's geometry differs from the cached upload.
-
-    Pure orbit/pan doesn't change either the box pose or the cage
-    rotation, so the computed strip vertices are byte-identical to the
-    previous frame's. Hitting the cache lets the back-facing branch
-    skip ``new_custom_shape`` and the GPU upload.
-    """
-    cached = getattr(quad_gz, "_strips_cache_key", None)
-    last_state = getattr(quad_gz, "_last_geometry_state", None)
-    key = (face_quad_local, all_tris)
-    if cached is None or last_state != "strips" or cached != key:
-        quad_gz._strips_cache_key = key
-        quad_gz._last_geometry_state = "strips"
-        return True
-    return False
-
-
-def _compute_face_basis(
-    mw: Any,
-    mw_rot: Any,
-    cage_rotation: Any,
-    pivot_local: Any,
-    face_local: Any,
-    orient: Any,
-) -> tuple[Any, Any]:
-    """World-space (translation, outward-normal-direction) for one face."""
-    rotated_face_local = cage_rotation.to_3x3() @ (face_local - pivot_local) + pivot_local
-    face_world = mw @ rotated_face_local
-    world_axis = (mw_rot @ cage_rotation.to_3x3() @ (orient.to_3x3() @ Vector((0.0, 0.0, 1.0)))).normalized()
-    return face_world, world_axis
-
-
-def _compose_face_matrix_basis(
-    face_world: Any,
-    mw_rot_scale: Any,
-    cage_rotation: Any,
-    orient: Any,
-    w: float,
-    h: float,
-) -> Any:
-    """Compose the 5-term ``matrix_basis`` for a face-plane gizmo.
-
-    Returns ``Translation @ mw_rot_scale @ cage_rotation @ orient @
-    Diagonal((w, h, 1, 1))`` — maps a unit-square local quad onto the
-    world-space face rectangle, including the host's scale.
-    """
-    quad_scale = Matrix.Diagonal((w, h, 1.0, 1.0))
-    return Matrix.Translation(face_world) @ mw_rot_scale.to_4x4() @ cage_rotation @ orient @ quad_scale
-
-
-def _compute_box_corners_world(
-    bmin: Any,
-    bmax: Any,
-    pivot_local: Any,
-    cage_rotation_3x3: Any,
-    mw: Any,
-) -> dict[tuple[int, int, int], Any]:
-    """Return the 8 OBB corners in world space, keyed by bit-triple."""
-    corners: dict[tuple[int, int, int], Any] = {}
-    for ix in (0, 1):
-        for iy in (0, 1):
-            for iz in (0, 1):
-                local = Vector(
-                    (
-                        float(bmax.x if ix else bmin.x),
-                        float(bmax.y if iy else bmin.y),
-                        float(bmax.z if iz else bmin.z),
-                    )
-                )
-                rotated = cage_rotation_3x3 @ (local - pivot_local) + pivot_local
-                corners[(ix, iy, iz)] = mw @ rotated
-    return corners
-
-
-def _abs_scale_matrix(mw: Any) -> Any:
-    """Return a copy of ``mw`` with all scale components ``abs()``-ed.
-
-    Without this, a negative-scale host produces a visible/clickable
-    face inversion: ``mw @ local_vec`` flips the +axis face onto the
-    -axis world side, while the rotation-only normal stays pointing
-    in the +axis direction — so the gizmo for "the +X face" sits at
-    world -X but reports its outward normal as +X.
-    """
-    loc, rot, scale = mw.decompose()
-    abs_scale = Vector((abs(scale.x), abs(scale.y), abs(scale.z)))
-    return Matrix.LocRotScale(loc, rot, abs_scale)
-
-
-def _world_radius_to_screen_pixels(
-    region: Any,
-    rv3d: Any,
-    center_world: Vector,
-    world_radius: float,
-    *,
-    min_pixels: float = 0.0,
-) -> float:
-    """Return the on-screen pixel radius of a world-space circle.
-
-    Projects ``center_world`` and a sample point offset by
-    ``world_radius`` along the camera's view-aligned right axis to
-    region pixels, and returns the screen-pixel distance between them.
-    Falls back to ``min_pixels`` if either projection fails.
-    """
-    try:
-        view_inv = rv3d.view_matrix.inverted()
-        right = Vector((view_inv[0][0], view_inv[0][1], view_inv[0][2])).normalized()
-    except (AttributeError, ValueError):
-        right = Vector((1.0, 0.0, 0.0))
-    sample_world = center_world + right * world_radius
-    return _world_segment_to_screen_pixels(region, rv3d, center_world, sample_world, min_pixels=min_pixels)
-
-
-def _world_segment_to_screen_pixels(
-    region: Any,
-    rv3d: Any,
-    p0_world: Vector,
-    p1_world: Vector,
-    *,
-    min_pixels: float = 0.0,
-) -> float:
-    """Return the on-screen pixel length of an arbitrary world segment.
-
-    Unlike :func:`_world_radius_to_screen_pixels`, this measures the
-    ACTUAL projected length of the segment — foreshortening included.
-    Use this when the segment direction is known to be oblique to the
-    screen plane (e.g. a back face's outward normal): a perpendicular
-    radius measurement overestimates the on-screen length, leaving
-    halo strips visually narrower than the requested pixel target.
-    """
-    p0 = location_3d_to_region_2d(region, rv3d, p0_world)
-    p1 = location_3d_to_region_2d(region, rv3d, p1_world)
-    if not p0 or not p1:
-        return min_pixels
-    dx = float(p1[0]) - float(p0[0])
-    dy = float(p1[1]) - float(p0[1])
-    return max(min_pixels, (dx * dx + dy * dy) ** 0.5)
-
-
-# ---------------------------------------------------------------------------
-# Gizmo classes
-# ---------------------------------------------------------------------------
-
-
-class BIM_GT_box_face_quad(bpy.types.Gizmo):  # noqa: N801 — Blender bl_idname convention
-    """Near-invisible face-quad click target with drag-to-resize modal.
-
-    Geometry: a unit quad in the local XY plane at z=0. The adapter
-    group's layout helper rotates and scales it onto the face plane;
-    the quad is welded to the world face (``use_draw_scale = False``).
-    """
-
-    bl_idname = "BIM_GT_box_face_quad"
-    bl_target_properties = ({"id": "offset", "type": "FLOAT", "array_length": 1},)
-
-    __slots__ = (
-        "custom_shape",
-        "custom_shape_select",
-        "init_value",
-        "move_get_cb",
-        "move_set_cb",
-        "axis",
-        "start_location",
-        "depth_point",
-        "callback",
-        "ctrl_click_cb",
-        "_group",
-        "_face_axis",
-        "is_max",
-        "_drag_snapshot",
-        "_last_geometry_state",
-        "_strips_cache_key",
-    )
-
-    def draw(self, context: Any) -> None:
-        self.draw_custom_shape(self.custom_shape)
-
-    def draw_select(self, context: Any, select_id: int) -> None:
-        # Back-facing quads bind ``custom_shape_select`` to the halo-strip
-        # TRIS so clicks OUTSIDE the box silhouette catch the back face.
-        # Front-facing quads leave it None and reuse ``custom_shape``.
-        shape = getattr(self, "custom_shape_select", None) or self.custom_shape
-        self.draw_custom_shape(shape, select_id=select_id)
-
-    def setup(self) -> None:
-        if not hasattr(self, "custom_shape_"):
-            self.custom_shape = self.new_custom_shape("TRIS", _QUAD_TRIS)
-        self.custom_shape_select = None
-        # Quad welded to world geometry — clicks must align with the
-        # visible face, not a screen-size widget. Disables Blender's
-        # per-frame pixel-constant autoscale.
-        self.use_draw_scale = False
-
-    # ---- modal -------------------------------------------------------------
-
-    def invoke(self, context: Any, event: Any) -> set[str]:
-        # CTRL+click handoff: dispatch a host-defined callback (e.g.
-        # align-view) instead of starting a drag.
-        if event.ctrl and getattr(self, "ctrl_click_cb", None) is not None:
-            self.ctrl_click_cb(context, event)
-            return {"FINISHED"}
-
-        region = context.region
-        rv3d = context.region_data
-        if region is None or rv3d is None:
-            return {"CANCELLED"}
-        self.init_value = self.move_get_cb()
-        # Freeze the projection plane at invoke — projection-plane
-        # drift on tilted axes causes exponential delta runaway.
-        self.depth_point = self.matrix_basis.translation.copy()
-        self.start_location = region_2d_to_location_3d(region, rv3d, (event.mouse_x, event.mouse_y), self.depth_point)
-
-        if getattr(self, "_group", None) is not None:
-            self._group._lock_for(self)
-        return {"RUNNING_MODAL"}
-
-    def exit(self, context: Any, cancel: bool) -> None:
-        try:
-            if context.area:
-                context.area.header_text_set(None)
-            if cancel:
-                self.move_set_cb(self.init_value)
-            if hasattr(self, "callback"):
-                self.callback(self.move_get_cb())
-        finally:
-            self._drag_snapshot = None
-            if getattr(self, "_group", None) is not None:
-                self._group._unlock_all()
-
-    def modal(self, context: Any, event: Any, tweak: set[str]) -> set[str]:
-        if event.type == "ESC":
-            return {"CANCELLED"}
-        region = context.region
-        rv3d = context.region_data
-        if region is None or rv3d is None:
-            return {"CANCELLED"}
-        end_location = region_2d_to_location_3d(region, rv3d, (event.mouse_x, event.mouse_y), self.depth_point)
-        delta = (end_location - self.start_location).dot(self.axis)
-        if "SNAP" in tweak:
-            delta = round(delta, 1)
-        if "PRECISE" in tweak:
-            delta /= 10.0
-        self.move_set_cb(self.init_value + delta)
-        if context.area:
-            context.area.header_text_set(f"Value: {self.move_get_cb():.3f} ({delta:.3f})")
-        return {"RUNNING_MODAL"}
-
-
-class BIM_GT_box_face_outline(bpy.types.Gizmo):  # noqa: N801 — Blender bl_idname convention
-    """Thin non-interactive colored edge outline for one face.
-
-    Drawn as 4 line segments in the face plane. The layout helper
-    toggles its ``alpha`` between near-zero and ``1.0`` based on the
-    sibling face-quad's ``is_highlight`` state — so hovering the quad
-    lights up the matching outline. ``hide_select = True`` keeps the
-    outline out of the GPU selection buffer.
-    """
-
-    bl_idname = "BIM_GT_box_face_outline"
-    bl_target_properties = ()
-
-    __slots__ = (
-        "custom_shape",
-        "_face_axis",
-        "is_max",
-        "_last_outline_state",
-    )
-
-    def draw(self, context: Any) -> None:
-        self.draw_custom_shape(self.custom_shape)
-
-    def draw_select(self, context: Any, select_id: int) -> None:
-        return None
-
-    def setup(self) -> None:
-        if not hasattr(self, "custom_shape_"):
-            self.custom_shape = self.new_custom_shape("LINES", _QUAD_OUTLINE_LINES)
-        self.use_draw_scale = False
-        self.hide_select = True
-        self._last_outline_state = "unit"
-
-
-# ---------------------------------------------------------------------------
-# Per-redraw orchestrator
-# ---------------------------------------------------------------------------
-
-
-def apply_face_quad_layout(
-    *,
-    quad_gizmos,
-    outline_gizmos,
-    bmin: Any,
-    bmax: Any,
-    matrix_world: Any,
-    cage_rotation: Any,
-    region: Any,
-    rv3d: Any,
-    locked: bool,
-) -> None:
-    """Lay out 6 face quads + 6 outlines on the box for this redraw.
-
-    ``quad_gizmos`` / ``outline_gizmos`` are length-6 sequences in
-    :data:`FACE_ROUTES` order. ``bmin`` / ``bmax`` are the box corners
-    in the host's local frame; ``matrix_world`` is the host's world
-    matrix; ``cage_rotation`` is the OBB rotation as a 4x4 (use
-    ``Matrix.Identity(4)`` when rotation rides in ``matrix_world``).
-    ``region`` / ``rv3d`` drive the view-dependent front/back split and
-    the screen-constant halo margin; passing ``rv3d = None`` bails.
-
-    Negative scale on the host is normalized to positive internally so
-    the visible cube and the clickable face gizmos stay aligned —
-    callers don't need to pre-process ``matrix_world``.
-
-    When ``locked`` (a drag is active), ``hide`` / ``select_bias``
-    writes are skipped — the active quad's geometry is still refreshed
-    so it tracks the moving box.
-    """
-    if rv3d is None or getattr(rv3d, "view_rotation", None) is None:
-        return
-    if len(quad_gizmos) != 6 or len(outline_gizmos) != 6:
-        return
-
-    mw = _abs_scale_matrix(matrix_world)
-    mw_rot = mw.to_quaternion().to_matrix()
-    mw_rot_scale = mw.to_3x3()
-    cage_rotation_3x3 = cage_rotation.to_3x3()
-    pivot_local = (bmin + bmax) * 0.5
-    box_center_local = pivot_local
-    face_midpoints_local = {
-        (0, False): Vector((float(bmin.x), box_center_local.y, box_center_local.z)),
-        (0, True): Vector((float(bmax.x), box_center_local.y, box_center_local.z)),
-        (1, False): Vector((box_center_local.x, float(bmin.y), box_center_local.z)),
-        (1, True): Vector((box_center_local.x, float(bmax.y), box_center_local.z)),
-        (2, False): Vector((box_center_local.x, box_center_local.y, float(bmin.z))),
-        (2, True): Vector((box_center_local.x, box_center_local.y, float(bmax.z))),
-    }
-
-    view_dir = (rv3d.view_rotation @ Vector((0.0, 0.0, -1.0))).normalized()
-    view_dir_tuple = (float(view_dir.x), float(view_dir.y), float(view_dir.z))
-    face_normals_world = []
-    for route_axis, route_is_max in FACE_ROUTES:
-        axis_local = Vector(face_outward_axis_local(route_axis, route_is_max))
-        n_world = (mw_rot @ cage_rotation_3x3 @ axis_local).normalized()
-        face_normals_world.append((float(n_world.x), float(n_world.y), float(n_world.z)))
-    front = front_facing_face_mask(tuple(face_normals_world), view_dir_tuple)
-
-    box_center_world = mw @ pivot_local
-    corners_world = _compute_box_corners_world(bmin, bmax, pivot_local, cage_rotation_3x3, mw)
-    route_to_index = {route: i for i, route in enumerate(FACE_ROUTES)}
-
-    for i, route in enumerate(FACE_ROUTES):
-        quad_gz = quad_gizmos[i]
-        is_front = front[i]
-        axis_b, is_max_b = route
-
-        # Place the colored OUTLINE on every face using the same composed
-        # face matrix the front-facing solid quad uses. Hidden/shown via
-        # alpha at the end of the pass.
-        outline_orient = _AXIS_ORIENT[route]
-        outline_face_world, _outline_axis = _compute_face_basis(
-            mw,
-            mw_rot,
-            cage_rotation,
-            pivot_local,
-            face_midpoints_local[route],
-            outline_orient,
-        )
-        ow, oh = _compute_face_quad_scale(bmin, bmax, axis_b, is_max_b)
-        outline_gizmos[i].matrix_basis = _compose_face_matrix_basis(
-            outline_face_world, mw_rot_scale, cage_rotation, outline_orient, ow, oh
-        )
-
-        if is_front:
-            if not locked:
-                quad_gz.hide = False
-                quad_gz.select_bias = _FACE_QUAD_FRONT_FACING_SELECT_BIAS
-            orient = _AXIS_ORIENT[route]
-            face_world, world_axis = _compute_face_basis(
-                mw,
-                mw_rot,
-                cage_rotation,
-                pivot_local,
-                face_midpoints_local[route],
-                orient,
-            )
-            w, h = _compute_face_quad_scale(bmin, bmax, axis_b, is_max_b)
-            quad_gz.matrix_basis = _compose_face_matrix_basis(face_world, mw_rot_scale, cage_rotation, orient, w, h)
-            quad_gz.axis = world_axis
-            if getattr(quad_gz, "_last_geometry_state", None) != "solid":
-                quad_gz.custom_shape = quad_gz.new_custom_shape("TRIS", _QUAD_TRIS)
-                quad_gz.custom_shape_select = None
-                quad_gz._last_geometry_state = "solid"
-            continue
-
-        # Back-facing: anchor at the back face centre; build halo strips
-        # in the planes of the adjacent FRONT faces, extruded outside
-        # the silhouette toward this face's outward normal.
-        face_world = mw @ (cage_rotation_3x3 @ (face_midpoints_local[route] - pivot_local) + pivot_local)
-        quad_gz.matrix_basis = Matrix.Translation(face_world)
-        quad_gz.axis = (mw_rot @ cage_rotation_3x3 @ Vector(face_outward_axis_local(axis_b, is_max_b))).normalized()
-
-        adjacent_front_routes = [
-            (axis_a, is_max_a)
-            for axis_a in range(3)
-            if axis_a != axis_b
-            for is_max_a in (False, True)
-            if front[route_to_index[(axis_a, is_max_a)]]
-        ]
-        # Per-face world margin: measure the screen-projected length of
-        # ONE world unit along THIS face's outward normal. The world
-        # margin that yields ~N pixels on screen is then ``N / length``.
-        # Foreshortening on oblique faces shortens the projected step,
-        # so the world step must grow to keep the strip the same width
-        # on screen.
-        face_world_margin = 0.0
-        if region is not None:
-            sample_end = box_center_world + quad_gz.axis * 1.0
-            screen_step = _world_segment_to_screen_pixels(region, rv3d, box_center_world, sample_end, min_pixels=0.0)
-            if screen_step > 0.0:
-                face_world_margin = _FACE_QUAD_HALO_TARGET_PIXELS / screen_step
-        if face_world_margin <= 0.0 or not adjacent_front_routes:
-            if not locked:
-                quad_gz.hide = True
-                quad_gz.select_bias = _FACE_QUAD_HALO_FRAME_SELECT_BIAS
-            if getattr(quad_gz, "_last_geometry_state", None) != "empty":
-                quad_gz.custom_shape = quad_gz.new_custom_shape("TRIS", _EMPTY_TRIS)
-                quad_gz.custom_shape_select = None
-                quad_gz._last_geometry_state = "empty"
-            continue
-
-        extrusion_world = quad_gz.axis * face_world_margin
-        extrusion_local = (
-            float(extrusion_world.x),
-            float(extrusion_world.y),
-            float(extrusion_world.z),
-        )
-        all_tris: list[tuple[float, float, float]] = []
-        for axis_a, is_max_a in adjacent_front_routes:
-            edge_keys = _shared_edge_corner_keys(axis_a, is_max_a, axis_b, is_max_b)
-            if edge_keys is None:
-                continue
-            key0, key1 = edge_keys
-            wp0 = corners_world[key0]
-            wp1 = corners_world[key1]
-            local_p0 = (
-                float(wp0.x - face_world.x),
-                float(wp0.y - face_world.y),
-                float(wp0.z - face_world.z),
-            )
-            local_p1 = (
-                float(wp1.x - face_world.x),
-                float(wp1.y - face_world.y),
-                float(wp1.z - face_world.z),
-            )
-            all_tris.extend(_build_strip_tris_relative(local_p0, local_p1, extrusion_local))
-
-        if not locked:
-            quad_gz.hide = False
-            quad_gz.select_bias = _FACE_QUAD_HALO_FRAME_SELECT_BIAS
-
-        corner_keys = _face_corner_keys(axis_b, is_max_b)
-        wc_local = [
-            (
-                float(corners_world[k].x - face_world.x),
-                float(corners_world[k].y - face_world.y),
-                float(corners_world[k].z - face_world.z),
-            )
-            for k in corner_keys
-        ]
-        face_quad_local = [
-            wc_local[0],
-            wc_local[1],
-            wc_local[2],
-            wc_local[0],
-            wc_local[2],
-            wc_local[3],
-        ]
-        if _strips_geometry_changed(quad_gz, tuple(face_quad_local), tuple(all_tris)):
-            quad_gz.custom_shape = quad_gz.new_custom_shape("TRIS", face_quad_local)
-            quad_gz.custom_shape_select = quad_gz.new_custom_shape("TRIS", all_tris)
-        quad_gz._last_geometry_state = "strips"
-
-    # Outline alpha follows ONLY the hovered quad's own state — light
-    # the outline of the face under the cursor, nothing else.
-    if not locked:
-        for outline_gz, quad_gz in zip(outline_gizmos, quad_gizmos, strict=True):
-            lit = bool(getattr(quad_gz, "is_highlight", False))
-            outline_gz.alpha = 1.0 if lit else 0.0
-            outline_gz.alpha_highlight = 1.0 if lit else 0.0
-
-
-__all__ = [
-    "AXIS_COLOR",
-    "FACE_QUAD_ALPHA",
-    "FACE_QUAD_ALPHA_HIGHLIGHT",
-    "FACE_QUAD_SELECT_BIAS",
-    "FACE_ROUTES",
-    "BIM_GT_box_face_outline",
-    "BIM_GT_box_face_quad",
-    "apply_face_quad_layout",
-    "compute_face_resize",
-    "face_outward_axis_local",
-    "front_facing_face_mask",
-    "view_axis_parallel_face_mask",
-]
@@ -1,312 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Interactive face-quad resize gizmos for the active clip box.
-
-Adapter group that binds the generic :mod:`face_quad` core to a Bonsai
-clip-box Empty: six near-invisible click quads + six edge outlines on
-the cube's faces. Dragging a face does a ONE-SIDED resize — the dragged
-face moves along its outward world normal while the opposite face stays
-put — by writing the empty's ``location`` and ``scale``. Bonsai's
-depsgraph handler then re-arms the clip planes from the new matrix.
-"""
-
-from __future__ import annotations
-
-import contextlib
-from typing import Any
-
-import bpy
-from mathutils import Matrix, Vector
-
-import bonsai.tool as tool
-
-from . import face_quad
-
-# Local-frame bounds of the empty's CUBE display. The display spans
-# ``[-empty_display_size, +empty_display_size]^3``; Bonsai always sets
-# ``empty_display_size = 1.0`` on clip-box hosts, so the local box is
-# the unit cube. The empty's per-axis scale + rotation + translation
-# ride in ``matrix_world``, which the layout helper applies.
-_LOCAL_BMIN = Vector((-1.0, -1.0, -1.0))
-_LOCAL_BMAX = Vector((1.0, 1.0, 1.0))
-
-
-def _world_axis(empty: bpy.types.Object, axis: int, is_max: bool) -> Vector:
-    """Outward world-space unit normal of the ``(axis, is_max)`` face.
-
-    Uses the rotation-only matrix so a negative-scale empty doesn't
-    flip the resulting direction — the visible "+X face" then stays
-    associated with world +X (transformed through rotation).
-    """
-    rot_mat = empty.matrix_world.to_quaternion().to_matrix()
-    n = Vector(rot_mat.col[axis])
-    if n.length <= 0.0:
-        return Vector((0.0, 0.0, 0.0))
-    n.normalize()
-    return n if is_max else -n
-
-
-def _world_half_extent(empty: bpy.types.Object, axis: int) -> float:
-    """The empty's box half-extent along local ``axis`` in WORLD units.
-
-    A CUBE empty's local cube is ``±empty_display_size``; ``matrix_world``
-    stretches it by the column length on ``axis``. So the world
-    half-extent is ``|column[axis]| * empty_display_size``.
-    """
-    col_len = empty.matrix_world.to_3x3().col[axis].length
-    display_size = abs(float(getattr(empty, "empty_display_size", 1.0) or 1.0))
-    return float(col_len) * display_size
-
-
-def _make_face_get_cb(gz: Any, group: Any, axis: int, is_max: bool):
-    """Closure returning the world half-extent at drag start and
-    snapshotting the empty's full transform on the gizmo instance.
-
-    The snapshot lives on the gizmo (not the group) so a PERSISTENT
-    group servicing multiple clip boxes can't bleed one drag's state
-    onto another. Cleared on ``exit`` by the shared face-quad hook.
-    """
-
-    def getter() -> float:
-        empty = group._empty
-        if empty is None:
-            return 0.0
-        existing = getattr(gz, "_drag_snapshot", None)
-        if existing is not None and existing.get("empty_name") == getattr(empty, "name", None):
-            return float(existing["world_half"])
-
-        world_half = _world_half_extent(empty, axis)
-        display_size = abs(float(getattr(empty, "empty_display_size", 1.0) or 1.0))
-        gz._drag_snapshot = {
-            "empty_name": getattr(empty, "name", None),
-            "world_half": world_half,
-            "location": tuple(float(v) for v in empty.location),
-            "scale": tuple(float(v) for v in empty.scale),
-            "display_size": display_size if display_size != 0.0 else 1.0,
-            "world_axis": tuple(_world_axis(empty, axis, is_max)),
-        }
-        return float(world_half)
-
-    return getter
-
-
-def _make_ctrl_click_cb(axis: int, is_max: bool):
-    """Closure that dispatches CTRL+click on a face to the align-view operator.
-
-    Routing through an operator (rather than mutating ``rv3d`` here)
-    keeps the action F3-searchable and undoable.
-    """
-
-    def _callback(_context: Any, _event: Any) -> None:
-        bpy.ops.bim.align_view_to_clip_face("INVOKE_DEFAULT", axis=axis, is_max=is_max)
-
-    return _callback
-
-
-def _make_face_set_cb(gz: Any, group: Any, axis: int, is_max: bool):
-    """Closure that applies a one-sided face resize by writing the
-    empty's ``location`` + ``scale``.
-
-    The modal calls this with ``value = init + delta`` where ``delta``
-    is the cursor's projection onto the face's OUTWARD world normal.
-    Both reads come from ``gz._drag_snapshot`` so every frame is
-    relative to drag start, never compounding.
-    """
-    del is_max  # snapshot's world_axis carries the direction
-
-    def setter(value: float) -> None:
-        empty = group._empty
-        if empty is None:
-            return
-        snap = getattr(gz, "_drag_snapshot", None)
-        if snap is None or snap.get("empty_name") != getattr(empty, "name", None):
-            return
-
-        new_scale_axis, new_location = face_quad.compute_face_resize(
-            value=value,
-            init_world_half=snap["world_half"],
-            init_location=snap["location"],
-            world_axis=snap["world_axis"],
-            display_size=snap["display_size"],
-        )
-        new_scale = list(snap["scale"])
-        # Preserve the sign of the original scale so a user-flipped empty
-        # stays flipped after the resize — compute_face_resize returns a
-        # positive magnitude, the sign is the user's intent to keep.
-        sign = -1.0 if snap["scale"][axis] < 0.0 else 1.0
-        new_scale[axis] = sign * new_scale_axis
-
-        empty.scale = new_scale
-        empty.location = Vector(new_location)
-
-    return setter
-
-
-class OBJECT_GGT_bim_clip_box(bpy.types.GizmoGroup):  # noqa: N801 — Blender bl_idname convention
-    """Face-quad resize handles on the active clip box.
-
-    Renders six near-invisible click-target quads and six colored edge
-    outlines on the active clip-box empty whenever clipping is enabled.
-    Click-and-drag a face to resize one-sided; the opposite face stays
-    put. CTRL+click and plain click fall through to selection.
-    """
-
-    bl_idname = "OBJECT_GGT_bim_clip_box"
-    bl_label = "Bonsai Clip Box Faces"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "WINDOW"
-    bl_options = {"3D", "PERSISTENT", "SHOW_MODAL_ALL"}
-
-    @classmethod
-    def poll(cls, context: Any) -> bool:
-        scene = getattr(context, "scene", None)
-        if scene is None:
-            return False
-        scene_props = tool.ClipBox.get_scene_props(scene)
-        if not scene_props.enabled or not scene_props.enable_gizmos:
-            return False
-        active_clip_box = tool.ClipBox.get_active_clip_box(scene)
-        if active_clip_box is None:
-            return False
-        # Only render when the user has the active clip box itself
-        # selected — otherwise the face handles would intercept clicks
-        # meant for the geometry behind them.
-        return getattr(context, "active_object", None) is active_clip_box
-
-    @classmethod
-    def setup_keymap(cls, keyconfig):
-        # Bind CLICK_DRAG so plain LEFTMOUSE PRESS passes through to
-        # selection — the user can still click through a near-invisible
-        # face quad to pick a mesh behind it.
-        km = keyconfig.keymaps.new(
-            name=cls.bl_idname,
-            space_type=cls.bl_space_type,
-            region_type=cls.bl_region_type,
-        )
-        km.keymap_items.new("gizmogroup.gizmo_tweak", type="LEFTMOUSE", value="CLICK_DRAG")
-        km.keymap_items.new("gizmogroup.gizmo_tweak", type="LEFTMOUSE", value="PRESS", ctrl=True)
-        return km
-
-    def setup(self, context: Any) -> None:
-        # ``_empty`` is resolved each refresh so the PERSISTENT group
-        # follows whichever clip box is active in the scene PG.
-        self._empty: bpy.types.Object | None = None
-        self._locked = False
-        self._face_routes: list[tuple[int, bool]] = []
-
-        for axis, is_max in face_quad.FACE_ROUTES:
-            gz = self.gizmos.new(face_quad.BIM_GT_box_face_quad.bl_idname)
-            gz._group = self
-            gz._face_axis = axis
-            gz.is_max = is_max
-            gz._drag_snapshot = None
-            gz._last_geometry_state = "solid"
-            gz._strips_cache_key = None
-            gz.color = face_quad.AXIS_COLOR[axis]
-            gz.color_highlight = tuple(min(1.0, c + 0.3) for c in face_quad.AXIS_COLOR[axis])
-            gz.alpha = face_quad.FACE_QUAD_ALPHA
-            gz.alpha_highlight = face_quad.FACE_QUAD_ALPHA_HIGHLIGHT
-            gz.use_draw_modal = True
-            gz.scale_basis = 1.0
-            gz.select_bias = face_quad.FACE_QUAD_SELECT_BIAS
-            gz.move_get_cb = _make_face_get_cb(gz, self, axis, is_max)
-            gz.move_set_cb = _make_face_set_cb(gz, self, axis, is_max)
-            # CTRL+click on a face aligns the viewport to look at it.
-            gz.ctrl_click_cb = _make_ctrl_click_cb(axis, is_max)
-            self._face_routes.append((axis, is_max))
-
-        # Outlines added last so they composite on top of the quad
-        # fills (Blender draws gizmos in creation order).
-        for axis, is_max in face_quad.FACE_ROUTES:
-            ol = self.gizmos.new(face_quad.BIM_GT_box_face_outline.bl_idname)
-            ol._face_axis = axis
-            ol.is_max = is_max
-            ol.color = face_quad.AXIS_COLOR[axis]
-            ol.color_highlight = face_quad.AXIS_COLOR[axis]
-            ol.alpha = 0.0
-            ol.alpha_highlight = 0.0
-            ol.line_width = 2.5
-
-    def _quad_gizmos(self):
-        return self.gizmos[: len(self._face_routes)]
-
-    def _outline_gizmos(self):
-        n = len(self._face_routes)
-        return self.gizmos[n : 2 * n]
-
-    def refresh(self, context: Any) -> None:
-        """State-change path: resolve the active empty, then run the
-        shared face-quad layout so the quads aren't stale for a frame
-        after a selection or active-index change."""
-        empty = tool.ClipBox.get_active_clip_box(context.scene)
-        self._empty = empty
-        if empty is None:
-            for gz in self.gizmos:
-                gz.hide = True
-            return
-        self._layout(context, empty)
-
-    def draw_prepare(self, context: Any) -> None:
-        """Per-redraw — fires on orbit — re-run the layout so the
-        front/back split, halo strips, and outline highlights track
-        the camera and any live G/R/S on the empty."""
-        empty = self._empty
-        if empty is None:
-            return
-        self._layout(context, empty)
-
-    def _layout(self, context: Any, empty: bpy.types.Object) -> None:
-        face_quad.apply_face_quad_layout(
-            quad_gizmos=self._quad_gizmos(),
-            outline_gizmos=self._outline_gizmos(),
-            bmin=_LOCAL_BMIN,
-            bmax=_LOCAL_BMAX,
-            matrix_world=empty.matrix_world,
-            # The empty's rotation rides in matrix_world, so the
-            # box-local OBB rotation is identity.
-            cage_rotation=Matrix.Identity(4),
-            region=getattr(context, "region", None),
-            rv3d=getattr(context, "region_data", None),
-            locked=self._locked,
-        )
-
-    # ---- mutual exclusion (lock siblings during a drag) ------------------
-
-    def _lock_for(self, active_gizmo) -> None:
-        self._locked = True
-        for gz in self.gizmos:
-            if gz is not active_gizmo:
-                with contextlib.suppress(ReferenceError, RuntimeError):
-                    gz.hide = True
-
-    def _unlock_all(self) -> None:
-        self._locked = False
-        for gz in self.gizmos:
-            with contextlib.suppress(ReferenceError, RuntimeError):
-                gz.hide = False
-        # Rebuild caps synchronously so the cross-section overlay
-        # re-forms the instant the user releases the handle, rather
-        # than waiting for the depsgraph's debounced rebuild path.
-        with contextlib.suppress(RuntimeError, ReferenceError):
-            tool.ClipBox.rebuild_caps_now()
-        # Push an undo step so the user can revert a face drag with Ctrl+Z.
-        with contextlib.suppress(RuntimeError):
-            bpy.ops.ed.undo_push(message="Resize Clip Box")
@@ -1,294 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-import bpy
-from mathutils import Matrix, Vector
-
-import bonsai.tool as tool
-from bonsai.bim.helper import prop_with_search
-
-from . import data
-
-# NOTE: do NOT add ``from __future__ import annotations`` to this module.
-# PEP 563 stringifies the operator's EnumProperty class annotations, which
-# breaks any introspection that reads ``cls.__annotations__[name].keywords``
-# — including the enum-search helper that draws the search-button icon.
-
-CLIP_BOX_NAME = "ClipBox"
-
-# Display labels for the source-based picker, used for the menu entries and
-# the dialog title. The dict keys are the canonical source-kind identifiers.
-SOURCE_KIND_LABELS: dict[str, str] = {
-    "SPATIAL": "Spatial Element",
-    "CLASS": "Class",
-    "TYPE": "Type",
-    "MATERIAL": "Material",
-    "PROFILE": "Profile",
-    "DRAWING": "Drawing",
-    "STATUS": "Status",
-    "SYSTEM": "System",
-    "GROUP": "Group",
-    "ZONE": "Zone",
-}
-
-
-_SOURCE_ID_DISPATCH = {
-    "SPATIAL": data.spatial_items,
-    "CLASS": data.class_items,
-    "TYPE": data.type_items,
-    "MATERIAL": data.material_items,
-    "PROFILE": data.profile_items,
-    "DRAWING": data.drawing_items,
-    "STATUS": data.status_items,
-    "SYSTEM": data.system_items,
-    "GROUP": data.group_items,
-    "ZONE": data.zone_items,
-}
-
-
-def _source_id_items(self, context):
-    """Dispatch the ``source_id`` enum items based on the picked ``source_kind``."""
-    fn = _SOURCE_ID_DISPATCH.get(self.source_kind)
-    if fn is None:
-        return [(data.NO_OPTIONS_ID, "No options", "")]
-    return fn(self, context)
-
-
-def _source_display_name(kind, source_id):
-    """Human-readable name of the picked source, used in the clip-box name."""
-    if kind == "STATUS":
-        return next((label for value, label in data.STATUS_LABELS if value == source_id), source_id)
-    if kind == "CLASS":
-        # source_id IS the human-readable IFC class name.
-        return source_id
-    ifc = tool.Ifc.get()
-    if ifc is None:
-        return source_id
-    try:
-        entity = ifc.by_id(int(source_id))
-    except (TypeError, ValueError, RuntimeError):
-        return source_id
-    return (getattr(entity, "Name", None) or "Unnamed").strip() or "Unnamed"
-
-
-class BIM_OT_align_view_to_clip_face(bpy.types.Operator):
-    bl_idname = "bim.align_view_to_clip_face"
-    bl_label = "Align View to Clip Box Face"
-    bl_description = "Orient the 3D viewport to look directly at the picked clip-box face"
-    bl_options = {"REGISTER"}
-
-    axis: bpy.props.IntProperty(default=0, options={"SKIP_SAVE"})
-    is_max: bpy.props.BoolProperty(default=True, options={"SKIP_SAVE"})
-
-    def execute(self, context):
-        rv3d = getattr(context, "region_data", None)
-        if rv3d is None:
-            return {"CANCELLED"}
-        clip_box = tool.ClipBox.get_active_clip_box(context.scene)
-        if clip_box is None:
-            return {"CANCELLED"}
-        rot_mat = clip_box.matrix_world.to_quaternion().to_matrix()
-        outward_local = Vector((0.0, 0.0, 0.0))
-        outward_local[self.axis] = 1.0 if self.is_max else -1.0
-        outward = (rot_mat @ outward_local).normalized()
-        if outward.length == 0.0:
-            return {"CANCELLED"}
-        up_world = (rot_mat @ _local_up_for_face(self.axis, self.is_max)).normalized()
-        rv3d.view_rotation = _view_rotation_from_forward_and_up(-outward, up_world)
-        return {"FINISHED"}
-
-
-def _local_up_for_face(axis: int, is_max: bool) -> Vector:
-    """Box-local up direction for a face, following Blender numpad conventions.
-
-    Side faces (local ±X / ±Y normal) → local +Z is up. Top face (local +Z
-    normal) → local +Y is up; bottom face (local -Z normal) → local -Y is
-    up. The caller rotates this through the empty's matrix so the
-    resulting world up axis tracks the box's orientation.
-    """
-    if axis == 2:
-        return Vector((0.0, 1.0, 0.0)) if is_max else Vector((0.0, -1.0, 0.0))
-    return Vector((0.0, 0.0, 1.0))
-
-
-def _view_rotation_from_forward_and_up(forward: Vector, up_hint: Vector) -> "bpy.types.Quaternion":
-    """Build a camera ``view_rotation`` that looks along ``forward`` with
-    ``up_hint`` projected to the camera's local +Y."""
-    back = -forward.normalized()
-    right = up_hint.cross(back)
-    if right.length < 1e-6:
-        right = Vector((1.0, 0.0, 0.0))
-    right.normalize()
-    up = back.cross(right).normalized()
-    return Matrix(
-        (
-            (right.x, up.x, back.x),
-            (right.y, up.y, back.y),
-            (right.z, up.z, back.z),
-        )
-    ).to_quaternion()
-
-
-class BIM_OT_add_clip_box(bpy.types.Operator):
-    bl_idname = "bim.add_clip_box"
-    bl_label = "Add Clip Box"
-    bl_description = (
-        "Create a clip box empty at the 3D cursor. The empty's location, rotation, and scale "
-        "drive the viewport clip planes; resize with S, move with G, rotate with R"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        # Default to a 20m cube (scale 10 around [-1, +1] local cube) so
-        # the volume covers a typical building storey or two rather than
-        # the meaningless 2m unit cube. The user resizes with S.
-        matrix = Matrix.Translation(context.scene.cursor.location.copy()) @ Matrix.Diagonal((10.0, 10.0, 10.0, 1.0))
-        tool.ClipBox.create_clip_box_empty(context, matrix, name=CLIP_BOX_NAME)
-        return {"FINISHED"}
-
-
-class BIM_OT_add_clip_box_for_source(bpy.types.Operator):
-    bl_idname = "bim.add_clip_box_for_source"
-    bl_label = "Add Clip Box From Source"
-    bl_description = (
-        "Create a clip box sized to a chosen source: a spatial container, IFC type, material, "
-        "profile, drawing camera frustum, element status, system, group, or zone"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    source_kind: bpy.props.EnumProperty(
-        name="Source Kind",
-        items=[(kind, label, "") for kind, label in SOURCE_KIND_LABELS.items()],
-        default="SPATIAL",
-        options={"SKIP_SAVE"},
-    )
-    source_id: bpy.props.EnumProperty(
-        name="Source",
-        items=_source_id_items,
-        options={"SKIP_SAVE"},
-    )
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self)
-
-    def draw(self, context):
-        layout = self.layout
-        label = f"Clip {SOURCE_KIND_LABELS.get(self.source_kind, 'Source')}"
-        # Search button appears once the enum exceeds the helper's threshold,
-        # giving the user a popup picker instead of a plain dropdown.
-        prop_with_search(layout, self, "source_id", text=label)
-
-    def execute(self, context):
-        if not self.source_id or self.source_id == data.NO_OPTIONS_ID:
-            self.report({"ERROR"}, "No source selected.")
-            return {"CANCELLED"}
-        matrix = tool.ClipBox.compute_matrix_for_source(self.source_kind, self.source_id)
-        if matrix is None:
-            kind_label = SOURCE_KIND_LABELS.get(self.source_kind, self.source_kind)
-            self.report(
-                {"ERROR"},
-                f"No elements found for {kind_label} '{_source_display_name(self.source_kind, self.source_id)}'.",
-            )
-            return {"CANCELLED"}
-        name = f"ClipBox.{SOURCE_KIND_LABELS.get(self.source_kind, self.source_kind)}.{_source_display_name(self.source_kind, self.source_id)}"
-        tool.ClipBox.create_clip_box_empty(context, matrix, name=name)
-        return {"FINISHED"}
-
-
-class BIM_OT_remove_clip_box(bpy.types.Operator):
-    bl_idname = "bim.remove_clip_box"
-    bl_label = "Remove Clip Box"
-    bl_description = "Remove this clip box and its host empty"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty(default=-1, options={"SKIP_SAVE"})
-    delete_object: bpy.props.BoolProperty(default=True, name="Delete Host Object")
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        index = self.index if self.index >= 0 else scene_props.active_clip_box_index
-        if index < 0 or index >= len(scene_props.clip_boxes):
-            return {"CANCELLED"}
-
-        entry = scene_props.clip_boxes[index]
-        obj = entry.obj
-        scene_props.clip_boxes.remove(index)
-        if scene_props.active_clip_box_index >= len(scene_props.clip_boxes):
-            scene_props.active_clip_box_index = max(0, len(scene_props.clip_boxes) - 1)
-
-        if self.delete_object and obj is not None:
-            bpy.data.objects.remove(obj, do_unlink=True)
-
-        tool.ClipBox.refresh(context.scene)
-        tool.ClipBox.save_to_project_pset(context.scene)
-        return {"FINISHED"}
-
-
-class BIM_OT_set_active_clip_box(bpy.types.Operator):
-    bl_idname = "bim.set_active_clip_box"
-    bl_label = "Set Active Clip Box"
-    bl_description = "Set this clip box as the active one driving the viewport clip"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty(default=-1, options={"SKIP_SAVE"})
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        if self.index < 0 or self.index >= len(scene_props.clip_boxes):
-            return {"CANCELLED"}
-        scene_props.active_clip_box_index = self.index
-        return {"FINISHED"}
-
-
-class BIM_OT_toggle_clip_box_enabled(bpy.types.Operator):
-    bl_idname = "bim.toggle_clip_box_enabled"
-    bl_label = "Toggle Clip Box"
-    bl_description = "Toggle whether the active clip box is driving the viewport clip planes"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        scene_props.enabled = not scene_props.enabled
-        return {"FINISHED"}
-
-
-class BIM_OT_duplicate_clip_box(bpy.types.Operator):
-    bl_idname = "bim.duplicate_clip_box"
-    bl_label = "Duplicate Clip Box"
-    bl_description = "Duplicate this clip box: copy its empty + matrix into a new entry"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty(default=-1, options={"SKIP_SAVE"})
-
-    def execute(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        source_index = self.index if self.index >= 0 else scene_props.active_clip_box_index
-        if source_index < 0 or source_index >= len(scene_props.clip_boxes):
-            return {"CANCELLED"}
-        source = scene_props.clip_boxes[source_index].obj
-        if source is None:
-            return {"CANCELLED"}
-
-        copy = tool.ClipBox.create_clip_box_empty(context, source.matrix_world.copy(), name=source.name)
-        # Preserve the source's display attrs so the duplicate matches.
-        copy.empty_display_type = source.empty_display_type
-        copy.empty_display_size = source.empty_display_size
-        copy.show_in_front = source.show_in_front
-        return {"FINISHED"}
@@ -1,165 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import bpy
-from bpy.types import PropertyGroup
-
-import bonsai.tool as tool
-from bonsai.bim.prop import ObjProperty
-
-
-class BIMClipBoxProperties(PropertyGroup):
-    """Per-object marker for a clip-box host empty.
-
-    The host empty's ``matrix_world`` is the single source of truth for
-    the clip box's pose and dimensions: translation = box centre,
-    rotation = box orientation, per-axis scale = world half-extents. The
-    visible cube comes from the empty's CUBE display.
-
-    Only ``is_clip_box`` lives here; visibility (``enabled``) and overlay
-    (``show_caps``) are global per-file and live on the Scene PG.
-    """
-
-    is_clip_box: bpy.props.BoolProperty(
-        default=False,
-        description="True when this empty was created as a clip-box host. Internal flag; not user-edited.",
-    )
-
-    if TYPE_CHECKING:
-        is_clip_box: bool
-
-
-def update_active_clip_box_index(self, context):
-    tool.ClipBox.schedule_refresh()
-    tool.ClipBox.select_active_clip_box(context)
-    # Rebuild caps for the new active box's clip volume.
-    tool.ClipBox.invalidate_cap_cache(immediate=True)
-
-
-def update_show_caps(self, context):
-    tool.ClipBox.schedule_refresh()
-    # Off → on must trigger a rebuild so caps reappear immediately rather
-    # than wait for the next depsgraph tick. The rebuild is a no-op when
-    # show_caps is now False (it clears and returns), so this is safe in
-    # both directions.
-    tool.ClipBox.invalidate_cap_cache()
-
-
-def update_enabled(self, context):
-    tool.ClipBox.schedule_refresh()
-
-
-def update_clip_only_ifc_products(self, context):
-    # The eligibility set for capping changed — drop the cache and let the
-    # debounced rebuild pick up the new objects on the next idle tick.
-    tool.ClipBox.invalidate_cap_cache()
-
-
-def update_include_linked_ifc(self, context):
-    tool.ClipBox.invalidate_cap_cache()
-
-
-class BIMSceneClipBoxProperties(PropertyGroup):
-    """Scene-level registry of clip boxes in this file.
-
-    Multiple boxes may exist; ``active_clip_box_index`` selects which one
-    drives the viewport clip at any time. ``enabled`` and ``show_caps``
-    are global because the user's intent ("hide everything outside the
-    box", "draw cap overlays") applies file-wide, not per box.
-
-    ``enabled`` is intentionally not persisted to the project pset:
-    opening a fresh IFC should never silently hide geometry behind a
-    remembered toggle. Selecting any clip-box empty in the viewport
-    re-arms it (see :meth:`tool.ClipBox._sync_active_to_selection`).
-    """
-
-    clip_boxes: bpy.props.CollectionProperty(type=ObjProperty)
-    active_clip_box_index: bpy.props.IntProperty(
-        default=0,
-        min=0,
-        update=update_active_clip_box_index,
-        description="Index of the clip box currently driving the viewport clip planes",
-    )
-    enabled: bpy.props.BoolProperty(
-        name="Enabled",
-        default=False,
-        update=update_enabled,
-        description="When enabled, the active clip box hides all viewport geometry outside its 6 faces",
-    )
-    show_caps: bpy.props.BoolProperty(
-        name="Show Caps",
-        default=True,
-        update=update_show_caps,
-        description=(
-            "Draw filled cross-section caps where IFC product geometry "
-            "crosses the active clip planes. Disable for performance on "
-            "very heavy scenes"
-        ),
-    )
-    # Stored on the Scene PG so Blender persists it in the .blend; deliberately
-    # NOT written to the project pset so the IFC stays portable across users
-    # who may have different Blender-side reference geometry to clip.
-    clip_only_ifc_products: bpy.props.BoolProperty(
-        name="Only IFC Products",
-        default=True,
-        update=update_clip_only_ifc_products,
-        description=(
-            "When enabled, only IFC element geometry gets cross-section caps. "
-            "Disable to also cap Blender-side reference meshes (sketches, "
-            "imported obj, primitive cubes, …)"
-        ),
-    )
-    # Opt-in inclusion of geometry sitting inside loaded Project › Links
-    # collection-instance empties. Off by default — linked IFCs commonly
-    # carry the entire site / structural / MEP context, and bisecting
-    # them on every clip-box edit can be expensive.
-    include_linked_ifc: bpy.props.BoolProperty(
-        name="Include Linked IFC",
-        default=False,
-        update=update_include_linked_ifc,
-        description=(
-            "Also generate cross-section caps for geometry inside linked "
-            "IFC files (Project ▸ Links). Off by default — linked IFCs may "
-            "carry the entire site / structural backbone, and capping them "
-            "adds per-mesh bisect cost on every clip-box edit"
-        ),
-    )
-    # Also Scene-only — gizmo visibility is a per-user editing preference,
-    # not a portable IFC property.
-    enable_gizmos: bpy.props.BoolProperty(
-        name="Show Face Handles",
-        default=True,
-        description=(
-            "Show interactive face-resize handles on the active clip box. "
-            "Disable to fall back to plain G/R/S transforms on the empty"
-        ),
-    )
-
-    if TYPE_CHECKING:
-        active_clip_box_index: int
-        enabled: bool
-        show_caps: bool
-        clip_only_ifc_products: bool
-        include_linked_ifc: bool
-        enable_gizmos: bool
@@ -1,145 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-from __future__ import annotations
-
-from bpy.types import Menu, Panel, UIList
-
-import bonsai.tool as tool
-
-# Per-kind icon for the source-picker menu. Picked from Blender's built-in
-# icon set; semantically close to the kind so users can scan the menu visually.
-_SOURCE_MENU_ENTRIES: tuple[tuple[str, str, str], ...] = (
-    ("SPATIAL", "Clip Spatial Element", "OUTLINER_COLLECTION"),
-    ("CLASS", "Clip by Class", "BLANK1"),
-    ("TYPE", "Clip Type", "FILE_3D"),
-    ("MATERIAL", "Clip Material", "MATERIAL"),
-    ("PROFILE", "Clip Profile", "MESH_CIRCLE"),
-    ("DRAWING", "Clip Drawing Extents", "CAMERA_DATA"),
-    ("STATUS", "Clip by Status", "INFO"),
-    ("SYSTEM", "Clip by System", "MOD_FLUID"),
-    ("GROUP", "Clip by Group", "OUTLINER_OB_GROUP_INSTANCE"),
-    ("ZONE", "Clip by Zone", "MOD_LATTICE"),
-)
-
-
-class BIM_MT_clip_box_add_for_source(Menu):
-    bl_idname = "BIM_MT_clip_box_add_for_source"
-    bl_label = "Add Clip Box From Source"
-
-    def draw(self, context):
-        layout = self.layout
-        for kind, label, icon in _SOURCE_MENU_ENTRIES:
-            op = layout.operator("bim.add_clip_box_for_source", text=label, icon=icon)
-            op.source_kind = kind
-
-
-class BIM_MT_clip_box_settings(Menu):
-    bl_idname = "BIM_MT_clip_box_settings"
-    bl_label = "Clip Box Settings"
-
-    def draw(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        self.layout.prop(scene_props, "clip_only_ifc_products")
-        self.layout.prop(scene_props, "include_linked_ifc")
-        self.layout.prop(scene_props, "enable_gizmos")
-
-
-class BIM_MT_clip_box_info(Menu):
-    bl_idname = "BIM_MT_clip_box_info"
-    bl_label = "Clip Box Face Handles"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="Face Handles", icon="INFO")
-        layout.separator()
-        layout.label(text="Drag a face to resize the clip box on that axis.")
-        layout.label(text="The opposite face stays fixed (one-sided resize).")
-        layout.label(text="Ctrl+Click a face to align the viewport to it.")
-        layout.separator()
-        layout.label(text="Toggle handles from the Settings (gear) menu.")
-
-
-class BIM_UL_clip_box(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index, flt_flag):
-        obj = item.obj
-        row = layout.row(align=True)
-        if obj is None:
-            # Host empty was deleted from outliner; still expose the
-            # remove button so the orphan entry isn't permanent.
-            row.label(text="(missing)", icon="ERROR")
-            row.operator("bim.remove_clip_box", text="", icon="X", emboss=False).index = index
-            return
-        row.prop(obj, "name", text="", emboss=False, icon="MESH_CUBE")
-        row.operator("bim.duplicate_clip_box", text="", icon="DUPLICATE", emboss=False).index = index
-        row.operator("bim.remove_clip_box", text="", icon="X", emboss=False).index = index
-
-
-class BIM_PT_clip_box(Panel):
-    bl_idname = "BIM_PT_clip_box"
-    bl_label = "Clip Box"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_parent_id = "BIM_PT_tab_sandbox"
-
-    def draw(self, context):
-        layout = self.layout
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-
-        toggles = layout.row(align=True)
-        toggles.scale_y = 2.0
-        toggles.prop(
-            scene_props,
-            "enabled",
-            text="Enable Clipping",
-            icon="HIDE_OFF" if scene_props.enabled else "HIDE_ON",
-            toggle=True,
-        )
-        toggles.prop(scene_props, "show_caps", text="Show Caps", icon="MOD_SOLIDIFY", toggle=True)
-        toggles.menu("BIM_MT_clip_box_settings", icon="PREFERENCES", text="")
-        toggles.menu("BIM_MT_clip_box_info", icon="INFO", text="")
-
-        layout.separator()
-        row = layout.row(align=True)
-        row.operator("bim.add_clip_box", icon="ADD", text="Add Clip Box")
-        row.menu("BIM_MT_clip_box_add_for_source", icon="DOWNARROW_HLT", text="")
-
-        layout.template_list(
-            "BIM_UL_clip_box",
-            "",
-            scene_props,
-            "clip_boxes",
-            scene_props,
-            "active_clip_box_index",
-            rows=3,
-        )
-
-        obj = tool.ClipBox.get_active_clip_box(context.scene)
-        if obj is None:
-            layout.label(text="No active clip box", icon="INFO")
-            return
-
-        col = layout.column(align=True)
-        col.label(text="Edit the empty with G / R / S to move / rotate / resize")
-        col.prop(obj, "location")
-        col.prop(obj, "rotation_euler")
-        col.prop(obj, "scale")
@@ -156,8 +156,6 @@ class CostSchedulesData:
            values = root_element.CostValues
        elif root_element.is_a("IfcConstructionResource"):
            values = root_element.BaseCosts
-        else:
-            assert False, root_element
        for cost_value in values or []:
            cls._load_cost_value(root_element, data, cost_value)
            # data["CostValues"].append(cost_value.id())
@@ -127,25 +127,36 @@ class ObjectDocumentData:
                identification = None

                if is_information:
-                    identification = tool.Document.get_document_information_id(relating_document)
+                    if tool.Ifc.get_schema() == "IFC2X3":
+                        identification = relating_document.DocumentId
+                    else:
+                        identification = relating_document.Identification

                    location = getattr(relating_document, "Location", None)
                    description = getattr(relating_document, "Description", "No description")
                else:
                    description = relating_document.Description
-                    referenced_document = tool.Document.get_reference_document(relating_document)
+                    if tool.Ifc.get_schema() == "IFC2X3":
+                        reference_to_document = relating_document.ReferenceToDocument
+                        if not name and reference_to_document:
+                            name = reference_to_document[0].Name

-                    if not name and referenced_document:
-                        name = referenced_document.Name
+                        identification = relating_document.ItemReference
+                        if not identification and reference_to_document:
+                            identification = reference_to_document[0].DocumentId
+                        location = relating_document.Location
+                    else:
+                        referenced_document = relating_document.ReferencedDocument
+                        if not name and referenced_document:
+                            name = referenced_document.Name

-                    identification = tool.Document.get_external_reference_id(relating_document)
-                    if not identification and referenced_document:
-                        identification = tool.Document.get_document_information_id(referenced_document)
+                        identification = relating_document.Identification
+                        if not identification and referenced_document:
+                            identification = referenced_document.Identification

-                    location = relating_document.Location
-                    # IFC2X3 IfcDocumentInformation has no Location to fall back to.
-                    if location is None and referenced_document and tool.Ifc.get_schema() != "IFC2X3":
-                        location = referenced_document.Location
+                        location = relating_document.Location
+                        if location is None and referenced_document:
+                            location = referenced_document.Location

                location = cls.convert_to_file_uri(location) if location else None

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.

 import bpy

@@ -47,7 +45,6 @@ classes = (
    operator.CleanWireframes,
    operator.ContractSheet,
    operator.ConvertSVGToDXF,
-    operator.CopyAnnotationToDrawing,
    operator.CopyTextToSelection,
    operator.CreateDrawing,
    operator.CreateSheets,
@@ -139,34 +136,14 @@ classes = (
    gizmos.GizmoArrow2D,
    gizmos.GizmoCone,
    gizmos.GizmoDimension,
-    gizmos.GizmoLockOpen,
-    gizmos.GizmoLockClosed,
+    gizmos.GizmoLock,
    gizmos.GizmoArc,
-    gizmos.GizmoLinkToggle,
-    gizmos.GizmoFillet,
-    gizmos.GizmoWallCornerIcon,
-    gizmos.GizmoWallTeeIcon,
    gizmos.GizmoPen,
    gizmos.GizmoValidate,
    gizmos.GizmoCancel,
    gizmos.GizmoPlus,
    gizmos.GizmoMinus,
-    gizmos.GizmoTrash,
-    gizmos.GizmoArrayParent,
-    gizmos.GizmoArrayAll,
-    gizmos.GizmoArrayLayerIndicator,
-    gizmos.GizmoCountLabel,
-    gizmos.GizmoMerge,
-    gizmos.GizmoSplit,
-    gizmos.GizmoUnjoin,
-    gizmos.GizmoExtend,
-    gizmos.GizmoExtendVertical,
-    gizmos.GizmoOffsetExterior,
-    gizmos.GizmoOffsetCenter,
-    gizmos.GizmoOffsetInterior,
-    gizmos.GizmoAddOpening,
    gizmos.GizmoCycle,
-    gizmos.GizmoMenu,
    # Drawing-specific gizmos
    gizmos.UglyDotGizmo,
    gizmos.ExtrusionGuidesGizmo,
@@ -425,12 +425,10 @@ class BaseDecorator:

        blf.size(font_id, font_size_px)

-        w, h = None, None
        if box_alignment or center or vcenter:
            w, h = blf.dimensions(font_id, text)

        if box_alignment:
-            assert w is not None and h is not None
            box_alignment_offset = Vector((0, 0))
            if "bottom" in box_alignment:
                pass
@@ -452,12 +450,10 @@ class BaseDecorator:
        else:
            # horizontal centering
            if center:
-                assert w is not None
                pos -= Vector((cos, sin)) * w * 0.5

            # vertical centering
            if vcenter:
-                assert h is not None
                pos -= Vector((-sin, cos)) * h * 0.5

            # side-shifting
@@ -1005,8 +1001,6 @@ class FallDecorator(BaseDecorator):
            O = A.copy()
            O.z = B.z
            run = (B - O).length
-
-            angle_tg = None
            if run != 0:
                angle_tg = rise / run
                angle = round(degrees(atan(angle_tg)))
@@ -1024,7 +1018,6 @@ class FallDecorator(BaseDecorator):
            elif object_type == "SLOPE_PERCENT":
                if angle == 90:
                    return "-"
-                assert angle_tg is not None
                return f"{round(angle_tg * 100)} %"
            return "NO DATA"

@@ -1256,7 +1249,6 @@ class SectionLevelDecorator(BaseDecorator):
        }

        # process edges
-        text_position, text_dir = None, None
        for edge in edges_original:
            v0, v1 = winspace_verts[edge[0]], winspace_verts[edge[1]]
            start_i = len(output_verts)
@@ -1562,39 +1554,32 @@ class SectionDecorator(BaseDecorator):
            v0, v1 = winspace_verts[edge[0]], winspace_verts[edge[1]]
            start_i = len(output_verts)

-            circle_head = None
            if display_start_circle or display_end_circle:
                circle_head = get_circle_head(circle_size)

-            triangle_head, divider_offset, edge_dir_circle = None, None, None
-            display_symbol = display_start_symbol or display_end_symbol
-            if display_symbol or connect_markers:
+            if display_start_symbol or display_end_symbol or connect_markers:
                edge_dir = (v1 - v0).normalized()
                side = (edge_dir.yx * Vector((1, -1))).to_3d()
                edge_dir_circle = edge_dir * circle_size

-                if display_symbol:
-                    triangle_head = get_triangle_head(edge_dir, -side, triangle_length, triangle_width)
-                    divider_offset = []
-                    divider_offset.append(edge_dir_circle if connect_markers else edge_dir_circle * 3)
-                    divider_offset.append(edge_dir_circle)
+            if display_start_symbol or display_end_symbol:
+                triangle_head = get_triangle_head(edge_dir, -side, triangle_length, triangle_width)
+                divider_offset = []
+                divider_offset.append(edge_dir_circle if connect_markers else edge_dir_circle * 3)
+                divider_offset.append(edge_dir_circle)

            if display_start_circle:
-                assert circle_head is not None
                start_i = add_verts_sequence([v + v0 for v in circle_head], start_i, **out_kwargs, closed=True)
                # circle middle divider
                if not display_start_symbol:
-                    assert divider_offset is not None
                    start_i = add_verts_sequence(
                        [v0 + divider_offset[0], v0 - divider_offset[1]], start_i, **out_kwargs
                    )

            if display_start_symbol:
-                assert triangle_head is not None
                start_i = add_verts_sequence([v + v0 for v in triangle_head], start_i, **out_kwargs, closed=True)

            if display_end_circle:
-                assert circle_head is not None
                start_i = add_verts_sequence([v + v1 for v in circle_head], start_i, **out_kwargs, closed=True)
                # circle middle divider
                if not display_end_symbol:
@@ -1603,11 +1588,9 @@ class SectionDecorator(BaseDecorator):
                    )

            if display_end_symbol:
-                assert triangle_head is not None
                start_i = add_verts_sequence([v + v1 for v in triangle_head], start_i, **out_kwargs, closed=True)

            if connect_markers:
-                assert edge_dir_circle is not None
                gap = []
                gap.append(edge_dir_circle if display_start_symbol else Vector((0, 0, 0)))
                gap.append(edge_dir_circle if display_end_symbol else Vector((0, 0, 0)))
@@ -1694,12 +1677,6 @@ class CutDecorator:
        selected_elements_color = self.addon_prefs.decorator_color_selected
        self.fallback_colour = (0.3, 0.3, 0.3, 1)

-        # Evaluate camera movement once per redraw rather than twice per object: is_camera_moved()
-        # runs eval()/numpy on the camera matrix and, as a side effect, refreshes the stored
-        # checksum on the first True result - so calling it per object also made the second call
-        # (fill) see an already-updated checksum and skip recalculating when it shouldn't.
-        self.camera_moved = self.is_camera_moved()
-
        all_vertices = []
        all_edges = []
        selected_vertices = []
@@ -1825,35 +1802,23 @@ class CutDecorator:

        # Currently selected objects must be recalculated as they may be being moved / edited.
        # If the camera is selected, we also recalculate as the user may be moving the camera.
-        is_selected = obj.select_get()
-        recalc_cut = not has_cut_cache or is_selected or self.camera_moved
-        recalc_fill = not has_fill_cache or is_selected or self.camera_moved
-        if not (recalc_cut or recalc_fill):
-            return

-        # The intersection test builds a bmesh and scans every vertex; both recalculations need
-        # the same answer, so compute it once here rather than once in each.
-        is_intersecting = tool.Drawing.is_intersecting_camera(obj, context.scene.camera)
-        if recalc_cut:
-            self.recalculate_cut(context, obj, element, is_intersecting)
-        if recalc_fill:
-            self.recalculate_fill(context, obj, element, is_intersecting)
+        if not has_cut_cache or obj.select_get() or self.is_camera_moved():
+            self.recalculate_cut(context, obj, element)
+        if not has_fill_cache or obj.select_get() or self.is_camera_moved():
+            self.recalculate_fill(context, obj, element)

-    def recalculate_cut(
-        self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance, is_intersecting: bool
-    ) -> None:
-        if is_intersecting:
+    def recalculate_cut(self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
+        if tool.Drawing.is_intersecting_camera(obj, context.scene.camera):
            verts, edges = tool.Drawing.bisect_mesh(obj, context.scene.camera)
            DecoratorData.cut_cache[element.id()] = (verts, edges)
        else:
            DecoratorData.cut_cache[element.id()] = (False, False)

-    def recalculate_fill(
-        self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance, is_intersecting: bool
-    ) -> None:
+    def recalculate_fill(self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
        element_id = element.id()

-        if not is_intersecting:
+        if not tool.Drawing.is_intersecting_camera(obj, context.scene.camera):
            DecoratorData.fill_cache[element_id] = {}
            return

@@ -1906,8 +1871,6 @@ class CutDecorator:
            layer_set = material
            offset = 0
            sense_factor = 1
-        else:
-            assert False, material

        if len(layer_set.MaterialLayers) == 1:
            material = layer_set.MaterialLayers[0].Material
@@ -1934,8 +1897,6 @@ class CutDecorator:
            co = Vector((0.0, 0.0, offset))
            no = tool.Drawing.get_extrusion_vector(element).normalized()
            no = Vector([1.0, 0.0, 0.0])
-        else:
-            assert False, usage
        no *= sense_factor
        last_i = len(layer_set.MaterialLayers) - 1

@@ -50,9 +50,6 @@ def set_active_camera_resolution(scene: bpy.types.Scene) -> None:
    if camera.type != props.camera_type:
        camera.type = props.camera_type

-    if props.update_props and (drawing := tool.Ifc.get_entity(camera_obj)):
-        tool.Drawing.sync_perspective_camera_shifts(drawing, camera)
-
    ortho_scale, aspect_ratio = props.get_scale_and_aspect_ratio()
    scene_render = scene.render
    if (camera.ortho_scale != ortho_scale) or not tool.Cad.is_x(
@@ -189,20 +189,14 @@ def format_distance(
            if hasattr(length_unit, "Prefix") and length_unit.Prefix:
                unit_length = length_unit.Prefix + length_unit.Name
            unit_length_mapping = {
-                "MILE": "MILES",
                "FOOT": "FEET",
                "INCH": "INCHES",
-                "KILOMETRE": "KILOMETERS",
                "METRE": "METERS",
                "DECIMETRE": "DECIMETERS",
                "CENTIMETRE": "CENTIMETERS",
                "MILLIMETRE": "MILLIMETERS",
-                "MICROMETRE": "MICROMETERS",
            }
-            # Fall through for units without a dedicated formatter (e.g.
-            # HECTOMETRE) so they use the adaptive branch instead of a
-            # KeyError (#8255).
-            unit_length = unit_length_mapping.get(unit_length, unit_length)
+            unit_length = unit_length_mapping[unit_length]
        # For now we only format area in IFC Units
        if area_unit := ifcopenshell.util.unit.get_project_unit(tool.Ifc.get(), "AREAUNIT"):
            area_unit_symbol = " " + ifcopenshell.util.unit.get_unit_symbol(area_unit)
@@ -225,11 +219,9 @@ def format_distance(
            unit_system, unit_length, unit_fraction = unit_mapping[custom_unit]

    value *= unit_scale
-    tx_dist = None

    # Imperial Formatting
    if unit_system == "IMPERIAL":
-        toInches = None
        if in_unit_length:
            if unit_length == "INCHES":
                toInches = 1
@@ -243,7 +235,6 @@ def format_distance(
            toInches = 1550
            inPerFoot = 144

-        assert toInches is not None
        decInches = value * toInches
        decFeet = decInches / 12

@@ -322,7 +313,7 @@ def format_distance(
            if not feet and not add_inches:
                tx_dist += str(feet) + "'"

-            if not feet and add_inches and unit_length != "INCHES":
+            if not feet and add_inches:
                if value < 0:
                    tx_dist += "-0' - "
                else:
@@ -386,7 +377,6 @@ def format_distance(
        if precision and isinstance(precision, float):
            value = precision * round(float(value) / precision)

-        fmt = None
        if decimal_places is not None:
            fmt = "%1." + str(decimal_places) + "f"

@@ -469,7 +459,6 @@ def format_distance(
        assert f"Unexpected unit_system - '{unit_system}'."
        # tx_dist = fmt % value

-    assert tx_dist is not None
    return tx_dist


@@ -57,7 +57,7 @@ import shapely
 from bpy_extras.image_utils import load_image
 from bpy_extras.io_utils import ImportHelper
 from lxml import etree
-from mathutils import Color, Matrix, Vector
+from mathutils import Color, Vector

 import bonsai.bim.export_ifc
 import bonsai.bim.handler
@@ -228,90 +228,6 @@ class DuplicateDrawing(bpy.types.Operator, tool.Ifc.Operator):
        )


-def get_copy_annotation_target_drawings(self, context):
-    global COPY_ANNOTATION_TARGET_DRAWINGS_ENUM
-    drawings = [e for e in tool.Ifc.get().by_type("IfcAnnotation") if e.ObjectType == "DRAWING"]
-    drawings.sort(key=lambda d: d.Name or "")
-    COPY_ANNOTATION_TARGET_DRAWINGS_ENUM = [(str(d.id()), d.Name or "Unnamed", "") for d in drawings]
-    return COPY_ANNOTATION_TARGET_DRAWINGS_ENUM
-
-
-COPY_ANNOTATION_TARGET_DRAWINGS_ENUM = []
-
-
-class CopyAnnotationToDrawing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.copy_annotation_to_drawing"
-    bl_label = "Copy Annotation To Drawing"
-    bl_description = (
-        "Copy the selected annotations to another drawing.\n\n"
-        "The copies become independent annotations assigned to the chosen drawing, "
-        "placed in its view plane. The originals stay in their current drawing"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-    target_drawing: bpy.props.EnumProperty(name="Target Drawing", items=get_copy_annotation_target_drawings)
-
-    if TYPE_CHECKING:
-        target_drawing: str
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            cls.poll_message_set("No IFC project loaded.")
-            return False
-        if not cls.get_selected_annotations(context):
-            cls.poll_message_set("No annotation selected.")
-            return False
-        return True
-
-    @classmethod
-    def get_selected_annotations(cls, context) -> list[ifcopenshell.entity_instance]:
-        return [
-            element
-            for obj in context.selected_objects
-            if (element := tool.Ifc.get_entity(obj))
-            and element.is_a("IfcAnnotation")
-            and element.ObjectType != "DRAWING"
-        ]
-
-    def invoke(self, context, event):
-        assert context.window_manager
-        return context.window_manager.invoke_props_dialog(self)
-
-    def draw(self, context):
-        assert self.layout
-        row = self.layout.row()
-        row.prop(self, "target_drawing")
-
-    def _execute(self, context):
-        if not self.target_drawing:
-            self.report({"ERROR"}, "No target drawing selected.")
-            return {"CANCELLED"}
-        target_drawing = tool.Ifc.get().by_id(int(self.target_drawing))
-        annotations = self.get_selected_annotations(context)
-        previous_selection = [obj for a in annotations if (obj := tool.Ifc.get_object(a))]
-        previous_active = context.view_layer.objects.active
-        copied = core.copy_annotations_to_drawing(
-            tool.Ifc,
-            tool.Collector,
-            tool.Drawing,
-            tool.Geometry,
-            annotations=annotations,
-            target_drawing=target_drawing,
-        )
-        for obj in context.selected_objects:
-            obj.select_set(False)
-        for obj in previous_selection:
-            if obj.name in context.view_layer.objects:
-                obj.select_set(True)
-        if previous_active and previous_active.name in context.view_layer.objects:
-            context.view_layer.objects.active = previous_active
-        skipped = len(annotations) - len(copied)
-        message = f"Copied {len(copied)} annotations to {target_drawing.Name or 'Unnamed'}."
-        if skipped:
-            message += f" Skipped {skipped} already in that drawing."
-        self.report({"INFO"}, message)
-
-
 class CreateDrawing(bpy.types.Operator):
    """Creates/refreshes a .svg drawing

@@ -686,7 +602,6 @@ class CreateDrawing(bpy.types.Operator):
        context_type: Literal["body", "annotation"],
        drawing_elements: set[ifcopenshell.entity_instance],
        target_view: str,
-        link_matrix: Optional[Matrix] = None,
    ) -> None:
        drawing_elements = drawing_elements.copy()
        contexts_: list[list[int]] = getattr(contexts, context_type)
@@ -698,19 +613,9 @@ class CreateDrawing(bpy.types.Operator):
                geom_settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
                geom_settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.NATIVE)

-                is_plan = ifc.by_id(context[0]).ContextType == "Plan" and "PLAN_VIEW" in target_view
-                z_offset = (0.002 if target_view == "PLAN_VIEW" else -0.002) if is_plan else 0.0
-
-                if link_matrix is not None:
-                    unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc)
-                    t = link_matrix.to_translation()
-                    offset = (t.x / unit_scale, t.y / unit_scale, t.z / unit_scale + z_offset)
-                    geom_settings.set("model-offset", offset)
-                    q = link_matrix.to_quaternion()
-                    geom_settings.set("model-rotation", (q.x, q.y, q.z, q.w))
-                elif z_offset:
+                if ifc.by_id(context[0]).ContextType == "Plan" and "PLAN_VIEW" in target_view:
                    # A 2mm Z offset to combat Z-fighting in plan or RCPs
-                    geom_settings.set("model-offset", (0.0, 0.0, z_offset))
+                    geom_settings.set("model-offset", (0.0, 0.0, 0.002 if target_view == "PLAN_VIEW" else -0.002))

                geom_settings.set("context-ids", context)
                it = ifcopenshell.geom.iterator(
@@ -782,8 +687,6 @@ class CreateDrawing(bpy.types.Operator):
                layer_set = material
                offset = 0
                sense_factor = 1
-            else:
-                assert False, material

            camera_matrix_i = context.scene.camera.matrix_world.inverted()

@@ -808,6 +711,7 @@ class CreateDrawing(bpy.types.Operator):
            bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.000001)
            bmesh.ops.triangle_fill(bm, use_dissolve=True, edges=bm.edges)

+            prev_co = None
            if not usage:
                sense_factor = 1  # Assume the extrusion vector points in the direction sense
                no = tool.Drawing.get_extrusion_vector(element).normalized()
@@ -824,8 +728,6 @@ class CreateDrawing(bpy.types.Operator):
                co = Vector((0.0, 0.0, offset))
                no = tool.Drawing.get_extrusion_vector(element).normalized()
                no = Vector([1.0, 0.0, 0.0])
-            else:
-                assert False, usage
            no *= sense_factor
            last_i = len(layer_set.MaterialLayers) - 1
            for i, layer in enumerate(layer_set.MaterialLayers):
@@ -993,10 +895,6 @@ class CreateDrawing(bpy.types.Operator):
        if os.path.isfile(svg_path) and self.props.should_use_linework_cache:
            return svg_path

-        ifc = tool.Ifc.get()
-        semantics = None
-        pairs = None
-
        # in case of printing multiple drawings we need to sync just once
        if self.sync and self.drawing_index == 0:
            with profile("sync"):
@@ -1025,16 +923,11 @@ class CreateDrawing(bpy.types.Operator):

        bim_props = tool.Blender.get_bim_props()
        prefs = tool.Blender.get_addon_preferences()
-        # Map ifc_path → (ifc_file, link_matrix); main file has no link_matrix (None)
-        files: dict[str, tuple[ifcopenshell.file, Optional[Matrix]]] = {bim_props.ifc_file: (tool.Ifc.get(), None)}
+        files = {bim_props.ifc_file: tool.Ifc.get()}

        props = tool.Project.get_project_props()
        for link in props.get_loaded_links_for_drawings():
-            try:
-                link_matrix = tool.Project.calculate_link_matrix(link)
-            except Exception:
-                link_matrix = None
-            files[link.filepath] = (self.get_linked_file(link), link_matrix)
+            files[link.filepath] = self.get_linked_file(link)

        target_view = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]["TargetView"]
        self.setup_serialiser(target_view)
@@ -1042,13 +935,7 @@ class CreateDrawing(bpy.types.Operator):
        tree = ifcopenshell.geom.tree()
        tree.enable_face_styles(True)

-        # Accumulated across every file in the loop below (main model plus any
-        # linked models) so the SHAPELY fill pass after the loop covers all of
-        # them, not just whichever file happened to be processed last.
-        raycast_objs = set()
-        elements_with_faces = set()
-
-        for ifc_path, (ifc, link_matrix) in files.items():
+        for ifc_path, ifc in files.items():
            # Don't use draw.main() just whilst we're prototyping and experimenting
            # TODO: hash paths are never used
            ifc_hash = hashlib.md5(ifc_path.encode("utf-8")).hexdigest()
@@ -1057,24 +944,13 @@ class CreateDrawing(bpy.types.Operator):
            self.serialiser.setFile(ifc)
            drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element, ifc_file=ifc)

-            if self.cprops.fill_mode == "SHAPELY":
-                for element in drawing_elements.copy():
-                    if element.is_a("IfcAnnotation"):
-                        continue
-                    obj = tool.Ifc.get_object(element)
-                    if obj and obj.type == "MESH" and len(obj.data.polygons):
-                        elements_with_faces.add(element.GlobalId)
-                        raycast_objs.add(obj)
-
            # Get all representation contexts to see what we're dealing with.
            # Drawings only draw bodies and annotations (and facetation, due to a Revit bug).
            # A drawing prioritises a target view context first, followed by a model view context as a fallback.
            # Specifically for PLAN_VIEW and REFLECTED_PLAN_VIEW, any Plan context is also prioritised.
            contexts = self.get_linework_contexts(ifc, target_view)
-            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view, link_matrix)
-            self.serialize_contexts_elements(
-                ifc, tree, contexts, "annotation", drawing_elements, target_view, link_matrix
-            )
+            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view)
+            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view)

            if tool.Ifc.get() == ifc and self.camera_element not in drawing_elements:
                with profile("Camera element"):
@@ -1141,6 +1017,16 @@ class CreateDrawing(bpy.types.Operator):
            # shapely variant
            group = root.find("{http://www.w3.org/2000/svg}g")

+            raycast_objs = set()
+            elements_with_faces = set()
+            for element in drawing_elements.copy():
+                if element.is_a("IfcAnnotation"):
+                    continue
+                obj = tool.Ifc.get_object(element)
+                if obj and obj.type == "MESH" and len(obj.data.polygons):
+                    elements_with_faces.add(element.GlobalId)
+                    raycast_objs.add(obj)
+
            projections = root.xpath(
                ".//svg:g[contains(@class, 'projection')]", namespaces={"svg": "http://www.w3.org/2000/svg"}
            )
@@ -1400,18 +1286,6 @@ class CreateDrawing(bpy.types.Operator):
        self.svg_settings = ifcopenshell.geom.settings()
        self.svg_settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
        self.svg_settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.NATIVE)
-        # SVG edge classification (issue #3668). See edge-classification.md. Settings are
-        # per-drawing, stored in EPset_Drawing and read into self.cprops by import_camera_props.
-        try:
-            self.svg_settings.set("svg-use-edge-classification", self.cprops.use_edge_classification)
-            self.svg_settings.set("svg-render-crease-edges", self.cprops.render_creases)
-            self.svg_settings.set("svg-valley-angle-min-degrees", self.cprops.valley_angle_min_degrees)
-            self.svg_settings.set("svg-render-sharp-edges", self.cprops.render_sharp)
-            self.svg_settings.set("svg-ridge-angle-min-degrees", self.cprops.ridge_angle_min_degrees)
-            self.svg_settings.set("svg-emit-flush-edges", self.cprops.render_flush)
-        except Exception:
-            # Backwards compatibility with older ifcopenshell builds that don't expose these keys.
-            pass
        self.svg_buffer = ifcopenshell.geom.serializers.buffer()
        self.serialiser_settings = ifcopenshell.geom.serializer_settings()
        self.serialiser = ifcopenshell.geom.serializers.svg(
@@ -1555,15 +1429,6 @@ class CreateDrawing(bpy.types.Operator):
                "Material.Name",
            ]

-        join_classes = ifcopenshell.util.element.get_pset(self.camera_element, "EPset_Drawing", "JoinClasses")
-        if join_classes:
-            join_classes = tuple(c.strip() for c in join_classes.split(",") if c.strip())
-        else:
-            # Architectural convention only merges these objects by default. E.g. pipe
-            # segments and fittings shouldn't merge. Users may override this per-drawing
-            # via the EPset_Drawing.JoinClasses property (e.g. to also join IfcCovering).
-            join_classes = ("IfcWall", "IfcSlab")
-
        group = root.find("{http://www.w3.org/2000/svg}g")
        joined_paths = {}
        self.is_manifold_cache = {}
@@ -1665,7 +1530,8 @@ class CreateDrawing(bpy.types.Operator):
                            )
                        path.attrib["d"] = d

-            if not any(element.is_a(c) for c in join_classes):
+            # Architectural convention only merges these objects. E.g. pipe segments and fittings shouldn't merge.
+            if not element.is_a("IfcWall") and not element.is_a("IfcSlab"):
                continue

            keys = []
@@ -1817,12 +1683,6 @@ class CreateDrawing(bpy.types.Operator):
            key=lambda a: (
                tool.Drawing.get_annotation_z_index(a),
                1 if ifcopenshell.util.element.get_predefined_type(a) == "TEXT" else 0,
-                # Deterministic tiebreaker so equal-priority annotations keep a
-                # stable order across sessions. Without it the order comes from
-                # the set union above, which depends on entity hashes (and thus
-                # the file pointer), shuffling annotations between Blender
-                # restarts. See #6608.
-                a.id(),
            ),
        )

@@ -2459,10 +2319,7 @@ class ActivateDrawingBase(tool.Ifc.Operator):
    bl_description = (
        "Activates the selected drawing view.\n\n"
        + "ALT+CLICK to keep the viewport position.\n\n"
-        + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views, "
-        + "then select their cameras (the first selected drawing's camera becomes active).\n\n"
-        + "SHIFT+CTRL+ALT+CLICK to do the same but also select the annotations, not just the cameras"
+        + "SHIFT+CLICK to load a quick preview of the drawing view"
    )

    drawing: bpy.props.IntProperty()
@@ -2478,32 +2335,13 @@ class ActivateDrawingBase(tool.Ifc.Operator):
        default=False,
        options={"SKIP_SAVE"},
    )
-    load_selected_annotations: bpy.props.BoolProperty(
-        name="Load Selected Annotations",
-        description="Load the annotations of all selected drawings without switching the active view.",
-        default=False,
-        options={"SKIP_SAVE"},
-    )
-    include_annotations_in_selection: bpy.props.BoolProperty(
-        name="Include Annotations In Selection",
-        description="Also select the loaded annotation objects, not just the drawing cameras.",
-        default=False,
-        options={"SKIP_SAVE"},
-    )

    if TYPE_CHECKING:
        drawing: int
        should_view_from_camera: bool
        use_quick_preview: bool
-        load_selected_annotations: bool
-        include_annotations_in_selection: 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
-            if event.alt:
-                self.include_annotations_in_selection = 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:
@@ -2516,37 +2354,6 @@ class ActivateDrawingBase(tool.Ifc.Operator):
        if props.is_editing_drawings == False:
            bpy.ops.bim.load_drawings()

-        if self.load_selected_annotations:
-            objs_to_select = []
-            active_camera = None
-            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 (camera := tool.Ifc.get_object(selected_drawing)):
-                    camera = tool.Drawing.import_drawing(selected_drawing)
-                group = tool.Drawing.get_drawing_group(selected_drawing)
-                tool.Drawing.import_annotations_in_group(group)
-
-                if active_camera is None:
-                    active_camera = camera
-                objs_to_select.append(camera)
-                if self.include_annotations_in_selection:
-                    for element in tool.Drawing.get_group_elements(group) or []:
-                        if element.is_a("IfcAnnotation") and element.ObjectType != "DRAWING":
-                            if annotation_obj := tool.Ifc.get_object(element):
-                                objs_to_select.append(annotation_obj)
-
-            # Select the checked drawings' objects, with the first drawing's camera as active.
-            bpy.ops.object.select_all(action="DESELECT")
-            for obj in objs_to_select:
-                obj.select_set(True)
-            if active_camera is not None:
-                context.view_layer.objects.active = active_camera
-            return {"FINISHED"}
-
        drawing = tool.Ifc.get().by_id(self.drawing)
        dprops = tool.Drawing.get_document_props()

@@ -2632,10 +2439,7 @@ class ActivateDrawing(bpy.types.Operator, ActivateDrawingBase):
    bl_description = (
        "Activates the selected drawing view.\n\n"
        + "ALT+CLICK to keep the viewport position.\n\n"
-        + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views, "
-        + "then select their cameras (the first selected drawing's camera becomes active).\n\n"
-        + "SHIFT+CTRL+ALT+CLICK to do the same but also select the annotations, not just the cameras"
+        + "SHIFT+CLICK to load a quick preview of the drawing view"
    )


@@ -3697,7 +3501,7 @@ class EditSheet(bpy.types.Operator, tool.Ifc.Operator):
        if sheet.is_a("IfcDocumentInformation"):
            self.document_type = "SHEET"
            self.name = sheet.Name
-            self.identification = tool.Document.get_document_information_id(sheet)
+            self.identification = sheet.DocumentId if tool.Ifc.get_schema() == "IFC2X3" else sheet.Identification
        elif sheet.is_a("IfcDocumentReference") and tool.Drawing.get_reference_description(sheet) == "TITLEBLOCK":
            self.document_type = "TITLEBLOCK"
        else:
@@ -536,50 +536,6 @@ class BIMCameraProperties(PropertyGroup):
        default=True,
        update=get_update_layer_callback("has_annotation", "HasAnnotation"),
    )
-    use_edge_classification: BoolProperty(
-        name="Use Edge Classification",
-        description="Classify projection edges into boundary/outline/sharp/crease/flush "
-        "instead of drawing all linework identically. See edge-classification.md",
-        default=False,
-        update=get_update_layer_callback("use_edge_classification", "UseEdgeClassification"),
-    )
-    render_creases: BoolProperty(
-        name="Render Creases",
-        description="Render 'crease' (concave) projection edges",
-        default=True,
-        update=get_update_layer_callback("render_creases", "RenderCreases"),
-    )
-    valley_angle_min_degrees: FloatProperty(
-        name="Valley Angle Minimum",
-        description="Minimum concave dihedral deviation from flat, in degrees, for a projection "
-        "edge to be classified as 'crease' rather than 'flush'",
-        default=12.0,
-        min=0.0,
-        max=180.0,
-        update=get_update_layer_callback("valley_angle_min_degrees", "ValleyAngleMinDegrees"),
-    )
-    render_sharp: BoolProperty(
-        name="Render Sharp",
-        description="Render 'sharp' (convex) projection edges",
-        default=True,
-        update=get_update_layer_callback("render_sharp", "RenderSharp"),
-    )
-    ridge_angle_min_degrees: FloatProperty(
-        name="Ridge Angle Minimum",
-        description="Minimum convex dihedral deviation from flat, in degrees, for a projection "
-        "edge to be classified as 'sharp' rather than 'flush'",
-        default=45.0,
-        min=0.0,
-        max=180.0,
-        update=get_update_layer_callback("ridge_angle_min_degrees", "RidgeAngleMinDegrees"),
-    )
-    render_flush: BoolProperty(
-        name="Render Flush",
-        description="Render 'flush' projection edges (dihedral deviation below both ridge/valley "
-        "thresholds). Omitted by default",
-        default=False,
-        update=get_update_layer_callback("render_flush", "RenderFlush"),
-    )
    target_view: EnumProperty(
        name="Target View",
        default="PLAN_VIEW",
@@ -648,7 +604,6 @@ class BIMCameraProperties(PropertyGroup):
        return tool.Blender.get_active_uilist_element(dprops.drawing_styles, self.active_drawing_style_index)

    # For now, this JSON dump are all the parameters that determine a camera's "Block representation"
-    # Perspective camera shift is stored in EPset_Drawing and intentionally excluded here.
    # By checking this, you will know whether or not the camera IFC representation needs to be refreshed
    def update_representation(self, matrix_world: Matrix) -> bool:
        """Update ``representation`` based on current camera properties and the provided world matrix.
@@ -110,14 +110,12 @@ class Scheduler:
        y = self.margin
        rows = list(sheet.iter_rows())
        total_rows = len(rows)
-        x = None
        for i, row in enumerate(rows):
            # The last row may contain only null values
            if i == (total_rows - 1) and not [c for c in row if c.value is not None]:
                continue

            x = self.margin
-            unmerged_height = None
            for cell in row:
                if isinstance(cell, openpyxl.cell.cell.MergedCell):
                    column_letter = openpyxl.utils.get_column_letter(cell.column)
@@ -232,11 +230,8 @@ class Scheduler:
                )

                x += unmerged_width
-
-            assert unmerged_height is not None
            y += unmerged_height

-        assert x is not None
        total_width = x + self.margin
        total_height = y + self.margin
        self.svg["width"] = "{}mm".format(total_width)
@@ -380,7 +375,6 @@ class Scheduler:
        tri = 0
        stop_iterating_over_rows = False
        # TODO: row spans support?
-        x = None
        for tr in table.getElementsByType(TableRow):
            if stop_iterating_over_rows:
                break
@@ -497,7 +491,6 @@ class Scheduler:
                tri += 1
                y += height

-        assert x is not None
        total_width = x + self.margin
        total_height = y + self.margin
        self.svg["width"] = "{}mm".format(total_width)
@@ -102,16 +102,16 @@ void angle_circle_head(
    in vec4 circle_start, in float circle_angle,
    in bool counterclockwise,
    out vec4 head[CIRCLE_SEGS+1], out float angle_segs) {
-
+    
    // 1 added to CIRCLE_SEGS because we're number of vertices
    // for n segments is n+1
-
+    
    float angle_d;
    angle_d = PI * 2 / CIRCLE_SEGS; // 30d
    // need to bottom clamp it to 1, otherwise it causes Blender crash at extruding the curve
    angle_segs = max(1, ceil(circle_angle / angle_d));
    angle_d = circle_angle / angle_segs;
-
+    
    for(int i = 0; i < (angle_segs + 1); i++) {
        float angle = angle_d * i;
        if (counterclockwise) {
@@ -143,7 +143,7 @@ void cross_head(in vec4 dir, in float size, out vec4 head[3]) {
 #define do_vertex(pos, e) (do_vertex_util(pos, vec2(-(e).y, (e).x) / winsize.xy))
 #define do_vertex_win(pos, e) ( do_vertex( WIN2CLIP( pos ), e ) )

-// if vertex is shared by two segments of the line still need to emit it twice
+// if vertex is shared by two segments of the line still need to emit it twice 
 // to avoid smoothing artifacts
 // don't forget to initialize `vec2 EDGE_DIR` for macro to work
 // `pos0` / `pos1` - vertex position in clip space
@@ -197,13 +197,10 @@ void do_circle_head(vec4 pos_w, vec4 head[CIRCLE_SEGS]) {

 def add_verts_sequence(verts, start_i, output_verts, output_edges, closed=False):
    """Add sequence of verts to output lists, returns next vertex index"""
-    i = None
    for i, v in enumerate(verts[:-1], start_i):
        output_verts.append(v)
        output_edges.append((i, i + 1))
    output_verts.append(verts[-1])
-    assert i is not None
-
    if closed:
        output_edges.append((i + 1, start_i))
    return i + 2
@@ -276,7 +273,7 @@ class BaseShader:
    FRAG_GLSL = """
    uniform vec4 color;
    uniform float lineWidth;
-
+    
    in float smoothline;
    out vec4 fragColor;
    void main() {
@@ -903,8 +903,12 @@ class SvgWriter:
                    continue
                sheet = tool.Drawing.get_reference_document(sheet_reference)
                if sheet:
-                    reference_id = tool.Document.get_external_reference_id(sheet_reference) or "-"
-                    sheet_id = tool.Document.get_document_information_id(sheet) or "-"
+                    if tool.Ifc.get_schema() == "IFC2X3":
+                        reference_id = sheet_reference.ItemReference or "-"
+                        sheet_id = sheet.DocumentId or "-"
+                    else:
+                        reference_id = sheet_reference.Identification or "-"
+                        sheet_id = sheet.Identification or "-"
                    return (reference_id, sheet_id)
                break
        return ("-", "-")
@@ -1449,7 +1453,6 @@ class SvgWriter:
                    angle_tg = rise / run
                    angle = round(degrees(atan(angle_tg)))
                else:
-                    angle_tg = None
                    angle = 90

                # ues SLOPE_ANGLE as default
@@ -1463,7 +1466,6 @@ class SvgWriter:
                elif object_type == "SLOPE_PERCENT":
                    if angle == 90:
                        return "-"
-                    assert angle_tg is not None
                    return f"{round(angle_tg * 100)} %"

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

        row = self.layout.row()
        row.prop(props, "linework_mode")
@@ -113,19 +109,6 @@ class BIM_PT_camera(Panel):
            row.prop(props, "fill_mode")
            row = self.layout.row()
            row.prop(props, "cut_mode")
-
-        row = self.layout.row()
-        row.prop(props, "use_edge_classification")
-        if props.use_edge_classification:
-            row = self.layout.row()
-            row.prop(props, "render_creases")
-            row.prop(props, "valley_angle_min_degrees")
-            row = self.layout.row()
-            row.prop(props, "render_sharp")
-            row.prop(props, "ridge_angle_min_degrees")
-            row = self.layout.row()
-            row.prop(props, "render_flush")
-
        row = self.layout.row()
        row.prop(props, "width")
        row = self.layout.row()
@@ -332,8 +315,6 @@ class BIM_PT_drawings(Panel):

                row3.separator(factor=0.5, type="SPACE")

-                row3.operator("bim.copy_annotation_to_drawing", icon="PASTEDOWN", text="")
-
                row3.operator("bim.select_all_drawings", icon="CHECKBOX_HLT", text="")
                row3.operator("bim.create_drawing", text="", icon="OUTPUT")
                row3.operator("bim.convert_svg_to_dxf", text="", icon="SEQ_PREVIEW").view = active_drawing.name
@@ -979,14 +960,14 @@ class BIM_UL_sheets(bpy.types.UIList):

        if self.filter_name:
            filter_name = self.filter_name.lower()
-            active_sheet_index = None
+            active_sheet = None
            for sheet in data.sheets:
                if sheet.is_sheet:
+                    active_sheet = sheet
                    active_sheet_index = len(flt_flags)
                if filter_name in sheet.name.lower() or filter_name in sheet.identification.lower():
                    flt_flags.append(self.bitflag_filter_item)
                    if not sheet.is_sheet:
-                        assert active_sheet_index is not None
                        flt_flags[active_sheet_index] = self.bitflag_filter_item
                else:
                    flt_flags.append(0)
@@ -225,9 +225,6 @@ class AnnotationToolUI:
    def draw_edit_object_interface(cls, context):
        if DecoratorData.get_text_data(bpy.context.active_object):
            add_layout_hotkey_operator(cls.layout, "Edit Text", "S_E", "")
-        if bpy.ops.bim.copy_annotation_to_drawing.poll():
-            row = cls.layout.row(align=True)
-            row.operator("bim.copy_annotation_to_drawing", icon="PASTEDOWN", text="Copy To Drawing")

    @classmethod
    def draw_type_selection_interface(cls):
@@ -44,12 +44,8 @@ class ViewportData:

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

    @classmethod
    def mode(cls) -> tool.Blender.BLENDER_ENUM_ITEMS:
@@ -80,9 +76,9 @@ class ViewportData:
                modes.append(edit_mode)
            elif element.is_a("IfcGridAxis"):
                modes.append(edit_mode)
-            elif tool.Parametric.is_roof(element):
+            elif tool.Blender.Modifier.is_roof(element):
                modes.append(edit_mode)
-            elif tool.Parametric.is_railing(element):
+            elif tool.Blender.Modifier.is_railing(element):
                modes.append(edit_mode)
            elif item_mode not in modes:
                modes.append(item_mode)
@@ -16,6 +16,8 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.

+from collections.abc import Sequence
+
 import blf
 import bpy
 import gpu
@@ -23,16 +25,15 @@ import ifcopenshell
 import numpy as np
 from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Matrix, Vector

 import bonsai.tool as tool


-class ItemDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw", "POST_VIEW"),
-    )
+class ItemDecorator:
+    is_installed = False
+    handlers = []
    objs: dict[str, dict[str, list]]
    obj_is_selected: dict[str, bool]
    obj_is_boolean: dict[str, list[ifcopenshell.entity_instance]]
@@ -118,6 +119,23 @@ class ItemDecorator(tool.Blender.ViewportDecorator):
            "special_edges": special_edges,
        }

+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
    def draw_text(self, context):
        self.addon_prefs = tool.Blender.get_addon_preferences()
        selected_elements_color = self.addon_prefs.decorator_color_selected
@@ -145,6 +163,11 @@ class ItemDecorator(tool.Blender.ViewportDecorator):
        blf.disable(font_id, blf.SHADOW)

    def draw(self, context: bpy.types.Context) -> None:
+        def transparent_color(color: Sequence[float], alpha: float = 0.05) -> list[float]:
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
        self.addon_prefs = tool.Blender.get_addon_preferences()
        selected_elements_color = self.addon_prefs.decorator_color_selected
        unselected_elements_color = self.addon_prefs.decorator_color_unselected
@@ -174,33 +197,15 @@ class ItemDecorator(tool.Blender.ViewportDecorator):
                    if context.mode != "OBJECT":
                        continue
                    self.draw_batch("LINES", data["verts"], selected_elements_color, data["edges"])
-                    self.draw_batch(
-                        "TRIS",
-                        data["verts"],
-                        tool.Blender.transparent_color(selected_elements_color, alpha=0.05),
-                        data["tris"],
-                    )
+                    self.draw_batch("TRIS", data["verts"], transparent_color(selected_elements_color), data["tris"])
                    self.draw_batch("LINES", data["special_verts"], selected_elements_color, data["special_edges"])
                elif self.obj_is_boolean[obj_name]:
                    self.draw_batch("LINES", data["verts"], special_elements_color, data["edges"])
-                    self.draw_batch(
-                        "TRIS",
-                        data["verts"],
-                        tool.Blender.transparent_color(special_elements_color, alpha=0.05),
-                        data["tris"],
-                    )
+                    self.draw_batch("TRIS", data["verts"], transparent_color(special_elements_color), data["tris"])
                    self.draw_batch("LINES", data["special_verts"], special_elements_color, data["special_edges"])
                else:
                    self.draw_batch(
-                        "LINES",
-                        data["verts"],
-                        tool.Blender.transparent_color(unselected_elements_color, alpha=0.2),
-                        data["edges"],
-                    )
-                    self.draw_batch(
-                        "TRIS",
-                        data["verts"],
-                        tool.Blender.transparent_color(special_elements_color, alpha=0.05),
-                        data["tris"],
+                        "LINES", data["verts"], transparent_color(unselected_elements_color, alpha=0.2), data["edges"]
                    )
+                    self.draw_batch("TRIS", data["verts"], transparent_color(special_elements_color), data["tris"])
                    self.draw_batch("LINES", data["special_verts"], special_elements_color, data["special_edges"])
@@ -75,13 +75,9 @@ class Helper:
        for face in bm.faces:
            if len(face.verts) > 4:
                potential_faces.append(face)
-
-        # TODO: replace with next(..., None)
-        face = None
        for face in potential_faces:
            if face.normal.z < -0.1:
                break
-        assert face is not None

        profile = [l.vert.index for l in face.loops]
        extrusion = self.detect_extrusion_edge(bm, face)
@@ -112,12 +108,10 @@ class Helper:
        if not potential_faces:
            potential_faces = bm.faces

-        # TODO: replace with next(..., None)
-        face = None
        for face in potential_faces:
            if face.normal.z < -0.1:
                break
-        assert face is not None
+
        profile = [l.vert.index for l in face.loops]
        extrusion = self.detect_extrusion_edge(bm, face)

@@ -151,12 +145,9 @@ class Helper:
            if total_verts > 4:
                potential_faces.append(face)

-        # TODO: replace with next(..., None)
-        face = None
        for face in potential_faces:
            if face.normal.z < -0.1:
                break
-        assert face is not None

        end_faces = []
        end_face_normal = face.normal
@@ -60,7 +60,6 @@ import bonsai.core.root
 import bonsai.core.spatial
 import bonsai.tool as tool
 from bonsai.bim.ifc import IfcStore
-from bonsai.bim.module.model import preview_base
 from bonsai.bim.module.model.decorator import ProfileDecorator

 if TYPE_CHECKING:
@@ -546,13 +545,6 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
        objs = [bpy.data.objects[obj_name]] if obj_name else context.selected_objects
        self.file = tool.Ifc.get()

-        # Tessellated face sets (IfcTriangulatedFaceSet/IfcPolygonalFaceSet) were
-        # introduced in IFC4 and do not exist in IFC2X3. Catch this early so we
-        # don't silently fall back to a faceted brep after stripping materials.
-        if self.ifc_representation_class == "IfcTessellatedFaceSet" and self.file.schema == "IFC2X3":
-            self.report({"ERROR"}, "Tessellated face sets are not supported in IFC2X3.")
-            return {"CANCELLED"}
-
        for obj in objs:
            # TODO: write unit tests to see how this bulk operation handles
            # contradictory ifc_representation_class values and when
@@ -581,11 +573,7 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
        if has_openings and not self.apply_openings:
            # Meshlike things with openings can only be updated without openings applied.
            if self.from_ui:
-                self.report(
-                    {"ERROR"},
-                    f"Object '{obj.name}' has openings. "
-                    "ALT+click the button to bake the openings into the new representation.",
-                )
+                self.report({"ERROR"}, f"Object '{obj.name}' has openings - representation cannot be updated.")
            return

        if not product.is_a("IfcGridAxis"):
@@ -894,16 +882,6 @@ class OverrideDelete(bpy.types.Operator):
        # Track aggregates before deleting their parts
        aggregates_to_check = self.track_aggregates(objects_to_remove)

-        # Snapshot the set of IFC entity ids being deleted in this batch so the
-        # connection-rel cascade inside `delete_ifc_object` can suppress
-        # partner-side regenerate when the partner is also about to vanish.
-        batch_being_deleted_ids: set[int] = set()
-        for obj in objects_to_remove:
-            if not tool.Blender.is_valid_data_block(obj):
-                continue
-            if (entity := tool.Ifc.get_entity(obj)) is not None:
-                batch_being_deleted_ids.add(entity.id())
-
        clear_active_object = True

        for i, obj in enumerate(objects_to_remove, 1):
@@ -945,7 +923,7 @@ class OverrideDelete(bpy.types.Operator):
                if tool.Drawing.is_auto_annotation(element):
                    self.report({"INFO"}, "References cannot be deleted. Exclude the referenced element instead.")
                    continue
-                tool.Geometry.delete_ifc_object(obj, batch_being_deleted_ids=batch_being_deleted_ids)
+                tool.Geometry.delete_ifc_object(obj)
            elif tool.Geometry.is_representation_item(obj):
                tool.Geometry.delete_ifc_item(obj)
            else:
@@ -1044,17 +1022,14 @@ class OverrideDelete(bpy.types.Operator):
            pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
            if not pset:
                continue
-            try:
-                array_parents.add(ifc_file.by_guid(pset["Parent"]))
-            except RuntimeError:
-                continue
+            array_parents.add(ifc_file.by_guid(pset["Parent"]))

        for array_parent in array_parents:
            array_parent_obj = tool.Ifc.get_object(array_parent)
-            data = [(i, data) for i, data in enumerate(tool.Array.get_modifiers_data(array_parent))]
+            data = [(i, data) for i, data in enumerate(tool.Blender.Modifier.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.Array.get_children_objects(modifier_data))
+                children = set(tool.Blender.Modifier.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)
@@ -1208,7 +1183,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
        operator: bpy.types.Operator, context: bpy.types.Context, linked: bool = False
    ) -> set["rna_enums.OperatorReturnItems"]:
        # Deep magick from the dawn of time
-        if tool.Ifc.get() and tool.Model.has_selected_ifc_objects(include_active=False):
+        if tool.Ifc.get():
            IfcStore.execute_ifc_operator(operator, context)
            return {"FINISHED"}

@@ -1312,9 +1287,6 @@ class OverrideDuplicateMove(bpy.types.Operator):
                            if part_obj:
                                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))
-
        # Deselect everything first
        bpy.ops.object.select_all(action="DESELECT")

@@ -2251,8 +2223,6 @@ class OverrideEscape(bpy.types.Operator):
            bpy.ops.bim.hide_all_openings()
        elif tool.Aggregate.get_aggregate_props().in_aggregate_mode:
            bpy.ops.bim.disable_aggregate_mode()
-        elif preview_base.try_cancel_active_preview(context):
-            pass
        elif active_object := context.active_object:
            if tool.Blender.Modifier.try_canceling_editing_modifier_parameters_or_path(active_object):
                pass
@@ -2294,8 +2264,6 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
                gprops = tool.Geometry.get_geometry_props()
                if gprops.representation_obj:
                    tool.Geometry.disable_item_mode()
-                    if active_obj := bpy.context.active_object:
-                        active_obj.select_set(False)
                else:
                    bonsai.core.aggregate.exit_aggregate_mode(tool.Aggregate)
                return {"FINISHED"}
@@ -2382,7 +2350,6 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
            and usage in ("LAYER1", "LAYER2")
        ):
            self.report({"INFO"}, f"Parametric {usage} elements cannot be edited directly")
-            obj.select_set(False)
        elif item.is_a("IfcSweptAreaSolid"):
            tool.Geometry.sync_item_positions()
            res = tool.Model.import_profile((profile := item.SweptArea), obj=obj)
@@ -2391,7 +2358,6 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
                    {"INFO"},
                    f"Couldn't import profile, editing it directly is not yet supported. Failing profile: {profile}.",
                )
-                obj.select_set(False)
                return
            tool.Ifc.link(item, obj.data)
            self.enable_edit_mode(context)
@@ -2519,9 +2485,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.Parametric.is_railing(element):
+                elif tool.Blender.Modifier.is_railing(element):
                    bpy.ops.bim.finish_editing_railing_path()
-                elif tool.Parametric.is_roof(element):
+                elif tool.Blender.Modifier.is_roof(element):
                    bpy.ops.bim.finish_editing_roof_path()
                elif tool.Model.get_usage_type(element) == "PROFILE":
                    bpy.ops.bim.edit_extrusion_axis()
@@ -3190,7 +3156,7 @@ class EnableEditingRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
                product_reps = element.RepresentationMaps
            item_aspect = {}
            for product_rep in product_reps:
-                for aspect in getattr(product_rep, "HasShapeAspects", ()):
+                for aspect in product_rep.HasShapeAspects:
                    for aspect_rep in aspect.ShapeRepresentations:
                        if aspect_rep.ContextOfItems != representation.ContextOfItems:
                            continue
@@ -3527,15 +3493,12 @@ class EditRepresentationItemShapeAspect(bpy.types.Operator, tool.Ifc.Operator):
        if props.representation_item_shape_aspect == "NEW":
            active_representation = tool.Geometry.get_active_representation(obj)
            # find IfcProductRepresentationSelect based on current representation
-            product_shape = None
            if hasattr(element, "Representation"):  # IfcProduct
                product_shape = element.Representation
            else:  # IfcTypeProduct
                for representation_map in element.RepresentationMaps:
                    if representation_map.MappedRepresentation == active_representation:
                        product_shape = representation_map
-            assert product_shape is not None
-
            previous_shape_aspect_id = props.active_item.shape_aspect_id
            # will be None if item didn't had a shape aspect
            previous_shape_aspect = tool.Ifc.get_entity_by_id(previous_shape_aspect_id)
@@ -3885,8 +3848,6 @@ class AddSweptAreaSolidItem(bpy.types.Operator, tool.Ifc.Operator):
            curve = builder.rectangle(size=Vector((0.5, 0.5)) / unit_scale)
        elif self.shape == "CYLINDER":
            curve = builder.circle(radius=0.25 / unit_scale)
-        else:
-            assert False, self.shape
        item = builder.extrude(
            curve,
            magnitude=0.5 / unit_scale,
@@ -4124,31 +4085,6 @@ class OverrideMoveSelect(bpy.types.Operator):
                self.new_active_obj = obj
            return {"FINISHED"}

-        # Get arrays
-        ifc_file = tool.Ifc.get()
-        array_parents_to_move: list[bpy.types.Object] = []
-        for obj in list(context.selected_objects):
-            element = tool.Ifc.get_entity(obj)
-            if not element:
-                continue
-            pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
-            if not pset:
-                continue
-            parent_element = ifc_file.by_guid(pset["Parent"])
-            parent_obj = tool.Ifc.get_object(parent_element)
-            if parent_obj not in array_parents_to_move:
-                array_parents_to_move.append(parent_obj)
-            if element.GlobalId != pset["Parent"]:
-                obj.select_set(False)
-
-        if array_parents_to_move:
-            for parent_obj in array_parents_to_move:
-                parent_element = tool.Ifc.get_entity(parent_obj)
-                for array_obj in tool.Array.get_all_objects(parent_element):
-                    array_obj.select_set(True)
-                self.new_active_obj = parent_obj
-            return {"FINISHED"}
-
        # Get nests
        props = tool.Nest.get_nest_props()
        not_editing_objs = [o.obj for o in props.not_editing_objects]
@@ -17,7 +17,6 @@
 # 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 bonsai.bim
@@ -484,32 +483,10 @@ class BIM_PT_placement(Panel):
            row.label(text="No Object Placement Found")
            return

-        is_imperial = False
-        if tool.Ifc.get():
-            length_unit = ifcopenshell.util.unit.get_project_unit(tool.Ifc.get(), "LENGTHUNIT")
-            if length_unit and length_unit.Name != "METRE":
-                is_imperial = True
-
        row = self.layout.row()
-        row.label(text="Location:")
-
-        if is_imperial:
-            loc = context.active_object.location
-            for i, (axis, comp) in enumerate(zip("XYZ", (loc.x, loc.y, loc.z))):
-                split = self.layout.split(factor=0.6)
-                split.prop(context.active_object, "location", index=i, text=axis)
-                sub = split.row()
-                sub.enabled = False
-                sub.alignment = "LEFT"
-                sub.label(text=tool.Unit.format_distance(comp))
-        else:
-            for i, axis in enumerate("XYZ"):
-                self.layout.prop(context.active_object, "location", index=i, text=axis)
-
+        row.prop(context.active_object, "location", text="Location")
        row = self.layout.row()
-        row.label(text="Rotation:")
-        for i, axis in enumerate("XYZ"):
-            self.layout.prop(context.active_object, "rotation_euler", index=i, text=axis)
+        row.prop(context.active_object, "rotation_euler", text="Rotation")

        if props.blender_offset_type != "NONE":
            row = self.layout.row(align=True)
@@ -21,6 +21,7 @@ from math import radians
 import blf
 import gpu
 import ifcopenshell.util.geolocation
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
 from gpu_extras.batch import batch_for_shader
 from mathutils import Matrix, Vector
@@ -29,11 +30,27 @@ import bonsai.tool as tool
 from bonsai.bim.module.georeference.data import GeoreferenceData


-class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw_geometry", "POST_VIEW"),
-    )
+class GeoreferenceDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False

    def draw_batch(self, shader_type, content_pos, color, indices=None, should_scale=True):
        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
@@ -180,10 +197,6 @@ class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
        decorator_color_error = self.addon_prefs.decorator_color_error

        gpu.state.blend_set("ALPHA")
-        # The georef gizmo is a coordinate-system overlay: it must communicate
-        # orientation regardless of model contents, so depth testing is bypassed.
-        original_depth_test = gpu.state.depth_test_get()
-        gpu.state.depth_test_set("ALWAYS")

        self.line_shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
        self.line_shader.bind()  # required to be able to change uniforms of the shader
@@ -322,8 +335,6 @@ class GeoreferenceDecorator(tool.Blender.ViewportDecorator):
                self.draw_batch("LINES", verts, decorator_color_special, edges)
                self.draw_dashed_line(location * 3, location * 6, decorator_color_error)

-        gpu.state.depth_test_set(original_depth_test)
-
    def draw_dashed_line(self, start, end, colour, should_scale=True):
        direction = (end - start).normalized()
        distance = (end - start).length
@@ -163,52 +163,14 @@ class AssignGroup(bpy.types.Operator, tool.Ifc.Operator):
    def _execute(self, context):
        if not self.is_assigning:
            return bpy.ops.bim.unassign_group(group=self.group)
-        ifc_file = tool.Ifc.get()
-        group = ifc_file.by_id(self.group)
        products = [
            element
            for o in tool.Blender.get_selected_objects(include_active=False)
            if (element := tool.Ifc.get_entity(o))
        ]
-        relocated_annotations = self.unassign_from_previous_drawing(ifc_file, group, products)
-        ifcopenshell.api.group.assign_group(ifc_file, products=products, group=group)
-        self.relocate_annotations_to_drawing(relocated_annotations, group)
+        ifcopenshell.api.group.assign_group(tool.Ifc.get(), products=products, group=tool.Ifc.get().by_id(self.group))
        self.report({"INFO"}, f"Assigned {len(products)} objects to group.")

-    def unassign_from_previous_drawing(self, ifc_file, group, products) -> list[ifcopenshell.entity_instance]:
-        """Assigning an annotation to a group that represents a drawing means the
-        annotation should belong to that drawing only, so it needs to leave
-        whichever drawing it was previously part of, instead of ending up
-        visible in both at once.
-        """
-        new_drawing = tool.Drawing.get_group_drawing(group)
-        if not new_drawing:
-            return []
-        relocated = []
-        for product in products:
-            if not product.is_a("IfcAnnotation") or product.ObjectType == "DRAWING":
-                continue
-            old_drawing = tool.Drawing.get_annotation_drawing(product)
-            if not old_drawing or old_drawing.id() == new_drawing.id():
-                continue
-            if old_group := tool.Drawing.get_drawing_group(old_drawing):
-                ifcopenshell.api.group.unassign_group(ifc_file, products=[product], group=old_group)
-            relocated.append(product)
-        return relocated
-
-    def relocate_annotations_to_drawing(self, products, group) -> None:
-        """Move the relocated annotations into the new drawing's collection and
-        depth, now that they have actually been assigned to its group.
-        """
-        if not products:
-            return
-        new_drawing = tool.Drawing.get_group_drawing(group)
-        new_camera = tool.Ifc.get_object(new_drawing) or tool.Drawing.import_drawing(new_drawing)
-        for product in products:
-            if obj := tool.Ifc.get_object(product):
-                tool.Drawing.ensure_annotation_in_drawing_plane(obj, camera=new_camera)
-                tool.Collector.assign(obj)
-

 class UnassignGroup(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.unassign_group"
@@ -103,7 +103,9 @@ class LibraryReferencesData:
                results.append(
                    {
                        "id": library.id(),
-                        "identification": tool.Document.get_external_reference_id(library),
+                        "identification": (
+                            library.ItemReference if tool.Ifc.get_schema() == "IFC2X3" else library.Identification
+                        ),
                        "name": library.Name or "Unnamed",
                    }
                )
@@ -20,18 +20,44 @@
 import blf
 import bpy
 import gpu
+from bpy.types import SpaceView3D
 from bpy_extras.view3d_utils import location_3d_to_region_2d
+from gpu_extras.batch import batch_for_shader
 from mathutils import Matrix, Vector

 import bonsai.tool as tool
 from bonsai.bim.module.light.data import SolarData


-class SolarDecorator(tool.Blender.ViewportDecorator):
-    draw_methods = (
-        ("draw_text", "POST_PIXEL"),
-        ("draw_geometry", "POST_VIEW"),
-    )
+class SolarDecorator:
+    is_installed = False
+    handlers = []
+
+    @classmethod
+    def install(cls, context):
+        if cls.is_installed:
+            cls.uninstall()
+        handler = cls()
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
+
+    @classmethod
+    def uninstall(cls):
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
+            return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)

    def draw_text(self, context: bpy.types.Context) -> None:
        self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -156,7 +156,6 @@ class RadianceRender(bpy.types.Operator):
        print(f"Quality: {quality}, Detail: {detail}, Variability: {variability}")
        print(f"Output directory: {output_dir}")

-        hdr_image_path, hdr_mask_path, sky_map_cal_path = None, None
        if use_hdr:
            hdr_image = "noon_grass_2k.hdr"
            hdr_mask = "noon_grass_2k_mask.hdr"
@@ -255,9 +254,6 @@ class RadianceRender(bpy.types.Operator):
        # 4 0 0 -1 180

        if use_hdr and choose_hdr_image == "Noon":
-            assert hdr_image_path is not None
-            assert hdr_mask_path is not None
-            assert sky_map_cal_path is not None

            with open(sky_file_path, "w") as f:
                f.write(sky_description_str)
@@ -630,23 +630,13 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                    slab.DumbSlabPlaner().regenerate_from_layer_set(layer_set)

            if material_set_usage.is_a("IfcMaterialProfileSetUsage"):
-                if "CardinalPoint" in attributes and attributes["CardinalPoint"] is not None:
+                if "CardinalPoint" in attributes:
                    attributes["CardinalPoint"] = int(attributes["CardinalPoint"])
                ifcopenshell.api.material.edit_profile_usage(
                    self.file,
                    usage=material_set_usage,
                    attributes=attributes,
                )
-
-                for obj in objects:
-                    obj_element = tool.Ifc.get_entity(obj)
-                    if not obj_element:
-                        continue
-                    obj_material_usage = ifcopenshell.util.element.get_material(obj_element)
-                    if obj_material_usage and obj_material_usage.is_a("IfcMaterialProfileSetUsage"):
-                        obj_material_usage.CardinalPoint = material_set_usage.CardinalPoint
-                        obj_material_usage.ReferenceExtent = material_set_usage.ReferenceExtent
-
                model_profile.DumbProfileRecalculator().recalculate(objects)

        bpy.ops.bim.disable_editing_assigned_material(obj=active_obj.name)
@@ -418,13 +418,6 @@ class ImportQuickFavorites(bpy.types.Operator):
    bl_description = "Import operators from Blender's Quick Favorites menu, including their configured properties"
    bl_options = {"REGISTER", "UNDO"}

-    @classmethod
-    def poll(cls, context):
-        if bpy.app.version[:2] not in tool.Misc.QuickFavorites.OFFSET_USER_MENUS:
-            cls.poll_message_set(f"Blender version {bpy.app.version_string} is not supported.")
-            return False
-        return True
-
    def execute(self, context) -> set["rna_enums.OperatorReturnItems"]:
        props = tool.Misc.get_misc_props()
        props.quick_favorites.clear()
@@ -15,26 +15,19 @@
 #
 # 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 typing import NamedTuple

 import bpy

-import bonsai.tool as tool
-
 from . import (
    array,
    covering,
-    decorator,
    door,
    external,
    grid,
    handler,
-    host_add_opening_gizmo,
    mep,
-    mep_bend_preview,
    opening,
    product,
    profile,
@@ -53,28 +46,17 @@ from . import (

 classes = (
    array.AddArray,
-    array.CancelEditingArray,
+    array.DisableEditingArray,
+    array.EditArray,
    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,
@@ -86,51 +68,21 @@ classes = (
    product.SetActiveType,
    workspace.Hotkey,
    workspace.BIM_MT_add_representation_item,
-    wall.AddPerpendicularWall,
    wall.AddWallsFromSlab,
    wall.AlignWall,
-    wall.CancelEditingWall,
    wall.ChangeExtrusionDepth,
    wall.ChangeExtrusionXAngle,
    wall.ChangeLayerLength,
-    wall.CycleWallOffset,
    wall.DrawPolylineWall,
-    wall.EnableEditingWall,
-    wall.ExtendWallHeightToCursor,
    wall.ExtendWallsToUnderside,
-    wall.RegenerateWallToUnderside,
    wall.ExtendWallsToWall,
    wall.ExtendWallsToPolylinePoint,
-    wall.ExtendWallToCursor,
-    wall.FinishEditingWall,
    wall.FlipWall,
-    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,
    wall.OffsetWalls,
    wall.RecalculateWall,
-    wall.RotateWall90,
    wall.SplitWall,
-    wall.SplitWallAtCursor,
-    wall.DisconnectElements,
    wall.UnjoinWalls,
-    wall.EnableWallFilletPreview,
-    wall.FinishWallFilletPreview,
-    wall.CancelWallFilletPreview,
-    wall.EnableWallFilletPreviewFromCorner,
-    wall.CreateWallFillet,
    opening.AddBoolean,
    opening.CloneOpening,
    opening.EditOpenings,
@@ -142,7 +94,6 @@ classes = (
    opening.RemoveBoolean,
    opening.SelectBoolean,
    opening.ShowOpenings,
-    opening.ToggleHostOpenings,
    opening.UpdateOpeningsFocus,
    profile.ChangeCardinalPoint,
    profile.ChangeProfileDepth,
@@ -158,14 +109,11 @@ classes = (
    slab.DisableEditingExtrusionProfile,
    slab.DisableEditingSketchExtrusionProfile,
    slab.AddSlabFromWall,
-    slab.CancelEditingSlab,
    slab.DrawPolylineSlab,
    slab.EditExtrusionProfile,
    slab.EditSketchExtrusionProfile,
    slab.EnableEditingExtrusionProfile,
    slab.EnableEditingSketchExtrusionProfile,
-    slab.EnableEditingSlab,
-    slab.FinishEditingSlab,
    slab.RecalculateSlab,
    slab.ResetVertex,
    slab.SetArcIndex,
@@ -192,19 +140,10 @@ 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,
    ui.BIM_PT_sverchok,
    ui.BIM_PT_window,
    ui.BIM_PT_door,
@@ -225,8 +164,7 @@ classes = (
    stair.ToggleStairProperty,
    stair.AdjustStairTreads,
    stair.SetStairTreads,
-    stair.InputStairTreads,
-    stair.PickStairType,
+    stair.CycleStairType,
    stair.GizmoStairEdition,
    sverchok_modifier.CreateNewSverchokGraph,
    sverchok_modifier.UpdateDataFromSverchok,
@@ -239,7 +177,7 @@ classes = (
    window.FinishEditingWindow,
    window.EnableEditingWindow,
    window.RemoveWindow,
-    window.PickWindowType,
+    window.CycleWindowType,
    window.GizmoWindowEdition,
    door.BIM_OT_add_door,
    door.AddDoor,
@@ -248,19 +186,15 @@ classes = (
    door.EnableEditingDoor,
    door.RemoveDoor,
    door.ToggleDoorSwing,
-    door.PickDoorType,
+    door.CycleDoorType,
    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,
@@ -269,39 +203,16 @@ 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,
 )

@@ -353,17 +264,15 @@ def register():
    bpy.types.Scene.BIMModelProperties = bpy.props.PointerProperty(type=prop.BIMModelProperties)
    bpy.types.Scene.BIMPolylineProperties = bpy.props.PointerProperty(type=prop.BIMPolylineProperties)
    bpy.types.Object.BIMArrayProperties = bpy.props.PointerProperty(type=prop.BIMArrayProperties)
+    bpy.types.Object.BIMStairProperties = bpy.props.PointerProperty(type=prop.BIMStairProperties)
    bpy.types.Object.BIMSverchokProperties = bpy.props.PointerProperty(type=prop.BIMSverchokProperties)
-    # Per-parametric-type ``BIM<Name>Properties`` PointerProperties — driven by
-    # ``tool.Parametric.EDIT_TYPES``; adding a registry entry is the single touchpoint.
-    tool.Parametric.register_object_properties(prop)
+    bpy.types.Object.BIMWindowProperties = bpy.props.PointerProperty(type=prop.BIMWindowProperties)
+    bpy.types.Object.BIMDoorProperties = bpy.props.PointerProperty(type=prop.BIMDoorProperties)
+    bpy.types.Object.BIMRailingProperties = bpy.props.PointerProperty(type=prop.BIMRailingProperties)
+    bpy.types.Object.BIMRoofProperties = bpy.props.PointerProperty(type=prop.BIMRoofProperties)
    bpy.types.Object.BIMExternalParametricGeometryProperties = bpy.props.PointerProperty(
        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)
@@ -372,17 +281,6 @@ def register():


 def unregister():
-    # DecorationsHandler is installed lazily by bim.show_openings; tear it down
-    # (along with its persistent depsgraph / undo / redo / load cache handlers)
-    # before the rest of unregister so those handlers can't fire against
-    # 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)
@@ -390,11 +288,13 @@ def unregister():
    del bpy.types.Scene.BIMModelProperties
    del bpy.types.Scene.BIMPolylineProperties
    del bpy.types.Object.BIMArrayProperties
+    del bpy.types.Object.BIMStairProperties
    del bpy.types.Object.BIMSverchokProperties
-    tool.Parametric.unregister_object_properties()
+    del bpy.types.Object.BIMWindowProperties
+    del bpy.types.Object.BIMDoorProperties
+    del bpy.types.Object.BIMRailingProperties
+    del bpy.types.Object.BIMRoofProperties
    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)
@@ -51,10 +51,6 @@ class AuthoringData:

    @classmethod
    def load(cls, ifc_element_type: Optional[str] = None):
-        # ``is_loaded`` is set first as a recursion guard: one of the data
-        # computations evaluates a PropertyGroup enum's ``items`` callback,
-        # which re-enters this method. Without the guard, load recurses to
-        # RecursionError.
        cls.is_loaded = True
        cls.props = tool.Model.get_model_props()
        cls.data["default_container"] = cls.default_container()
@@ -37,9 +37,7 @@ 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, PickTypeMixin

 if TYPE_CHECKING:
    from bonsai.bim.module.model.prop import BIMDoorProperties
@@ -568,58 +566,103 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
        return {"FINISHED"}


-class _DoorEditMixin(FeatureModifierEditMixin):
-    """Type-specific hooks for door parametric-edit operators. Multi-object —
-    iterates ``tool.Blender.get_selected_objects()`` so a finish/cancel applies
-    to every selected door at once."""
-
-    pset_name = "BBIM_Door"
-
-    @classmethod
-    def _iter_targets(cls, context: bpy.types.Context) -> list[bpy.types.Object]:
-        return tool.Blender.get_selected_objects()
-
-    @classmethod
-    def _is_element_type(cls, element):
-        return tool.Parametric.is_door(element)
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        return tool.Model.get_door_props(obj)
-
-    @classmethod
-    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_door_modifier_representation(obj)
-
-
-class CancelEditingDoor(_DoorEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class CancelEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.cancel_editing_door"
    bl_label = "Cancel Editing Door on Selected Objects"
    bl_description = "Cancel editing and revert door parameters to their previous values"
    bl_options = {"REGISTER", "UNDO"}

-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cancel_targets(context)
+    def cancel_editing_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):
+            return
+        props = tool.Model.get_door_props(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Door", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+
+        # restore previous settings since editing was canceled
+        props.set_props_kwargs_from_ifc_data(data)
+
+        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+        core.switch_representation(
+            tool.Ifc,
+            tool.Geometry,
+            obj=obj,
+            representation=body,
+        )
+
+        props.is_editing = False
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.cancel_editing_door_on_object(obj)
+        return {"FINISHED"}


-class FinishEditingDoor(_DoorEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.finish_editing_door"
    bl_label = "Finish Editing Door on Selected Objects"
    bl_description = "Apply changes and finish editing door parameters"
    bl_options = {"REGISTER", "UNDO"}

-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._finish_targets(context)
+    def finish_editing_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):
+            return
+        props = tool.Model.get_door_props(obj)
+
+        door_data = props.get_general_kwargs(convert_to_project_units=True)
+        lining_props = props.get_lining_kwargs(convert_to_project_units=True)
+        panel_props = props.get_panel_kwargs(convert_to_project_units=True)
+
+        door_data["lining_properties"] = lining_props
+        door_data["panel_properties"] = panel_props
+
+        props.is_editing = False
+
+        update_door_modifier_representation(obj)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            tool.Model.mark_thumbnail_for_update(element_type)
+
+        pset = tool.Pset.get_element_pset(element, "BBIM_Door")
+        door_data = tool.Ifc.get().createIfcText(json.dumps(door_data, default=list))
+        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": door_data})
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.finish_editing_door_on_object(obj)
+        return {"FINISHED"}


-class EnableEditingDoor(_DoorEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.enable_editing_door"
    bl_label = "Enable Editing Door on Selected Objects"
    bl_description = "Enter edit mode to modify door parameters interactively"
    bl_options = {"REGISTER", "UNDO"}

-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._enable_targets(context)
+    def edit_door_on_obj(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Door", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        data.update(tool.Model.get_constituents_props_data(element))
+
+        # required since we could load pset from .ifc and BIMDoorProperties won't be set
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.edit_door_on_obj(obj)
+        return {"FINISHED"}


 class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
@@ -630,7 +673,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.Parametric.is_door(element):
+        if not tool.Blender.Modifier.is_door(element):
            return
        props = tool.Model.get_door_props(obj)
        props.is_editing = False
@@ -645,8 +688,12 @@ 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 = "Change Door Swing"
+    bl_label = "Toggle Door Swing"
    bl_options = {"REGISTER", "UNDO"}

    flip_geometry: bpy.props.BoolProperty(name="Flip Geometry", default=False)
@@ -657,15 +704,6 @@ 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)
@@ -692,7 +730,7 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
        if not element:
            return {"CANCELLED"}

-        is_door = tool.Parametric.is_door(element)
+        is_door = tool.Blender.Modifier.is_door(element)

        if self.flip_geometry:
            tool.Geometry.flip_object(obj, self.flip_local_axes)
@@ -706,20 +744,20 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
        return {"FINISHED"}


-class PickDoorType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
-    """Pick a door type from a popup menu."""
+class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin):
+    """Cycle through available door types. Shift+click to cycle in reverse."""

-    bl_idname = "bim.pick_door_type"
-    bl_label = "Pick Door Type"
+    bl_idname = "bim.cycle_door_type"
+    bl_label = "Cycle Door Type"
    bl_options = {"REGISTER", "UNDO"}

-    element_checker = tool.Parametric.is_door
-    props_getter = tool.Model.get_door_props
+    element_checker = "is_door"
+    props_getter = "get_door_props"
    type_literal = tool.Model.DoorType
    type_attr = "door_type"

    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._pick_type(context)
+        return self._cycle_type(context)


 class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
@@ -732,7 +770,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"
-    pick_type_operator = "bim.pick_door_type"
+    cycle_type_operator = "bim.cycle_door_type"

    # Declarative dimension gizmo configuration with visibility and position
    # matrix_position lambdas replace the get_dimension_matrix_* methods
@@ -839,44 +877,14 @@ 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
+    props_getter = "get_door_props"
    gizmo_pref_name = "door"

    @classmethod
    def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Parametric.is_door(element)
+        return tool.Blender.Modifier.is_door(element)

    def get_icon_y_extent(self, props: "BIMDoorProperties") -> tuple[float, float]:
        """Get Y extents for door icon positioning.
@@ -894,20 +902,24 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
        return (furthest_y, furthest_y)

    def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create one (main, flip) swing-arc pair per ``swing_arc_props`` entry.
-
-        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."""
+        """Create door-specific swing arc gizmos."""
        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)
+        inactive_color = prefs.decorator_color_background[:3]
+        special_color = prefs.decorator_color_special[:3]
+
+        self.gizmo_door_type = self.create_arc_gizmo(
+            special_color,
+            "bim.toggle_door_swing",
+            prop_path="BIMDoorProperties.door_type",
+            flip_geometry=False,
+        )
+        self.gizmo_flip_arc = self.create_arc_gizmo(
+            inactive_color,
+            "bim.toggle_door_swing",
+            prop_path="BIMDoorProperties.door_type",
+            flip_geometry=True,
+            flip_local_axes="XY",
+        )

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

 from collections.abc import Sequence
 from math import radians
@@ -43,211 +41,8 @@ from mathutils import Matrix, Vector

 import bonsai.core.geometry
 import bonsai.tool as tool
-from bonsai.bim import decorator_cache
 from bonsai.bim.module.drawing.decoration import DecoratorData

-# Multi-entry cache for the opening preview's dissolved-edges fallback.
-# Single-entry wouldn't fit: the draw handler iterates every active opening
-# per frame, each with its own mesh. Bumped wholesale on the shared
-# decorator-cache token (depsgraph / undo / redo / load), one slot per
-# (mesh.session_uid, angle_limit). Outlier vs. the per-object caches below —
-# consulted only on world-draw-data miss, so the global wipe rarely fires in
-# steady state and the simpler invalidation is enough.
-_dissolved_edges_cache: dict[
-    tuple[int, float],
-    tuple[list[Vector], list[tuple[int, int]]],
-] = {}
-_dissolved_edges_cache_token: int = -1
-
-
-def _get_cached_dissolved_edges(
-    mesh: bpy.types.Mesh,
-    angle_limit: float = radians(1.0),
-) -> tuple[list[Vector], list[tuple[int, int]]]:
-    global _dissolved_edges_cache_token
-    token = decorator_cache.get_decorator_cache_token()
-    if token != _dissolved_edges_cache_token:
-        _dissolved_edges_cache.clear()
-        _dissolved_edges_cache_token = token
-    key = (mesh.session_uid, angle_limit)
-    cached = _dissolved_edges_cache.get(key)
-    if cached is not None:
-        return cached
-    result = tool.Geometry.get_dissolved_edges(mesh, angle_limit=angle_limit)
-    _dissolved_edges_cache[key] = result
-    return result
-
-
-# Per-object epoch: bumped only when this specific object's transform or geometry
-# updates land in the depsgraph delta. Invalidation work scales with the number
-# of changed objects, not total scene size — moving one object leaves every
-# other entry valid. Bumped by the depsgraph handler below; cleared on
-# undo/redo/load alongside the cache dicts.
-_object_epochs: dict[int, int] = {}
-
-
-@bpy.app.handlers.persistent
-def _bump_object_epochs_for_decoration(*args) -> None:
-    # depsgraph_update_post is called as (scene, depsgraph) in 4.x but the
-    # *args signature follows decorator_cache's defensive idiom.
-    depsgraph = args[1] if len(args) >= 2 else None
-    if depsgraph is None or not hasattr(depsgraph, "updates"):
-        return
-    for u in depsgraph.updates:
-        if not isinstance(u.id, bpy.types.Object):
-            continue
-        if not (u.is_updated_geometry or u.is_updated_transform):
-            continue
-        # u.id is the evaluated COW copy; the cache keys are written from the
-        # original Object (read by the draw handler), and session_uid can
-        # differ across the COW boundary. Resolve to the original before keying.
-        original = getattr(u.id, "original", u.id)
-        if original is None:
-            continue
-        uid = original.session_uid
-        _object_epochs[uid] = _object_epochs.get(uid, 0) + 1
-
-
-@bpy.app.handlers.persistent
-def _clear_decoration_caches_globally(*args) -> None:
-    # Undo/redo/load: depsgraph deltas can't be trusted to describe the
-    # transition, so wipe every per-object cache state.
-    _object_epochs.clear()
-    _world_draw_data_cache.clear()
-    _batch_cache.clear()
-
-
-def _decoration_invalidation_hooks() -> tuple:
-    return (
-        bpy.app.handlers.undo_post,
-        bpy.app.handlers.redo_post,
-        bpy.app.handlers.load_post,
-    )
-
-
-def install_decoration_cache_handlers() -> None:
-    if _bump_object_epochs_for_decoration not in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.append(_bump_object_epochs_for_decoration)
-    for hook in _decoration_invalidation_hooks():
-        if _clear_decoration_caches_globally not in hook:
-            hook.append(_clear_decoration_caches_globally)
-
-
-def uninstall_decoration_cache_handlers() -> None:
-    try:
-        bpy.app.handlers.depsgraph_update_post.remove(_bump_object_epochs_for_decoration)
-    except ValueError:
-        pass
-    for hook in _decoration_invalidation_hooks():
-        try:
-            hook.remove(_clear_decoration_caches_globally)
-        except ValueError:
-            pass
-
-
-# Per-object world-space draw payload: line_verts (dissolved or ios_edges-filtered),
-# verts (full mesh, indexed by loop_triangles), edges_indices, tris. Entries are
-# (epoch, payload) tuples; lookup compares epoch to _object_epochs[uid], so a
-# stale entry for an object that didn't change since the last build still hits.
-_world_draw_data_cache: dict[
-    int,
-    tuple[
-        int,
-        tuple[
-            list[tuple[float, float, float]],
-            list[tuple[float, float, float]],
-            list[tuple[int, int]],
-            list[tuple[int, ...]],
-        ],
-    ],
-] = {}
-
-
-def _get_cached_world_draw_data(
-    obj: bpy.types.Object,
-) -> tuple[
-    list[tuple[float, float, float]],
-    list[tuple[float, float, float]],
-    list[tuple[int, int]],
-    list[tuple[int, ...]],
-]:
-    uid = obj.session_uid
-    epoch = _object_epochs.get(uid, 0)
-    entry = _world_draw_data_cache.get(uid)
-    if entry is not None and entry[0] == epoch:
-        return entry[1]
-
-    mw = obj.matrix_world
-    verts = [tuple(mw @ v.co) for v in obj.data.vertices]
-    obj.data.calc_loop_triangles()
-    tris = [tuple(t.vertices) for t in obj.data.loop_triangles]
-
-    ios_edges_attribute = obj.data.attributes.get("ios_edges")
-    if ios_edges_attribute:
-        # Loader-curated edges: read the attribute aligned with bm.edges order.
-        bm = bmesh.new()
-        bm.from_mesh(obj.data)
-        edges_indices = [
-            tuple(v.index for v in e.verts) for i, e in enumerate(bm.edges) if ios_edges_attribute.data[i].value
-        ]
-        bm.free()
-        line_verts = verts
-    else:
-        dissolved, edges_indices = _get_cached_dissolved_edges(obj.data)
-        line_verts = [tuple(mw @ v) for v in dissolved]
-
-    result = (line_verts, verts, edges_indices, tris)
-    _world_draw_data_cache[uid] = (epoch, result)
-    return result
-
-
-# GPUBatch cache: skip per-frame batch_for_shader. Entries are (epoch, batch);
-# lookup compares epoch to _object_epochs[uid] so other objects' batches stay
-# alive when one object's depsgraph delta bumps only its own epoch. The cached
-# batches reference GPU-side buffers tied to Blender's built-in shaders, which
-# are themselves cached by name (gpu.shader.from_builtin returns the same
-# 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]
-    epoch = _object_epochs.get(uid, 0)
-    entry = _batch_cache.get(cache_key)
-    if entry is not None and entry[0] == epoch:
-        return entry[1]
-    return None
-
-
-def _store_batch_in_cache(cache_key: tuple[int, str], batch: "gpu.types.GPUBatch") -> None:
-    uid = cache_key[0]
-    epoch = _object_epochs.get(uid, 0)
-    _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(
@@ -255,15 +50,9 @@ class FilledOpeningGenerator:
        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()
@@ -285,7 +74,7 @@ class FilledOpeningGenerator:
            should_set_z_level = False

        # Sometimes, the voided_obj may be an aggregate, which won't have any representation.
-        if not preserve_placement and voided_obj.data:
+        if 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()
@@ -418,16 +207,18 @@ class FilledOpeningGenerator:
                representation = tool.Geometry.get_representation_by_context(voided_element, context)
                assert representation

-                tool.Geometry.recut_host(voided_obj, representation)
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc,
+                    tool.Geometry,
+                    obj=voided_obj,
+                    representation=representation,
+                )

    def regenerate_from_type(self, usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
        relating_type = settings["relating_type"]

-        # Filling type-switch on an array of fillings fans out N host recuts —
-        # one per related object — without batching. Coalesce them.
-        with tool.Geometry.batch_host_recut():
-            for related_object in settings["related_objects"]:
-                self._regenerate_from_type(related_object)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)

    def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
        filling = related_object
@@ -476,7 +267,12 @@ class FilledOpeningGenerator:
            representation = tool.Geometry.get_active_representation(voided_obj)
            if not representation:
                continue
-            tool.Geometry.recut_host(voided_obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc,
+                tool.Geometry,
+                obj=voided_obj,
+                representation=representation,
+            )

    def generate_opening_from_filling(
        self,
@@ -611,31 +407,6 @@ class RecalculateFill(bpy.types.Operator, tool.Ifc.Operator):
        return context.selected_objects

    def _execute(self, context):
-        # N selected fillings × M voided host parts would fire N×M host recuts
-        # without batching. Coalesce per host.
-        with tool.Geometry.batch_host_recut():
-            return self._recalculate_fills(context)
-
-    def _recalculate_fills(self, context):
-        # Refresh each selected filling's mapped opening source before
-        # recutting the host. Dedup by source id covers the common shared-
-        # source case in one rewrite while leaving unrelated sibling sources
-        # untouched.
-        seen_source_ids: set[int] = set()
-        for obj in context.selected_objects:
-            element = tool.Ifc.get_entity(obj)
-            if not element or not element.FillsVoids:
-                continue
-            opening = element.FillsVoids[0].RelatingOpeningElement
-            body = tool.Geometry.get_body_representation(opening)
-            if body is None:
-                continue
-            source = tool.Geometry.resolve_mapped_representation(body)
-            if source.id() in seen_source_ids:
-                continue
-            seen_source_ids.add(source.id())
-            tool.Model.regenerate_filling_opening_body(element)
-
        for obj in context.selected_objects:
            element = tool.Ifc.get_entity(obj)
            if not element or not element.FillsVoids:
@@ -664,7 +435,12 @@ class RecalculateFill(bpy.types.Operator, tool.Ifc.Operator):
                if building_obj and building_obj.data:
                    representation = tool.Geometry.get_active_representation(building_obj)
                    if representation:
-                        tool.Geometry.recut_host(building_obj, representation)
+                        bonsai.core.geometry.switch_representation(
+                            tool.Ifc,
+                            tool.Geometry,
+                            obj=building_obj,
+                            representation=representation,
+                        )

        # Refresh cut decorator
        DecoratorData.cut_cache.clear()
@@ -782,29 +558,6 @@ 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"
@@ -986,29 +739,27 @@ class EditOpenings(Operator, tool.Ifc.Operator):
        for opening_element in opening_elements:
            opening_obj = tool.Ifc.get_object(opening_element)

+            similar_openings = bonsai.core.geometry.get_similar_openings(tool.Ifc, opening_element)
+            similar_openings_building_objs = bonsai.core.geometry.get_similar_openings_building_objs(
+                tool.Ifc, similar_openings
+            )
+            building_objs.update(similar_openings_building_objs)
+
            if opening_obj:
-                opening_edited = tool.Ifc.is_edited(opening_obj)
-                opening_moved = tool.Ifc.is_moved(opening_obj)
-                # Sibling walls only need a viewport-level refresh when the
-                # opening's shape or placement actually changed — a pure
-                # show/hide toggle leaves them in their existing state.
-                if opening_edited or opening_moved:
-                    similar_openings = bonsai.core.geometry.get_similar_openings(tool.Ifc, opening_element)
-                    similar_openings_building_objs = bonsai.core.geometry.get_similar_openings_building_objs(
-                        tool.Ifc, similar_openings
-                    )
-                    building_objs.update(similar_openings_building_objs)
-                    if opening_edited:
-                        tool.Geometry.run_geometry_update_representation(obj=opening_obj)
-                    else:
-                        bonsai.core.geometry.edit_object_placement(
-                            tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj
-                        )
+                if tool.Ifc.is_edited(opening_obj):
+                    tool.Geometry.run_geometry_update_representation(obj=opening_obj)
+                    bonsai.core.geometry.edit_similar_opening_placement(
+                        tool.Geometry, opening_element, similar_openings
+                    )
+                elif tool.Ifc.is_moved(opening_obj):
+                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj)
                    bonsai.core.geometry.edit_similar_opening_placement(
                        tool.Geometry, opening_element, similar_openings
                    )
-                    building_objs.update(self.get_all_building_objects_of_similar_openings(opening_element))

+                building_objs.update(
+                    self.get_all_building_objects_of_similar_openings(opening_element)
+                )  # NB this has nothing to do with clone similar_opening
                tool.Ifc.unlink(element=opening_element)
                if props.representation_obj == opening_obj:
                    props.representation_obj = None
@@ -1046,12 +797,6 @@ class CloneOpening(Operator, tool.Ifc.Operator):
        return True

    def _execute(self, context):
-        # The voided host may be an aggregate whose parts each get recut.
-        # Coalesce per host so a many-parts aggregate doesn't fan out.
-        with tool.Geometry.batch_host_recut():
-            return self._clone_opening(context)
-
-    def _clone_opening(self, context):
        # NOTE: Operator displayed in UI only with IfcOpeningElement being active.
        ifc_file = tool.Ifc.get()
        objects = bpy.context.selected_objects
@@ -1081,7 +826,12 @@ class CloneOpening(Operator, tool.Ifc.Operator):
                continue
            representation = tool.Geometry.get_active_representation(obj)
            assert representation
-            tool.Geometry.recut_host(obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc,
+                tool.Geometry,
+                obj=obj,
+                representation=representation,
+            )

        return {"FINISHED"}

@@ -1191,6 +941,7 @@ class SelectBoolean(Operator):
        return {"FINISHED"}


+# TODO: merge with ProfileDecorator?
 class DecorationsHandler:
    installed = None

@@ -1200,7 +951,6 @@ class DecorationsHandler:
            cls.uninstall()
        handler = cls()
        cls.installed = SpaceView3D.draw_handler_add(handler, (context,), "WINDOW", "POST_VIEW")
-        install_decoration_cache_handlers()

    @classmethod
    def uninstall(cls):
@@ -1209,79 +959,15 @@ class DecorationsHandler:
        except ValueError:
            pass
        cls.installed = None
-        uninstall_decoration_cache_handlers()

-    def _get_or_build_batch(self, shader, shader_type, content_pos, indices=None, cache_key=None):
-        if cache_key is not None:
-            cached = _get_cached_batch_or_none(cache_key)
-            if cached is not None:
-                return cached
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
-            return None
-        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
-        if cache_key is not None:
-            _store_batch_in_cache(cache_key, batch)
-        return batch
-
-    def draw_batch(self, shader_type, content_pos, color, indices=None, cache_key=None):
-        shader = self.line_shader if shader_type == "LINES" else self.shader
-        batch = self._get_or_build_batch(shader, shader_type, content_pos, indices, cache_key=cache_key)
-        if batch is None:
            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_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")
-        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):
        props = tool.Model.get_model_props()
        if not props.openings:
@@ -1315,7 +1001,7 @@ class DecorationsHandler:
            self.line_shader.bind()  # required to be able to change uniforms of the shader
            # POLYLINE_UNIFORM_COLOR specific uniforms
            self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
-            self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
+            self.line_shader.uniform_float("lineWidth", 2.0)

            # general shader
            self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
@@ -1353,18 +1039,23 @@ class DecorationsHandler:
                self.draw_batch("LINES", verts, selected_elements_color, selected_edges)
                self.draw_batch("POINTS", unselected_vertices, unselected_elements_color)
                self.draw_batch("POINTS", selected_vertices, selected_elements_color)
-                tool.Blender.draw_bmesh_face_tris(bm, verts, transparent_color(special_elements_color), self.draw_batch)
            else:
-                line_verts, verts, edges_indices, tris = _get_cached_world_draw_data(obj)
+                bm = bmesh.new()
+                bm.from_mesh(obj.data)
+
+                verts = [tuple(obj.matrix_world @ v.co) for v in bm.verts]
+                if ios_edges_attribute := obj.data.attributes.get("ios_edges"):
+                    edges = [e for i, e in enumerate(bm.edges) if ios_edges_attribute.data[i].value]
+                else:
+                    edges = bm.edges
+                edges_indices = [tuple([v.index for v in e.verts]) for e in edges]
+
                color = selected_elements_color if obj in context.selected_objects else special_elements_color
-                self._draw_lines_with_occlusion(line_verts, color, edges_indices, cache_key=(obj.session_uid, "lines"))
-                self.draw_batch(
-                    "TRIS",
-                    verts,
-                    transparent_color(special_elements_color),
-                    tris,
-                    cache_key=(obj.session_uid, "tris"),
-                )
+                self.draw_batch("LINES", verts, color, edges_indices)
+
+            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)

            if "HalfSpaceSolid" in obj.name:
                # Arrow shape
@@ -1378,4 +1069,7 @@ class DecorationsHandler:
                ]
                edges = [(0, 1), (1, 2), (1, 3), (1, 4), (1, 5)]
                color = selected_elements_color if obj in context.selected_objects else special_elements_color
-                self._draw_lines_with_occlusion(verts, color, edges, cache_key=(obj.session_uid, "arrow"))
+                self.draw_batch("LINES", verts, color, edges)
+
+            if obj.mode != "EDIT":
+                bm.free()
@@ -75,7 +75,6 @@ class PolylineOperator:
        self.is_typing = False
        self.snap_angle = None
        self.snapping_points = []
-        self.unit_scale = 1.0
        self.instructions = {
            "Cycle Input": {"icons": True, "keys": ["EVENT_TAB"]},
            "Distance Input": {"icons": True, "keys": ["EVENT_D"]},
@@ -1,274 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Shared helpers for Bonsai's parametric preview flows.
-
-Multiple Bonsai features follow the same Scene-level preview pattern:
-
-    Enable<X>Preview   — validates a selection, populates draft state on
-                         ``Scene.BIMPreviewProperties.<x>``, flips ``is_active``.
-    Gizmo<X>Preview    — polls on ``is_active``, surfaces tunable widgets +
-                         validate/cancel icons.
-    <X>PreviewDecorator — GPU lines drawn while ``is_active`` is True.
-    Finish<X>Preview   — direct ``bpy.ops.bim.<verb>(...)`` call with kwargs
-                         read off the draft state, then clears it.
-    Cancel<X>Preview   — pure state reset.
-
-The MEP bend and wall fillet flows are the two current callers. They write
-their Finish / Cancel operators directly, matching the convention used
-throughout the rest of ``bim/module/model/`` for operator-to-operator
-dispatch (explicit ``bpy.ops.bim.X(kwarg=value)`` at the call site, no
-string indirection). This module hosts the cross-cutting accessors only;
-no base class layer.
-
-The GPU draw-handler lifecycle for ``<X>PreviewDecorator`` lives on the
-feature-neutral ``tool.Blender.ViewportDecorator`` base, which every
-viewport decorator (preview or otherwise) inherits from."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any
-
-import bpy
-
-import bonsai.tool as tool
-
-# --- Props accessors ---------------------------------------------------------
-
-
-def get_preview_props(context: bpy.types.Context, attr: str):
-    """Resolve a child preview PropertyGroup under ``Scene.BIMPreviewProperties``.
-
-    Returns ``None`` if the umbrella isn't attached yet — true briefly
-    during addon register and during plug-out, so polls / draw callbacks
-    must defend against ``None`` rather than assuming the prop is always
-    available. Also tolerates contexts without a ``scene`` attribute
-    (test mocks built from ``SimpleNamespace``)."""
-    scene = getattr(context, "scene", None)
-    if scene is None:
-        return None
-    preview = getattr(scene, "BIMPreviewProperties", None)
-    return getattr(preview, attr, None) if preview is not None else None
-
-
-def is_preview_active(context: bpy.types.Context, attr: str) -> bool:
-    """``True`` while a specific preview is open. Used by sibling gizmo
-    polls to hide themselves so the preview is the only interactive
-    surface in the viewport (the bend / fillet preview groups take over
-    the same selection's icon stack)."""
-    props = get_preview_props(context, attr)
-    return bool(props is not None and props.is_active)
-
-
-def any_preview_active(context: bpy.types.Context) -> bool:
-    """``True`` if any registered preview is currently open. Sister gizmo
-    polls call this to hide themselves uniformly during ANY preview, so a
-    new preview registered in ``PREVIEW_CANCEL_OPS`` automatically gates
-    every parametric gizmo without each one growing a specific check."""
-    for attr, _op_name in PREVIEW_CANCEL_OPS:
-        if is_preview_active(context, attr):
-            return True
-    return False
-
-
-# --- Lazy closure factories --------------------------------------------------
-#
-# Used by preview gizmo groups when wiring ``BIM_GT_gizmo_dimension``'s
-# ``move_get_cb`` / ``move_set_cb`` callbacks. The closures re-resolve
-# ``bpy.context.scene`` per CALL rather than capturing it at setup() time
-# — the captured Scene's RNA struct can be freed on file open / undo, and
-# referencing a freed struct crashes Blender. Lazy lookup survives the
-# whole undo / reload lifecycle.
-
-
-def make_props_callback(attr: str) -> Callable[[], Any]:
-    """Return a zero-arg callable that lazily fetches the preview props.
-
-    Equivalent to ``getattr(bpy.context.scene.BIMPreviewProperties, attr)``
-    with full defensiveness against missing scene / missing umbrella."""
-
-    def _props():
-        scene = bpy.context.scene
-        preview = getattr(scene, "BIMPreviewProperties", None) if scene else None
-        return getattr(preview, attr, None) if preview is not None else None
-
-    return _props
-
-
-def make_dim_getter(props_callback: Callable[[], Any], field: str) -> Callable[[], float]:
-    """Factory for ``BIM_GT_gizmo_dimension.move_get_cb`` reading a single
-    FloatProperty off the live preview state. Returns ``0.0`` defensively
-    when the props are temporarily unavailable so the widget doesn't crash
-    Blender during plug-out / reload."""
-
-    def _get() -> float:
-        props = props_callback()
-        return getattr(props, field) if props is not None else 0.0
-
-    return _get
-
-
-def make_dim_setter(
-    props_callback: Callable[[], Any],
-    field: str,
-    min_value: float = 0.001,
-) -> Callable[[float], None]:
-    """Factory for ``BIM_GT_gizmo_dimension.move_set_cb`` writing a single
-    FloatProperty + tagging viewport areas for redraw so the GPU preview
-    decorator tracks the value live during drag. Clamps at ``min_value``
-    to match the FloatProperty's declared lower bound."""
-
-    def _set(value: float) -> None:
-        props = props_callback()
-        if props is None:
-            return
-        setattr(props, field, max(min_value, float(value)))
-        tool.Blender.update_all_viewports()
-
-    return _set
-
-
-# --- Shared Enable lifecycle helpers -----------------------------------------
-
-
-def sync_uncommitted_moves(objects: list) -> None:
-    """Push any Blender-side translation / rotation of ``objects`` back to
-    their IFC ``ObjectPlacement`` before a preview decorator starts reading
-    ``obj.matrix_world`` per frame.
-
-    Without this sync, a user who grabbed-moved an object but didn't commit
-    the move sees the live preview at the dragged position while the final
-    commit lands at the stale IFC position — a confusing "where did my
-    preview go?" experience. Both bend and fillet enable paths call this
-    on the relevant pair just before activating the preview."""
-    for obj in objects:
-        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], ...] = (
-    ("bend", "cancel_bend_preview"),
-    ("wall_fillet", "cancel_wall_fillet_preview"),
-)
-"""Registry of ``(child PointerProperty on Scene.BIMPreviewProperties, bim
-operator name)`` consulted by the Esc handler. Adding a new preview means
-appending one tuple; the forward-compat test pins that every preview
-PropertyGroup with ``is_active`` has an entry here."""
-
-
-def try_cancel_active_preview(context: bpy.types.Context) -> bool:
-    """Cancel every registered preview that is currently active.
-
-    Returns ``True`` iff at least one preview was cancelled. Multiple
-    previews can be simultaneously active (e.g. a stale bend preview opened
-    just before the user starts a wall fillet) — one Esc must clear them
-    all rather than forcing the user to tap Esc once per preview.
-
-    Tags 3D viewports for redraw on success — the Esc keymap entry runs
-    outside a viewport mouse event so the gizmo poll wouldn't re-evaluate
-    until the next interaction without an explicit redraw."""
-    cancelled = False
-    for attr, op_name in PREVIEW_CANCEL_OPS:
-        if is_preview_active(context, attr):
-            getattr(bpy.ops.bim, op_name)()
-            cancelled = True
-    if cancelled:
-        tool.Blender.update_all_viewports(context)
-    return cancelled
-
-
-def discard_pending_previews(scene: bpy.types.Scene) -> None:
-    """Clear every active preview under ``Scene.BIMPreviewProperties`` so
-    saved preview state never resurfaces on file load.
-
-    Mirrors ``tool.Parametric.heal_stale_edit_flags`` for the object-level
-    parametric-edit lifecycle — except previews are *discarded* rather than
-    validated. A preview's only UI cue is its in-viewport widget; reloading
-    a ``.blend`` saved mid-preview restores the flag but not the surrounding
-    user attention, and a stuck ``is_active`` silently hides every sibling
-    gizmo poll gated on it.
-
-    Iterates ``PREVIEW_CANCEL_OPS`` so any preview registered for Esc
-    cancellation is automatically covered here too. Sets ``is_active``
-    directly rather than dispatching the cancel operator: load_post may
-    fire before ``bpy.context.screen`` is reattached, and the cancel
-    operators bail on ``context.screen is None``."""
-    preview = getattr(scene, "BIMPreviewProperties", None)
-    if preview is None:
-        return
-    for attr, _op_name in PREVIEW_CANCEL_OPS:
-        child = getattr(preview, attr, None)
-        if child is not None and getattr(child, "is_active", False):
-            child.is_active = False
@@ -325,7 +325,7 @@ class AddOccurrence(bpy.types.Operator, tool.Ifc.Operator):
        if self.from_invoke and str(self.relating_type_id) in AuthoringData.data["relating_type_id"]:
            props.relating_type_id = str(self.relating_type_id)

-        building_obj, building_element = None, None
+        building_obj = None
        if len(context.selected_objects) == 1 and context.active_object:
            building_obj = context.active_object
            building_element = tool.Ifc.get_entity(building_obj)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Richard Brice	c031a0edf4	Add import hashlib and formatted with black	2026-04-20 07:26:40 -07:00
Richard Brice	61f715c148	Enables images for IfcImageTexture to be loaded from remote sources	2026-04-18 06:49:53 -07:00