closes #6235 - Add copy toggle to CAD offset

Add a "Copy" option to bim.cad_offset. When enabled (the
default) it offsets a new copy of the selected edges as
before; when disabled it moves the existing edges to the
offset location instead. The toggle is exposed in the CAD
tool's Offset panel and the operator redo panel.

Generated with the assistance of an AI coding tool.

.github/scripts/publish-bonsai-releases.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = [
+#     "PyGithub",
+#     "requests",
+# ]
+# ///
+
+import os
+from pathlib import Path
+
+import requests
+from github import Github
+from github.GitReleaseAsset import GitReleaseAsset
+
+EXTENSION_ID = "bonsai"
+CURRENT_PYTHON_VERSION = "py313"
+CURRENT_PLATFORMS = ["linux-x64", "macos-arm64", "windows-x64"]
+
+
+def publish_asset(asset: GitReleaseAsset, token: str, repo_root: Path) -> None:
+    """
+    Publish an asset to Blender Extensions.
+    Reference: https://extensions.blender.org/api/v1/swagger
+    """
+    temp_path = repo_root / asset.name
+
+    response = requests.get(asset.browser_download_url)
+    response.raise_for_status()
+    temp_path.write_bytes(response.content)
+
+    url = f"https://extensions.blender.org/api/v1/extensions/{EXTENSION_ID}/versions/upload/"
+    headers = {"Authorization": f"Bearer {token}"}
+
+    files = {"version_file": temp_path.read_bytes()}
+    response = requests.post(url, headers=headers, files=files)
+    response.raise_for_status()
+
+    temp_path.unlink()
+
+    print(f"✓ Published {asset.name}")
+
+
+def main() -> None:
+    token = os.getenv("BLENDER_EXTENSIONS_TOKEN")
+    if not token:
+        raise Exception("BLENDER_EXTENSIONS_TOKEN environment variable not set")
+
+    # Get the repository root
+    repo_root = Path(__file__).parent.parent.parent
+
+    # Read VERSION file
+    version_file = repo_root / "VERSION"
+    version = version_file.read_text().strip()
+
+    print(f"Current VERSION: {version}")
+
+    tag_name = f"bonsai-{version}"
+
+    # Get release from GitHub
+    gh = Github()
+    gh_repo = gh.get_repo("IfcOpenShell/IfcOpenShell")
+    release = gh_repo.get_release(tag_name)
+
+    assets = release.get_assets()
+
+    asset_platform_map: dict[str, tuple[GitReleaseAsset, str]] = {}
+    for asset in assets:
+        if CURRENT_PYTHON_VERSION not in asset.name:
+            continue
+        for platform in CURRENT_PLATFORMS:
+            if platform in asset.name:
+                asset_platform_map[asset.name] = (asset, platform)
+                break
+
+    if len(asset_platform_map) != len(CURRENT_PLATFORMS):
+        found_platforms = {platform for _, (_, platform) in asset_platform_map.items()}
+        missing_platforms = set(CURRENT_PLATFORMS) - found_platforms
+        raise Exception(
+            f"Expected {len(CURRENT_PLATFORMS)} assets but found {len(asset_platform_map)}. "
+            f"Missing: {', '.join(sorted(missing_platforms))}"
+        )
+
+    print("\nRelease assets:")
+    for asset_name in sorted(asset_platform_map.keys()):
+        print(f"- {asset_name}")
+
+    # https://extensions.blender.org/api/v1/swagger
+    print("\nPublishing assets to Blender Extensions:")
+    for asset_name, (asset, platform) in asset_platform_map.items():
+        publish_asset(asset, token, repo_root)
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/build_osx.yml

@@ -53,7 +53,7 @@ jobs:
           python ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
         with:
           key: mac-${{ matrix.arch }}
 

.github/workflows/build_pyodide.yml

@@ -29,7 +29,7 @@ jobs:
           python ../IfcOpenShell/nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
         with:
           key: ubuntu-22.04-${{ runner.arch }}
 

.github/workflows/build_rocky.yml

@@ -9,6 +9,13 @@ jobs:
     container: rockylinux:9
 
     steps:
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+
+      - name: Install Python
+        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
+        run: uv python install
+
       - name: Install Dependencies
         run: |
           dnf update -y
@@ -17,7 +24,6 @@ jobs:
                          sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                          readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                          findutils xz byacc
-          python3 -m pip install typing_extensions
           git config --global --add safe.directory '*'
 
       - name: Install aws cli
@@ -45,10 +51,10 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py unpack
+          uv run ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 
@@ -56,7 +62,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
 
       - name: Upload Build Logs
         if: always()
@@ -71,7 +77,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py pack
+          uv run ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |

.github/workflows/build_rocky_arm.yml

@@ -9,6 +9,13 @@ jobs:
     container: arm64v8/rockylinux:9
 
     steps:
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+
+      - name: Install Python
+        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
+        run: uv python install
+
       - name: Install Dependencies
         run: |
           dnf update -y
@@ -17,7 +24,6 @@ jobs:
                          sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                          readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                          findutils xz byacc
-          python3 -m pip install typing_extensions
           git config --global --add safe.directory '*'
 
       - name: Install aws cli
@@ -45,10 +51,10 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py unpack
+          uv run ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 
@@ -56,7 +62,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
 
       - name: Upload Build Logs
         if: always()
@@ -71,7 +77,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py pack
+          uv run ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |

.github/workflows/build_win.yml

@@ -52,7 +52,7 @@ jobs:
           }
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
         with:
           key: win-${{ matrix.arch }}
           # Windows ccache needs ~1GB

.github/workflows/ci-ifcopenshell-docker.yml

@@ -35,7 +35,7 @@ jobs:
 
     -
       name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.22
+      uses: hendrikmuhs/ccache-action@v1.2.23
 
     - 
       name: Build ifcopenshell

.github/workflows/ci-lint.yaml

@@ -30,7 +30,7 @@ jobs:
           uv tool install ruff
           uv tool install black
           uv tool install poethepoet
-          uv tool install ty
+          uv tool install ty==0.0.34
 
       # black doesn't catch all syntax errors, so we check them explicitly.
       - name: Check syntax errors
@@ -95,8 +95,7 @@ jobs:
             echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
           }
 
-          run_check poe ruff-main
-          run_check poe ruff-old
+          run_check poe ruff
 
           exit $ERROR
         continue-on-error: true

.github/workflows/ci.yml

@@ -51,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
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing
           pip install src/bcf --no-deps
           pip install pytest-xdist==3.8.0
 
@@ -79,7 +79,7 @@ jobs:
           libhdf5-dev libcgal-dev libeigen3-dev
           
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
         with:
           key: ubuntu-22.04-${{ runner.arch }}
 

.github/workflows/publish-bonsai-releases.yml

@@ -0,0 +1,16 @@
+name: Publish Bonsai Releases
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: astral-sh/setup-uv@v7
+
+      - run: uv run .github/scripts/publish-bonsai-releases.py
+        env:
+          BLENDER_EXTENSIONS_TOKEN: ${{ secrets.BLENDER_EXTENSIONS_TOKEN }}

cmake/CMakeLists.txt

@@ -258,10 +258,14 @@ if(WITH_ROCKSDB)
     set(ROCKSDB_LIBRARIES "IFCOPENSHELL_RocksDB")
     target_compile_definitions(IFCOPENSHELL_RocksDB INTERFACE IFOPSH_WITH_ROCKSDB)
     set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_ROCKSDB)
-    # Shared binaries for `rocksdb` only support limited API (only `c.h`), but we use `db.h` API.
-    # So rocksdb supported only as a static library.
     # See https://github.com/facebook/rocksdb/issues/981.
-    target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
+    if(TARGET RocksDB::rocksdb)
+        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
+    elseif(TARGET RocksDB::rocksdb-shared)
+        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb-shared)
+    else()
+        message(FATAL_ERROR "RocksDB found but neither RocksDB::rocksdb nor RocksDB::rocksdb-shared target exists")
+    endif()
 
     if(WITH_ZSTD)
         # @todo do we actually need the zstd include dir or rather just pass

cmake/FindHDF5.cmake

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

nix/build-all.py

@@ -1,4 +1,6 @@
 #!/usr/bin/python
+# /// script
+# ///
 ###############################################################################
 #                                                                             #
 # This file is part of IfcOpenShell.                                          #
@@ -124,16 +126,9 @@ 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
 
-try:
-    from typing import Literal, Union
-except:
-    # python 3.6 compatibility for rocky 8
-    from typing import Union
-
-    from typing_extensions import Literal
-
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 ch = logging.StreamHandler()

nix/cache_dependencies.py

@@ -1,3 +1,5 @@
+# /// script
+# ///
 """
 Cache built dependencies for builds.
 

pyodide/build_pyodide.sh

@@ -1,6 +1,11 @@
 #!/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.
 
@@ -11,14 +16,15 @@ source .venv/bin/activate
 
 # Install pyodide cross build environment.
 # Instructions: https://pyodide.org/en/stable/development/building-packages.html
-uv pip install pyodide-build
+uv pip install "pyodide-build==${PYODIDE_BUILD_VERSION}"
 # `uv run` is required, so xbuildenv would skip using `pip`.
-uv run pyodide xbuildenv install
+uv run pyodide xbuildenv install "${PYODIDE_VERSION}"
 uv run pyodide xbuildenv install-emscripten
 
-EMSDK_ROOT=$(pyodide config get emscripten_dir)
-source ${EMSDK_ROOT}/emsdk_env.sh
+EMSDK_ROOT="${PYODIDE_XBUILDENV}/emsdk"
+source "${EMSDK_ROOT}/emsdk_env.sh"
 which emcc
+emcc --version
 
 mkdir -p packages/ifcopenshell
 VERSION=`cat IfcOpenShell/VERSION`

pyproject.toml

@@ -3,9 +3,9 @@ name = "IfcOpenShell"
 version = "0.0.0"
 dependencies = [
     "black==26.3.1",
-    "ruff==0.15.9",
+    "ruff==0.15.12",
     "poethepoet",
-    "ty==0.0.29",
+    "ty==0.0.32",
     "gersemi==0.26.1",
 ]
 
@@ -215,10 +215,7 @@ exclude = [
 
 [tool.poe.tasks]
 
-ruff-main = "ruff check --extend-exclude nix/build-all.py"
-# It's actually Python 3.6, but ruff only supports 3.7+, but it should do.
-ruff-old = "ruff check nix/build-all.py --target-version py37"
-ruff.sequence = ["ruff-main", "ruff-old"]
+ruff = "ruff check"
 
 black = "black ."
 
@@ -238,7 +235,7 @@ ty-venv-ios.sequence = [
     {cmd = "uv pip install -r src/ifcopenshell-python/type-check-requirements.txt --python=src/ifcopenshell-python/.venv"},
 ]
 
-format.sequence = ["black", "ruff-main", "ruff-old"]
+format.sequence = ["black", "ruff"]
 
 cmake-format = "gersemi . --in-place"
 

src/bonsai/Makefile

@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 SHELL := sh
-PYTHON:=python3.11
-PIP:=pip3.11
+PYTHON:=python3
+PIP:=pip3
 PATCH:=patch
 SED:=sed -i
 VENV_ACTIVATE:=bin/activate
@@ -192,7 +192,11 @@ endif
 	# Provides networkx graph analysis for project dependency calculations
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download networkx --dest=./wheels
 	# Required by IFCDiff
-	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download deepdiff --dest=./wheels
+	# 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
 	# Required by IFCCSV and ifcopenshell.util.selector
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download lark --dest=./wheels
 	# Required by IFC4D
@@ -356,6 +360,10 @@ else
 	pytest test/tool/test_$(MODULE).py --maxfail=1
 endif
 
+.PHONY: test-modal
+test-modal:
+	blender --enable-event-simulate --python test/modal/test_modal.py --window-maximized
+
 # Reregistering test is not added to the standard test suite because during unregister
 # Blender removes all Bonsai dependencies breaking dev-environment symlinks.
 .PHONY: test-reregister

src/bonsai/bonsai/bim/__init__.py

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 import importlib
 import os
@@ -25,7 +27,7 @@ import bpy
 import bpy.utils.previews
 from bpy_extras.io_utils import ExportHelper, ImportHelper
 
-from . import handler, operator, prop, ui
+from . import handler, operator, parametric_lifecycle, prop, ui
 
 try:
     from bonsai.translations import translations_dict
@@ -157,9 +159,6 @@ 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,6 +267,8 @@ 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)
@@ -325,6 +326,7 @@ 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

src/bonsai/bonsai/bim/data/fonts/LICENSE

@@ -0,0 +1,96 @@
+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.

src/bonsai/bonsai/bim/decorator_cache.py

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

src/bonsai/bonsai/bim/handler.py

@@ -15,11 +15,12 @@
 #
 # 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
@@ -31,16 +32,30 @@ 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.ifc import IfcStore
+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.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,
     SlabDirectionDecorator,
     WallAxisDecorator,
+    WallFilletPreviewDecorator,
 )
+from bonsai.bim.module.model.wall import WallGizmoPreviewDecorator
 from bonsai.bim.module.nest.decorator import NestDecorator
 
 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -108,19 +123,13 @@ def active_object_callback():
 
 
 def update_bim_tool_props():
-    """update BIM Tools props (such as extrusion_depth, length and x_angle) when active object changes"""
-    obj = bpy.context.active_object
-
-    # bunch of checks to see if we're in a valid state
-    if not obj:
-        return
-    mode = bpy.context.mode
-    current_tool = bpy.context.workspace.tools.from_space_view3d_mode(mode)
-    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
-        return
-    element = tool.Ifc.get_entity(obj)
-    if not element:
+    """Selection-driven BIM Tool sync: re-target user-intent enums
+    (ifc_class, relating_type_id) AND refresh header values
+    (extrusion_depth, length, x_angle) for the new active object."""
+    ctx = _resolve_bim_tool_context()
+    if ctx is None:
         return
+    obj, current_tool, element = ctx
 
     props = tool.Model.get_model_props()
     aprops = tool.Drawing.get_annotation_props()
@@ -133,18 +142,85 @@ 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
-                aprops.relating_type_id = str(element_type.id())
+                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
                 return
 
             if is_bim_tool:
-                props.ifc_class = element_type.is_a()
+                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
 
-            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())
+            # 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_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
@@ -162,10 +238,13 @@ def update_bim_tool_props():
     if not AuthoringData.is_loaded:
         AuthoringData.load()
 
+    props = tool.Model.get_model_props()
     if AuthoringData.data["active_material_usage"] == "LAYER2":
         x_angle = get_x_angle(extrusion)
         axis = tool.Model.get_wall_axis(obj)["reference"]
-        props.extrusion_depth = abs(extrusion.Depth * si_conversion * cos(x_angle))
+        props.extrusion_depth = core_model.vertical_height_from_extrusion_depth(
+            extrusion.Depth * si_conversion, x_angle
+        )
         props.length = (axis[1] - axis[0]).length
         props.x_angle = x_angle
 
@@ -356,8 +435,10 @@ def subscribe_to_viewport_shading_changes():
             )
 
 
-@persistent
-def load_post(scene):
+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."""
     global global_subscription_owner
     active_object_key = bpy.types.LayerObjects, "active"
     bpy.msgbus.subscribe_rna(
@@ -368,6 +449,23 @@ def load_post(scene):
     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()
@@ -391,11 +489,21 @@ def load_post(scene):
         tool.Blender.override_scene_panel(panel)
     tool.Blender.setup_tabs()
 
-    if tool.Ifc.get() and bpy.data.is_saved:
-        props = tool.Blender.get_bim_props()
-        props.has_blend_warning = True
+    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"}
 
-    # Bonsai overlays
+    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()``."""
     georeference_props = tool.Georeference.get_georeference_props()
     aggregate_props = tool.Aggregate.get_aggregate_props()
     nest_props = tool.Nest.get_nest_props()
@@ -405,23 +513,57 @@ def load_post(scene):
     NestDecorator.uninstall()
     WallAxisDecorator.uninstall()
     SlabDirectionDecorator.uninstall()
-    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)
+    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_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 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"}
 
-    tool.Blender.sync_old_preferences()
+@persistent
+def load_post(scene):
+    _apply_save_file_invariants(scene)
+    _apply_user_preferences()
+    _install_viewport_overlays()

src/bonsai/bonsai/bim/ifc.py

@@ -64,6 +64,44 @@ 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``."""
@@ -196,7 +234,7 @@ class IfcStore:
                 shutil.copy2(IfcStore.cache_path, new_cache_path)
             except PermissionError:
                 pass  # Well we tried. No cache for you!
-        IfcStore.get_cache()
+        get_cache_or_detect_lock()
 
     @staticmethod
     def load_file(path: str) -> None:
@@ -514,6 +552,7 @@ 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
@@ -527,6 +566,19 @@ class IfcStore:
                 result = getattr(operator, "_modal")(context, event)
         except:
             bonsai.last_error = traceback.format_exc()
+            # An operator that mutated IFC then raised leaves the IFC graph captured
+            # by the transaction but the Blender side stale. Blender does not push an
+            # undo step for a raised operator (mirror of the CANCELLED-modal gap
+            # handled below), so we push one here so Ctrl+Z actually rewinds the
+            # partial mutation, then surface the recovery path to the user.
+            ifc_file = tool.Ifc.get()
+            if ifc_file and ifc_file.transaction and ifc_file.transaction.operations:
+                bpy.ops.ed.undo_push(message=f"Recover {operator.bl_idname}")
+                operator.report(
+                    {"WARNING"},
+                    "Operation partially completed (IFC changed, Blender state may be stale). "
+                    "Press Ctrl+Z to restore the previous state.",
+                )
             # Try to ensure undo will work since Blender undo does work in case of errors.
             # As error come unexpectedly, it's important that user might have a chance to save the file
             # before they got the error and not to lose the work they've done.

src/bonsai/bonsai/bim/import_ifc.py

@@ -1219,8 +1219,8 @@ class IfcImporter:
                         if element not in elements_to_import:
                             continue
                     for i in range(len(data)):
-                        tool.Blender.Modifier.Array.set_children_lock_state(element, i, True)
-                        tool.Blender.Modifier.Array.constrain_children_to_parent(element)
+                        tool.Array.set_children_lock_state(element, i, True)
+                        tool.Array.constrain_children_to_parent(element)
 
     def update_linked_aggregates(self):
         # TODO Remove this after a while. See commit 17d6b8a

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

@@ -139,6 +139,7 @@ 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,
@@ -155,5 +156,6 @@ 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

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

@@ -48,12 +48,14 @@ 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 = attribute["name"]
+            op.key = key_prefix + attribute["name"]
 
     # TODO: reimplement, see #1222
     # if "IfcSite/" in context.active_object.name or "IfcBuilding/" in context.active_object.name:

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

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

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

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

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

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

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

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 import bpy
 
@@ -136,14 +138,34 @@ classes = (
     gizmos.GizmoArrow2D,
     gizmos.GizmoCone,
     gizmos.GizmoDimension,
-    gizmos.GizmoLock,
+    gizmos.GizmoLockOpen,
+    gizmos.GizmoLockClosed,
     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,

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

@@ -313,7 +313,7 @@ def format_distance(
             if not feet and not add_inches:
                 tx_dist += str(feet) + "'"
 
-            if not feet and add_inches:
+            if not feet and add_inches and unit_length != "INCHES":
                 if value < 0:
                     tx_dist += "-0' - "
                 else:

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

@@ -44,8 +44,12 @@ class ViewportData:
 
     @classmethod
     def load(cls):
-        cls.is_loaded = True
+        # 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
 
     @classmethod
     def mode(cls) -> tool.Blender.BLENDER_ENUM_ITEMS:
@@ -76,9 +80,9 @@ class ViewportData:
                 modes.append(edit_mode)
             elif element.is_a("IfcGridAxis"):
                 modes.append(edit_mode)
-            elif tool.Blender.Modifier.is_roof(element):
+            elif tool.Parametric.is_roof(element):
                 modes.append(edit_mode)
-            elif tool.Blender.Modifier.is_railing(element):
+            elif tool.Parametric.is_railing(element):
                 modes.append(edit_mode)
             elif item_mode not in modes:
                 modes.append(item_mode)

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

@@ -60,6 +60,7 @@ 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:
@@ -545,6 +546,13 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
         objs = [bpy.data.objects[obj_name]] if obj_name else context.selected_objects
         self.file = tool.Ifc.get()
 
+        # Tessellated face sets (IfcTriangulatedFaceSet/IfcPolygonalFaceSet) were
+        # introduced in IFC4 and do not exist in IFC2X3. Catch this early so we
+        # don't silently fall back to a faceted brep after stripping materials.
+        if self.ifc_representation_class == "IfcTessellatedFaceSet" and self.file.schema == "IFC2X3":
+            self.report({"ERROR"}, "Tessellated face sets are not supported in IFC2X3.")
+            return {"CANCELLED"}
+
         for obj in objs:
             # TODO: write unit tests to see how this bulk operation handles
             # contradictory ifc_representation_class values and when
@@ -1026,10 +1034,10 @@ class OverrideDelete(bpy.types.Operator):
 
         for array_parent in array_parents:
             array_parent_obj = tool.Ifc.get_object(array_parent)
-            data = [(i, data) for i, data in enumerate(tool.Blender.Modifier.Array.get_modifiers_data(array_parent))]
+            data = [(i, data) for i, data in enumerate(tool.Array.get_modifiers_data(array_parent))]
             # NOTE: there is a way to remove arrays more precisely but it's more complex
             for i, modifier_data in reversed(data):
-                children = set(tool.Blender.Modifier.Array.get_children_objects(modifier_data))
+                children = set(tool.Array.get_children_objects(modifier_data))
                 if children.issubset(selected_objects):
                     with context.temp_override(active_object=array_parent_obj):
                         bpy.ops.bim.remove_array(item=i)
@@ -1183,7 +1191,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():
+        if tool.Ifc.get() and tool.Model.has_selected_ifc_objects(include_active=False):
             IfcStore.execute_ifc_operator(operator, context)
             return {"FINISHED"}
 
@@ -1287,6 +1295,9 @@ 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")
 
@@ -2223,6 +2234,8 @@ 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
@@ -2264,6 +2277,8 @@ 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"}
@@ -2350,6 +2365,7 @@ 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)
@@ -2358,6 +2374,7 @@ 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)
@@ -2485,9 +2502,9 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
                     profile = tool.Ifc.get().by_id(profile_id)
                     if tool.Ifc.get_object(profile):  # We are editing an arbitrary profile
                         bpy.ops.bim.edit_arbitrary_profile()
-                elif tool.Blender.Modifier.is_railing(element):
+                elif tool.Parametric.is_railing(element):
                     bpy.ops.bim.finish_editing_railing_path()
-                elif tool.Blender.Modifier.is_roof(element):
+                elif tool.Parametric.is_roof(element):
                     bpy.ops.bim.finish_editing_roof_path()
                 elif tool.Model.get_usage_type(element) == "PROFILE":
                     bpy.ops.bim.edit_extrusion_axis()
@@ -3156,7 +3173,7 @@ class EnableEditingRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
                 product_reps = element.RepresentationMaps
             item_aspect = {}
             for product_rep in product_reps:
-                for aspect in product_rep.HasShapeAspects:
+                for aspect in getattr(product_rep, "HasShapeAspects", ()):
                     for aspect_rep in aspect.ShapeRepresentations:
                         if aspect_rep.ContextOfItems != representation.ContextOfItems:
                             continue

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

@@ -19,6 +19,7 @@
 import bpy
 from bpy.types import Menu, Panel, UIList
 
+import ifcopenshell.util.unit
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import prop_with_search
@@ -483,10 +484,32 @@ 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.prop(context.active_object, "location", text="Location")
+        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 = self.layout.row()
-        row.prop(context.active_object, "rotation_euler", text="Rotation")
+        row.label(text="Rotation:")
+        for i, axis in enumerate("XYZ"):
+            self.layout.prop(context.active_object, "rotation_euler", index=i, text=axis)
 
         if props.blender_offset_type != "NONE":
             row = self.layout.row(align=True)

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

@@ -23,7 +23,7 @@ from pathlib import Path
 import bpy
 import pyradiance
 
-from . import export, ies, list, material, prepare, prop, render, solar, ui
+from . import list, operator, prop, ui
 
 
 def get_pyradiance_path():
@@ -31,43 +31,31 @@ def get_pyradiance_path():
 
 
 classes = (
-    export.ExportOBJ,
-    solar.ImportLatLong,
-    solar.ImportTrueNorth,
-    solar.MoveSunPathTo3DCursor,
-    render.RadianceRender,
-    render.FalseColorRadiance,
-    render.RADIANCE_OT_select_camera,
-    solar.ViewFromSun,
-    solar.LightPickCoordinates,
-    solar.LightSetTimeToNow,
-    material.RefreshIFCMaterials,
-    material.UnmapMaterial,
-    material.RADIANCE_OT_export_material_mappings,
-    material.RADIANCE_OT_import_material_mappings,
-    material.RADIANCE_OT_open_spectraldb,
-    prepare.PrepareRadianceScene,
-    ies.AddIESLight,
-    ies.RemoveIESLight,
-    export.CleanupRadianceFiles,
+    operator.ExportOBJ,
+    operator.ImportLatLong,
+    operator.ImportTrueNorth,
+    operator.MoveSunPathTo3DCursor,
+    operator.RadianceRender,
+    operator.ViewFromSun,
+    operator.LightPickCoordinates,
+    operator.LightSetTimeToNow,
+    operator.RefreshIFCMaterials,
+    operator.UnmapMaterial,
+    operator.RADIANCE_OT_select_camera,
+    operator.RADIANCE_OT_export_material_mappings,
+    operator.RADIANCE_OT_import_material_mappings,
+    operator.RADIANCE_OT_open_spectraldb,
     prop.RadianceMaterial,
-    prop.IESLight,
     prop.BIMSolarProperties,
     prop.RadianceExporterProperties,
     ui.BIM_PT_radiance_exporter,
-    ui.BIM_PT_radiance_scene_setup,
-    ui.BIM_PT_radiance_materials,
-    ui.BIM_PT_radiance_lighting,
-    ui.BIM_PT_radiance_render_settings,
-    ui.BIM_PT_radiance_pipeline,
     ui.BIM_PT_solar,
     list.MATERIAL_UL_radiance_materials,
-    list.MATERIAL_UL_ies_lights,
 )
 
 
 def register():
-    bpy.types.Scene.BIMRadianceExporterProperties = bpy.props.PointerProperty(type=prop.RadianceExporterProperties)
+    bpy.types.Scene.BIMRadianceExporeterProperies = bpy.props.PointerProperty(type=prop.RadianceExporterProperties)
     bpy.types.Scene.BIMSolarProperties = bpy.props.PointerProperty(type=prop.BIMSolarProperties)
 
     if pyradiance:
@@ -80,5 +68,5 @@ def register():
 
 
 def unregister():
-    del bpy.types.Scene.BIMRadianceExporterProperties
+    del bpy.types.Scene.BIMRadianceExporeterProperies
     del bpy.types.Scene.BIMSolarProperties

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

@@ -1,488 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 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/>.
-
-import multiprocessing
-import os
-from pathlib import Path
-
-import bpy
-import ifcopenshell
-import ifcopenshell.geom
-
-import bonsai.tool as tool
-from bonsai.bim.module.light.shared import ifc_materials, linked_model_exports
-
-
-class ExportOBJ(bpy.types.Operator):
-    """Exports the IFC File to OBJ"""
-
-    bl_idname = "export_scene.radiance"
-    bl_label = "Export"
-    bl_description = "Export the IFC to OBJ"
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            cls.poll_message_set("No IFC file loaded in Bonsai.")
-            return False
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        return True
-
-    def _get_geom_settings(self):
-        """Create standard geometry and serializer settings for OBJ export."""
-        settings = ifcopenshell.geom.settings()
-        serializer_settings = ifcopenshell.geom.serializer_settings()
-        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.SURFACES_AND_SOLIDS)
-        settings.set("apply-default-materials", True)
-        serializer_settings.set("use-element-guids", True)
-        settings.set("use-world-coords", True)
-        return settings, serializer_settings
-
-    def _get_exportable_elements(self, ifc_file, filter_visibility=True):
-        """Get the list of elements to export from an IFC file."""
-        if ifc_file.schema in ("IFC2X3", "IFC4"):
-            elements = ifc_file.by_type("IfcElement") + ifc_file.by_type("IfcProxy")
-        else:
-            elements = ifc_file.by_type("IfcElement")
-
-        elements += ifc_file.by_type("IfcSite")
-        elements = [e for e in elements if not e.is_a("IfcFeatureElement") or e.is_a("IfcSurfaceFeature")]
-
-        if not filter_visibility:
-            return elements
-
-        # Filter by visibility in Blender.
-        # We use hide_get() (user-toggled eye icon) instead of visible_get()
-        # because visible_get() also considers collection/view-layer visibility
-        # which incorrectly excludes objects in linked aggregate sub-collections.
-        visible_elements = []
-        for element in elements:
-            blender_obj = tool.Ifc.get_object(element)
-            if blender_obj is None:
-                # No Blender object (linked aggregate copies, or not yet represented)
-                # Include by default — the geometry exists in the IFC file
-                visible_elements.append(element)
-                continue
-            if not blender_obj.hide_get():
-                visible_elements.append(element)
-            else:
-                print(f"Skipping hidden element: {element.GlobalId if hasattr(element, 'GlobalId') else element.id()}")
-        return visible_elements
-
-    def _export_ifc_to_obj(self, ifc_file, obj_path, mtl_path, settings, serializer_settings, elements):
-        """Export elements from an IFC file to OBJ format. Returns collected material names."""
-        materials_collected = []
-        serialiser = ifcopenshell.geom.serializers.obj(obj_path, mtl_path, settings, serializer_settings)
-        serialiser.setFile(ifc_file)
-        serialiser.setUnitNameAndMagnitude("METER", 1.0)
-        serialiser.writeHeader()
-
-        print(f"Exporting {len(elements)} elements to {obj_path}")
-        iterator = ifcopenshell.geom.iterator(settings, ifc_file, multiprocessing.cpu_count(), include=elements)
-        if iterator.initialize():
-            while True:
-                shape = iterator.get()
-                for material in shape.geometry.materials:
-                    materials_collected.append(material.name)
-                serialiser.write(shape)
-                if not iterator.next():
-                    break
-
-        serialiser.finalize()
-        return materials_collected
-
-    def _sync_moved_object_placements(self):
-        """Sync Blender object positions to IFC ObjectPlacements for all moved objects.
-
-        This is critical for linked aggregate copies: their IFC ObjectPlacements
-        are initially copies of the original's placement. After the user moves them
-        in Blender, the IFC placements are stale until explicitly synced. Without
-        this, the iterator with use-world-coords=True exports all copies at the
-        original position.
-        """
-        import bonsai.core.geometry as core_geometry
-
-        synced = 0
-        for obj in bpy.data.objects:
-            element = tool.Ifc.get_entity(obj)
-            if element is None:
-                continue
-            if not element.is_a("IfcProduct"):
-                continue
-            try:
-                if tool.Ifc.is_moved(obj):
-                    core_geometry.edit_object_placement(
-                        ifc=tool.Ifc,
-                        geometry=tool.Geometry,
-                        surveyor=tool.Surveyor,
-                        obj=obj,
-                        apply_scale=False,
-                    )
-                    synced += 1
-            except Exception as e:
-                print(f"Could not sync placement for {obj.name}: {e}")
-        if synced:
-            print(f"Synced {synced} moved object placement(s) to IFC before export")
-
-    def _export_collection_instances_obj(self, context, output_dir):
-        """Export Blender collection instances as per-parent OBJ files.
-
-        Collection instances (empties with instance_type='COLLECTION') are purely
-        Blender constructs — they don't exist in the IFC file. The ifcopenshell
-        iterator ignores them entirely, so we must export their geometry via
-        Blender's depsgraph which evaluates all instances with correct world transforms.
-
-        Each collection instance parent gets its own OBJ file because obj2mesh
-        cannot handle all instances in a single file ("too many patch triangles").
-        """
-        depsgraph = context.evaluated_depsgraph_get()
-
-        # Find which objects are collection instance parents (visible, not hidden)
-        # Skip collections that belong to linked IFC models — those are already
-        # exported by _export_linked_models() via the IFC serializer.
-        instance_parents = set()
-        for obj in bpy.data.objects:
-            if obj.instance_type == "COLLECTION" and obj.instance_collection is not None:
-                if not obj.visible_get():
-                    continue
-                # Check if this collection contains linked IFC objects
-                coll = obj.instance_collection
-                is_linked_ifc = any("guids" in child for child in coll.all_objects if child.type == "MESH")
-                if is_linked_ifc:
-                    print(f"Skipping collection instance '{obj.name}' (linked IFC model, exported via IFC serializer)")
-                    continue
-                instance_parents.add(obj.name)
-
-        if not instance_parents:
-            return
-
-        print(f"Found {len(instance_parents)} collection instance(s) to export")
-
-        # Export one OBJ per collection instance parent
-        identity = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
-        total_meshes = 0
-
-        for parent_name in sorted(instance_parents):
-            obj_path = os.path.join(output_dir, f"instance_{parent_name}.obj")
-            vert_offset = 0
-            mesh_count = 0
-
-            with open(obj_path, "w") as f:
-                f.write(f"# Collection instance geometry for {parent_name}\n")
-                f.write("usemtl white\n\n")
-
-                for dep_inst in depsgraph.object_instances:
-                    if not dep_inst.is_instance:
-                        continue
-                    if dep_inst.parent is None:
-                        continue
-                    if dep_inst.parent.original.name != parent_name:
-                        continue
-
-                    eval_obj = dep_inst.object
-                    if eval_obj.type != "MESH":
-                        continue
-
-                    try:
-                        mesh = eval_obj.to_mesh()
-                    except RuntimeError:
-                        continue
-                    if mesh is None:
-                        continue
-
-                    matrix = dep_inst.matrix_world
-                    f.write(f"g obj_{mesh_count}\n")
-
-                    for v in mesh.vertices:
-                        co = matrix @ v.co
-                        f.write(f"v {co.x} {co.y} {co.z}\n")
-
-                    mesh.calc_loop_triangles()
-                    for tri in mesh.loop_triangles:
-                        i0 = vert_offset + tri.vertices[0] + 1
-                        i1 = vert_offset + tri.vertices[1] + 1
-                        i2 = vert_offset + tri.vertices[2] + 1
-                        f.write(f"f {i0} {i1} {i2}\n")
-
-                    vert_offset += len(mesh.vertices)
-                    mesh_count += 1
-                    eval_obj.to_mesh_clear()
-
-            if mesh_count == 0:
-                try:
-                    os.remove(obj_path)
-                except OSError:
-                    pass
-                continue
-
-            # Identity matrix — geometry is already at world coordinates
-            linked_model_exports.append((obj_path, "", identity))
-            total_meshes += mesh_count
-            print(f"  {parent_name}: {mesh_count} meshes, {vert_offset} vertices")
-
-        if total_meshes > 0:
-            print(f"Exported {total_meshes} instanced meshes across {len(linked_model_exports)} file(s)")
-
-    def _export_non_ifc_meshes(self, context, output_dir):
-        """Export visible Blender mesh objects that have no IFC entity.
-
-        These are plain Blender geometry (e.g. manually added planes, cubes)
-        that don't exist in any IFC file. They are skipped by the IFC iterator
-        and by the collection instance exporter, so we handle them separately.
-        """
-        non_ifc_meshes = []
-        for obj in bpy.data.objects:
-            if obj.type != "MESH":
-                continue
-            if not obj.visible_get():
-                continue
-            # Skip objects that have an IFC entity (handled by main/linked IFC export)
-            if tool.Ifc.get_entity(obj) is not None:
-                continue
-            # Skip objects inside instanced collections (handled by collection instance export)
-            if any(col.library for col in obj.users_collection):
-                continue
-            # Skip linked IFC element objects (have "guids" custom prop)
-            if "guids" in obj:
-                continue
-            non_ifc_meshes.append(obj)
-
-        if not non_ifc_meshes:
-            return
-
-        obj_path = os.path.join(output_dir, "blender_meshes.obj")
-        vert_offset = 0
-        mesh_count = 0
-        identity = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
-
-        depsgraph = context.evaluated_depsgraph_get()
-
-        with open(obj_path, "w") as f:
-            f.write("# Non-IFC Blender mesh geometry\n")
-            f.write("usemtl white\n\n")
-
-            for obj in non_ifc_meshes:
-                eval_obj = obj.evaluated_get(depsgraph)
-                try:
-                    mesh = eval_obj.to_mesh()
-                except RuntimeError:
-                    continue
-                if mesh is None:
-                    continue
-
-                matrix = obj.matrix_world
-                f.write(f"g {obj.name}\n")
-
-                for v in mesh.vertices:
-                    co = matrix @ v.co
-                    f.write(f"v {co.x} {co.y} {co.z}\n")
-
-                mesh.calc_loop_triangles()
-                for tri in mesh.loop_triangles:
-                    i0 = vert_offset + tri.vertices[0] + 1
-                    i1 = vert_offset + tri.vertices[1] + 1
-                    i2 = vert_offset + tri.vertices[2] + 1
-                    f.write(f"f {i0} {i1} {i2}\n")
-
-                vert_offset += len(mesh.vertices)
-                mesh_count += 1
-                eval_obj.to_mesh_clear()
-
-        if mesh_count == 0:
-            try:
-                os.remove(obj_path)
-            except OSError:
-                pass
-            return
-
-        linked_model_exports.append((obj_path, "", identity))
-        print(f"Exported {mesh_count} non-IFC Blender mesh(es) ({vert_offset} vertices)")
-
-    def execute(self, context):
-        ifc_materials.clear()
-        linked_model_exports.clear()
-
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-        props.is_exporting = True
-
-        # Sync all moved Blender object positions to IFC before export.
-        self._sync_moved_object_placements()
-
-        settings, serializer_settings = self._get_geom_settings()
-
-        ifc_file = tool.Ifc.get()
-
-        # --- Export main model ---
-        obj_file_path = os.path.join(output_dir, "model.obj")
-        mtl_file_path = os.path.join(output_dir, "model.mtl")
-
-        visible_elements = self._get_exportable_elements(ifc_file, filter_visibility=True)
-        mats = self._export_ifc_to_obj(
-            ifc_file, obj_file_path, mtl_file_path, settings, serializer_settings, visible_elements
-        )
-        ifc_materials.extend(mats)
-
-        self.report({"INFO"}, f"Exported main model OBJ to: {obj_file_path}")
-
-        # --- Export linked models (external IFC files) ---
-        self._export_linked_models(ifc_file, output_dir, settings, serializer_settings)
-
-        # --- Export collection instances (Blender-level linked copies) ---
-        self._export_collection_instances_obj(context, output_dir)
-
-        # --- Export non-IFC Blender meshes (plain geometry with no IFC entity) ---
-        self._export_non_ifc_meshes(context, output_dir)
-
-        props.is_exporting = False
-        total_linked = len(linked_model_exports)
-        if total_linked:
-            self.report({"INFO"}, f"Also exported {total_linked} linked/instanced model(s)")
-        return {"FINISHED"}
-
-    def _export_linked_models(self, main_ifc_file, output_dir, settings, serializer_settings):
-        """Detect and export all linked IFC models."""
-        try:
-            project_props = tool.Project.get_project_props()
-        except Exception:
-            print("Could not access project properties for linked models")
-            return
-
-        for idx, link in enumerate(project_props.links):
-            if not link.is_loaded:
-                print(f"Skipping linked model '{link.name}' (not loaded)")
-                continue
-
-            # Check if the link's empty handle is hidden in Blender
-            try:
-                link_empty = tool.Project.get_link_empty_handle(link)
-                if link_empty is not None and not link_empty.visible_get():
-                    print(f"Skipping linked model '{link.name}' (hidden in viewport)")
-                    continue
-            except Exception:
-                pass  # If we can't check visibility, export anyway
-
-            try:
-                filepath = Path(tool.Ifc.resolve_uri(link.filepath))
-            except Exception as e:
-                print(f"Could not resolve path for linked model '{link.name}': {e}")
-                continue
-
-            if not filepath.exists():
-                print(f"Linked IFC file not found: {filepath}")
-                continue
-
-            print(f"Exporting linked model {idx}: {filepath.name}")
-            try:
-                linked_ifc = ifcopenshell.open(str(filepath))
-            except Exception as e:
-                print(f"  Failed to open linked IFC: {e}")
-                continue
-
-            link_obj_path = os.path.join(output_dir, f"linked_{idx}.obj")
-            link_mtl_path = os.path.join(output_dir, f"linked_{idx}.mtl")
-
-            # For linked models we don't filter by Blender visibility
-            # (their objects are collection instances, not individually tracked)
-            elements = self._get_exportable_elements(linked_ifc, filter_visibility=False)
-            if not elements:
-                print(f"  No exportable elements found in linked model")
-                continue
-
-            mats = self._export_ifc_to_obj(
-                linked_ifc, link_obj_path, link_mtl_path, settings, serializer_settings, elements
-            )
-            ifc_materials.extend(mats)
-
-            # Get the link transformation matrix
-            try:
-                link_matrix = tool.Project.calculate_link_matrix(link)
-                matrix_list = [list(row) for row in link_matrix]
-            except Exception as e:
-                print(f"  Could not calculate link matrix: {e}, using identity")
-                matrix_list = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
-
-            linked_model_exports.append((link_obj_path, link_mtl_path, matrix_list))
-            print(f"  Exported {len(elements)} elements from linked model '{link.name}'")
-
-
-class CleanupRadianceFiles(bpy.types.Operator):
-    """Delete all generated Radiance files from the output directory"""
-
-    bl_idname = "radiance.cleanup_files"
-    bl_label = "Cleanup Radiance Files"
-    bl_description = "Remove all generated files (OBJ, MTL, RTM, RAD, HDR, TIFF, DAT) from the output directory"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        return True
-
-    def execute(self, context):
-        import bonsai.bim.module.light.shared as shared
-
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-
-        if not os.path.isdir(output_dir):
-            self.report({"WARNING"}, f"Output directory does not exist: {output_dir}")
-            return {"CANCELLED"}
-
-        cleanup_patterns = (
-            "model.obj",
-            "model.mtl",
-            "model.rtm",
-            "sky.rad",
-            "materials.rad",
-            "scene.rad",
-            "ascene.oct",
-            "mascene.oct",
-            "ascene.amb",
-        )
-        cleanup_extensions = (".hdr", ".tiff", ".rad", ".dat")
-        cleanup_prefixes = ("instance_", "linked_", "blender_meshes")
-
-        removed = 0
-        for filename in os.listdir(output_dir):
-            filepath = os.path.join(output_dir, filename)
-            if not os.path.isfile(filepath):
-                continue
-            is_generated = (
-                filename in cleanup_patterns
-                or os.path.splitext(filename)[1].lower() in cleanup_extensions
-                or any(filename.startswith(p) for p in cleanup_prefixes)
-            )
-            if is_generated:
-                try:
-                    os.remove(filepath)
-                    removed += 1
-                except OSError as e:
-                    print(f"Failed to remove {filepath}: {e}")
-
-        # Reset the global scene reference
-        shared.scene = None
-
-        self.report({"INFO"}, f"Cleaned up {removed} generated files from {output_dir}")
-        return {"FINISHED"}

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

@@ -1,80 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 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/>.
-
-from pathlib import Path
-
-import bpy
-from bpy_extras.io_utils import ImportHelper
-
-import bonsai.tool as tool
-
-
-class AddIESLight(bpy.types.Operator, ImportHelper):
-    """Upload and add an IES light fixture to the scene"""
-
-    bl_idname = "radiance.add_ies_light"
-    bl_label = "Add IES Light"
-    bl_options = {"REGISTER", "UNDO"}
-
-    filename_ext = ".ies"
-    filter_glob: bpy.props.StringProperty(default="*.ies;*.IES", options={"HIDDEN"})
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-
-        # Create new IES light entry
-        ies_light = props.ies_lights.add()
-        # Store as relative path if the blend file is saved
-        if bpy.data.filepath:
-            ies_light.ies_file_path = bpy.path.relpath(self.filepath)
-        else:
-            ies_light.ies_file_path = self.filepath
-        ies_light.rotation_z = 0.0
-        ies_light.is_enabled = True
-
-        # Set as active
-        props.active_ies_light_index = len(props.ies_lights) - 1
-
-        self.report({"INFO"}, f"Added IES light: {Path(self.filepath).name}")
-        return {"FINISHED"}
-
-
-class RemoveIESLight(bpy.types.Operator):
-    """Remove an IES light fixture mapping"""
-
-    bl_idname = "radiance.remove_ies_light"
-    bl_label = "Remove IES Light"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty()
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-
-        if 0 <= self.index < len(props.ies_lights):
-            props.ies_lights.remove(self.index)
-
-            # Adjust active index if needed
-            if props.active_ies_light_index >= len(props.ies_lights):
-                props.active_ies_light_index = len(props.ies_lights) - 1
-
-            self.report({"INFO"}, "IES light removed")
-            return {"FINISHED"}
-
-        self.report({"WARNING"}, "Invalid IES light index")
-        return {"CANCELLED"}

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

@@ -18,18 +18,21 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+import json
+import os
 from typing import TYPE_CHECKING
 
 import bpy
 
 if TYPE_CHECKING:
     from bonsai.bim.module.light.prop import (
-        IESLight,
         RadianceExporterProperties,
         RadianceMaterial,
     )
 
+with open(os.path.join(os.path.dirname(__file__), "spectraldb.json"), "r") as f:
+    spectraldb = json.load(f)
+
 
 class MATERIAL_UL_radiance_materials(bpy.types.UIList):
     def draw_item(
@@ -61,41 +64,3 @@ class MATERIAL_UL_radiance_materials(bpy.types.UIList):
                 op.material_index = index
             else:
                 row.label(text="Not Mapped (White)")
-
-
-class MATERIAL_UL_ies_lights(bpy.types.UIList):
-    """UIList for displaying IES light fixtures."""
-
-    def draw_item(
-        self,
-        context,
-        layout: bpy.types.UILayout,
-        data: RadianceExporterProperties,
-        item: IESLight,
-        icon,
-        active_data,
-        active_propname,
-        index,
-    ) -> None:
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            row = layout.row(align=True)
-
-            # Enable/disable checkbox (visible toggle)
-            row.prop(item, "is_enabled", text="", emboss=True)
-
-            # IES file name
-            if item.ies_file_path:
-                filename = Path(item.ies_file_path).name
-                row.label(text=filename, icon="FILE")
-            else:
-                row.label(text="(No file selected)", icon="ERROR")
-
-            # Target: collection or single object
-            if item.use_collection:
-                row.prop(item, "target_collection", text="", icon="OUTLINER_COLLECTION", emboss=False)
-            else:
-                row.prop(item, "target_object", text="", emboss=False)
-
-            # Remove button (X icon - negative action)
-            op = row.operator("radiance.remove_ies_light", text="", icon="X")
-            op.index = index

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

@@ -1,136 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 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/>.
-
-import json
-import webbrowser
-
-import bpy
-from bpy_extras.io_utils import ExportHelper, ImportHelper
-
-import bonsai.tool as tool
-
-
-class RefreshIFCMaterials(bpy.types.Operator):
-    bl_idname = "bim.refresh_ifc_materials"
-    bl_label = "Refresh IFC Materials"
-    bl_description = "Refresh the list of IFC materials for mapping"
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            cls.poll_message_set("No IFC file loaded in Bonsai.")
-            return False
-        return True
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        ifc_file = tool.Ifc.get()
-
-        props.materials.clear()
-
-        for style in ifc_file.by_type("IfcSurfaceStyle"):
-            for render_item in style.Styles:
-                if render_item.is_a("IfcSurfaceStyleRendering"):
-                    style_id = f"IfcSurfaceStyleRendering-{render_item.id()}"
-                    style_name = style.Name or f"Unnamed Style {render_item.id()}"
-
-                    # Extract color
-                    color = (1.0, 1.0, 1.0)  # Default white
-                    if render_item.SurfaceColour:
-                        color = (
-                            render_item.SurfaceColour.Red,
-                            render_item.SurfaceColour.Green,
-                            render_item.SurfaceColour.Blue,
-                        )
-
-                    material = props.add_material_mapping(style_id, style_name)
-                    material.color = color
-
-                    material.category = ""
-                    material.subcategory = ""
-                    material.is_mapped = False
-
-        props.active_material_index = 0 if props.materials else -1
-
-        self.report({"INFO"}, f"Refreshed {len(props.materials)} IFC materials")
-        return {"FINISHED"}
-
-
-class UnmapMaterial(bpy.types.Operator):
-    bl_idname = "bim.unmap_material"
-    bl_label = "Unmap Material"
-    bl_options = {"REGISTER", "UNDO"}
-
-    material_index: bpy.props.IntProperty()
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        material = props.materials[self.material_index]
-        props.unmap_material(material.name)
-        return {"FINISHED"}
-
-
-class RADIANCE_OT_export_material_mappings(bpy.types.Operator, ExportHelper):
-    bl_idname = "radiance.export_material_mappings"
-    bl_label = "Export Material Mappings"
-    bl_description = "Export material mappings to a JSON file"
-
-    filename_ext = ".json"
-    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        mappings = {}
-
-        for material in props.materials:
-            if material.is_mapped:
-                mappings[material.style_id] = {
-                    "name": material.name,
-                    "category": material.category,
-                    "subcategory": material.subcategory,
-                }
-
-        with open(self.filepath, "w") as f:
-            json.dump(mappings, f, indent=4)
-
-        self.report({"INFO"}, f"Material mappings exported to {self.filepath}")
-        return {"FINISHED"}
-
-
-class RADIANCE_OT_import_material_mappings(bpy.types.Operator, ImportHelper):
-    bl_idname = "radiance.import_material_mappings"
-    bl_label = "Import Material Mappings"
-    bl_description = "Import material mappings from a JSON file"
-
-    filename_ext = ".json"
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        props.import_mappings(self.filepath)
-        self.report({"INFO"}, f"Material mappings imported from {self.filepath}")
-        return {"FINISHED"}
-
-
-class RADIANCE_OT_open_spectraldb(bpy.types.Operator):
-    bl_idname = "radiance.open_spectraldb"
-    bl_label = "Open SpectralDB"
-    bl_description = "Open the SpectralDB website for reference"
-
-    def execute(self, context):
-        webbrowser.open("https://spectraldb.com")
-        return {"FINISHED"}

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

@@ -16,44 +16,716 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
-"""Thin re-export module for backward compatibility.
+import json
+import math
+import multiprocessing
+import os
+import time
+import webbrowser
+from datetime import datetime
+from math import radians
+from pathlib import Path
+from typing import TYPE_CHECKING, Union
 
-All operator classes are defined in their respective submodules:
-  - export.py:   ExportOBJ, CleanupRadianceFiles
-  - prepare.py:  PrepareRadianceScene
-  - render.py:   RadianceRender, FalseColorRadiance, RADIANCE_OT_select_camera
-  - solar.py:    ImportTrueNorth, ImportLatLong, MoveSunPathTo3DCursor,
-                 ViewFromSun, LightPickCoordinates, LightSetTimeToNow
-  - material.py: RefreshIFCMaterials, UnmapMaterial,
-                 RADIANCE_OT_export_material_mappings,
-                 RADIANCE_OT_import_material_mappings,
-                 RADIANCE_OT_open_spectraldb
-  - ies.py:      AddIESLight, RemoveIESLight
+import bpy
+import ifcopenshell
+import ifcopenshell.geom
+import ifcopenshell.ifcopenshell_wrapper as W
+import ifcopenshell.util.geolocation
+import pyradiance as pr
+import requests
+from bpy_extras.io_utils import ExportHelper, ImportHelper
+from mathutils import Vector
 
-EnumPropertySearch and SetEnumProperty are provided by the global
-bonsai.bim.operator module (bl_idname "bim.enum_property_search").
-"""
+import bonsai.tool as tool
+from bonsai.bim.module.light.data import SolarData
 
-from bonsai.bim.module.light.export import CleanupRadianceFiles, ExportOBJ  # noqa: F401
-from bonsai.bim.module.light.ies import AddIESLight, RemoveIESLight  # noqa: F401
-from bonsai.bim.module.light.material import (  # noqa: F401
-    RADIANCE_OT_export_material_mappings,
-    RADIANCE_OT_import_material_mappings,
-    RADIANCE_OT_open_spectraldb,
-    RefreshIFCMaterials,
-    UnmapMaterial,
-)
-from bonsai.bim.module.light.prepare import PrepareRadianceScene  # noqa: F401
-from bonsai.bim.module.light.render import (  # noqa: F401
-    FalseColorRadiance,
-    RADIANCE_OT_select_camera,
-    RadianceRender,
-)
-from bonsai.bim.module.light.solar import (  # noqa: F401
-    ImportLatLong,
-    ImportTrueNorth,
-    LightPickCoordinates,
-    LightSetTimeToNow,
-    MoveSunPathTo3DCursor,
-    ViewFromSun,
-)
+ifc_materials = []
+
+with open(os.path.join(os.path.dirname(__file__), "spectraldb.json"), "r") as f:
+    spectraldb = json.load(f)
+
+
+class ExportOBJ(bpy.types.Operator):
+    """Exports the IFC File to OBJ"""
+
+    bl_idname = "export_scene.radiance"
+    bl_label = "Export"
+    bl_description = "Export the IFC to OBJ"
+
+    @classmethod
+    def poll(cls, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        if not props.should_load_from_memory and not props.ifc_file:
+            cls.poll_message_set("Select an IFC file or use 'load from memory' if it's loaded in Bonsai.")
+            return False
+        return True
+
+    def execute(self, context):
+        # Get the output directory
+        props = tool.Blender.get_radiance_exporter_props()
+        should_load_from_memory = props.should_load_from_memory
+        output_dir = props.output_dir
+
+        props.is_exporting = True
+
+        # Conversion from IFC to OBJ
+        # Settings for obj
+        settings = ifcopenshell.geom.settings()
+        serializer_settings = ifcopenshell.geom.serializer_settings()
+
+        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.SURFACES_AND_SOLIDS)
+        settings.set("apply-default-materials", True)
+        serializer_settings.set("use-element-guids", True)
+        settings.set("use-world-coords", True)
+
+        ifc_file: ifcopenshell.file
+        if should_load_from_memory:
+            ifc_file = tool.Ifc.get()
+
+        else:
+            ifc_file_path = props.ifc_file
+            ifc_file = ifcopenshell.open(ifc_file_path)
+
+        obj_file_path = os.path.join(output_dir, "model.obj")
+        mtl_file_path = os.path.join(output_dir, "model.mtl")
+
+        serialiser = ifcopenshell.geom.serializers.obj(obj_file_path, mtl_file_path, settings, serializer_settings)
+        serialiser.setFile(ifc_file)
+        serialiser.setUnitNameAndMagnitude("METER", 1.0)
+        serialiser.writeHeader()
+
+        if ifc_file.schema in ("IFC2X3", "IFC4"):
+            elements = ifc_file.by_type("IfcElement") + ifc_file.by_type("IfcProxy")
+        else:
+            elements = ifc_file.by_type("IfcElement")
+
+        elements += ifc_file.by_type("IfcSite")
+        elements = [e for e in elements if not e.is_a("IfcFeatureElement") or e.is_a("IfcSurfaceFeature")]
+
+        iterator = ifcopenshell.geom.iterator(settings, ifc_file, multiprocessing.cpu_count(), include=elements)
+        if iterator.initialize():
+            while True:
+                shape = iterator.get()
+                assert isinstance(shape, W.TriangulationElement)
+                materials = shape.geometry.materials
+
+                for material in materials:
+                    ifc_materials.append(material.name)
+
+                serialiser.write(shape)
+                if not iterator.next():
+                    break
+
+        serialiser.finalize()
+        props.is_exporting = False
+
+        self.report({"INFO"}, "Exported OBJ file to: {}".format(obj_file_path))
+
+        return {"FINISHED"}
+
+
+class RadianceRender(bpy.types.Operator):
+    """Radiance Rendering"""
+
+    bl_idname = "render_scene.radiance"
+    bl_label = "Render"
+    bl_description = "Renders the scene using Radiance"
+
+    def execute(self, context):
+        print("Starting Radiance rendering process...")
+        props = tool.Blender.get_radiance_exporter_props()
+        resolution_x, resolution_y = props.radiance_resolution_x, props.radiance_resolution_y
+
+        assert context.scene
+        context.scene.render.resolution_x = resolution_x
+        context.scene.render.resolution_y = resolution_y
+
+        aspect_ratio = resolution_x / resolution_y
+
+        quality = props.radiance_quality.upper()
+        detail = props.radiance_detail.upper()
+        variability = props.radiance_variability.upper()
+        output_dir = props.output_dir
+        output_file_name = props.output_file_name
+        output_file_format = props.output_file_format
+        use_hdr = props.use_hdr
+        choose_hdr_image = props.choose_hdr_image
+
+        print(f"Resolution: {resolution_x}x{resolution_y}")
+        print(f"Quality: {quality}, Detail: {detail}, Variability: {variability}")
+        print(f"Output directory: {output_dir}")
+
+        if use_hdr:
+            hdr_image = "noon_grass_2k.hdr"
+            hdr_mask = "noon_grass_2k_mask.hdr"
+            sky_map_cal = "skymap.cal"
+            hdr_image_path = os.path.join(os.path.dirname(__file__), "HDRs", hdr_image)
+            hdr_mask_path = os.path.join(os.path.dirname(__file__), "HDRs", hdr_mask)
+            sky_map_cal_path = os.path.join(os.path.dirname(__file__), "HDRs", sky_map_cal)
+
+        obj_file_path = os.path.join(output_dir, "model.obj")
+
+        sun_props = tool.Blender.get_solar_props()
+        sun_pos_props = tool.Blender.get_sun_props()
+        assert sun_pos_props
+        sky_file_path = os.path.join(output_dir, "sky.rad")
+        # latitude = sun_props.latitude
+        # longitude = sun_props.longitude
+        # month = sun_props.month
+        # day = sun_props.day
+        # hour = sun_props.hour
+        # minute = sun_props.minute
+
+        # print("Sun Properties:")
+        # print("Latitude: ", latitude)
+        # print("Longitude: ", longitude)
+        # print("Timezone: ", timezone)
+        # print("Month: ", month)
+        # print("Day: ", day)
+        # print("Hour: ", hour)
+        # print("Minute: ", minute)
+
+        print("Setting up camera...")
+        if props.use_active_camera:
+            camera = context.scene.camera
+        else:
+            camera = props.selected_camera
+
+        if camera is None:
+            self.report({"ERROR"}, "No active camera found in the scene. Please add a camera and set it as active.")
+            return {"CANCELLED"}
+
+        # Get camera position and direction
+        camera_position, camera_direction = self.get_camera_data(camera)
+
+        print(f"Camera position: {camera_position}")
+        print(f"Camera direction: {camera_direction}")
+
+        # sun_position = tool.Blender.get_addon("sun_position")
+        #     azimuth, elevation = sun_position.sun_calc.get_sun_coordinates(
+        #     sun_pos_props.time,
+        #     sun_pos_props.latitude,
+        #     sun_pos_props.longitude,
+        #     -sun_pos_props.UTC_zone,
+        #     sun_pos_props.month,
+        #     sun_pos_props.day,
+        #     sun_pos_props.year,
+        # )
+
+        dt = datetime(sun_pos_props.year, sun_props.month, sun_props.day, sun_props.hour, sun_props.minute)
+
+        sky_description = pr.gensky(
+            dt=dt,
+            # azimuth=64.1,
+            # altitude=-26.6,
+            latitude=sun_props.latitude,
+            longitude=sun_props.longitude,
+            year=sun_pos_props.year,
+            timezone=-int(sun_props.UTC_zone),
+            # sunny_with_sun=False,
+            # sunny_without_sun=False,
+            # cloudy=False,
+            # ground_reflectance=0.2,
+            # turbidity=3.0,
+        )
+
+        sky_description_str = sky_description.decode("utf-8")
+
+        # Write all this to file
+        # skyfunc glow sky_glow
+        # 0
+        # 0
+        # 4 .9 .9 1.15 0
+
+        # sky_glow source sky
+        # 0
+        # 0
+        # 4 0 0 1 180
+
+        # skyfunc glow ground_glow
+        # 0
+        # 0
+        # 4 1.4 .9 .6 0
+
+        # ground_glow source ground
+        # 0
+        # 0
+        # 4 0 0 -1 180
+
+        if use_hdr and choose_hdr_image == "Noon":
+
+            with open(sky_file_path, "w") as f:
+                f.write(sky_description_str)
+                f.write("\n")
+                # f.write("skyfunc glow sky_glow\n0\n0\n4 .9 .9 1.15 0\n")
+                # f.write("sky_glow source sky\n0\n0\n4 0 0 1 180\n")
+                # f.write("skyfunc glow ground_glow\n0\n0\n4 1.4 .9 .6 0\n")
+                # f.write("ground_glow source ground\n0\n0\n4 0 0 -1 180\n")
+
+                f.write(
+                    '''void colorpict env_map
+7 red green blue "'''
+                    + hdr_image_path
+                    + '''"  "'''
+                    + sky_map_cal_path
+                    + '''" map_u map_v
+0
+1 0.5
+
+# This is a multiplier to colour balance the env map
+# In this case, it provides a rough ground luminance from 3k-5k
+env_map colorfunc env_colour
+4 100 100 100 .
+0
+0
+
+# .37 .57 1.5 is measured from a HDRI image
+# It is multiplied by a factor such that grey(r,g,b) = 1
+skyfunc colorfunc sky_colour
+4 .64 .99 2.6 .
+0
+0
+
+void mixpict composite
+7 env_colour sky_colour grey "'''
+                    + hdr_mask_path
+                    + '''"  "'''
+                    + sky_map_cal_path
+                    + """" map_u map_v
+0
+2 0.5 1
+
+composite glow env_map_glow
+0
+0
+4 1 1 1 0
+
+env_map_glow source sky
+0
+0
+4 0 0 1 180
+
+env_colour glow ground_glow
+0
+0
+4 1 1 1 0
+
+ground_glow source ground
+0
+0
+4 0 0 -1 180"""
+                )
+
+        elif not use_hdr:
+            with open(sky_file_path, "w") as f:
+                f.write(sky_description_str)
+                f.write("\n")
+                # f.write("skyfunc glow sky_glow\n0\n0\n4 .9 .9 1.15 0\n")
+                # f.write("sky_glow source sky\n0\n0\n4 0 0 1 180\n")
+                # f.write("skyfunc glow ground_glow\n0\n0\n4 1.4 .9 .6 0\n")
+                # f.write("ground_glow source ground\n0\n0\n4 0 0 -1 180\n")
+
+        props = tool.Blender.get_radiance_exporter_props()
+
+        data = props.get_mappings_dict()
+
+        materials_file = os.path.join(output_dir, "materials.rad")
+        written_materials = set()
+
+        all_materials = set(ifc_materials)
+
+        with open(materials_file, "w") as file:
+            # Write default materials
+            default_materials = [
+                "void plastic white\n0\n0\n5 0.8 0.8 0.8 0 0\n",
+                # "void plastic blue_plastic\n0\n0\n5 0.1 0.2 0.8 0.05 0.1\n",
+                # "void plastic red_plastic\n0\n0\n5 0.8 0.1 0.2 0.05 0.1\n",
+                # "void metal silver_metal\n0\n0\n5 0.8 0.8 0.8 0.9 0.1\n",
+                # "void glass clear_glass\n0\n0\n3 0.96 0.96 0.96\n",
+                # "void light white_light\n0\n0\n3 1.0 1.0 1.0\n",
+                # "void trans olive_trans\n0\n0\n7 0.6 0.7 0.4 0.05 0.05 0.7 0.2\n",
+            ]
+            for material in default_materials:
+                file.write(material)
+                written_materials.add(material.split()[2])  # Add material name to written set
+
+            for style_id in all_materials:
+                material = next((m for m in props.materials if m.style_id == style_id), None)
+                if material and material.is_mapped:
+                    category, subcategory = material.category, material.subcategory
+                    if category in spectraldb and subcategory in spectraldb[category]:
+                        material_def = spectraldb[category][subcategory]
+                        material_name = material_def.split()[2]
+                        if material_name not in written_materials:
+                            file.write(material_def + "\n")
+                            written_materials.add(material_name)
+                        file.write(f"inherit alias {style_id} {material_name}\n")
+                    else:
+                        file.write(f"inherit alias {style_id} white\n")
+                else:
+                    # If the material is not mapped, alias it to white
+                    file.write(f"inherit alias {style_id} white\n")
+
+        self.report({"INFO"}, f"Exported Materials Rad file to: {materials_file}")
+
+        # Run obj2mesh
+        rtm_file_path = os.path.join(output_dir, "model.rtm")
+        mesh_file_path = save_obj2mesh_output(obj_file_path, rtm_file_path, matfiles=[materials_file])
+        # subprocess.run(["obj2mesh", "-a", materials_file, obj_file_path, rtm_file_path])
+        self.report({"INFO"}, "obj2mesh output: {}".format(mesh_file_path))
+        scene_file = os.path.join(output_dir, "scene.rad")
+        with open(scene_file, "w") as file:
+            file.write('void mesh model\n1 "' + rtm_file_path + '"\n0\n0\n')
+
+        self.report({"INFO"}, "Exported Scene file to: {}".format(scene_file))
+
+        print("Setting up Radiance scene...")
+        scene = pr.Scene("ascene")
+
+        material_path = os.path.join(output_dir, "materials.rad")
+        scene_path = os.path.join(output_dir, "scene.rad")
+
+        scene.add_material(material_path)
+        scene.add_surface(scene_path)
+        scene.add_source(sky_file_path)
+        print("Setting up view...")
+        assert isinstance(camera.data, bpy.types.Camera)
+        if camera.data.type == "PERSP":
+            # Perspective camera
+            camera_fov = camera.data.angle
+            # Calculate vertical FOV based on the desired aspect ratio
+            vertical_fov = 2 * math.atan(math.tan(camera_fov / 2) / aspect_ratio)
+
+            aview = pr.View(
+                vtype="v",  # Perspective view
+                position=camera_position,
+                direction=camera_direction,
+                vup=(0, 0, 1),  # Assuming Z is up
+                horiz=math.degrees(camera_fov),
+                vert=math.degrees(vertical_fov),
+            )
+        else:  # 'ORTHO'
+            # Orthographic camera
+            # Calculate the view size based on the camera's orthographic scale
+            ortho_scale = camera.data.ortho_scale
+            view_width = ortho_scale
+            view_height = ortho_scale / aspect_ratio
+
+            aview = pr.View(
+                vtype="l",  # Parallel projection (orthographic)
+                position=camera_position,
+                direction=camera_direction,
+                vup=(0, 0, 1),  # Assuming Z is up
+                horiz=view_width,
+                vert=view_height,
+            )
+        scene.add_view(aview)
+        print("Starting render...")
+        start_time = time.time()
+        image = pr.render(
+            scene,
+            ambbounce=1,
+            resolution=(resolution_x, resolution_y),
+            quality=quality,
+            detail=detail,
+            variability=variability,
+            nproc=multiprocessing.cpu_count(),
+        )
+        end_time = time.time()
+        print(f"Render completed in {end_time - start_time:.2f} seconds")
+
+        output_hdr_path = os.path.join(output_dir, f"{output_file_name}.{output_file_format.lower()}")
+        print(f"Saving HDR output to: {output_hdr_path}")
+        if output_file_format == "HDR":
+            with open(output_hdr_path, "wb") as wtr:
+                wtr.write(image)
+        else:
+            pass
+        print("Applying tone mapping...")
+        pcond_image = pr.pcond(hdr=output_hdr_path, human=True)
+
+        tiff_path = os.path.join(output_dir, f"{output_file_name}.tiff")
+        print(f"Saving TIFF output to: {tiff_path}")
+        pr.ra_tiff(inp=pcond_image, out=tiff_path, lzw=True)
+        print("Radiance rendering process completed successfully.")
+        self.report({"INFO"}, "Radiance rendering completed. Output: {}".format(tiff_path))
+        return {"FINISHED"}
+
+    def get_active_camera(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        if props.use_active_camera:
+            return context.scene.camera
+        else:
+            return props.selected_camera
+
+    def get_camera_data(self, camera):
+        # Get camera position
+        position = camera.matrix_world.to_translation()
+
+        # Get camera direction
+        direction = camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
+        direction.normalize()
+
+        return (position.x, position.y, position.z), (direction.x, direction.y, direction.z)
+
+    def getResolution(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        resolution_x = props.radiance_resolution_x
+        resolution_y = props.radiance_resolution_y
+        return resolution_x, resolution_y
+
+
+def save_obj2mesh_output(inp: Union[bytes, str, Path], output_file: str, **kwargs):
+    output_bytes = pr.obj2mesh(inp, **kwargs)
+
+    with open(output_file, "wb") as f:
+        f.write(output_bytes)
+    return output_file
+
+
+class ImportTrueNorth(bpy.types.Operator):
+    bl_idname = "bim.import_true_north"
+    bl_label = "Import True North"
+    bl_description = "Imports the True North from your IFC geometric context"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get():
+            return False
+        if not SolarData.is_loaded:
+            SolarData.load()
+        return SolarData.data["true_north"] is not None
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if not context.TrueNorth:
+                continue
+            value = context.TrueNorth.DirectionRatios
+            props.true_north = radians(ifcopenshell.util.geolocation.yaxis2angle(*value[:2]))
+        return {"FINISHED"}
+
+
+class ImportLatLong(bpy.types.Operator):
+    bl_idname = "bim.import_lat_long"
+    bl_label = "Import Latitude / Longitude"
+    bl_description = "Imports the latitude / longitude from an IfcSite"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        site = tool.Ifc.get().by_id(int(props.sites))
+        if site.RefLatitude and site.RefLongitude:
+            props.latitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLatitude)
+            props.longitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLongitude)
+        return {"FINISHED"}
+
+
+class MoveSunPathTo3DCursor(bpy.types.Operator):
+    bl_idname = "bim.move_sun_path_to_3d_cursor"
+    bl_label = "Move Sun Path To 3D Cursor"
+    bl_description = "Shifts the visualisation of the Sun Path to the 3D cursor"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        assert context.scene
+        props.sun_path_origin = context.scene.cursor.location
+        tool.Blender.update_viewport()
+        return {"FINISHED"}
+
+
+class ViewFromSun(bpy.types.Operator):
+    bl_idname = "bim.view_from_sun"
+    bl_label = "View From Sun"
+    bl_description = "Views your model as if you were looking from the perspective of the sun"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        if not (camera := bpy.data.objects.get("SunPathCamera")):
+            camera = bpy.data.objects.new("SunPathCamera", bpy.data.cameras.new("SunPathCamera"))
+            assert isinstance(camera.data, bpy.types.Camera)
+            assert context.scene
+            camera.data.type = "ORTHO"
+            camera.data.ortho_scale = 100  # The default of 6m is too small
+            context.scene.collection.objects.link(camera)
+        tool.Blender.activate_camera(camera)
+        props = tool.Blender.get_solar_props()
+        props.hour = props.hour  # Just to refresh camera position
+        return {"FINISHED"}
+
+
+class LightPickCoordinates(bpy.types.Operator):
+    bl_idname = "bim.light_pick_coordinates"
+    bl_label = "Pick Coordinates"
+    bl_description = (
+        "Open web browser with Google Maps to pick coordinates (Right Mouse Click in maps to copy selected location).\n\n"
+        "ALT+Click to insert current location based on the current IP-address (using ip-api.com)."
+    )
+    bl_options = {"REGISTER", "UNDO"}
+
+    use_current_location: bpy.props.BoolProperty(options={"SKIP_SAVE"})
+
+    if TYPE_CHECKING:
+        use_current_location: bool
+
+    def invoke(self, context, event):
+        if event.alt:
+            self.use_current_location = True
+        return self.execute(context)
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        if not self.use_current_location:
+            zoom = 13.5
+            url = f"https://www.google.com/maps/@{props.latitude},{props.longitude},{zoom}z"
+            webbrowser.open(url)
+            return {"FINISHED"}
+
+        response = requests.get("http://ip-api.com/json/")
+        data = response.json()
+        props.latitude = data["lat"]
+        props.longitude = data["lon"]
+        return {"FINISHED"}
+
+
+class LightSetTimeToNow(bpy.types.Operator):
+    bl_idname = "bim.light_set_time_to_now"
+    bl_label = "Now"
+    bl_description = "Set time to current local time."
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        props.set_from_datetime(datetime.now())
+        return {"FINISHED"}
+
+
+class RefreshIFCMaterials(bpy.types.Operator):
+    bl_idname = "bim.refresh_ifc_materials"
+    bl_label = "Refresh IFC Materials"
+    bl_description = "Refresh the list of IFC materials for mapping"
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        ifc_file: ifcopenshell.file
+        ifc_file = tool.Ifc.get() if props.should_load_from_memory else ifcopenshell.open(props.ifc_file)
+
+        props.materials.clear()
+
+        for style in ifc_file.by_type("IfcSurfaceStyle"):
+            for render_item in style.Styles:
+                if render_item.is_a("IfcSurfaceStyleRendering"):
+                    style_id = f"IfcSurfaceStyleRendering-{render_item.id()}"
+                    style_name = style.Name or f"Unnamed Style {render_item.id()}"
+
+                    # Extract color and transparency
+                    color = (1.0, 1.0, 1.0)  # Default white
+                    transparency = 0.0  # Default opaque
+                    if render_item.SurfaceColour:
+                        color = (
+                            render_item.SurfaceColour.Red,
+                            render_item.SurfaceColour.Green,
+                            render_item.SurfaceColour.Blue,
+                        )
+                    if hasattr(render_item, "Transparency") and render_item.Transparency is not None:
+                        transparency = render_item.Transparency
+
+                    # Add material with color
+                    material = props.add_material_mapping(style_id, style_name)
+                    material.color = color
+
+                    # If transparency is high, consider it as glass
+                    if transparency > 0.5:
+                        material.category = "Glass"
+                        material.subcategory = "Clear Glass"
+                        material.is_mapped = True
+
+        props.active_material_index = 0 if props.materials else -1
+
+        self.report({"INFO"}, f"Refreshed {len(props.materials)} IFC materials")
+        return {"FINISHED"}
+
+
+class UnmapMaterial(bpy.types.Operator):
+    bl_idname = "bim.unmap_material"
+    bl_label = "Unmap Material"
+    bl_options = {"REGISTER", "UNDO"}
+
+    material_index: bpy.props.IntProperty()
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        material = props.materials[self.material_index]
+        props.unmap_material(material.name)
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_select_camera(bpy.types.Operator):
+    bl_idname = "radiance.select_camera"
+    bl_label = "Select Camera"
+    bl_description = "Select a camera from the viewport"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.object is not None and context.object.type == "CAMERA"
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        props.selected_camera = context.object
+        props.use_active_camera = False
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_export_material_mappings(bpy.types.Operator, ExportHelper):
+    bl_idname = "radiance.export_material_mappings"
+    bl_label = "Export Material Mappings"
+    bl_description = "Export material mappings to a JSON file"
+
+    filename_ext = ".json"
+    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        mappings = {}
+
+        for material in props.materials:
+            if material.is_mapped:
+                mappings[material.style_id] = {
+                    "name": material.name,
+                    "category": material.category,
+                    "subcategory": material.subcategory,
+                }
+
+        with open(self.filepath, "w") as f:
+            json.dump(mappings, f, indent=4)
+
+        self.report({"INFO"}, f"Material mappings exported to {self.filepath}")
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_import_material_mappings(bpy.types.Operator, ImportHelper):
+    bl_idname = "radiance.import_material_mappings"
+    bl_label = "Import Material Mappings"
+    bl_description = "Import material mappings from a JSON file"
+
+    filename_ext = ".json"
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        props.import_mappings(self.filepath)
+        self.report({"INFO"}, f"Material mappings imported from {self.filepath}")
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_open_spectraldb(bpy.types.Operator):
+    bl_idname = "radiance.open_spectraldb"
+    bl_label = "Open SpectralDB"
+    bl_description = "Open the SpectralDB website for reference"
+
+    def execute(self, context):
+        webbrowser.open("https://spectraldb.com")
+        return {"FINISHED"}

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

@@ -1,741 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 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/>.
-
-import math
-import os
-import threading
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Union
-
-import bpy
-import pyradiance as pr
-from mathutils import Vector
-
-import bonsai.tool as tool
-from bonsai.bim.module.light.prop import spectraldb
-from bonsai.bim.module.light.shared import ifc_materials, linked_model_exports
-
-
-def _matrix_to_xform_args(matrix: list[list[float]]) -> str:
-    """Decompose a 4x4 matrix into Radiance xform arguments.
-
-    Decomposes into Z/Y/X Euler rotations + translation.
-    The matrix is expected in row-major format (Blender convention).
-    xform applies transforms right-to-left, so we write: -rx X -ry Y -rz Z -t tx ty tz
-    """
-    from mathutils import Matrix as MMatrix
-
-    m = MMatrix(matrix)
-    translation = m.to_translation()
-    euler = m.to_euler("XYZ")
-
-    parts = []
-    rx = math.degrees(euler.x)
-    ry = math.degrees(euler.y)
-    rz = math.degrees(euler.z)
-
-    if abs(rx) > 1e-6:
-        parts.append(f"-rx {rx:.6f}")
-    if abs(ry) > 1e-6:
-        parts.append(f"-ry {ry:.6f}")
-    if abs(rz) > 1e-6:
-        parts.append(f"-rz {rz:.6f}")
-
-    parts.append(f"-t {translation.x:.6f} {translation.y:.6f} {translation.z:.6f}")
-
-    return " ".join(parts)
-
-
-def save_obj2mesh_output(inp: Union[bytes, str, Path], output_file: str, **kwargs):
-    try:
-        output_bytes = pr.obj2mesh(inp, **kwargs)
-        with open(output_file, "wb") as f:
-            f.write(output_bytes)
-        return output_file
-    except Exception as e:
-        print(f"ERROR in obj2mesh conversion:")
-        print(f"  Input file: {inp}")
-        print(f"  Output file: {output_file}")
-        print(f"  Additional args: {kwargs}")
-        print(f"  Error: {str(e)}")
-        raise
-
-
-def convert_ies_to_radiance(
-    ies_file_path: str,
-    output_dir: str,
-    lamp_type: str = "",
-    lamp_color: tuple[float, float, float] = (1.0, 1.0, 1.0),
-    multiply_factor: float = 1.0,
-    radius: float = 0.0,
-) -> tuple[str, str]:
-    """Convert IES file to Radiance format using pyradiance.
-
-    Args:
-        ies_file_path: Path to the .ies file
-        output_dir: Directory where .rad and .dat files will be saved
-        lamp_type: Type of lamp (e.g., 'LED', 'metal halide')
-        lamp_color: RGB color tuple (0.0-1.0 each)
-        multiply_factor: Brightness multiplier (0.1-10.0)
-        radius: Illum sphere radius (0 = use IES geometry)
-
-    Returns:
-        Tuple of (rad_file_path, dat_file_path)
-    """
-    try:
-        ies_path = Path(bpy.path.abspath(ies_file_path))
-        base_name = ies_path.stem
-
-        output_path = os.path.join(output_dir, base_name)
-
-        kwargs = {"outname": output_path}
-
-        if lamp_type:
-            kwargs["lamp_type"] = lamp_type
-
-        if lamp_color != (1.0, 1.0, 1.0):
-            kwargs["lamp_color"] = lamp_color
-
-        if multiply_factor != 1.0:
-            kwargs["multiply_factor"] = multiply_factor
-
-        if radius > 0.0:
-            kwargs["radius"] = radius
-
-        pr.ies2rad(ies_path, **kwargs)
-
-        rad_file = os.path.join(output_dir, f"{base_name}.rad")
-        dat_file = os.path.join(output_dir, f"{base_name}.dat")
-
-        return rad_file, dat_file
-
-    except Exception as e:
-        raise RuntimeError(f"Failed to convert IES file '{ies_file_path}': {str(e)}")
-
-
-class PrepareRadianceScene(bpy.types.Operator):
-    """Prepares the Radiance scene (runs heavy work in background thread)"""
-
-    bl_idname = "scene.prepare_radiance"
-    bl_label = "Prepare Radiance Scene"
-    bl_description = "Prepares the Radiance scene by creating necessary files and setting up the view"
-
-    _timer = None
-    _thread: Union[threading.Thread, None] = None
-    _error: Union[str, None] = None
-    _start_time: float = 0.0
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        if props.is_preparing:
-            cls.poll_message_set("Scene preparation is already in progress.")
-            return False
-        return True
-
-    def get_camera_data(self, camera):
-        position = camera.matrix_world.to_translation()
-
-        direction = camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
-        direction.normalize()
-
-        up = camera.matrix_world.to_quaternion() @ Vector((0, 1, 0))
-        up.normalize()
-
-        if abs(direction.dot(up)) > 0.99:
-            if abs(direction.dot(Vector((0, 1, 0)))) > 0.99:
-                reference = Vector((1, 0, 0))
-            else:
-                reference = Vector((0, 1, 0))
-            right = direction.cross(reference)
-            if right.length < 0.01:
-                reference = Vector((0, 0, 1))
-                right = direction.cross(reference)
-            right.normalize()
-            up = right.cross(direction)
-            up.normalize()
-
-        if up.length < 0.01:
-            up = Vector((0, 0, 1))
-        else:
-            up.normalize()
-
-        return (
-            (position.x, position.y, position.z),
-            (direction.x, direction.y, direction.z),
-            (up.x, up.y, up.z),
-        )
-
-    def execute(self, context):
-        print("Starting Radiance scene preparation...")
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-
-        obj_file_path = os.path.join(output_dir, "model.obj")
-        if not os.path.exists(obj_file_path):
-            error_msg = "OBJ file not found. Please run 'Export Geometry for Simulation' first."
-            self.report({"ERROR"}, error_msg)
-            print(f"ERROR: {error_msg}")
-            print(f"  Expected file: {obj_file_path}")
-            return {"CANCELLED"}
-
-        resolution_x, resolution_y = props.radiance_resolution_x, props.radiance_resolution_y
-
-        assert context.scene
-        context.scene.render.resolution_x = resolution_x
-        context.scene.render.resolution_y = resolution_y
-
-        aspect_ratio = resolution_x / resolution_y
-        use_hdr = props.use_hdr
-        choose_hdr_image = props.choose_hdr_image
-
-        print(f"Resolution: {resolution_x}x{resolution_y}")
-        print(f"Output directory: {output_dir}")
-        print(f"Found OBJ file: {obj_file_path} ({os.path.getsize(obj_file_path)} bytes)")
-
-        hdr_image_path = ""
-        hdr_mask_path = ""
-        sky_map_cal_path = ""
-        if use_hdr:
-            hdr_image_path = os.path.join(os.path.dirname(__file__), "HDRs", "noon_grass_2k.hdr")
-            hdr_mask_path = os.path.join(os.path.dirname(__file__), "HDRs", "noon_grass_2k_mask.hdr")
-            sky_map_cal_path = os.path.join(os.path.dirname(__file__), "HDRs", "skymap.cal")
-
-        sky_file_path = os.path.join(output_dir, "sky.rad")
-
-        print("Setting up camera...")
-        if props.use_active_camera:
-            camera = context.scene.camera
-        else:
-            camera = props.selected_camera
-
-        if camera is None:
-            self.report({"ERROR"}, "No active camera found in the scene. Please add a camera and set it as active.")
-            return {"CANCELLED"}
-
-        camera_position, camera_direction, camera_up = self.get_camera_data(camera)
-        camera_type = camera.data.type
-        camera_fov = camera.data.angle if camera_type == "PERSP" else 0.0
-        camera_ortho_scale = camera.data.ortho_scale if camera_type == "ORTHO" else 0.0
-
-        print(f"Camera position: {camera_position}")
-        print(f"Camera direction: {camera_direction}")
-        print(f"Camera up: {camera_up}")
-
-        # Collect sky generation data (must be on main thread)
-        sky_data = None
-        if props.use_sun:
-            sun_props = tool.Blender.get_solar_props()
-            sun_pos_props = tool.Blender.get_sun_props()
-            if not sun_pos_props:
-                self.report(
-                    {"ERROR"}, "Sun position addon not available. Enable 'Sun Position' addon or disable 'Use Sun'."
-                )
-                return {"CANCELLED"}
-
-            sky_data = {
-                "year": sun_props.year,
-                "month": sun_props.month,
-                "day": sun_props.day,
-                "hour": sun_props.hour,
-                "minute": sun_props.minute,
-                "latitude": sun_props.latitude,
-                "longitude": sun_props.longitude,
-                "UTC_zone": sun_props.UTC_zone,
-                "sun_year": sun_pos_props.year,
-                "sky_condition": props.sky_condition,
-                "ground_reflectance": props.ground_reflectance,
-                "turbidity": props.turbidity,
-            }
-
-        # Collect IES light data (must be on main thread)
-        ies_light_data = []
-        for idx, ies_light in enumerate(props.ies_lights):
-            if not ies_light.is_enabled or not ies_light.ies_file_path:
-                ies_light_data.append(None)
-                continue
-
-            target_empties = ies_light.get_target_empties()
-            if not target_empties:
-                ies_light_data.append(None)
-                continue
-
-            positions = []
-            for obj in target_empties:
-                try:
-                    positions.append((obj.location.x, obj.location.y, obj.location.z))
-                except ReferenceError:
-                    continue
-
-            if not positions:
-                ies_light_data.append(None)
-                continue
-
-            ies_light_data.append(
-                {
-                    "ies_file_path": ies_light.ies_file_path,
-                    "lamp_type": ies_light.lamp_type,
-                    "lamp_color": ies_light.lamp_color,
-                    "multiply_factor": ies_light.multiply_factor,
-                    "radius": ies_light.radius,
-                    "rotation_z": ies_light.rotation_z,
-                    "positions": positions,
-                    "is_enabled": ies_light.is_enabled,
-                }
-            )
-
-        # Collect material mapping data (must be on main thread)
-        material_mappings = []
-        for m in props.materials:
-            material_mappings.append(
-                {
-                    "style_id": m.style_id,
-                    "is_mapped": m.is_mapped,
-                    "category": m.category,
-                    "subcategory": m.subcategory,
-                }
-            )
-
-        linked_exports_snapshot = list(linked_model_exports)
-
-        # All Blender data collected — now launch background thread
-        props.is_preparing = True
-        self._start_time = time.time()
-        self._error = None
-
-        import bonsai.bim.module.light.shared as shared
-
-        shared.scene = None
-
-        self._thread = threading.Thread(
-            target=self._prepare_worker,
-            args=(
-                output_dir,
-                obj_file_path,
-                sky_file_path,
-                use_hdr,
-                choose_hdr_image,
-                hdr_image_path,
-                hdr_mask_path,
-                sky_map_cal_path,
-                sky_data,
-                ies_light_data,
-                material_mappings,
-                linked_exports_snapshot,
-                camera_position,
-                camera_direction,
-                camera_up,
-                camera_type,
-                camera_fov,
-                camera_ortho_scale,
-                aspect_ratio,
-            ),
-            daemon=True,
-        )
-        self._thread.start()
-
-        wm = context.window_manager
-        self._timer = wm.event_timer_add(0.5, window=context.window)
-        wm.modal_handler_add(self)
-
-        self.report({"INFO"}, "Scene preparation started in background...")
-        context.window.cursor_set("WAIT")
-        return {"RUNNING_MODAL"}
-
-    def _prepare_worker(
-        self,
-        output_dir,
-        obj_file_path,
-        sky_file_path,
-        use_hdr,
-        choose_hdr_image,
-        hdr_image_path,
-        hdr_mask_path,
-        sky_map_cal_path,
-        sky_data,
-        ies_light_data,
-        material_mappings,
-        linked_exports_snapshot,
-        camera_position,
-        camera_direction,
-        camera_up,
-        camera_type,
-        camera_fov,
-        camera_ortho_scale,
-        aspect_ratio,
-    ):
-        """Runs in a background thread — no Blender API calls allowed here."""
-        try:
-            self._do_prepare(
-                output_dir,
-                obj_file_path,
-                sky_file_path,
-                use_hdr,
-                choose_hdr_image,
-                hdr_image_path,
-                hdr_mask_path,
-                sky_map_cal_path,
-                sky_data,
-                ies_light_data,
-                material_mappings,
-                linked_exports_snapshot,
-                camera_position,
-                camera_direction,
-                camera_up,
-                camera_type,
-                camera_fov,
-                camera_ortho_scale,
-                aspect_ratio,
-            )
-        except Exception as e:
-            self._error = str(e)
-            import traceback
-
-            traceback.print_exc()
-
-    def _do_prepare(
-        self,
-        output_dir,
-        obj_file_path,
-        sky_file_path,
-        use_hdr,
-        choose_hdr_image,
-        hdr_image_path,
-        hdr_mask_path,
-        sky_map_cal_path,
-        sky_data,
-        ies_light_data,
-        material_mappings,
-        linked_exports_snapshot,
-        camera_position,
-        camera_direction,
-        camera_up,
-        camera_type,
-        camera_fov,
-        camera_ortho_scale,
-        aspect_ratio,
-    ):
-        """The actual preparation logic (no Blender API)."""
-        import bonsai.bim.module.light.shared as shared
-
-        # --- Generate sky file ---
-        if sky_data is not None:
-            dt = datetime(sky_data["year"], sky_data["month"], sky_data["day"], sky_data["hour"], sky_data["minute"])
-
-            print(f"Sun position data for Radiance gensky:")
-            print(f"  DateTime: {dt}")
-            print(f"  Latitude: {sky_data['latitude']}°")
-            print(f"  Longitude: {sky_data['longitude']}°")
-
-            sky_condition = sky_data["sky_condition"]
-            longitude_for_gensky = -sky_data["longitude"]
-            timezone_for_gensky = -int(sky_data["UTC_zone"]) * 15
-
-            sky_description = pr.gensky(
-                dt=dt,
-                latitude=sky_data["latitude"],
-                longitude=longitude_for_gensky,
-                year=sky_data["sun_year"],
-                timezone=timezone_for_gensky,
-                sunny_with_sun=sky_condition == "SUNNY_WITH_SUN",
-                sunny_without_sun=sky_condition == "SUNNY_WITHOUT_SUN",
-                cloudy=sky_condition == "CLOUDY",
-                ground_reflectance=sky_data["ground_reflectance"],
-                turbidity=sky_data["turbidity"],
-            )
-
-            sky_description_str = sky_description.decode("utf-8")
-
-            if use_hdr and choose_hdr_image == "Noon":
-                with open(sky_file_path, "w") as f:
-                    f.write(sky_description_str)
-                    f.write("\n")
-                    f.write(
-                        '''void colorpict env_map
-7 red green blue "'''
-                        + hdr_image_path
-                        + '''"  "'''
-                        + sky_map_cal_path
-                        + '''" map_u map_v
-0
-1 0.5
-
-# This is a multiplier to colour balance the env map
-# In this case, it provides a rough ground luminance from 3k-5k
-env_map colorfunc env_colour
-4 100 100 100 .
-0
-0
-
-# .37 .57 1.5 is measured from a HDRI image
-# It is multiplied by a factor such that grey(r,g,b) = 1
-skyfunc colorfunc sky_colour
-4 .64 .99 2.6 .
-0
-0
-
-void mixpict composite
-7 env_colour sky_colour grey "'''
-                        + hdr_mask_path
-                        + '''"  "'''
-                        + sky_map_cal_path
-                        + """" map_u map_v
-0
-2 0.5 1
-
-composite glow env_map_glow
-0
-0
-4 1 1 1 0
-
-env_map_glow source sky
-0
-0
-4 0 0 1 180
-
-env_colour glow ground_glow
-0
-0
-4 1 1 1 0
-
-ground_glow source ground
-0
-0
-4 0 0 -1 180"""
-                    )
-            elif not use_hdr:
-                with open(sky_file_path, "w") as f:
-                    f.write(sky_description_str)
-                    f.write("\n")
-                    f.write("skyfunc glow sky_glow\n0\n0\n4 .9 .9 1.15 0\n")
-                    f.write("sky_glow source sky\n0\n0\n4 0 0 1 180\n")
-                    f.write("skyfunc glow ground_glow\n0\n0\n4 1.4 .9 .6 0\n")
-                    f.write("ground_glow source ground\n0\n0\n4 0 0 -1 180\n")
-        else:
-            print("Skipping sky generation (use_sun is False)...")
-
-        # --- Write materials.rad ---
-        materials_file = os.path.join(output_dir, "materials.rad")
-        written_materials = set()
-
-        all_materials = set(ifc_materials)
-
-        with open(materials_file, "w") as file:
-            default_materials = [
-                "void plastic white\n0\n0\n5 0.8 0.8 0.8 0 0\n",
-            ]
-            for material in default_materials:
-                file.write(material)
-                written_materials.add(material.split()[2])
-
-            for style_id in all_materials:
-                mat_data = next((m for m in material_mappings if m["style_id"] == style_id), None)
-                if mat_data and mat_data["is_mapped"]:
-                    category, subcategory = mat_data["category"], mat_data["subcategory"]
-                    if category in spectraldb and subcategory in spectraldb[category]:
-                        material_def = spectraldb[category][subcategory]
-                        material_name = material_def.split()[2]
-                        if material_name not in written_materials:
-                            file.write(material_def + "\n")
-                            written_materials.add(material_name)
-                        file.write(f"inherit alias {style_id} {material_name}\n")
-                    else:
-                        file.write(f"inherit alias {style_id} white\n")
-                else:
-                    file.write(f"inherit alias {style_id} white\n")
-
-        print(f"Exported Materials Rad file to: {materials_file}")
-
-        # --- Convert IES light files ---
-        print("Processing IES light files...")
-        converted_ies_lights = {}
-        for idx, ies_data in enumerate(ies_light_data):
-            if ies_data is None:
-                continue
-            try:
-                rad_file, dat_file = convert_ies_to_radiance(
-                    ies_data["ies_file_path"],
-                    output_dir,
-                    lamp_type=ies_data["lamp_type"],
-                    lamp_color=ies_data["lamp_color"],
-                    multiply_factor=ies_data["multiply_factor"],
-                    radius=ies_data["radius"],
-                )
-                converted_ies_lights[idx] = (rad_file, dat_file)
-                print(f"  Converted IES light {idx}: {Path(ies_data['ies_file_path']).name}")
-            except Exception as e:
-                print(f"  ERROR converting IES light {idx}: {str(e)}")
-
-        # --- Convert OBJ to RTM ---
-        print(f"OBJ file size: {os.path.getsize(obj_file_path)} bytes")
-        print(f"Materials file size: {os.path.getsize(materials_file)} bytes")
-        print(f"Converting OBJ to RTM format...")
-
-        rtm_file_path = os.path.join(output_dir, "model.rtm")
-        mesh_file_path = save_obj2mesh_output(obj_file_path, rtm_file_path, matfiles=[materials_file])
-        print(f"obj2mesh output: {mesh_file_path}")
-
-        # Convert linked model OBJs to RTM
-        linked_rtm_files = []
-        for link_idx, (link_obj_path, link_mtl_path, link_matrix) in enumerate(linked_exports_snapshot):
-            if not os.path.exists(link_obj_path):
-                print(f"Linked model OBJ not found: {link_obj_path}")
-                continue
-            link_rtm_path = os.path.join(output_dir, f"linked_{link_idx}.rtm")
-            try:
-                save_obj2mesh_output(link_obj_path, link_rtm_path, matfiles=[materials_file])
-                linked_rtm_files.append((link_rtm_path, link_matrix))
-                print(f"Converted linked model {link_idx} to RTM")
-            except Exception as e:
-                print(f"Failed to convert linked model {link_idx} to RTM: {e}")
-
-        # --- Write scene.rad ---
-        scene_file = os.path.join(output_dir, "scene.rad")
-        with open(scene_file, "w") as file:
-            file.write('void mesh model\n1 "' + rtm_file_path + '"\n0\n0\n')
-            file.write("\n")
-
-            if linked_rtm_files:
-                file.write("\n# Linked Models\n")
-                for link_idx, (link_rtm_path, link_matrix) in enumerate(linked_rtm_files):
-                    is_identity = all(
-                        abs(link_matrix[i][j] - (1.0 if i == j else 0.0)) < 1e-6 for i in range(4) for j in range(4)
-                    )
-
-                    if is_identity:
-                        file.write(f'void mesh linked_{link_idx}\n1 "{link_rtm_path}"\n0\n0\n\n')
-                        print(f"Added linked model {link_idx} to scene (identity, inline mesh)")
-                    else:
-                        link_rad_path = os.path.join(output_dir, f"linked_{link_idx}.rad")
-                        with open(link_rad_path, "w") as link_file:
-                            link_file.write(f'void mesh linked_{link_idx}\n1 "{link_rtm_path}"\n0\n0\n')
-
-                        xform_args = _matrix_to_xform_args(link_matrix)
-                        file.write(f'!xform {xform_args} "{link_rad_path}"\n')
-                        print(f"Added linked model {link_idx} to scene with xform: {xform_args}")
-
-            # IES light fixtures
-            if ies_light_data:
-                file.write("\n# IES Light Fixtures\n")
-                for idx, ies_data in enumerate(ies_light_data):
-                    if ies_data is None:
-                        continue
-                    z_rot = math.degrees(ies_data["rotation_z"])
-
-                    for pos in ies_data["positions"]:
-                        if idx in converted_ies_lights:
-                            rad_path = converted_ies_lights[idx][0]
-                            rad_filename = Path(rad_path).name
-                            file.write(f'!xform -rz {z_rot} -t {pos[0]} {pos[1]} {pos[2]} "{rad_filename}"\n')
-                        else:
-                            rad_base = Path(ies_data["ies_file_path"]).stem
-                            rad_filename = f"{rad_base}.rad"
-                            file.write(f'# !xform -rz {z_rot} -t {pos[0]} {pos[1]} {pos[2]} "{rad_filename}"\n')
-
-        print(f"Exported Scene file to: {scene_file}")
-
-        # --- Validate light sources ---
-        has_sky = sky_data is not None
-        has_ies_lights = len(converted_ies_lights) > 0
-
-        if not has_sky and not has_ies_lights:
-            raise RuntimeError("No light sources available. Please enable 'Use Sun' or add and map IES light fixtures.")
-
-        # --- Build pr.Scene ---
-        print("Setting up Radiance scene...")
-        new_scene = pr.Scene("ascene")
-
-        material_path = os.path.join(output_dir, "materials.rad")
-        scene_path = os.path.join(output_dir, "scene.rad")
-
-        new_scene.add_material(material_path)
-        new_scene.add_surface(scene_path)
-
-        if has_sky:
-            new_scene.add_source(sky_file_path)
-            print(f"Added sky light source")
-
-        if has_ies_lights:
-            print(f"Added {len(converted_ies_lights)} IES light source(s)")
-
-        print("Setting up view...")
-        if camera_type == "PERSP":
-            vertical_fov = 2 * math.atan(math.tan(camera_fov / 2) / aspect_ratio)
-            aview = pr.create_default_view()
-            aview.type = "v"
-            aview.vp = camera_position
-            aview.vdir = camera_direction
-            aview.vu = camera_up
-            aview.horiz = math.degrees(camera_fov)
-            aview.vert = math.degrees(vertical_fov)
-        else:
-            view_width = camera_ortho_scale
-            view_height = camera_ortho_scale / aspect_ratio
-            aview = pr.create_default_view()
-            aview.type = "l"
-            aview.vp = camera_position
-            aview.vdir = camera_direction
-            aview.vu = camera_up
-            aview.horiz = view_width
-            aview.vert = view_height
-
-        new_scene.add_view(aview)
-
-        # Set the global scene reference (thread-safe assignment)
-        shared.scene = new_scene
-        print("Scene preparation complete.")
-
-    def modal(self, context, event):
-        if event.type == "TIMER":
-            if self._thread is not None and self._thread.is_alive():
-                return {"RUNNING_MODAL"}
-
-            # Thread finished — clean up
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_preparing = False
-            context.window.cursor_set("DEFAULT")
-
-            if self._error:
-                self.report({"ERROR"}, f"Scene preparation failed: {self._error}")
-                return {"CANCELLED"}
-
-            elapsed = time.time() - self._start_time
-            self.report({"INFO"}, f"Radiance scene prepared successfully in {elapsed:.1f}s")
-            print(f"Scene preparation completed in {elapsed:.2f} seconds")
-            return {"FINISHED"}
-
-        elif event.type == "ESC":
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_preparing = False
-            context.window.cursor_set("DEFAULT")
-            self.report({"WARNING"}, "Scene preparation cannot be cancelled mid-operation")
-            return {"RUNNING_MODAL"}
-
-        return {"PASS_THROUGH"}
-
-    def _cleanup_timer(self, context):
-        if self._timer is not None:
-            context.window_manager.event_timer_remove(self._timer)
-            self._timer = None

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

@@ -16,7 +16,6 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
-import calendar
 import datetime
 import json
 import os
@@ -44,6 +43,7 @@ from bonsai.bim.module.light.data import SolarData
 from bonsai.bim.module.light.decorator import SolarDecorator
 
 sun_position = tool.Blender.get_addon("sun_position")
+now = datetime.datetime.now()
 
 with open(os.path.join(os.path.dirname(__file__), "spectraldb.json"), "r") as f:
     spectraldb: dict[str, dict[str, str]] = json.load(f)
@@ -72,8 +72,8 @@ def update_coordinates(self: "BIMSolarProperties", context: bpy.types.Context) -
 def update_latlong(self: "BIMSolarProperties", context: bpy.types.Context) -> None:
     sun_props = tool.Blender.get_sun_props()
     assert sun_props
-    sun_props.longitude = self.longitude
-    sun_props.latitude = self.latitude
+    sun_props.longitude = sun_props.longitude
+    sun_props.latitude = sun_props.latitude
     self["coordinates"] = sun_props.coordinates
     update_sun_path(self)
 
@@ -135,14 +135,6 @@ def update_resolution(self: "RadianceExporterProperties", context: bpy.types.Con
     context.scene.render.resolution_y = self.radiance_resolution_y
 
 
-def update_day(self: "BIMSolarProperties", context: bpy.types.Context) -> None:
-    """Clamp the day to the valid range for the current month/year."""
-    max_day = calendar.monthrange(self.year, self.month)[1]
-    if self.day > max_day:
-        self["day"] = max_day
-    update_sun_path(self)
-
-
 def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context, None] = None) -> None:
     if not SolarData.is_loaded:
         SolarData.load()
@@ -160,13 +152,9 @@ def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context
     sun_props.sun_distance = self.sun_path_size
     sun_props.latitude = self.latitude
     sun_props.longitude = self.longitude
-    # Clamp day to valid range for the current month/year
-    max_day = calendar.monthrange(self.year, self.month)[1]
-    day = min(self.day, max_day)
-
     sun_props.year = self.year
     sun_props.month = self.month
-    sun_props.day = day
+    sun_props.day = self.day
     sun_props.time = self.hour + (self.minute / 60)
     # Preserve IFC sign convention
     sun_props.north_offset = self.true_north * -1
@@ -193,11 +181,8 @@ def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context
     )
     sun_vector = sun_position.sun_calc.get_sun_vector(azimuth, elevation) * sun_props.sun_distance
     props.sun_position = sun_vector
-
-    # Update Blender viewport light direction for shadow visualization
-    # This coordinate transformation converts from sun_position addon's coordinate system
-    # to Blender's display.light_direction coordinate system
-    # Note: This only affects viewport shading, not the Radiance rendering
+    # sun_vector.z = max(0, sun_vector.z)
+    # Light direction is a bit weird?
     mat = Matrix(((-1.0, 0.0, 0.0, 0.0), (0.0, 0, 1.0, 0.0), (-0.0, -1.0, 0, 0.0), (0.0, 0.0, 0.0, 1.0))).inverted()
     rotation_euler = Euler((elevation - pi / 2, 0, -azimuth))
     rotation_quaternion = rotation_euler.to_quaternion()
@@ -208,9 +193,6 @@ def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context
 
     assert bpy.context.scene
     assert bpy.context.scene.display
-    # Set viewport light direction based on sun position
-    # If sun is below horizon (z < 0), use default upward direction
-    # Otherwise, use calculated direction from sun position
     if sun_vector.z < 0:
         bpy.context.scene.display.light_direction = mat @ Vector((0, 0, 1))
     else:
@@ -241,106 +223,6 @@ class RadianceMaterial(PropertyGroup):
         color: tuple[float, float, float]
 
 
-class IESLight(PropertyGroup):
-    """Represents a mapping between an IES light file and scene Empty objects.
-
-    Supports two targeting modes:
-    - Object mode: target a single Empty object
-    - Collection mode: target all Empty objects in a collection
-    """
-
-    ies_file_path: StringProperty(
-        name="IES File Path",
-        description="Path to the IES luminaire data file",
-        subtype="FILE_PATH",
-        default="",
-    )
-    use_collection: BoolProperty(
-        name="Use Collection",
-        description="Apply this light to all Empty objects in a collection instead of a single object",
-        default=False,
-    )
-    target_object: PointerProperty(
-        type=bpy.types.Object,
-        name="Target Object",
-        description="Empty object where the light fixture will be placed",
-        poll=lambda self, obj: obj.type == "EMPTY",
-    )
-    target_collection: PointerProperty(
-        type=bpy.types.Collection,
-        name="Target Collection",
-        description="Collection of Empty objects where the light fixture will be placed",
-    )
-    rotation_z: FloatProperty(
-        name="Rotation Z",
-        description="Rotation around Z-axis in degrees (-180 to 180)",
-        min=-180.0,
-        max=180.0,
-        default=0.0,
-        subtype="ANGLE",
-    )
-    is_enabled: BoolProperty(
-        name="Enabled",
-        description="Include this light in the Radiance export",
-        default=True,
-    )
-
-    # Additional lamp properties for customization
-    lamp_type: StringProperty(
-        name="Lamp Type",
-        description="Type of lamp (e.g., 'LED', 'metal halide', 'fluorescent')",
-        default="",
-    )
-    lamp_color: FloatVectorProperty(
-        name="Lamp Color",
-        description="Lamp color (RGB) for custom color adjustments",
-        subtype="COLOR",
-        default=(1.0, 1.0, 1.0),
-        min=0.0,
-        max=1.0,
-        size=3,
-    )
-    multiply_factor: FloatProperty(
-        name="Brightness Factor",
-        description="Multiply all output quantities by this factor (0.1 to 10.0)",
-        min=0.1,
-        max=10.0,
-        default=1.0,
-    )
-    radius: FloatProperty(
-        name="Illum Sphere Radius",
-        description="Radius of illum sphere (ignores geometry from IES file). 0 = use IES geometry",
-        min=0.0,
-        max=10.0,
-        default=0.0,
-    )
-
-    def get_target_empties(self) -> list[bpy.types.Object]:
-        """Return all Empty objects this light targets."""
-        if self.use_collection and self.target_collection is not None:
-            return [obj for obj in self.target_collection.all_objects if obj.type == "EMPTY" and not obj.hide_get()]
-        elif not self.use_collection and self.target_object is not None:
-            try:
-                _ = self.target_object.name
-                if not self.target_object.hide_get():
-                    return [self.target_object]
-            except ReferenceError:
-                pass
-        return []
-
-    if TYPE_CHECKING:
-        ies_file_path: str
-        use_collection: bool
-        target_object: Union[bpy.types.Object, None]
-        target_collection: Union[bpy.types.Collection, None]
-        rotation_z: float
-        is_enabled: bool
-        lamp_type: str
-        lamp_color: tuple[float, float, float]
-        multiply_factor: float
-        radius: float
-
-
 class RadianceExporterProperties(PropertyGroup):
 
     def update_output_dir(self, context) -> None:
@@ -351,9 +233,6 @@ class RadianceExporterProperties(PropertyGroup):
         if self.ifc_file:
             self.ifc_file = bpy.path.abspath(self.ifc_file)
 
-    def get_categories(self, context):
-        return sorted([(k, k, "") for k in spectraldb.keys()])
-
     def add_material_mapping(self, style_id: str, style_name: str) -> RadianceMaterial:
         item = self.materials.add()
         item.name = style_name
@@ -368,10 +247,7 @@ class RadianceExporterProperties(PropertyGroup):
             mappings = json.load(f)
 
         for style_id, mapping in mappings.items():
-            # Try matching by style_id first, fall back to name
-            material = self.get_material_mapping_by_id(style_id)
-            if material is None:
-                material = self.get_material_mapping(mapping["name"])
+            material = self.get_material_mapping(mapping["name"])
             if material:
                 material.style_id = style_id
                 material.category = mapping["category"]
@@ -383,14 +259,11 @@ class RadianceExporterProperties(PropertyGroup):
                 new_material.subcategory = mapping["subcategory"]
                 new_material.is_mapped = True
 
-    def get_material_mapping_by_id(self, style_id: str) -> Union[RadianceMaterial, None]:
-        return next((item for item in self.materials if item.style_id == style_id), None)
-
     def get_material_mapping(self, style_name: str) -> Union[RadianceMaterial, None]:
         return next((item for item in self.materials if item.name == style_name), None)
 
     def set_material_mapping(self, style_id: str, style_name: str, category: str, subcategory: str) -> None:
-        item = self.get_material_mapping_by_id(style_id) or self.get_material_mapping(style_name)
+        item = self.get_material_mapping(style_name)
         if item:
             item.category = category
             item.subcategory = subcategory
@@ -406,12 +279,8 @@ class RadianceExporterProperties(PropertyGroup):
             if item.category and item.subcategory
         }
 
-    def unmap_material(self, style_name: str, style_id: str = "") -> None:
-        item = None
-        if style_id:
-            item = self.get_material_mapping_by_id(style_id)
-        if item is None:
-            item = self.get_material_mapping(style_name)
+    def unmap_material(self, style_name: str) -> None:
+        item = self.get_material_mapping(style_name)
         if item:
             item.category = ""
             item.subcategory = ""
@@ -421,14 +290,6 @@ class RadianceExporterProperties(PropertyGroup):
         name="Is Exporting", description="Whether the OBJ export is in progress", default=False
     )
 
-    is_preparing: bpy.props.BoolProperty(
-        name="Is Preparing", description="Whether scene preparation is in progress", default=False
-    )
-
-    is_rendering: bpy.props.BoolProperty(
-        name="Is Rendering", description="Whether a Radiance render is in progress", default=False
-    )
-
     categories = [
         ("Wall", "Wall", ""),
         ("Floor", "Floor", ""),
@@ -455,13 +316,16 @@ class RadianceExporterProperties(PropertyGroup):
             print(f"Material '{active_material.name}' mapped to {self.category} - {self.subcategory}")
 
     category: bpy.props.EnumProperty(
-        items=get_categories, name="Category", description="Material category", update=update_material_mapping
+        items=categories, name="Category", description="Material category", update=update_material_mapping
     )
 
     def get_subcategories(self, context: bpy.types.Context) -> tool.Blender.BLENDER_ENUM_ITEMS:
+        global SUBCATEGORIES_ENUM_ITEMS  # ty: ignore[unresolved-global]
         if self.category in spectraldb:
-            return sorted([(k, k, "") for k in spectraldb[self.category].keys()])
-        return []
+            SUBCATEGORIES_ENUM_ITEMS = [(k, k, "") for k in spectraldb[self.category].keys()]
+        else:
+            SUBCATEGORIES_ENUM_ITEMS = []
+        return SUBCATEGORIES_ENUM_ITEMS
 
     subcategory: bpy.props.EnumProperty(
         items=get_subcategories, name="Subcategory", description="Material subcategory", update=update_material_mapping
@@ -470,9 +334,12 @@ class RadianceExporterProperties(PropertyGroup):
     materials: CollectionProperty(type=RadianceMaterial)
     active_material_index: IntProperty()
 
+    # material_mappings: bpy.props.CollectionProperty(type=bpy.types.PropertyGroup, name="Material Mappings")
+    # material_mappings: CollectionProperty(type=MaterialMapping)
+
     should_load_from_memory: BoolProperty(
         name="Load from Memory",
-        default=True,
+        default=False,
     )
 
     radiance_resolution_x: IntProperty(
@@ -481,13 +348,6 @@ class RadianceExporterProperties(PropertyGroup):
     radiance_resolution_y: IntProperty(
         name="Y", description="Vertical resolution of the output image", default=1080, min=1, update=update_resolution
     )
-    radiance_bin_dir: StringProperty(
-        name="Radiance Bin",
-        description="Path to the Radiance bin folder (containing falsecolor, pcomb, etc.)",
-        default="",
-        subtype="DIR_PATH",
-    )
-
     output_dir: StringProperty(
         name="Output Directory",
         description="Directory to output Radiance files",
@@ -503,15 +363,6 @@ class RadianceExporterProperties(PropertyGroup):
         update=lambda self, context: self.update_ifc_file(context),
     )
 
-    ambient_bounces: IntProperty(
-        name="Ambient Bounces",
-        description="Number of indirect light bounces. Higher = more light fills dark areas but slower. "
-        "1 is minimal, 2-3 recommended for IES-only scenes, 4+ for complex interiors",
-        min=0,
-        max=8,
-        default=2,
-    )
-
     radiance_quality: EnumProperty(
         name="Quality",
         description="Radiance rendering quality",
@@ -542,15 +393,14 @@ class RadianceExporterProperties(PropertyGroup):
         name="Output File Format",
         description="Format of the output image file",
         items=[
-            ("HDR", "HDR", "High Dynamic Range (HDR) file only"),
-            ("HDR_TIFF", "HDR + Tiff", "High Dynamic Range (HDR) and Tiff files"),
+            ("HDR", "HDR + Tiff", "High Dynamic Range"),
         ],
-        default="HDR_TIFF",
+        default="HDR",
     )
 
     use_hdr: BoolProperty(
-        name="HDR Environment Map",
-        description="Use an HDR image as the sky dome for realistic environment lighting and reflections",
+        name="Use HDR",
+        description="Use HDR image format",
         default=True,
     )
 
@@ -563,40 +413,6 @@ class RadianceExporterProperties(PropertyGroup):
         default="Noon",
     )
 
-    use_sun: BoolProperty(
-        name="Use Sun",
-        description="Use sun position data to generate sky. If disabled, generates a default sky without sun",
-        default=True,
-    )
-
-    # Sky generation parameters
-    sky_condition: EnumProperty(
-        name="Sky Condition",
-        description="Type of sky condition to generate",
-        items=[
-            ("SUNNY_WITH_SUN", "Sunny with Sun", "Clear sky with direct sun"),
-            ("SUNNY_WITHOUT_SUN", "Sunny without Sun", "Clear sky without direct sun"),
-            ("CLOUDY", "Cloudy", "Overcast sky condition"),
-        ],
-        default="SUNNY_WITH_SUN",
-    )
-
-    ground_reflectance: FloatProperty(
-        name="Ground Reflectance",
-        description="Ground reflectance value (0.0 to 1.0)",
-        min=0.0,
-        max=1.0,
-        default=0.2,
-    )
-
-    turbidity: FloatProperty(
-        name="Turbidity",
-        description="Atmospheric turbidity (1.0 to 10.0). Lower values = clearer sky",
-        min=1.0,
-        max=10.0,
-        default=3.0,
-    )
-
     use_active_camera: BoolProperty(
         name="Use Active Camera", description="Use the active camera in the scene", default=True
     )
@@ -608,90 +424,8 @@ class RadianceExporterProperties(PropertyGroup):
         poll=lambda self, object: object.type == "CAMERA",
     )
 
-    ies_lights: CollectionProperty(
-        type=IESLight,
-        name="IES Lights",
-        description="Collection of IES light fixtures mapped to scene objects",
-    )
-    active_ies_light_index: IntProperty(
-        name="Active IES Light Index",
-        description="Index of the active IES light in the collection",
-        default=-1,
-    )
-
-    # False color analysis properties
-    use_false_color: BoolProperty(
-        name="Generate False Color Image",
-        description="Generate a false color HDR image for illuminance analysis",
-        default=False,
-    )
-
-    false_color_label: EnumProperty(
-        name="Legend Label Unit",
-        description="Unit for the false color legend",
-        items=[
-            ("fc", "Foot-Candles", "US lighting standard unit"),
-            ("lux", "Lux", "International lighting standard unit"),
-            ("cd/m2", "Candela per m²", "Luminance unit"),
-        ],
-        default="fc",
-    )
-
-    false_color_scale: FloatProperty(
-        name="Scale Factor",
-        description="Maximum scale value for the false color legend",
-        min=0.1,
-        max=100000.0,
-        default=3.0,
-    )
-
-    false_color_steps: IntProperty(
-        name="Legend Steps",
-        description="Number of divisions on the legend. Contour increment = Scale / Steps. "
-        "E.g. Scale=20, Steps=10 → contours at 2, 4, 6, 8...",
-        min=2,
-        max=50,
-        default=10,
-    )
-
-    false_color_contour_lines: BoolProperty(
-        name="Enable Contour Lines",
-        description="Add contour lines to the false color image",
-        default=True,
-    )
-
-    false_color_contour_mode: EnumProperty(
-        name="Contour Mode",
-        description="Contour line display mode",
-        items=[
-            (
-                "WITH_BG",
-                "Contour Lines with Background",
-                "Show contour lines overlaid on the colored false color background",
-            ),
-            ("WITHOUT_BG", "Contour Lines Only", "Show only contour lines without the false color background"),
-        ],
-        default="WITH_BG",
-    )
-
-    false_color_multiplier: FloatProperty(
-        name="Multiplier",
-        description="Conversion multiplier (179.0 for lux, 16.6295 for foot-candles)",
-        min=0.1,
-        max=1000.0,
-        default=16.629505759940542,
-    )
-
-    false_color_output_name: StringProperty(
-        name="False Color Output Name",
-        description="Name of the false color output file (without extension)",
-        default="false_color",
-    )
-
     if TYPE_CHECKING:
         is_exporting: bool
-        is_preparing: bool
-        is_rendering: bool
         category: str
         subcategory: str
         materials: bpy.types.bpy_prop_collection_idprop[RadianceMaterial]
@@ -699,10 +433,8 @@ class RadianceExporterProperties(PropertyGroup):
         should_load_from_memory: bool
         radiance_resolution_x: int
         radiance_resolution_y: int
-        radiance_bin_dir: str
         output_dir: str
         ifc_file: str
-        ambient_bounces: int
         radiance_quality: Literal["LOW", "MEDIUM", "HIGH"]
         radiance_detail: Literal["LOW", "MEDIUM", "HIGH"]
         radiance_variability: Literal["LOW", "MEDIUM", "HIGH"]
@@ -710,22 +442,8 @@ class RadianceExporterProperties(PropertyGroup):
         output_file_format: Literal["HDR"]
         use_hdr: bool
         choose_hdr_image: Literal["Noon"]
-        use_sun: bool
-        sky_condition: Literal["SUNNY_WITH_SUN", "SUNNY_WITHOUT_SUN", "CLOUDY"]
-        ground_reflectance: float
-        turbidity: float
         use_active_camera: bool
         selected_camera: Union[bpy.types.Object, None]
-        ies_lights: bpy.types.bpy_prop_collection_idprop[IESLight]
-        active_ies_light_index: int
-        use_false_color: bool
-        false_color_label: Literal["fc", "lux", "cd/m2"]
-        false_color_scale: float
-        false_color_steps: int
-        false_color_contour_lines: bool
-        false_color_contour_mode: Literal["WITH_BG", "WITHOUT_BG"]
-        false_color_multiplier: float
-        false_color_output_name: str
 
 
 class BIMSolarProperties(PropertyGroup):
@@ -752,12 +470,11 @@ class BIMSolarProperties(PropertyGroup):
     )
     timezone: StringProperty(name="Timezone", default="Etc/GMT")
     true_north: FloatProperty(name="True North", min=-pi, max=pi, subtype="ANGLE", update=update_sun_path)
-    # Defaults are static; use the "Now" button (LightSetTimeToNow) to set current time.
-    year: IntProperty(name="Year", min=1, max=9999, default=2025, update=update_day)
-    month: IntProperty(name="Month", min=1, max=12, default=1, update=update_day)
-    day: IntProperty(name="Date", min=1, max=31, default=1, update=update_day)
-    hour: IntProperty(name="Hour", min=0, max=23, default=12, update=update_sun_path)
-    minute: IntProperty(name="Minute", min=0, max=59, default=0, update=update_sun_path)
+    year: IntProperty(name="Year", min=1, max=9999, default=now.year, update=update_sun_path)
+    month: IntProperty(name="Month", min=1, max=12, default=now.month, update=update_sun_path)
+    day: IntProperty(name="Date", min=1, max=31, default=now.day, update=update_sun_path)
+    hour: IntProperty(name="Hour", min=0, max=23, default=now.hour, update=update_sun_path)
+    minute: IntProperty(name="Minute", min=0, max=59, default=now.minute, update=update_sun_path)
     sun_position: FloatVectorProperty(name="Sun Position", subtype="XYZ", default=(0, 0, 0))
     sun_path_origin: FloatVectorProperty(name="Sun Path Origin", subtype="XYZ", default=(0, 0, 0))
     sun_path_size: FloatProperty(name="Sun Path Size", min=0.1, default=50, update=update_sun_path)

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

@@ -1,328 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 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/>.
-
-import multiprocessing
-import os
-import subprocess
-import threading
-import time
-from pathlib import Path
-from typing import Union
-
-import bpy
-import pyradiance as pr
-
-import bonsai.bim.module.light.shared as shared
-import bonsai.tool as tool
-
-# pyradiance's bundled Radiance binaries
-_PYRAD_BIN = Path(pr.__file__).parent / "bin"
-
-
-class RadianceRender(bpy.types.Operator):
-    """Radiance Rendering (runs in background thread)"""
-
-    bl_idname = "render_scene.radiance"
-    bl_label = "Render"
-    bl_description = "Renders the scene using Radiance"
-
-    _timer = None
-    _thread: Union[threading.Thread, None] = None
-    _result_image: Union[bytes, None] = None
-    _error: Union[str, None] = None
-    _start_time: float = 0.0
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        if props.is_rendering:
-            cls.poll_message_set("A render is already in progress.")
-            return False
-        if shared.scene is None:
-            cls.poll_message_set("Radiance scene not prepared. Please run 'Prepare Scene' (Step 2) first.")
-            return False
-        return True
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        resolution_x, resolution_y = props.radiance_resolution_x, props.radiance_resolution_y
-
-        context.scene.render.resolution_x = resolution_x
-        context.scene.render.resolution_y = resolution_y
-
-        quality = props.radiance_quality.upper()
-        detail = props.radiance_detail.upper()
-        variability = props.radiance_variability.upper()
-        ambient_bounces = props.ambient_bounces
-        output_dir = props.output_dir
-
-        props.is_rendering = True
-        self._start_time = time.time()
-        self._result_image = None
-        self._error = None
-
-        self._thread = threading.Thread(
-            target=self._render_worker,
-            args=(shared.scene, output_dir, resolution_x, resolution_y, quality, detail, variability, ambient_bounces),
-            daemon=True,
-        )
-        self._thread.start()
-
-        wm = context.window_manager
-        self._timer = wm.event_timer_add(0.5, window=context.window)
-        wm.modal_handler_add(self)
-
-        self.report({"INFO"}, "Radiance render started in background...")
-        context.window.cursor_set("WAIT")
-        return {"RUNNING_MODAL"}
-
-    def _render_worker(self, render_scene, output_dir, res_x, res_y, quality, detail, variability, ambient_bounces):
-        """Runs in a background thread — no Blender API calls allowed here."""
-        cwd_saved = os.getcwd()
-        try:
-            os.chdir(output_dir)
-            self._result_image = pr.render(
-                render_scene,
-                ambbounce=ambient_bounces,
-                resolution=(res_x, res_y),
-                quality=quality,
-                detail=detail,
-                variability=variability,
-                nproc=multiprocessing.cpu_count(),
-            )
-        except Exception as e:
-            self._error = str(e)
-        finally:
-            os.chdir(cwd_saved)
-
-    def modal(self, context, event):
-        if event.type == "TIMER":
-            if self._thread is not None and self._thread.is_alive():
-                return {"RUNNING_MODAL"}
-
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_rendering = False
-            context.window.cursor_set("DEFAULT")
-
-            if self._error:
-                self.report({"ERROR"}, f"Radiance render failed: {self._error}")
-                return {"CANCELLED"}
-
-            elapsed = time.time() - self._start_time
-            print(f"Render completed in {elapsed:.2f} seconds")
-
-            output_dir = props.output_dir
-            output_file_name = props.output_file_name
-            output_file_format = props.output_file_format
-
-            output_hdr_path = os.path.join(output_dir, f"{output_file_name}.hdr")
-            print(f"Saving HDR output to: {output_hdr_path}")
-            with open(output_hdr_path, "wb") as wtr:
-                wtr.write(self._result_image)
-
-            if output_file_format == "HDR_TIFF":
-                print("Applying tone mapping...")
-                pcond_image = pr.pcond(hdr=output_hdr_path, human=True)
-                tiff_path = os.path.join(output_dir, f"{output_file_name}.tiff")
-                print(f"Saving TIFF output to: {tiff_path}")
-                pr.ra_tiff(inp=pcond_image, out=tiff_path, lzw=True)
-
-            print("Radiance rendering process completed successfully.")
-            self.report({"INFO"}, f"Radiance rendering completed. HDR Output: {output_hdr_path}")
-            if output_file_format == "HDR_TIFF":
-                self.report({"INFO"}, f"TIFF Output: {tiff_path}")
-
-            for area in context.screen.areas:
-                area.tag_redraw()
-
-            return {"FINISHED"}
-
-        elif event.type == "ESC":
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_rendering = False
-            context.window.cursor_set("DEFAULT")
-            self.report({"WARNING"}, "Render cancelled by user. Background process may still be running.")
-            return {"CANCELLED"}
-
-        return {"PASS_THROUGH"}
-
-    def _cleanup_timer(self, context):
-        if self._timer is not None:
-            context.window_manager.event_timer_remove(self._timer)
-            self._timer = None
-
-
-class FalseColorRadiance(bpy.types.Operator):
-    """Generate false color HDR image for illuminance analysis"""
-
-    bl_idname = "render_scene.false_color_radiance"
-    bl_label = "Generate False Color Image"
-    bl_description = "Generate a false color HDR image for illuminance analysis"
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        return True
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-        output_file_name = props.output_file_name
-
-        hdr_path = os.path.join(output_dir, f"{output_file_name}.hdr")
-        if not os.path.exists(hdr_path):
-            self.report(
-                {"ERROR"},
-                f"HDR file not found at: {hdr_path}. Please run 'Radiance Render' first.",
-            )
-            return {"CANCELLED"}
-
-        fc_scale = (
-            str(int(props.false_color_scale))
-            if props.false_color_scale == int(props.false_color_scale)
-            else str(props.false_color_scale)
-        )
-
-        # Multiplier converts Radiance raw values to display units
-        # fc (foot-candles) = 16.629..., lux & cd/m2 = 179.0
-        multiplier = 179.0 if props.false_color_label in ("lux", "cd/m2") else 16.629505759940542
-
-        print(
-            f"False color parameters: label={props.false_color_label}, scale={fc_scale}, "
-            f"steps={props.false_color_steps}, multiplier={multiplier}, "
-            f"contour={props.false_color_contour_lines}"
-        )
-
-        try:
-            fc_output_name = props.false_color_output_name
-            fc_hdr_path = os.path.join(output_dir, f"{fc_output_name}.hdr")
-
-            # Find falsecolor binary from user-specified Radiance bin directory
-            radiance_bin_dir = os.path.normpath(props.radiance_bin_dir) if props.radiance_bin_dir else ""
-            if radiance_bin_dir:
-                falsecolor_bin = os.path.join(radiance_bin_dir, "falsecolor.exe")
-                if not os.path.exists(falsecolor_bin):
-                    falsecolor_bin = os.path.join(radiance_bin_dir, "falsecolor")
-                if not os.path.exists(falsecolor_bin):
-                    self.report({"ERROR"}, f"falsecolor not found in: {radiance_bin_dir}")
-                    return {"CANCELLED"}
-            else:
-                import shutil
-
-                falsecolor_bin = shutil.which("falsecolor") or shutil.which("falsecolor.exe")
-                if not falsecolor_bin:
-                    self.report(
-                        {"ERROR"}, "Set the Radiance Bin path in False Color settings, or add Radiance to system PATH."
-                    )
-                    return {"CANCELLED"}
-                radiance_bin_dir = os.path.dirname(falsecolor_bin)
-
-            radiance_lib = os.path.join(os.path.dirname(radiance_bin_dir), "lib")
-            print(f"Using falsecolor: {falsecolor_bin}")
-            print(f"Radiance bin: {radiance_bin_dir}, lib: {radiance_lib}")
-
-            cmd = [falsecolor_bin]
-            cmd.extend(["-m", str(multiplier)])
-            cmd.extend(["-s", fc_scale])
-            cmd.extend(["-n", str(props.false_color_steps)])
-            cmd.extend(["-l", props.false_color_label])
-
-            if props.false_color_contour_lines:
-                cmd.append("-cl")
-                if props.false_color_contour_mode == "WITH_BG":
-                    cmd.extend(["-ip", hdr_path])
-                else:
-                    cmd.extend(["-i", hdr_path])
-            else:
-                cmd.extend(["-ip", hdr_path])
-
-            # Setup environment so falsecolor can find pcomb, psign, pcompos etc.
-            env = os.environ.copy()
-            if os.path.exists(radiance_bin_dir):
-                env["PATH"] = radiance_bin_dir + os.pathsep + env.get("PATH", "")
-            if os.path.exists(radiance_lib):
-                env["RAYPATH"] = "." + os.pathsep + radiance_lib
-
-            print(f"Running: {' '.join(cmd)}")
-            # Write output to file via redirection to avoid Windows stdout binary corruption
-            cmd_str = subprocess.list2cmdline(cmd) + f' > "{fc_hdr_path}"'
-            result = subprocess.run(cmd_str, shell=True, stderr=subprocess.PIPE, env=env, cwd=output_dir)
-            if result.returncode != 0:
-                error_msg = result.stderr.decode() if result.stderr else "Unknown error"
-                self.report({"ERROR"}, f"falsecolor failed: {error_msg}")
-                return {"CANCELLED"}
-
-            fc_size = os.path.getsize(fc_hdr_path) if os.path.exists(fc_hdr_path) else 0
-            print(f"False color HDR generated: {fc_hdr_path} ({fc_size} bytes)")
-            self.report({"INFO"}, f"False color image generated: {fc_hdr_path}")
-
-            # Generate TIFF version
-            try:
-                pcond_fc_image = pr.pcond(hdr=fc_hdr_path, human=True)
-                fc_tiff_path = os.path.join(output_dir, f"{fc_output_name}.tiff")
-                pr.ra_tiff(inp=pcond_fc_image, out=fc_tiff_path, lzw=True)
-                print(f"False color TIFF generated: {fc_tiff_path}")
-                self.report({"INFO"}, f"False color TIFF also generated: {fc_tiff_path}")
-            except Exception as e:
-                self.report({"WARNING"}, f"TIFF generation failed: {str(e)}")
-
-            return {"FINISHED"}
-
-        except subprocess.CalledProcessError as e:
-            # Clean up incomplete HDR file on failure
-            if os.path.exists(fc_hdr_path):
-                os.remove(fc_hdr_path)
-            error_msg = f"falsecolor failed: {e.stderr.decode() if e.stderr else str(e)}"
-            self.report({"ERROR"}, error_msg)
-            return {"CANCELLED"}
-        except FileNotFoundError:
-            self.report({"ERROR"}, "falsecolor not found. Please install Radiance and add it to PATH.")
-            return {"CANCELLED"}
-        except Exception as e:
-            self.report({"ERROR"}, f"Failed to generate false color image: {str(e)}")
-            import traceback
-
-            traceback.print_exc()
-            return {"CANCELLED"}
-
-
-class RADIANCE_OT_select_camera(bpy.types.Operator):
-    bl_idname = "radiance.select_camera"
-    bl_label = "Select Camera"
-    bl_description = "Select a camera from the viewport"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object is not None and context.object.type == "CAMERA"
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        props.selected_camera = context.object
-        props.use_active_camera = False
-        return {"FINISHED"}
-
-

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

@@ -1,148 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 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/>.
-
-import webbrowser
-from datetime import datetime
-from math import radians
-from typing import TYPE_CHECKING
-
-import bpy
-import ifcopenshell.util.geolocation
-import requests
-
-import bonsai.tool as tool
-from bonsai.bim.module.light.data import SolarData
-
-
-class ImportTrueNorth(bpy.types.Operator):
-    bl_idname = "bim.import_true_north"
-    bl_label = "Import True North"
-    bl_description = "Imports the True North from your IFC geometric context"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            return False
-        if not SolarData.is_loaded:
-            SolarData.load()
-        return SolarData.data["true_north"] is not None
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
-            if not context.TrueNorth:
-                continue
-            value = context.TrueNorth.DirectionRatios
-            props.true_north = radians(ifcopenshell.util.geolocation.yaxis2angle(*value[:2]))
-        return {"FINISHED"}
-
-
-class ImportLatLong(bpy.types.Operator):
-    bl_idname = "bim.import_lat_long"
-    bl_label = "Import Latitude / Longitude"
-    bl_description = "Imports the latitude / longitude from an IfcSite"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        site = tool.Ifc.get().by_id(int(props.sites))
-        if site.RefLatitude and site.RefLongitude:
-            props.latitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLatitude)
-            props.longitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLongitude)
-        return {"FINISHED"}
-
-
-class MoveSunPathTo3DCursor(bpy.types.Operator):
-    bl_idname = "bim.move_sun_path_to_3d_cursor"
-    bl_label = "Move Sun Path To 3D Cursor"
-    bl_description = "Shifts the visualisation of the Sun Path to the 3D cursor"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        assert context.scene
-        props.sun_path_origin = context.scene.cursor.location
-        tool.Blender.update_viewport()
-        return {"FINISHED"}
-
-
-class ViewFromSun(bpy.types.Operator):
-    bl_idname = "bim.view_from_sun"
-    bl_label = "View From Sun"
-    bl_description = "Views your model as if you were looking from the perspective of the sun"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        if not (camera := bpy.data.objects.get("SunPathCamera")):
-            camera = bpy.data.objects.new("SunPathCamera", bpy.data.cameras.new("SunPathCamera"))
-            assert isinstance(camera.data, bpy.types.Camera)
-            assert context.scene
-            camera.data.type = "ORTHO"
-            camera.data.ortho_scale = 100  # The default of 6m is too small
-            context.scene.collection.objects.link(camera)
-        tool.Blender.activate_camera(camera)
-        props = tool.Blender.get_solar_props()
-        props.hour = props.hour  # Just to refresh camera position
-        return {"FINISHED"}
-
-
-class LightPickCoordinates(bpy.types.Operator):
-    bl_idname = "bim.light_pick_coordinates"
-    bl_label = "Pick Coordinates"
-    bl_description = (
-        "Open web browser with Google Maps to pick coordinates (Right Mouse Click in maps to copy selected location).\n\n"
-        "ALT+Click to insert current location based on the current IP-address (using ip-api.com)."
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    use_current_location: bpy.props.BoolProperty(options={"SKIP_SAVE"})  # pyright: ignore[reportRedeclaration]
-
-    if TYPE_CHECKING:
-        use_current_location: bool
-
-    def invoke(self, context, event):
-        if event.alt:
-            self.use_current_location = True
-        return self.execute(context)
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        if not self.use_current_location:
-            zoom = 13.5
-            url = f"https://www.google.com/maps/@{props.latitude},{props.longitude},{zoom}z"
-            webbrowser.open(url)
-            return {"FINISHED"}
-
-        response = requests.get("http://ip-api.com/json/")
-        data = response.json()
-        props.latitude = data["lat"]
-        props.longitude = data["lon"]
-        return {"FINISHED"}
-
-
-class LightSetTimeToNow(bpy.types.Operator):
-    bl_idname = "bim.light_set_time_to_now"
-    bl_label = "Now"
-    bl_description = "Set time to current local time."
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        props.set_from_datetime(datetime.now())
-        return {"FINISHED"}

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

@@ -22,97 +22,52 @@ from typing import TYPE_CHECKING
 import bpy
 
 import bonsai.tool as tool
-from bonsai.bim.helper import prop_with_search
 from bonsai.bim.module.light.data import SolarData
 
-# ---------------------------------------------------------------------------
-# Root panel (replaces the old "Radiance Exporter" nested panel)
-# ---------------------------------------------------------------------------
-
 
 class BIM_PT_radiance_exporter(bpy.types.Panel):
+    """Creates a Panel in the render properties window"""
+
     bl_label = "Radiance Exporter"
     bl_idname = "BIM_PT_radiance_exporter"
+    bl_options = {"DEFAULT_CLOSED"}
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
     bl_context = "scene"
     bl_parent_id = "BIM_PT_tab_lighting"
-    bl_options = {"HIDE_HEADER"}
-
-    def draw(self, context):
-        pass
-
-
-# ---------------------------------------------------------------------------
-# 1. Scene Setup
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_scene_setup(bpy.types.Panel):
-    bl_label = "Scene Setup"
-    bl_idname = "BIM_PT_radiance_scene_setup"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
 
     def draw(self, context):
+        assert self.layout
         layout = self.layout
         props = tool.Blender.get_radiance_exporter_props()
 
+        if tool.Ifc.get():
+            row = self.layout.row()
+            row.prop(props, "should_load_from_memory")
+
+        if not tool.Ifc.get() or not props.should_load_from_memory:
+            row = self.layout.row(align=True)
+            row.prop(props, "ifc_file")
+
         row = layout.row()
         row.prop(props, "output_dir")
 
-        layout.separator()
-
         row = layout.row()
-        row.prop(props, "use_active_camera")
-        if not props.use_active_camera:
-            row = layout.row()
-            row.prop(props, "selected_camera")
-            row.operator("radiance.select_camera", text="", icon="EYEDROPPER")
-
-        row = layout.row(align=True)
-        row.label(text="Resolution")
-        row.prop(props, "radiance_resolution_x", text="X")
-        row.prop(props, "radiance_resolution_y", text="Y")
-
-
-# ---------------------------------------------------------------------------
-# 2. Materials
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_materials(bpy.types.Panel):
-    bl_label = "Materials"
-    bl_idname = "BIM_PT_radiance_materials"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-    bl_options = {"DEFAULT_CLOSED"}
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
-
-        layout.label(text="Unmapped materials default to white", icon="INFO")
-
+        layout.label(text="Info: Unmapped materials default to white")
         row = layout.row()
         row.template_list("MATERIAL_UL_radiance_materials", "", props, "materials", props, "active_material_index")
-        row.operator("radiance.open_spectraldb", text="", icon="WORLD")
-
+        row.operator("radiance.open_spectraldb", text="", icon="WORLD")  # Globe icon
         if len(props.materials) > 0:
             col = layout.column(align=True)
-            prop_with_search(col, props, "category")
+            col.prop(props, "category")
             if props.category:
-                prop_with_search(col, props, "subcategory")
+                col.prop(props, "subcategory")
 
-            if 0 <= props.active_material_index < len(props.materials):
+            if props.active_material_index >= 0 and props.active_material_index < len(props.materials):
                 active_material = props.materials[props.active_material_index]
                 if active_material.category and active_material.subcategory:
                     layout.label(
-                        text=f"Mapped: {active_material.name} -> {active_material.category} - {active_material.subcategory}"
+                        text=f"Mapped: {active_material.name} to {active_material.category} - {active_material.subcategory}"
                     )
                 else:
                     layout.label(text=f"Select category and subcategory for: {active_material.name}")
@@ -123,95 +78,28 @@ class BIM_PT_radiance_materials(bpy.types.Panel):
         row = layout.row()
         row.operator("bim.refresh_ifc_materials", text="Refresh IFC Materials")
 
+        layout.separator()
 
-# ---------------------------------------------------------------------------
-# 3. Lighting (Environment + IES)
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_lighting(bpy.types.Panel):
-    bl_label = "Lighting"
-    bl_idname = "BIM_PT_radiance_lighting"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
-
-        # Environment
-        box = layout.box()
-        box.label(text="Environment", icon="WORLD")
-        row = box.row()
-        row.prop(props, "use_hdr")
-        row = box.row()
-        row.prop(props, "use_sun")
-        if props.use_sun:
-            box.prop(props, "sky_condition")
-            row = box.row()
-            row.prop(props, "ground_reflectance")
-            row = box.row()
-            row.prop(props, "turbidity")
+        row = layout.row()
+        layout.label(text="Step 1: Export geometry for simulation")
+        row = layout.row()
+        row.operator("export_scene.radiance", text="Export Geometry for Simulation")
 
         layout.separator()
 
-        # IES Light Fixtures
         box = layout.box()
-        box.label(text="IES Light Fixtures", icon="LIGHT_POINT")
+        box.label(text="Camera Settings")
         row = box.row()
-        row.template_list("MATERIAL_UL_ies_lights", "", props, "ies_lights", props, "active_ies_light_index")
-        col = row.column(align=True)
-        col.operator("radiance.add_ies_light", text="", icon="ADD")
+        row.prop(props, "use_active_camera")
+        if not props.use_active_camera:
+            row = box.row()
+            row.prop(props, "selected_camera")
+            row.operator("radiance.select_camera", text="", icon="EYEDROPPER")
 
-        if len(props.ies_lights) > 0 and 0 <= props.active_ies_light_index < len(props.ies_lights):
-            active_light = props.ies_lights[props.active_ies_light_index]
-
-            col = box.column(align=True)
-
-            row = col.row()
-            row.prop(active_light, "use_collection", text="Target Collection", icon="OUTLINER_COLLECTION")
-
-            row = col.row()
-            if active_light.use_collection:
-                row.prop(active_light, "target_collection", text="Collection")
-                if active_light.target_collection:
-                    empties = [o for o in active_light.target_collection.all_objects if o.type == "EMPTY"]
-                    row = col.row()
-                    row.label(text=f"{len(empties)} empty object(s) in collection", icon="INFO")
-            else:
-                row.prop(active_light, "target_object", text="Object")
-
-            row = col.row()
-            row.label(text="Rotation Z")
-            row.prop(active_light, "rotation_z", text="")
-
-            row = col.row()
-            row.prop(active_light, "lamp_color")
-
-            split = col.split(factor=0.5)
-            split.prop(active_light, "multiply_factor")
-            split.prop(active_light, "radius")
-
-
-# ---------------------------------------------------------------------------
-# 4. Render Settings
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_render_settings(bpy.types.Panel):
-    bl_label = "Render Settings"
-    bl_idname = "BIM_PT_radiance_render_settings"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-    bl_options = {"DEFAULT_CLOSED"}
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
+        row = box.row(align=True)
+        row.label(text="Resolution")
+        row.prop(props, "radiance_resolution_x", text="X")
+        row.prop(props, "radiance_resolution_y", text="Y")
 
         row = layout.row()
         row.prop(props, "radiance_quality")
@@ -222,9 +110,6 @@ class BIM_PT_radiance_render_settings(bpy.types.Panel):
         row = layout.row()
         row.prop(props, "radiance_variability")
 
-        row = layout.row()
-        row.prop(props, "ambient_bounces")
-
         layout.separator()
 
         row = layout.row()
@@ -232,94 +117,20 @@ class BIM_PT_radiance_render_settings(bpy.types.Panel):
 
         row = layout.row()
         row.prop(props, "output_file_format")
-
-
-# ---------------------------------------------------------------------------
-# 5. Pipeline (Steps 1-4 + Cleanup)
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_pipeline(bpy.types.Panel):
-    bl_label = "Pipeline"
-    bl_idname = "BIM_PT_radiance_pipeline"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
-
-        # Step 1
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 1: Export Geometry")
-        row = box.row()
-        if props.is_exporting:
-            row.label(text="Exporting...", icon="SORTTIME")
-        else:
-            row.operator("export_scene.radiance", text="Export Geometry")
-
-        # Step 2
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 2: Prepare Scene")
-        row = box.row()
-        if props.is_preparing:
-            row.label(text="Preparing scene...", icon="SORTTIME")
-        else:
-            row.operator("scene.prepare_radiance", text="Prepare Scene")
-
-        # Step 3
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 3: Render")
-        row = box.row()
-        if props.is_rendering:
-            row.label(text="Rendering...", icon="RENDER_STILL")
-        else:
-            row.operator("render_scene.radiance", text="Radiance Render")
-
-        # Step 4: False Color
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 4: False Color Analysis")
-
-        row = box.row()
-        row.prop(props, "radiance_bin_dir")
-
-        row = box.row()
-        row.prop(props, "false_color_label")
-
-        split = box.split(factor=0.5)
-        split.prop(props, "false_color_scale")
-        split.prop(props, "false_color_steps")
-
-        row = box.row()
-        row.label(text="Output Name")
-        row.prop(props, "false_color_output_name", text="")
-
-        row = box.row()
-        row.prop(props, "false_color_contour_lines")
-
-        if props.false_color_contour_lines:
-            row = box.row()
-            row.prop(props, "false_color_contour_mode")
-
-        row = box.row()
-        row.operator("render_scene.false_color_radiance", text="Generate False Color Image")
-
         layout.separator()
 
-        # Cleanup
         row = layout.row()
-        row.operator("radiance.cleanup_files", text="Cleanup Generated Files", icon="TRASH")
+        row.prop(props, "use_hdr")
 
+        if props.use_hdr:
+            row = layout.row()
+            row.prop(props, "choose_hdr_image")
 
-# ---------------------------------------------------------------------------
-# Solar Panel (unchanged)
-# ---------------------------------------------------------------------------
+        row = layout.row()
+        layout.label(text="Step 2: Run the simulation")
+        row = layout.row()
+        row.operator("render_scene.radiance", text="Radiance Render")
+        row.enabled = not props.is_exporting
 
 
 class BIM_PT_solar(bpy.types.Panel):
@@ -437,10 +248,7 @@ class BIM_PT_solar(bpy.types.Panel):
             row = self.layout.row()
             sun_props = tool.Blender.get_sun_props()
             assert sun_props
-            if sun_props.sun_object is not None and sun_props.sun_object.data is not None:
-                row.prop(sun_props.sun_object.data, "energy", text="Sun Intensity")
-            else:
-                row.label(text="Sun object not found. Toggle shadow mode to recreate.", icon="ERROR")
+            row.prop(sun_props.sun_object.data, "energy", text="Sun Intensity")
 
         row = self.layout.row(align=True)
         row.operator("bim.view_from_sun", icon="LIGHT_HEMI")

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

@@ -630,13 +630,23 @@ 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:
+                if "CardinalPoint" in attributes and attributes["CardinalPoint"] is not None:
                     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)

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

@@ -15,11 +15,15 @@
 #
 # 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,
@@ -27,7 +31,9 @@ from . import (
     external,
     grid,
     handler,
+    host_add_opening_gizmo,
     mep,
+    mep_bend_preview,
     opening,
     product,
     profile,
@@ -46,17 +52,28 @@ from . import (
 
 classes = (
     array.AddArray,
-    array.DisableEditingArray,
-    array.EditArray,
+    array.CancelEditingArray,
     array.EnableEditingArray,
+    array.FinishEditingArray,
     array.ApplyArray,
     array.RegenerateArray,
     array.RemoveArray,
     array.SelectAllArrayObjects,
     array.SelectArrayParent,
+    array.ArrayParentGizmoClick,
+    array.EditArrayFromChild,
     array.Input3DCursorXArray,
     array.Input3DCursorYArray,
     array.Input3DCursorZArray,
+    array.EnableEditingParametric,
+    array.AddArrayFromFeatureEdit,
+    array.ArrayGizmoClick,
+    array.ToggleArrayMethod,
+    array.RemoveArrayLayerFromEdit,
+    array.InputArrayCount,
+    array.AdjustArrayCount,
+    array.GizmoArrayEdition,
+    array.GizmoArrayChild,
     product.AddDefaultType,
     product.AddEmptyType,
     product.AddOccurrence,
@@ -68,21 +85,48 @@ 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.GizmoWallJoinIntersection,
+    wall.GizmoWallLinkToggle,
+    wall.GizmoWallUnjoinSingle,
+    wall.JoinWallsIntersection,
     wall.MergeWall,
     wall.OffsetWalls,
     wall.RecalculateWall,
+    wall.RotateWall90,
     wall.SplitWall,
+    wall.SplitWallAtCursor,
+    wall.UnjoinWallPathConnection,
     wall.UnjoinWalls,
+    wall.EnableWallFilletPreview,
+    wall.FinishWallFilletPreview,
+    wall.CancelWallFilletPreview,
+    wall.EnableWallFilletPreviewFromCorner,
+    wall.CreateWallFillet,
     opening.AddBoolean,
     opening.CloneOpening,
     opening.EditOpenings,
@@ -94,6 +138,7 @@ classes = (
     opening.RemoveBoolean,
     opening.SelectBoolean,
     opening.ShowOpenings,
+    opening.ToggleHostOpenings,
     opening.UpdateOpeningsFocus,
     profile.ChangeCardinalPoint,
     profile.ChangeProfileDepth,
@@ -140,10 +185,18 @@ classes = (
     prop.BIMDoorProperties,
     prop.BIMRailingProperties,
     prop.BIMRoofProperties,
+    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,
@@ -164,7 +217,8 @@ classes = (
     stair.ToggleStairProperty,
     stair.AdjustStairTreads,
     stair.SetStairTreads,
-    stair.CycleStairType,
+    stair.InputStairTreads,
+    stair.PickStairType,
     stair.GizmoStairEdition,
     sverchok_modifier.CreateNewSverchokGraph,
     sverchok_modifier.UpdateDataFromSverchok,
@@ -177,7 +231,7 @@ classes = (
     window.FinishEditingWindow,
     window.EnableEditingWindow,
     window.RemoveWindow,
-    window.CycleWindowType,
+    window.PickWindowType,
     window.GizmoWindowEdition,
     door.BIM_OT_add_door,
     door.AddDoor,
@@ -186,7 +240,7 @@ classes = (
     door.EnableEditingDoor,
     door.RemoveDoor,
     door.ToggleDoorSwing,
-    door.CycleDoorType,
+    door.PickDoorType,
     door.GizmoDoorEdition,
     railing.BIM_OT_add_railing,
     railing.CopyRailingParameters,
@@ -203,16 +257,41 @@ 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.MEPUnjoinAtPort,
+    mep.MEPRemoveTerminalFitting,
+    mep.MEPUnjoinPair,
+    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,
 )
 
@@ -264,15 +343,17 @@ 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)
-    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)
+    # 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.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)
@@ -281,6 +362,12 @@ 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()
+
     if not bpy.app.background:
         for tool_data in reversed(tools):
             bpy.utils.unregister_tool(tool_data.tool)
@@ -288,13 +375,11 @@ 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
-    del bpy.types.Object.BIMWindowProperties
-    del bpy.types.Object.BIMDoorProperties
-    del bpy.types.Object.BIMRailingProperties
-    del bpy.types.Object.BIMRoofProperties
+    tool.Parametric.unregister_object_properties()
     del bpy.types.Object.BIMExternalParametricGeometryProperties
+    del bpy.types.Scene.BIMPreviewProperties
+    del bpy.types.WindowManager.BIMParametricEditDialogPrefs
 
     bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.types.VIEW3D_MT_add.remove(ui.add_menu)

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

@@ -15,12 +15,14 @@
 #
 # 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 __future__ import annotations
 
 import math
 from math import cos, pi, radians, sin, tan
-from typing import Any, Literal
+from typing import Any, Literal, NamedTuple
 
 import blf
 import bmesh
@@ -41,6 +43,11 @@ from mathutils import Matrix, Quaternion, Vector
 
 import bonsai.core.geometry
 import bonsai.tool as tool
+from bonsai.bim.module.drawing.gizmos import (
+    ARC_SEGMENTS,
+    DOOR_SWING_ANGLE_MAX,
+    DOOR_SWING_ANGLE_MIN,
+)
 from bonsai.bim.module.drawing.helper import format_distance
 
 
@@ -88,15 +95,9 @@ class ProfileDecorator:
         batch.draw(shader)
 
     def draw_faces(self, bm, vertices_coords):
-        """mutates original bm (triangulates it)
-        so the triangulation edges will be shown too
-        """
-        traingulated_bm = bm
-        bmesh.ops.triangulate(traingulated_bm, faces=traingulated_bm.faces)
-
-        face_indices = [[v.index for v in f.verts] for f in traingulated_bm.faces]
+        """Submit a non-mutating beauty-triangulated TRIS batch over ``bm``'s faces."""
         faces_color = transparent_color(self.addon_prefs.decorator_color_special)
-        self.draw_batch("TRIS", vertices_coords, faces_color, face_indices)
+        tool.Blender.draw_bmesh_face_tris(bm, vertices_coords, faces_color, self.draw_batch)
 
     def __call__(self, context, get_custom_bmesh=None, draw_faces=False, exit_edit_mode_callback=None):
         self.addon_prefs = tool.Blender.get_addon_preferences()
@@ -108,7 +109,7 @@ class ProfileDecorator:
 
         obj = context.active_object
 
-        if obj.mode != "EDIT":
+        if obj is None or obj.mode != "EDIT":
             if exit_edit_mode_callback:
                 ProfileDecorator.uninstall()
                 exit_edit_mode_callback()
@@ -2029,3 +2030,502 @@ class BoundingBoxDecorator:
                         else:
                             co1.y += y_overlap / 2 + min_spacing
                             co2.y -= y_overlap / 2 + min_spacing
+
+
+def _fill_quads_alpha(
+    context: bpy.types.Context,
+    quads: list[
+        tuple[
+            tuple[float, float, float],
+            tuple[float, float, float],
+            tuple[float, float, float],
+            tuple[float, float, float],
+        ]
+    ],
+    color_rgb: tuple[float, float, float],
+    alpha: float,
+) -> None:
+    """Render ``quads`` (each a 4-tuple of world-space corner verts in CCW
+    order) as one TRIS batch with two triangles per quad."""
+    if not quads:
+        return
+    verts: list[tuple[float, float, float]] = []
+    indices: list[tuple[int, int, int]] = []
+    for quad in quads:
+        if len(quad) != 4:
+            continue
+        base = len(verts)
+        verts.extend(tuple(v) for v in quad)
+        indices.append((base, base + 1, base + 2))
+        indices.append((base, base + 2, base + 3))
+    if not tool.Blender.validate_shader_batch_data(verts, indices):
+        return
+    region = getattr(context, "region", None)
+    if region is None:
+        return
+    shader = gpu.shader.from_builtin("UNIFORM_COLOR")
+    shader.bind()
+    shader.uniform_float("color", (*color_rgb, alpha))
+    batch = batch_for_shader(shader, "TRIS", {"pos": verts}, indices=indices)
+    gpu.state.blend_set("ALPHA")
+    batch.draw(shader)
+    gpu.state.blend_set("NONE")
+
+
+def compute_mep_join_location():
+    """Midpoint between the closest endpoint pair of two selected MEP
+    segments — the world location where a connecting fitting (bend /
+    transition) would land. Returns ``None`` when prerequisites aren't met
+    (wrong cardinality, mixed non-MEP)."""
+    selected = list(tool.Blender.get_selected_objects())
+    if len(selected) != 2:
+        return None
+    for obj in selected:
+        element = tool.Ifc.get_entity(obj)
+        if element is None or not tool.System.is_mep_element(element):
+            return None
+    a_start, a_end = tool.Model.get_flow_segment_axis(selected[0])
+    b_start, b_end = tool.Model.get_flow_segment_axis(selected[1])
+    pairs = [(a_start, b_start), (a_start, b_end), (a_end, b_start), (a_end, b_end)]
+    closest = min(pairs, key=lambda p: (p[0] - p[1]).length)
+    return (closest[0] + closest[1]) * 0.5
+
+
+class MEPSegmentExtendPreviewDecorator(tool.Blender.ViewportDecorator):
+    """Preview line for the MEP segment extend-to-cursor gizmo. Renders one
+    line from the segment's current end to the cursor's projection on the
+    segment's local Z axis when the extend icon is hovered. Self-gates every
+    draw on the viewport gizmo toggle and the per-feature ``extend`` pref."""
+
+    draw_method = "draw_line"
+
+    LINE_WIDTH = 1.5
+    LINE_ALPHA = 0.8
+
+    def draw_line(self, context: bpy.types.Context) -> None:
+        if not tool.Blender.are_viewport_gizmos_enabled():
+            return
+        prefs = tool.Blender.get_addon_preferences()
+
+        active = context.active_object
+        if active is None:
+            return
+        selected = list(tool.Blender.get_selected_objects())
+        if active not in selected or len(selected) != 1:
+            return
+
+        element = tool.Ifc.get_entity(active)
+        if element is None:
+            return
+
+        from bonsai.bim.module.model.mep import (
+            GizmoDuctSegmentEdition,
+            GizmoPipeSegmentEdition,
+        )
+
+        if tool.Parametric.is_pipe_segment(element):
+            gizmo_prefs = getattr(prefs.gizmos, "pipe_segment", None)
+            gizmo_cls = GizmoPipeSegmentEdition
+        elif tool.Parametric.is_duct_segment(element):
+            gizmo_prefs = getattr(prefs.gizmos, "duct_segment", None)
+            gizmo_cls = GizmoDuctSegmentEdition
+        else:
+            return
+        if gizmo_prefs is None or not getattr(gizmo_prefs, "enabled", True):
+            return
+        if not self._cursor_icon_hovered(gizmo_cls, "extend_gizmo", context):
+            return
+
+        current_length = max(c[2] for c in active.bound_box) if active.bound_box else 0.0
+        line = self._compute_extend_preview_line(active.matrix_world, context.scene.cursor.location, current_length)
+        if line is None:
+            return
+        start_world, end_world = line
+        color = tuple(prefs.decorator_color_selected[:3])
+        draw_polyline_segments(
+            context,
+            [(tuple(start_world), tuple(end_world))],
+            color,
+            self.LINE_ALPHA,
+            self.LINE_WIDTH,
+        )
+
+    @staticmethod
+    def _compute_extend_preview_line(
+        matrix_world: Matrix,
+        cursor_world: Vector,
+        current_length: float,
+    ) -> tuple[Vector, Vector] | None:
+        """Returns ``(current_end_world, target_end_world)`` or ``None`` when
+        no extend would happen (degenerate segment, or cursor on the existing
+        end). Target follows the cursor's raw local-Z projection unbounded —
+        the line stays visible past the segment origin (negative local Z)
+        because the user expects to see where they're pointing even when the
+        operator would floor it."""
+        if current_length <= 0:
+            return None
+        cursor_local = matrix_world.inverted() @ cursor_world
+        if abs(cursor_local.z - current_length) < 1e-6:
+            return None
+        current_end_world = matrix_world @ Vector((0.0, 0.0, current_length))
+        target_end_world = matrix_world @ Vector((0.0, 0.0, cursor_local.z))
+        return current_end_world, target_end_world
+
+
+class BendPreviewDecorator(tool.Blender.ViewportDecorator):
+    """GPU preview lines for the bend-creation flow.
+
+    Polls on ``scene.BIMPreviewProperties.bend.is_active`` and renders the
+    centerline + leg projections returned by ``mep.compute_bend_preview_polylines``.
+    The two leg lines (segment → tangent point) show how each segment will
+    be shortened; the arc polyline approximates the bend curve. On invalid
+    geometry, draws the two rejected axes in warning colour instead so the
+    user sees why the bend cannot be placed.
+
+    Installed once per Blender session from ``bim/handler.py:load_post``.
+    Cheap to leave running because the first thing ``draw`` does is check
+    ``is_active`` and return when False.
+    """
+
+    LINE_WIDTH_LEG = 1.5
+    LINE_WIDTH_ARC = 2.5
+    LINE_ALPHA = 0.7
+
+    def draw(self, context: bpy.types.Context) -> None:
+        scene = context.scene
+        preview = getattr(scene, "BIMPreviewProperties", None)
+        props = preview.bend if preview is not None else None
+        if props is None or not props.is_active:
+            return
+        ifc_file = tool.Ifc.get()
+        if ifc_file is None:
+            return
+        try:
+            start_element = ifc_file.by_id(props.start_segment_id)
+            end_element = ifc_file.by_id(props.end_segment_id)
+        except Exception:
+            return
+        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
+        if start_obj is None or end_obj is None:
+            return
+
+        # Late import: decorator.py loads at addon enable but mep.py imports
+        # this module for the extend preview, so a module-level import would
+        # cycle.
+        from bonsai.bim.module.model.mep import cached_compute_bend_preview_polylines
+
+        preview = cached_compute_bend_preview_polylines(
+            start_obj, end_obj, props.start_length, props.end_length, props.radius
+        )
+        prefs = tool.Blender.get_addon_preferences()
+
+        if not preview["valid"]:
+            warning_color = tuple(prefs.decorator_color_error[:3])
+            axes = preview.get("invalid_axes") or []
+            if axes:
+                segments = [(tuple(a), tuple(b)) for a, b in axes]
+                draw_polyline_segments(context, segments, warning_color, self.LINE_ALPHA, self.LINE_WIDTH_ARC)
+            return
+
+        leg_color = tuple(prefs.decorations_colour[:3])
+        arc_color = tuple(prefs.decorator_color_selected[:3])
+
+        leg_a_far, leg_a_end = preview["leg_a"]
+        leg_b_far, leg_b_end = preview["leg_b"]
+        draw_polyline_segments(
+            context,
+            [(tuple(leg_a_far), tuple(leg_a_end)), (tuple(leg_b_far), tuple(leg_b_end))],
+            leg_color,
+            self.LINE_ALPHA,
+            self.LINE_WIDTH_LEG,
+        )
+
+        arc = preview["arc"]
+        if len(arc) >= 2:
+            arc_segments = [(tuple(arc[i]), tuple(arc[i + 1])) for i in range(len(arc) - 1)]
+            draw_polyline_segments(context, arc_segments, arc_color, self.LINE_ALPHA, self.LINE_WIDTH_ARC)
+
+
+class WallFilletPreviewDecorator(tool.Blender.ViewportDecorator):
+    """GPU preview lines for the wall-fillet flow.
+
+    Polls on ``scene.BIMPreviewProperties.wall_fillet.is_active`` and renders
+    the leg projections + arc + radial construction lines returned by
+    ``tool.Wall.compute_wall_fillet_geometry``. The two leg lines show how
+    each wall will be shortened to its tangent point; the arc approximates
+    the rounded corner; the two construction lines (arc center to each
+    tangent point) visually pin the radius.
+
+    Installed once per Blender session from ``bim/handler.py:load_post``
+    and uninstalled in ``bim/module/model/__init__.py:unregister``."""
+
+    LINE_WIDTH_LEG = 1.5
+    LINE_WIDTH_ARC = 2.5
+    LINE_WIDTH_CONSTRUCTION = 1.0
+    LINE_ALPHA = 0.7
+    CONSTRUCTION_ALPHA = 0.4
+
+    def draw(self, context: bpy.types.Context) -> None:
+        scene = context.scene
+        preview_props = getattr(scene, "BIMPreviewProperties", None)
+        props = preview_props.wall_fillet if preview_props is not None else None
+        if props is None or not props.is_active:
+            return
+        ifc_file = tool.Ifc.get()
+        if ifc_file is None:
+            return
+        try:
+            wall_a = ifc_file.by_id(props.wall_a_id)
+            wall_b = ifc_file.by_id(props.wall_b_id)
+        except Exception:
+            return
+        wall_a_obj = tool.Ifc.get_object(wall_a) if wall_a else None
+        wall_b_obj = tool.Ifc.get_object(wall_b) if wall_b else None
+        if wall_a_obj is None or wall_b_obj is None:
+            return
+
+        geom = tool.Wall.compute_wall_fillet_geometry(wall_a_obj, wall_b_obj, props.radius)
+        if geom is None:
+            return
+
+        prefs = tool.Blender.get_addon_preferences()
+        warning_color = tuple(prefs.decorator_color_error[:3])
+
+        if not geom["valid"]:
+            # Degenerate geometry paints red: invalid_radius shows legs+arc
+            # past the wall ends; invalid_axes shows the parallel/collinear
+            # axes.
+            if geom.get("invalid_radius"):
+                tangent_a = geom.get("tangent_a")
+                tangent_b = geom.get("tangent_b")
+                ref_a = tool.Wall.get_world_reference_line(wall_a_obj)
+                ref_b = tool.Wall.get_world_reference_line(wall_b_obj)
+                if tangent_a is not None and tangent_b is not None and ref_a is not None and ref_b is not None:
+                    far_a = self._far_endpoint(ref_a, geom["intersection"])
+                    far_b = self._far_endpoint(ref_b, geom["intersection"])
+                    legs = [
+                        (tuple(far_a), tuple(tangent_a)),
+                        (tuple(far_b), tuple(tangent_b)),
+                    ]
+                    draw_polyline_segments(context, legs, warning_color, self.LINE_ALPHA, self.LINE_WIDTH_LEG)
+                arc = geom.get("arc") or []
+                if len(arc) >= 2:
+                    arc_segments = [(tuple(arc[i]), tuple(arc[i + 1])) for i in range(len(arc) - 1)]
+                    draw_polyline_segments(context, arc_segments, warning_color, self.LINE_ALPHA, self.LINE_WIDTH_ARC)
+            elif geom.get("invalid_axes"):
+                axes = geom["invalid_axes"]
+                segments = [(tuple(a), tuple(b)) for a, b in axes]
+                draw_polyline_segments(context, segments, warning_color, self.LINE_ALPHA, self.LINE_WIDTH_ARC)
+            return
+
+        leg_color = tuple(prefs.decorations_colour[:3])
+        arc_color = tuple(prefs.decorator_color_selected[:3])
+
+        # Resolved against the IFC reference line, not mesh bounds, so trimmed
+        # walls and openings don't shift the leg endpoints.
+        ref_a = tool.Wall.get_world_reference_line(wall_a_obj)
+        ref_b = tool.Wall.get_world_reference_line(wall_b_obj)
+        if ref_a is not None and ref_b is not None and geom["intersection"] is not None:
+            far_a = self._far_endpoint(ref_a, geom["intersection"])
+            far_b = self._far_endpoint(ref_b, geom["intersection"])
+            legs = [
+                (tuple(far_a), tuple(geom["tangent_a"])),
+                (tuple(far_b), tuple(geom["tangent_b"])),
+            ]
+            draw_polyline_segments(context, legs, leg_color, self.LINE_ALPHA, self.LINE_WIDTH_LEG)
+
+        arc = geom["arc"]
+        if len(arc) >= 2:
+            arc_segments = [(tuple(arc[i]), tuple(arc[i + 1])) for i in range(len(arc) - 1)]
+            draw_polyline_segments(context, arc_segments, arc_color, self.LINE_ALPHA, self.LINE_WIDTH_ARC)
+
+        # Dim construction lines from arc_center to each tangent point so
+        # the radius reads as concrete during drag.
+        arc_center = geom.get("arc_center")
+        if arc_center is not None:
+            construction = [
+                (tuple(arc_center), tuple(geom["tangent_a"])),
+                (tuple(arc_center), tuple(geom["tangent_b"])),
+            ]
+            draw_polyline_segments(
+                context, construction, arc_color, self.CONSTRUCTION_ALPHA, self.LINE_WIDTH_CONSTRUCTION
+            )
+
+    @staticmethod
+    def _far_endpoint(reference_line, intersection):
+        """Endpoint of ``reference_line`` furthest from ``intersection``."""
+        p1, p2 = reference_line
+        d1 = (p1.x - intersection[0]) ** 2 + (p1.y - intersection[1]) ** 2 + (p1.z - intersection[2]) ** 2
+        d2 = (p2.x - intersection[0]) ** 2 + (p2.y - intersection[1]) ** 2 + (p2.z - intersection[2]) ** 2
+        return p2 if d2 >= d1 else p1
+
+
+class _DoorSwingArc(NamedTuple):
+    """Parameters for one swing-arc draw call in door-local space."""
+
+    hinge_x: float
+    hinge_y: float
+    panel_width: float
+    x_mirror: bool
+
+
+def _visible_arcs(door_type: str, overall_width: float, lining_offset: float) -> list[_DoorSwingArc]:
+    """Arc specs for the parametric door swing visualisation, agnostic of
+    edit-mode state so the readonly preview and the editor view stay aligned.
+
+    Empty only for sliding-door types; unknown ``door_type`` values fall
+    through to a single left-hinged arc."""
+    if "SLIDING" in door_type:
+        return []
+    is_double = "DOUBLE_DOOR" in door_type
+    is_right_single = door_type.endswith("RIGHT") and not is_double
+    arcs = [
+        _DoorSwingArc(
+            hinge_x=overall_width if is_right_single else 0.0,
+            hinge_y=lining_offset,
+            panel_width=overall_width / 2 if is_double else overall_width,
+            x_mirror=is_right_single,
+        )
+    ]
+    if is_double:
+        arcs.append(
+            _DoorSwingArc(
+                hinge_x=overall_width,
+                hinge_y=lining_offset,
+                panel_width=overall_width / 2,
+                x_mirror=True,
+            )
+        )
+    return arcs
+
+
+# Unit quarter-arc samples shared with the edit-mode swing gizmo so the
+# readonly arc traces the same curve. Re-scaled per draw via the per-arc
+# transform.
+_DOOR_SWING_ARC_ANGLE_MIN_RAD = math.radians(DOOR_SWING_ANGLE_MIN)
+_DOOR_SWING_ARC_ANGLE_RANGE_RAD = math.radians(DOOR_SWING_ANGLE_MAX) - _DOOR_SWING_ARC_ANGLE_MIN_RAD
+_DOOR_SWING_ARC_UNIT_POINTS: tuple[Vector, ...] = tuple(
+    Vector(
+        (
+            math.cos(_DOOR_SWING_ARC_ANGLE_MIN_RAD + _DOOR_SWING_ARC_ANGLE_RANGE_RAD * (_i / ARC_SEGMENTS)),
+            math.sin(_DOOR_SWING_ARC_ANGLE_MIN_RAD + _DOOR_SWING_ARC_ANGLE_RANGE_RAD * (_i / ARC_SEGMENTS)),
+            0.0,
+        )
+    )
+    for _i in range(ARC_SEGMENTS + 1)
+)
+
+
+class DoorSwingReadonlyDecorator(tool.Blender.ViewportDecorator):
+    """Always-on swing-arc preview for the active Bonsai-parametric IfcDoor
+    when it is not currently in parametric edit mode. Matches the visual
+    contract of the parametric door's swing-arc gizmos so the hinge side
+    and opening direction can be read without entering edit mode.
+
+    Silent-skip cases (no draw, no error):
+
+    - active object missing / not selected / not an IfcDoor;
+    - door is mid-edit (the swing gizmo is already painting the arc);
+    - door has no ``BBIM_Door`` pset (legacy import, never edited in Bonsai)."""
+
+    LINE_WIDTH = 1.5
+    LINE_ALPHA = 0.8
+
+    def draw(self, context: bpy.types.Context) -> None:
+        obj = context.active_object
+        if obj is None or not obj.select_get():
+            return
+        element = tool.Ifc.get_entity(obj)
+        if element is None or not element.is_a("IfcDoor"):
+            return
+        props = getattr(obj, "BIMDoorProperties", None)
+        if props is not None and props.is_editing:
+            return
+        pset = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Door")
+        if not pset:
+            return
+        data = pset.get("data_dict")
+        if not data:
+            return
+        door_type = data.get("door_type", "")
+        overall_width_project = data.get("overall_width", 0.0)
+        lining_offset_project = (data.get("lining_properties") or {}).get("lining_offset", 0.0)
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        overall_width = overall_width_project * si_conversion
+        lining_offset = lining_offset_project * si_conversion
+        specs = _visible_arcs(door_type, overall_width, lining_offset)
+        if not specs:
+            return
+        prefs = tool.Blender.get_addon_preferences()
+        main_color = tuple(prefs.decorator_color_special[:3])
+        mw = obj.matrix_world
+        segments: list[tuple[tuple[float, float, float], tuple[float, float, float]]] = []
+        for spec in specs:
+            x_flip = Matrix.Scale(-1, 4, (1, 0, 0)) if spec.x_mirror else Matrix.Identity(4)
+            transform = (
+                Matrix.Translation(Vector((spec.hinge_x, spec.hinge_y, 0.0)))
+                @ Matrix.Scale(spec.panel_width, 4)
+                @ x_flip
+            )
+            world_main = mw @ transform
+            pts = [world_main @ p for p in _DOOR_SWING_ARC_UNIT_POINTS]
+            for i in range(len(pts) - 1):
+                segments.append((tuple(pts[i]), tuple(pts[i + 1])))
+        draw_polyline_segments(context, segments, main_color, self.LINE_ALPHA, self.LINE_WIDTH)
+
+
+_BBOX_EDGES = (
+    (0, 1), (1, 2), (2, 3), (3, 0),
+    (4, 5), (5, 6), (6, 7), (7, 4),
+    (0, 4), (1, 5), (2, 6), (3, 7),
+)  # fmt: skip
+
+
+def bbox_world_edges(
+    obj: bpy.types.Object,
+) -> list[tuple[tuple[float, float, float], tuple[float, float, float]]]:
+    """Return world-space (start, end) tuples for the 12 edges of ``obj``'s
+    bounding box. Empty list if the object has no bound_box (e.g. Empties)."""
+    if not obj.bound_box:
+        return []
+    mw = obj.matrix_world
+    corners = [mw @ Vector(c) for c in obj.bound_box]
+    return [(tuple(corners[a]), tuple(corners[b])) for a, b in _BBOX_EDGES]
+
+
+def draw_polyline_segments(
+    context: bpy.types.Context,
+    segments: list[tuple[tuple[float, float, float], tuple[float, float, float]]],
+    color_rgb: tuple[float, float, float],
+    alpha: float,
+    line_width: float,
+) -> None:
+    """Render ``segments`` as one anti-aliased LINES batch in world space."""
+    if not segments:
+        return
+    verts: list[tuple[float, float, float]] = []
+    indices: list[tuple[int, int]] = []
+    for start, end in segments:
+        base = len(verts)
+        verts.append(start)
+        verts.append(end)
+        indices.append((base, base + 1))
+    if not tool.Blender.validate_shader_batch_data(verts, indices):
+        return
+    region = getattr(context, "region", None)
+    if region is None:
+        return
+    shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
+    shader.bind()
+    shader.uniform_float("viewportSize", (region.width, region.height))
+    shader.uniform_float("lineWidth", line_width)
+    shader.uniform_float("color", (*color_rgb, alpha))
+    batch = batch_for_shader(shader, "LINES", {"pos": verts}, indices=indices)
+    gpu.state.blend_set("ALPHA")
+    batch.draw(shader)
+    gpu.state.blend_set("NONE")
+
+
+_BBOX_HIGHLIGHT_LINE_WIDTH = 1.8
+_BBOX_HIGHLIGHT_LINE_ALPHA = 0.8

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

@@ -37,7 +37,9 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+from bonsai.bim.module.model.wall_offset_gizmos import WALL_OFFSET_GIZMO_CONFIGS
 from bonsai.bim.module.model.window import create_bm_box, create_bm_window
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin, PickTypeMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMDoorProperties
@@ -566,103 +568,58 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class CancelEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
+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):
     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 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"}
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        return self._cancel_targets(context)
 
 
-class FinishEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingDoor(_DoorEditMixin, 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 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"}
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        return self._finish_targets(context)
 
 
-class EnableEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingDoor(_DoorEditMixin, 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 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"}
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        return self._enable_targets(context)
 
 
 class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
@@ -673,7 +630,7 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
     def remove_door_on_object(self, obj: bpy.types.Object) -> None:
         element = tool.Ifc.get_entity(obj)
         assert element
-        if not tool.Blender.Modifier.is_door(element):
+        if not tool.Parametric.is_door(element):
             return
         props = tool.Model.get_door_props(obj)
         props.is_editing = False
@@ -688,12 +645,8 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
-    """Toggle door swing direction and optionally flip door geometry.
-
-    Shift+Click (when flip_geometry=True): Flip geometry only without changing door direction"""
-
     bl_idname = "bim.toggle_door_swing"
-    bl_label = "Toggle Door Swing"
+    bl_label = "Change Door Swing"
     bl_options = {"REGISTER", "UNDO"}
 
     flip_geometry: bpy.props.BoolProperty(name="Flip Geometry", default=False)
@@ -704,6 +657,15 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         name="Skip Direction Change", default=False, options={"HIDDEN", "SKIP_SAVE"}
     )
 
+    @classmethod
+    def description(cls, context: bpy.types.Context, properties: bpy.types.OperatorProperties) -> str:
+        if properties.flip_geometry:
+            return (
+                "Swing the door from the opposite side of the wall. "
+                "Shift+click: mirror the door without changing which side it opens to"
+            )
+        return "Move the door hinge to the opposite side"
+
     def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
         self.skip_direction_change = event.shift
         return self.execute(context)
@@ -730,7 +692,7 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         if not element:
             return {"CANCELLED"}
 
-        is_door = tool.Blender.Modifier.is_door(element)
+        is_door = tool.Parametric.is_door(element)
 
         if self.flip_geometry:
             tool.Geometry.flip_object(obj, self.flip_local_axes)
@@ -744,20 +706,20 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin):
-    """Cycle through available door types. Shift+click to cycle in reverse."""
+class PickDoorType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
+    """Pick a door type from a popup menu."""
 
-    bl_idname = "bim.cycle_door_type"
-    bl_label = "Cycle Door Type"
+    bl_idname = "bim.pick_door_type"
+    bl_label = "Pick Door Type"
     bl_options = {"REGISTER", "UNDO"}
 
-    element_checker = "is_door"
-    props_getter = "get_door_props"
+    element_checker = tool.Parametric.is_door
+    props_getter = tool.Model.get_door_props
     type_literal = tool.Model.DoorType
     type_attr = "door_type"
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cycle_type(context)
+        return self._pick_type(context)
 
 
 class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
@@ -770,7 +732,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     enable_editing_operator = "bim.enable_editing_door"
     finish_editing_operator = "bim.finish_editing_door"
     cancel_editing_operator = "bim.cancel_editing_door"
-    cycle_type_operator = "bim.cycle_door_type"
+    pick_type_operator = "bim.pick_door_type"
 
     # Declarative dimension gizmo configuration with visibility and position
     # matrix_position lambdas replace the get_dimension_matrix_* methods
@@ -877,14 +839,44 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
                 p.get_transom_window_center_z(),
             ),
         ),
+        *WALL_OFFSET_GIZMO_CONFIGS,
     ]
 
-    props_getter = "get_door_props"
+    # 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
     gizmo_pref_name = "door"
 
     @classmethod
     def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Blender.Modifier.is_door(element)
+        return tool.Parametric.is_door(element)
 
     def get_icon_y_extent(self, props: "BIMDoorProperties") -> tuple[float, float]:
         """Get Y extents for door icon positioning.
@@ -902,24 +894,20 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         return (furthest_y, furthest_y)
 
     def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create door-specific swing arc gizmos."""
-        prefs = tool.Blender.get_addon_preferences()
-        inactive_color = prefs.decorator_color_background[:3]
-        special_color = prefs.decorator_color_special[:3]
+        """Create one (main, flip) swing-arc pair per ``swing_arc_props`` entry.
 
-        self.gizmo_door_type = self.create_arc_gizmo(
-            special_color,
-            "bim.toggle_door_swing",
-            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",
-        )
+        Stored as ``self.gizmo_swing_arc_<name>`` and ``self.gizmo_swing_arc_<name>_flip``
+        and pinned to ``SWING_ARC_SELECT_BIAS`` so other door gizmos win selection."""
+        prefs = tool.Blender.get_addon_preferences()
+        main_color = prefs.decorator_color_special[:3]
+        flip_color = prefs.decorator_color_background[:3]
+        for cfg in self.swing_arc_props:
+            main = self.create_arc_gizmo(main_color, self.swing_arc_operator, flip_geometry=False)
+            flip = self.create_arc_gizmo(flip_color, self.swing_arc_operator, flip_geometry=True)
+            for gz in (main, flip):
+                gz.select_bias = self.SWING_ARC_SELECT_BIAS
+            setattr(self, f"gizmo_swing_arc_{cfg.name}", main)
+            setattr(self, f"gizmo_swing_arc_{cfg.name}_flip", flip)
 
     def _refresh_element_specific(
         self, context: bpy.types.Context, mw: Matrix, props: "BIMDoorProperties"  # noqa: ARG002
@@ -938,29 +926,23 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         self._update_view_dependent_dimensions(context, mw, props)
 
     def update_swing_gizmos(self, mw: Matrix, props: "BIMDoorProperties") -> None:
-        """Update swing gizmo position and color based on editing state."""
-        prefs = 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
+        """Position each declared swing-arc pair per its config + props state."""
+        mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
+        for cfg in self.swing_arc_props:
+            main = getattr(self, f"gizmo_swing_arc_{cfg.name}")
+            flip = getattr(self, f"gizmo_swing_arc_{cfg.name}_flip")
+            show = cfg.visibility_condition(props)
+            main_visible = self.update_gizmo_visibility(main, show)
+            flip_visible = self.update_gizmo_visibility(flip, show)
+            if not (main_visible or flip_visible):
+                continue
+            x_flip = Matrix.Scale(-1, 4, (1, 0, 0)) if cfg.x_mirror(props) else Matrix.Identity(4)
+            transform = (
+                Matrix.Translation(V_(cfg.hinge_x(props), cfg.hinge_y(props), 0))
+                @ Matrix.Scale(cfg.panel_width(props), 4)
+                @ x_flip
+            )
+            if main_visible:
+                main.matrix_basis = mw @ transform
+            if flip_visible:
+                flip.matrix_basis = mw @ transform @ mirror_y

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

@@ -0,0 +1,221 @@
+# 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.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 _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 a host element (wall / slab / roof) is the active object
+    and exactly one other selected object is *not* itself a host.
+
+    Renders a single ``VIEW3D_GT_add_opening`` icon at the void object's
+    projected location on the host. A click dispatches ``bim.add_opening``,
+    which handles any element exposing the ``HasOpenings`` inverse.
+
+    Per-frame positioning keeps the icon facing the camera as the viewport
+    orbits."""
+
+    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:
+        element = _resolve_active_host(context, n_selected=2)
+        if element is None:
+            return False
+        # The operator itself filters on HasOpenings, but checking here keeps
+        # the icon from appearing on host classes that can't accept openings
+        # in the active IFC schema.
+        if not hasattr(element, "HasOpenings"):
+            return False
+        active = context.active_object
+        other = next(o for o in tool.Blender.get_selected_objects() if o is not active)
+        # Host + host pairings are claimed by host-specific gizmos (wall-join,
+        # extend-vertical, …) — suppress here so the add-opening icon never
+        # stacks on top of them.
+        if is_supported_host(tool.Ifc.get_entity(other)):
+            return False
+        return True
+
+    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:
+        host_obj = context.active_object
+        if not host_obj:
+            return
+        selected = tool.Blender.get_selected_objects()
+        other = next((o for o in selected if o is not host_obj), None)
+        if not other:
+            return
+        element = tool.Ifc.get_entity(host_obj)
+        if not element:
+            return
+
+        if tool.Parametric.is_path_connectable_wall(element):
+            world_pos = wall_anchor(context, self, host_obj, other)
+        else:
+            world_pos = layer3_anchor(host_obj, other)
+        if world_pos is None:
+            return
+        self.add_opening_icon.matrix_basis = gizmo.billboarded_at(world_pos, gizmo.get_billboard_rotation(context))
+
+
+def wall_anchor(
+    context: bpy.types.Context, group: bpy.types.GizmoGroup, wall_obj: bpy.types.Object, other: bpy.types.Object
+) -> Vector | None:
+    """World-space anchor for the add-opening icon on a wall host: void origin
+    projected onto the wall reference-line X (clamped to wall extents), lifted to
+    the camera-facing wall-local Y."""
+    geom = _get_wall_geom_cached(group, wall_obj)
+    if not geom:
+        return None
+    mw = wall_obj.matrix_world
+    wall_local = mw.inverted() @ other.matrix_world.translation
+    local_x = max(geom["anchor_x"], min(wall_local.x, geom["anchor_x"] + geom["length"]))
+    icon_y = _wall_camera_facing_icon_y(context, mw, geom)
+    base_world = mw @ Vector((local_x, icon_y, 0.0))
+    top_world = mw @ Vector((local_x, icon_y, geom["height"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET))
+    return gizmo.BaseParametricGizmoGroup.pick_visible_anchor(context, base_world, top_world)
+
+
+def layer3_anchor(host_obj: bpy.types.Object, other: bpy.types.Object) -> Vector:
+    """World-space anchor for the add-opening icon on a LAYER3 host (slab / roof):
+    void's world XY, lifted just above the host's top face. Predictable height
+    regardless of where the void sits vertically — clicking the icon places the
+    opening at the void's XY, and the operator handles the actual cut depth."""
+    bbox = tool.Blender.get_object_world_bounding_box(host_obj)
+    anchor_xy = other.matrix_world.translation.xy
+    top_z = bbox["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
+    return Vector((anchor_xy.x, anchor_xy.y, top_z))
+
+
+def host_toggle_anchor(host_obj: bpy.types.Object) -> Vector:
+    """Object origin XY, lifted just above the topmost mesh vertex. Tracks
+    the parametric origin (useful reference even when the mesh extends
+    asymmetrically) and the visible top face (stays clear of sloped or
+    stepped bodies)."""
+    origin = host_obj.matrix_world.translation
+    top_z = tool.Blender.get_object_world_bounding_box(host_obj)["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
+    return Vector((origin.x, origin.y, top_z))
+
+
+class GizmoHostToggleOpenings(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
+    """Fallback toggle-openings icon for hosts that lack their own
+    parametric-edit toolbar — slabs today, plus any foreign-authored
+    IfcRoof that carries no BBIM_Roof pset (so ``GizmoRoofEdition`` doesn't
+    poll for it). Walls and parametric roofs already render an idle-row
+    toggle next to the pen and are excluded from this poll.
+
+    When slab parametric-edit lands the slab branch will pen-row-handle
+    its own toggle; updating the exclusion predicate here is the only
+    migration step needed."""
+
+    bl_idname = "OBJECT_GGT_bim_host_toggle_openings"
+    bl_label = "Host Toggle Openings Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        element = _resolve_active_host(context, n_selected=1)
+        if element is None:
+            return False
+        if not tool.Geometry.has_openings(element):
+            return False
+        # Skip when a per-feature parametric-edit gizmo already surfaces
+        # an idle-row toggle for this element — walls and parametric roofs
+        # both render their own toggle in the pen row.
+        if tool.Parametric.is_path_connectable_wall(element):
+            return False
+        if tool.Parametric.is_roof(element):
+            return False
+        return True
+
+    def setup(self, context: bpy.types.Context) -> None:
+        default_color, highlight_color = self.get_decoration_colors()
+        self.toggle_openings_icon = self.setup_icon_gizmo(
+            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.toggle_host_openings"
+        )
+
+    def position_gizmos(self, context: bpy.types.Context) -> None:
+        host_obj = context.active_object
+        if not host_obj:
+            return
+        self.toggle_openings_icon.matrix_basis = gizmo.billboarded_at(
+            host_toggle_anchor(host_obj), gizmo.get_billboard_rotation(context)
+        )

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

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

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

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 from collections.abc import Sequence
 from math import radians
@@ -41,8 +43,202 @@ 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)
+
 
 class FilledOpeningGenerator:
     def generate(
@@ -50,9 +246,15 @@ 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()
@@ -74,7 +276,7 @@ class FilledOpeningGenerator:
             should_set_z_level = False
 
         # Sometimes, the voided_obj may be an aggregate, which won't have any representation.
-        if voided_obj.data:
+        if not preserve_placement and voided_obj.data:
             raycast = voided_obj.closest_point_on_mesh(voided_obj.matrix_world.inverted() @ target, distance=0.01)
             if not raycast[0]:
                 target = filling_obj.matrix_world.translation.copy()
@@ -558,6 +760,29 @@ class AddBoolean(Operator, tool.Ifc.Operator):
         tool.Root.reload_item_decorator()
 
 
+class ToggleHostOpenings(Operator, tool.Ifc.Operator):
+    bl_idname = "bim.toggle_host_openings"
+    bl_label = "Toggle Openings"
+    bl_description = "Show or hide opening fills (doors and windows) in the viewport\n\nHotkey: Alt+O"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Model.has_selected_ifc_objects():
+            cls.poll_message_set("No IFC objects selected.")
+            return False
+        return True
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        # Opening visibility is independent of host geometry — don't commit any
+        # active parametric edit; the user can keep editing the host.
+        if tool.Model.get_model_props().openings:
+            bpy.ops.bim.edit_openings(apply_all=True)
+        else:
+            bpy.ops.bim.show_openings()
+        return {"FINISHED"}
+
+
 class ShowOpenings(Operator, tool.Ifc.Operator):
     bl_idname = "bim.show_openings"
     bl_label = "Show Openings"
@@ -941,7 +1166,6 @@ class SelectBoolean(Operator):
         return {"FINISHED"}
 
 
-# TODO: merge with ProfileDecorator?
 class DecorationsHandler:
     installed = None
 
@@ -951,6 +1175,7 @@ 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):
@@ -959,15 +1184,79 @@ class DecorationsHandler:
         except ValueError:
             pass
         cls.installed = None
+        uninstall_decoration_cache_handlers()
 
-    def draw_batch(self, shader_type, content_pos, color, indices=None):
+    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
         if not tool.Blender.validate_shader_batch_data(content_pos, indices):
-            return
-        shader = self.line_shader if shader_type == "LINES" else self.shader
+            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.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:
@@ -1001,7 +1290,7 @@ class DecorationsHandler:
             self.line_shader.bind()  # required to be able to change uniforms of the shader
             # POLYLINE_UNIFORM_COLOR specific uniforms
             self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
-            self.line_shader.uniform_float("lineWidth", 2.0)
+            self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
 
             # general shader
             self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
@@ -1039,23 +1328,18 @@ 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:
-                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]
-
+                line_verts, verts, edges_indices, tris = _get_cached_world_draw_data(obj)
                 color = selected_elements_color if obj in context.selected_objects else special_elements_color
-                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)
+                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"),
+                )
 
             if "HalfSpaceSolid" in obj.name:
                 # Arrow shape
@@ -1069,7 +1353,4 @@ 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_batch("LINES", verts, color, edges)
-
-            if obj.mode != "EDIT":
-                bm.free()
+                self._draw_lines_with_occlusion(verts, color, edges, cache_key=(obj.session_uid, "arrow"))

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

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

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

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

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

@@ -1157,7 +1157,8 @@ class DrawPolylineProfile(bpy.types.Operator, PolylineOperator, tool.Ifc.Operato
                         DumbProfileJoiner().join_V(profile2["obj"], profile1["obj"])
                         if connect_IfcFlowSegments:
                             bpy.ops.bim.mep_connect_elements(
-                                obj1_name=profile1["obj"].name, obj2_name=profile2["obj"].name
+                                obj1_guid=tool.Ifc.get_entity(profile1["obj"]).GlobalId,
+                                obj2_guid=tool.Ifc.get_entity(profile2["obj"]).GlobalId,
                             )
 
     def modal(self, context, event):

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

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 import math
 from collections.abc import Callable
@@ -101,8 +103,12 @@ def update_type_page(self: "BIMModelProperties", context: bpy.types.Context) ->
 
 
 def update_relating_array_from_object(self: "BIMArrayProperties", context: bpy.types.Context) -> None:
-    bpy.ops.bim.enable_editing_array(item=self.is_editing)
-    return
+    # Skip the cleanup-time clear: Finish/Cancel sets relating_array_object back to None,
+    # which has no source to hydrate from. Only the user-driven pick (None → some array)
+    # should auto-enter edit on the picked source's layer 0.
+    if self.relating_array_object is None:
+        return
+    bpy.ops.bim.enable_editing_array(item=0)
 
 
 def is_object_array_applicable(self: "BIMArrayProperties", obj: bpy.types.Object) -> bool:
@@ -193,6 +199,32 @@ def update_stair(self: "BIMStairProperties", context: bpy.types.Context) -> None
         _get_updater("stair", "regenerate_stair_mesh")(obj)
 
 
+def update_wall(self: "BIMWallProperties", context: bpy.types.Context) -> None:
+    """Regenerate wall mesh preview when property changes. Does NOT touch IFC."""
+    obj = context.active_object
+    if obj and self.is_editing:
+        _get_updater("wall", "regenerate_wall_mesh_from_props")(obj)
+
+
+def update_wall_offset_baseline(self: "BIMWallProperties", context: bpy.types.Context) -> None:
+    """Recompute the preview-only ``offset`` when the draft baseline cycles. Does not touch IFC.
+
+    ``offset`` itself has no ``update`` callback on purpose — adding one would make
+    every baseline cycle rebuild the bmesh twice (once via offset's callback, once
+    explicitly below)."""
+    obj = context.active_object
+    if not (obj and self.is_editing):
+        return
+    t = self.thickness
+    if self.desired_offset_baseline == "CENTER":
+        self.offset = -t / 2
+    elif self.desired_offset_baseline == "INTERIOR":
+        self.offset = -t
+    else:  # EXTERIOR
+        self.offset = 0.0
+    _get_updater("wall", "regenerate_wall_mesh_from_props")(obj)
+
+
 def update_railing(self: "BIMRailingProperties", context: bpy.types.Context) -> None:
     """Regenerate railing mesh when property changes."""
     if self.is_editing:
@@ -210,6 +242,20 @@ def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
         _get_updater("roof", "update_roof_modifier_bmesh")(obj)
 
 
+def update_pipe_segment(self: "BIMPipeSegmentProperties", context: bpy.types.Context) -> None:
+    """Regenerate pipe-segment preview mesh from props during edit. Does NOT touch IFC."""
+    obj = context.active_object
+    if obj and self.is_editing:
+        _get_updater("mep", "regenerate_pipe_segment_mesh_from_props")(obj)
+
+
+def update_duct_segment(self: "BIMDuctSegmentProperties", context: bpy.types.Context) -> None:
+    """Regenerate duct-segment preview mesh from props during edit. Does NOT touch IFC."""
+    obj = context.active_object
+    if obj and self.is_editing:
+        _get_updater("mep", "regenerate_duct_segment_mesh_from_props")(obj)
+
+
 class BIMModelProperties(PropertyGroup):
     ifc_class: bpy.props.EnumProperty(items=get_ifc_class, name="Construction Class", update=update_ifc_class)
     relating_type_id: bpy.props.EnumProperty(
@@ -369,8 +415,13 @@ class BIMModelProperties(PropertyGroup):
 
 
 class BIMArrayProperties(PropertyGroup):
-    is_editing: bpy.props.IntProperty(
-        default=-1, description="Currently edited array index. -1 if not in array editing mode."
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while an array layer is in parametric edit mode. The specific layer is in editing_item_index.",
+    )
+    editing_item_index: bpy.props.IntProperty(
+        default=-1,
+        description="Index of the array layer currently being edited; -1 when not in edit mode.",
     )
     count: bpy.props.IntProperty(name="Count", default=0, min=0)
     x: bpy.props.FloatProperty(name="X", default=0, subtype="DISTANCE")
@@ -386,6 +437,15 @@ class BIMArrayProperties(PropertyGroup):
         name="Method",
         default="OFFSET",
     )
+    per_child_opening: bpy.props.BoolProperty(
+        name="Per-Child Opening",
+        description=(
+            "When the array parent fills a wall (or any voidable host), give each array child its own opening + "
+            "filling pair so the host is cut once per child. Disable to leave the host uncut by the children — "
+            "only the parent's original opening remains"
+        ),
+        default=True,
+    )
     relating_array_object: bpy.props.PointerProperty(
         type=bpy.types.Object,
         name="Copy Array Properties",
@@ -394,13 +454,15 @@ class BIMArrayProperties(PropertyGroup):
     )
 
     if TYPE_CHECKING:
-        is_editing: int
+        is_editing: bool
+        editing_item_index: int
         count: int
         x: float
         y: float
         z: float
         use_local_space: bool
         method: Literal["OFFSET", "DISTRIBUTE"]
+        per_child_opening: bool
         sync_children: bool
         relating_array_object: Union[bpy.types.Object, None]
 
@@ -1631,6 +1693,118 @@ class BIMRoofProperties(PropertyGroup):
             setattr(target_props, prop_name, prop_value)
 
 
+class BIMWallProperties(PropertyGroup):
+    """Transient draft state for parametric wall gizmo editing.
+
+    Populated from IFC on `bim.enable_editing_wall`, mutated by gizmo drags during edit
+    (preview only — no IFC writes), and either committed by `bim.finish_editing_wall`
+    or discarded by `bim.cancel_editing_wall`.
+
+    The `snap_*` fields are the values captured on enable; `finish_editing_wall` compares
+    current vs snap to skip unchanged params and guarantee a no-op session leaves the
+    IFC file byte-identical.
+    """
+
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while wall parametric edit mode is active.",
+    )
+    mesh_dirty: bpy.props.BoolProperty(
+        default=False,
+        options={"HIDDEN", "SKIP_SAVE"},
+        description=(
+            "True while the visible mesh is the preview box; cleared once the real "
+            "IFC-derived geometry is restored (on commit or cancel)."
+        ),
+    )
+    length: bpy.props.FloatProperty(
+        name="Length",
+        default=1.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_wall,
+        description="Wall length along its reference axis (preview value; committed on finish).",
+    )
+    height: bpy.props.FloatProperty(
+        name="Height",
+        default=3.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_wall,
+        description="Wall vertical height (preview value; committed on finish).",
+    )
+    x_angle: bpy.props.FloatProperty(
+        name="Slope (X Angle)",
+        default=0.0,
+        soft_min=-math.pi / 3,
+        soft_max=math.pi / 3,
+        subtype="ANGLE",
+        update=update_wall,
+        description="Slope angle: tilt of the wall's top face along +Y (preview value; committed on finish).",
+    )
+    thickness: bpy.props.FloatProperty(
+        name="Thickness",
+        default=0.2,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Wall thickness captured from IFC at edit-enable; not gizmo-bound.",
+    )
+    offset: bpy.props.FloatProperty(
+        name="Offset",
+        default=0.0,
+        subtype="DISTANCE",
+        description="Layer-set offset captured from IFC at edit-enable; driven by desired_offset_baseline.",
+    )
+    desired_offset_baseline: bpy.props.EnumProperty(
+        items=[
+            ("EXTERIOR", "Exterior", "Reference axis at the exterior face"),
+            ("CENTER", "Center", "Reference axis at the wall centreline"),
+            ("INTERIOR", "Interior", "Reference axis at the interior face"),
+        ],
+        name="Desired Offset Baseline",
+        default="CENTER",
+        update=update_wall_offset_baseline,
+        description="Which face of the wall the reference axis aligns to (preview value; committed on finish).",
+    )
+    anchor_x: bpy.props.FloatProperty(
+        default=0.0,
+        subtype="DISTANCE",
+        description="Local-X of the wall's axis polyline start, so the preview box lands where the IFC mesh does.",
+    )
+
+    snap_length: bpy.props.FloatProperty(description="Snapshot of length at edit-enable; commit skips no-op writes.")
+    snap_height: bpy.props.FloatProperty(description="Snapshot of height at edit-enable; commit skips no-op writes.")
+    snap_thickness: bpy.props.FloatProperty(
+        description="Snapshot of thickness at edit-enable; commit skips no-op writes."
+    )
+    snap_offset: bpy.props.FloatProperty(description="Snapshot of offset at edit-enable; commit skips no-op writes.")
+    snap_x_angle: bpy.props.FloatProperty(
+        subtype="ANGLE",
+        description="Snapshot of x_angle at edit-enable; commit skips no-op writes.",
+    )
+    snap_offset_baseline: bpy.props.StringProperty(
+        default="",
+        description="Snapshot of desired_offset_baseline at edit-enable; commit skips no-op writes.",
+    )
+
+    if TYPE_CHECKING:
+        is_editing: bool
+        mesh_dirty: bool
+        length: float
+        height: float
+        x_angle: float
+        thickness: float
+        offset: float
+        desired_offset_baseline: Literal["EXTERIOR", "CENTER", "INTERIOR"]
+        anchor_x: float
+        snap_length: float
+        snap_height: float
+        snap_thickness: float
+        snap_offset: float
+        snap_x_angle: float
+        snap_offset_baseline: str
+
+
 class SnapMousePoint(PropertyGroup):
     x: bpy.props.FloatProperty(name="X")
     y: bpy.props.FloatProperty(name="Y")
@@ -1762,3 +1936,236 @@ class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
         geometry_source: Literal["GEONODES", "IFCSVERCHOK"]
         geo_nodes: Union[bpy.types.GeometryNodeTree, None]
         sverchok_nodes: Union[sverchok.node_tree.SverchCustomTree, None]
+
+
+class BIMPipeSegmentProperties(PropertyGroup):
+    """Transient draft state for parametric pipe-segment gizmo editing."""
+
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while pipe-segment parametric edit mode is active.",
+    )
+    mesh_dirty: bpy.props.BoolProperty(
+        default=False,
+        options={"HIDDEN", "SKIP_SAVE"},
+        description=(
+            "True while the visible mesh is the preview shape; cleared once the "
+            "real IFC-derived geometry is restored (on commit or cancel)."
+        ),
+    )
+    length: bpy.props.FloatProperty(
+        name="Length",
+        default=1.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_pipe_segment,
+        description="Pipe-segment extrusion length (preview value; committed on finish).",
+    )
+    snap_length: bpy.props.FloatProperty(
+        description="Snapshot of length at edit-enable; commit skips no-op writes.",
+    )
+    snap_object_scale_z: bpy.props.FloatProperty(
+        default=1.0,
+        description=(
+            "Snapshot of obj.scale.z at edit-enable. Cancel / no-op-finish restore "
+            "this exact value so a user's non-identity pre-edit scale isn't silently "
+            "zeroed by the scale-based preview."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_editing: bool
+        mesh_dirty: bool
+        length: float
+        snap_length: float
+        snap_object_scale_z: float
+
+
+class BIMDuctSegmentProperties(PropertyGroup):
+    """Transient draft state for parametric duct-segment gizmo editing."""
+
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while duct-segment parametric edit mode is active.",
+    )
+    mesh_dirty: bpy.props.BoolProperty(
+        default=False,
+        options={"HIDDEN", "SKIP_SAVE"},
+        description=(
+            "True while the visible mesh is the preview shape; cleared once the "
+            "real IFC-derived geometry is restored (on commit or cancel)."
+        ),
+    )
+    length: bpy.props.FloatProperty(
+        name="Length",
+        default=1.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_duct_segment,
+        description="Duct-segment extrusion length (preview value; committed on finish).",
+    )
+    snap_length: bpy.props.FloatProperty(
+        description="Snapshot of length at edit-enable; commit skips no-op writes.",
+    )
+    snap_object_scale_z: bpy.props.FloatProperty(
+        default=1.0,
+        description=(
+            "Snapshot of obj.scale.z at edit-enable. Cancel / no-op-finish restore "
+            "this exact value so a user's non-identity pre-edit scale isn't silently "
+            "zeroed by the scale-based preview."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_editing: bool
+        mesh_dirty: bool
+        length: float
+        snap_length: float
+        snap_object_scale_z: float
+
+
+class BIMBendPreviewProperties(PropertyGroup):
+    """Scene-level pending state for the bend-creation preview flow.
+
+    Scene-level (not per-object) because the bend involves two segments by
+    IFC id — neither alone owns the draft."""
+
+    is_active: bpy.props.BoolProperty(
+        default=False,
+        options={"SKIP_SAVE"},
+        description="True while the bend-creation preview flow is active.",
+    )
+    start_segment_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description="IFC element id of the start (active) segment.",
+    )
+    end_segment_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description="IFC element id of the end (other selected) segment.",
+    )
+    start_length: bpy.props.FloatProperty(
+        name="Start Length",
+        default=0.1,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Length of the bend fitting's tangent leg on the start (active) segment side",
+    )
+    end_length: bpy.props.FloatProperty(
+        name="End Length",
+        default=0.1,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Length of the bend fitting's tangent leg on the end (other) segment side",
+    )
+    radius: bpy.props.FloatProperty(
+        name="Radius",
+        default=0.2,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Inner radius of the bend curve",
+    )
+    editing_bend_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description=(
+            "IFC element id of an existing bend fitting being re-edited "
+            "(non-zero only on the pen-icon re-edit flow). The create "
+            "operator deletes this bend + its port connections before "
+            "recreating with the new parameters."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_active: bool
+        start_segment_id: int
+        end_segment_id: int
+        start_length: float
+        end_length: float
+        radius: float
+        editing_bend_id: int
+
+
+class BIMWallFilletPreviewProperties(PropertyGroup):
+    """Scene-level pending state for the wall-fillet preview flow.
+
+    Scene-level because the fillet spans two walls and commits a third
+    (corner) wall between them. ``SKIP_SAVE`` fields throughout."""
+
+    is_active: bpy.props.BoolProperty(
+        default=False,
+        options={"SKIP_SAVE"},
+        description="True while the wall-fillet preview flow is active.",
+    )
+    wall_a_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description=(
+            "IFC element id of the active wall — the corner wall inherits its "
+            "material layer set, height, x_angle, and type."
+        ),
+    )
+    wall_b_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description="IFC element id of the other selected wall.",
+    )
+    radius: bpy.props.FloatProperty(
+        name="Radius",
+        default=0.5,
+        soft_min=-10.0,
+        soft_max=10.0,
+        subtype="DISTANCE",
+        unit="LENGTH",
+        options={"SKIP_SAVE"},
+        description="Radius of the circular arc connecting the two walls.",
+    )
+    editing_corner_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description=(
+            "IFC element id of an existing fillet corner being re-edited "
+            "(non-zero only on the pen-icon re-edit flow). The create "
+            "operator deletes this corner + its connections before recreating "
+            "with the new radius."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_active: bool
+        wall_a_id: int
+        wall_b_id: int
+        radius: float
+        editing_corner_id: int
+
+
+class BIMPreviewProperties(PropertyGroup):
+    """Umbrella for parametric-edit preview drafts attached to ``Scene``."""
+
+    bend: bpy.props.PointerProperty(type=BIMBendPreviewProperties)
+    wall_fillet: bpy.props.PointerProperty(type=BIMWallFilletPreviewProperties)
+
+    if TYPE_CHECKING:
+        bend: BIMBendPreviewProperties
+        wall_fillet: BIMWallFilletPreviewProperties
+
+
+class BIMParametricEditDialogPrefs(PropertyGroup):
+    """Session-scoped flag for the parametric-edit pen-icon dispatcher.
+
+    Attached to ``WindowManager`` so the state lives for one Blender session
+    and resets on restart — the right scope for "don't show this again for
+    this session" toggles."""
+
+    suppress_shared_rep_warning: bpy.props.BoolProperty(
+        name="Suppress shared-representation warning",
+        description=(
+            "When true, the pen-icon dispatcher skips the shared-geometry "
+            "confirmation dialog. Resets on Blender restart."
+        ),
+        default=False,
+    )
+
+    if TYPE_CHECKING:
+        suppress_shared_rep_warning: bool

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

@@ -34,6 +34,7 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.model.data import RailingData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
+from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin
 
 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRailing.htm
@@ -92,7 +93,6 @@ def update_railing_modifier_ifc_data(context: bpy.types.Context) -> None:
         si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
 
         representation_data = {
-            "railing_type": props.railing_type,
             "context": body,
             "railing_path": railing_path,
             "use_manual_supports": props.use_manual_supports,
@@ -406,66 +406,65 @@ class CopyRailingParameters(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class EnableEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.enable_editing_railing"
-    bl_label = "Enable Editing Railing"
-    bl_options = {"REGISTER"}
+class _RailingEditMixin(PathPreservingEditMixin):
+    """Type-specific hooks for railing parametric-edit operators. Single-object
+    (active_object). ``path_data`` is preserved through the edit; the separate
+    ``Enable/Finish/CancelEditingRailingPath`` operators handle path editing."""
 
-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        props = tool.Model.get_railing_props(obj)
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
+    pset_name = "BBIM_Railing"
+
+    @classmethod
+    def _is_element_type(cls, element):
+        return tool.Parametric.is_railing(element)
+
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        return tool.Model.get_railing_props(obj)
+
+    @classmethod
+    def _post_load_data(cls, data: dict) -> dict:
+        # BIMRailingProperties.path_data is a StringProperty holding JSON.
         data["path_data"] = json.dumps(data["path_data"])
+        return data
 
-        # required since we could load pset from .ifc and BIMRailingProperties won't be set
-        props.set_props_kwargs_from_ifc_data(data)
+    @classmethod
+    def _update_pset(cls, element, data: dict) -> None:
+        update_bbim_railing_pset(element, data)
 
-        props.is_editing = True
-        return {"FINISHED"}
+    @classmethod
+    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        update_railing_modifier_ifc_data(context)
 
-
-class CancelEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.cancel_editing_railing"
-    bl_label = "Cancel Editing Railing"
-    bl_options = {"REGISTER"}
-
-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
-        props = tool.Model.get_railing_props(obj)
-
-        # restore previous settings since editing was canceled
-        props.set_props_kwargs_from_ifc_data(data)
+    @classmethod
+    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
         update_railing_modifier_bmesh(context)
 
-        props.is_editing = False
-        return {"FINISHED"}
 
-
-class FinishEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.finish_editing_railing"
-    bl_label = "Finish Editing Railing"
-    bl_options = {"REGISTER"}
+class EnableEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_railing"
+    bl_label = "Enable Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        props = tool.Model.get_railing_props(obj)
+        return self._enable_targets(context)
 
-        pset_data = tool.Model.get_modeling_bbim_pset_data(bpy.context.active_object, "BBIM_Railing")
-        path_data = pset_data["data_dict"]["path_data"]
 
-        railing_data = props.get_general_kwargs(convert_to_project_units=True)
-        railing_data["path_data"] = path_data
-        props.is_editing = False
+class CancelEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.cancel_editing_railing"
+    bl_label = "Cancel Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}
 
-        update_bbim_railing_pset(element, railing_data)
-        update_railing_modifier_ifc_data(context)
-        return {"FINISHED"}
+    def _execute(self, context):
+        return self._cancel_targets(context)
+
+
+class FinishEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.finish_editing_railing"
+    bl_label = "Finish Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        return self._finish_targets(context)
 
 
 class FlipRailingPathOrder(bpy.types.Operator, tool.Ifc.Operator):

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

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

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

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

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

@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING, Any
 import bpy
 from bpy.types import Panel
 
+import ifcopenshell.util.unit
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import prop_with_search
@@ -237,11 +238,11 @@ class BIM_PT_array(bpy.types.Panel):
 
             for i, array in enumerate(ArrayData.data["parameters"]["data_dict"]):
                 box = self.layout.box()
-                if props.is_editing == i:
+                if props.editing_item_index == i:
                     row = box.row(align=True)
                     row.prop(props, "count", icon="MOD_ARRAY")
-                    row.operator("bim.edit_array", icon="CHECKMARK", text="").item = i
-                    row.operator("bim.disable_editing_array", icon="CANCEL", text="")
+                    row.operator("bim.finish_editing_array", icon="CHECKMARK", text="")
+                    row.operator("bim.cancel_editing_array", icon="CANCEL", text="")
                     row = box.row(align=True)
                     row.prop(props, "method")
                     row = box.row(align=True)
@@ -303,6 +304,8 @@ class BIM_PT_stair(bpy.types.Panel):
             row = self.layout.row(align=True)
             row.label(text="Stair parameters", icon="IPO_CONSTANT")
 
+            si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+
             if props.is_editing:
                 calculated_params = tool.Model.get_active_stair_calculated_params()
                 row = self.layout.row(align=True)
@@ -322,22 +325,61 @@ class BIM_PT_stair(bpy.types.Panel):
                         row.label(text=f"{prop_name}:")
                         row = self.layout.row(align=True)
                         for prop_value_item in prop_value:
-                            row.label(text=str(prop_value_item))
+                            if isinstance(prop_value_item, float):
+                                row.label(text=tool.Unit.format_distance(prop_value_item * si_conversion))
+                            else:
+                                row.label(text=str(prop_value_item))
                     else:
                         row.label(text=prop_name)
-                        row.label(text=str(prop_value))
+                        if isinstance(prop_value, float):
+                            row.label(text=tool.Unit.format_distance(prop_value * si_conversion))
+                        else:
+                            row.label(text=str(prop_value))
 
             # calculated properties
             for prop_name, prop_value in calculated_params.items():
                 row = self.layout.row(align=True)
                 row.label(text=prop_name)
-                row.label(text=str(prop_value))
+                if isinstance(prop_value, float):
+                    row.label(text=tool.Unit.format_distance(prop_value * si_conversion))
+                else:
+                    row.label(text=str(prop_value))
         else:
             row = self.layout.row()
             row.label(text="No Stair Found")
             row.operator("bim.add_stair", icon="ADD", text="")
 
 
+class BIM_PT_wall(bpy.types.Panel):
+    bl_label = "Wall"
+    bl_idname = "BIM_PT_wall"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "scene"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_parent_id = "BIM_PT_tab_parametric_geometry"
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        if not obj:
+            return False
+        element = tool.Ifc.get_entity(obj)
+        return bool(element) and tool.Parametric.is_wall(element)
+
+    def draw(self, context):
+        obj = context.active_object
+        if obj is None:
+            return
+        props = tool.Model.get_wall_props(obj)
+        row = self.layout.row(align=True)
+        if props.is_editing:
+            row.operator("bim.finish_editing_wall", icon="CHECKMARK", text="Finish Editing")
+            row.operator("bim.cancel_editing_wall", icon="CANCEL", text="")
+        else:
+            row.operator("bim.enable_editing_wall", icon="GREASEPENCIL", text="Edit Wall")
+
+
 class BIM_PT_sverchok(bpy.types.Panel):
     bl_label = "Sverchok"
     bl_idname = "BIM_PT_sverchok"

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

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

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

@@ -39,6 +39,8 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+from bonsai.bim.module.model.wall_offset_gizmos import WALL_OFFSET_GIZMO_CONFIGS
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin, PickTypeMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMWindowProperties
@@ -482,90 +484,53 @@ class AddWindow(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class CancelEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
+class _WindowEditMixin(FeatureModifierEditMixin):
+    """Type-specific hooks for window parametric-edit operators. Single-object
+    by design (window edits target the active object only)."""
+
+    pset_name = "BBIM_Window"
+
+    @classmethod
+    def _is_element_type(cls, element):
+        return tool.Parametric.is_window(element)
+
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        return tool.Model.get_window_props(obj)
+
+    @classmethod
+    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        update_window_modifier_representation(context)
+
+
+class CancelEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.cancel_editing_window"
     bl_label = "Cancel Editing Window"
     bl_description = "Cancel editing and revert window parameters to their previous values"
-    bl_options = {"REGISTER"}
+    bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        obj = context.active_object
-        assert obj
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "Data"))
-        data.update(data.pop("lining_properties"))
-        data.update(data.pop("panel_properties"))
-        props = tool.Model.get_window_props(obj)
-        props.set_props_kwargs_from_ifc_data(data)
-
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        bonsai.core.geometry.switch_representation(
-            tool.Ifc,
-            tool.Geometry,
-            obj=obj,
-            representation=body,
-        )
-
-        props.is_editing = False
-        return {"FINISHED"}
+        return self._cancel_targets(context)
 
 
-class FinishEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.finish_editing_window"
     bl_label = "Finish Editing Window"
     bl_description = "Apply changes and finish editing window parameters"
-    bl_options = {"REGISTER"}
+    bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        obj = context.active_object
-        assert obj
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        props = tool.Model.get_window_props(obj)
-
-        window_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)
-
-        window_data["lining_properties"] = lining_props
-        window_data["panel_properties"] = panel_props
-
-        props.is_editing = False
-
-        update_window_modifier_representation(context)
-        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_Window")
-        window_data = tool.Ifc.get().createIfcText(json.dumps(window_data, default=list))
-        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": window_data})
-        return {"FINISHED"}
+        return self._finish_targets(context)
 
 
-class EnableEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_window"
     bl_label = "Enable Editing Window"
     bl_description = "Enter edit mode to modify window parameters interactively"
-    bl_options = {"REGISTER"}
+    bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        obj = context.active_object
-        assert obj
-        props = tool.Model.get_window_props(obj)
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "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 BIMWindowProperties won't be set
-        props.set_props_kwargs_from_ifc_data(data)
-
-        props.is_editing = True
-        return {"FINISHED"}
+        return self._enable_targets(context)
 
 
 class RemoveWindow(bpy.types.Operator, tool.Ifc.Operator):
@@ -587,20 +552,20 @@ class RemoveWindow(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class CycleWindowType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin):
-    """Cycle through available window types. Shift+click to cycle in reverse."""
+class PickWindowType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
+    """Pick a window type from a popup menu."""
 
-    bl_idname = "bim.cycle_window_type"
-    bl_label = "Cycle Window Type"
+    bl_idname = "bim.pick_window_type"
+    bl_label = "Pick Window Type"
     bl_options = {"REGISTER", "UNDO"}
 
-    element_checker = "is_window"
-    props_getter = "get_window_props"
+    element_checker = tool.Parametric.is_window
+    props_getter = tool.Model.get_window_props
     type_literal = tool.Model.WindowType
     type_attr = "window_type"
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cycle_type(context)
+        return self._pick_type(context)
 
 
 # Frame accessor factory - creates callbacks that delegate to BIMWindowProperties methods
@@ -638,7 +603,7 @@ class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     enable_editing_operator = "bim.enable_editing_window"
     finish_editing_operator = "bim.finish_editing_window"
     cancel_editing_operator = "bim.cancel_editing_window"
-    cycle_type_operator = "bim.cycle_window_type"
+    pick_type_operator = "bim.pick_window_type"
 
     # matrix_position lambdas replace the get_dimension_matrix_* methods
     dimension_gizmo_props = [
@@ -779,14 +744,15 @@ class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         ),
         # lining_offset is handled specially in _update_dimension_gizmo_positions due to negative value support
         DimensionGizmoConfig(attr_name="lining_offset", axis=(0, 1, 0), min_value=-10.0),
+        *WALL_OFFSET_GIZMO_CONFIGS,
     ]
 
-    props_getter = "get_window_props"
+    props_getter = tool.Model.get_window_props
     gizmo_pref_name = "window"
 
     @classmethod
     def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Blender.Modifier.is_window(element)
+        return tool.Parametric.is_window(element)
 
     def get_icon_y_extent(self, props: "BIMWindowProperties") -> tuple[float, float]:
         """Get Y extents for window icon positioning.

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

@@ -841,7 +841,7 @@ class EditObjectUI:
         row = cls.layout.row(align=True)
         row.separator()
         row.label(text="Operations") if ui_context != "TOOL_HEADER" else row
-        cls.draw_regen_operations(row)
+        cls.draw_regen_operations(row, ui_context)
 
         if AuthoringData.data["active_material_usage"] == "LAYER2":
             row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
@@ -962,20 +962,16 @@ class EditObjectUI:
         return row
 
     @classmethod
-    def draw_regen_operations(cls, row):
-        custom_icon = custom_icon_previews.get("REGEN", custom_icon_previews["IFC"]).icon_id
-
+    def draw_regen_operations(cls, row, ui_context):
         if AuthoringData.data["is_regenable_element"]:
-            op = row.operator("bim.hotkey", text="", icon_value=custom_icon)
-            description = "Recalculate Element Geometry\nHotkey: S G"
-            op.hotkey = "S_G"
-            op.description = description.strip()
+            row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
+            add_layout_hotkey_operator(row, "Regen", "S_G", "Recalculate Element Geometry", ui_context)
 
         if PortData.data["total_ports"] > 0:
-            op = row.operator("bim.hotkey", text="", icon_value=custom_icon)
-            description = f"{bpy.ops.bim.regenerate_distribution_element.__doc__}\n\nHotkey: S G"
-            op.hotkey = "S_G"
-            op.description = description.strip()
+            row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
+            add_layout_hotkey_operator(
+                row, "Regen", "S_G", bpy.ops.bim.regenerate_distribution_element.__doc__, ui_context
+            )
 
     @classmethod
     def draw_void(cls, context, row):
@@ -1300,9 +1296,15 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
                 bpy.ops.bim.generate_space()
             return
         if self.active_material_usage == "LAYER2":
-            bpy.ops.bim.recalculate_wall()
+            if element and tool.Model.has_underside_connection(element):
+                bpy.ops.bim.regenerate_wall_to_underside()
+            else:
+                bpy.ops.bim.recalculate_wall()
         elif self.active_material_usage == "LAYER3":
             bpy.ops.bim.recalculate_slab()
+            wall_objs = tool.Model.get_connected_wall_objs(element)
+            if wall_objs:
+                core.regenerate_wall_to_underside(tool.Ifc, tool.Geometry, tool.Model, wall_objs)
         elif tool.System.get_ports(element):
             bpy.ops.bim.regenerate_distribution_element()
         elif self.active_material_usage == "PROFILE":
@@ -1442,10 +1444,7 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             bpy.ops.bim.enable_editing_extrusion_axis()
 
     def hotkey_A_O(self):
-        if tool.Model.get_model_props().openings:
-            bpy.ops.bim.edit_openings(apply_all=True)
-        else:
-            bpy.ops.bim.show_openings()
+        bpy.ops.bim.toggle_host_openings()
 
     def hotkey_C_E(self):
         if not bpy.context.selected_objects:

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

@@ -28,6 +28,10 @@ classes = (
     operator.AppendLibraryElementByQuery,
     operator.AssignLibraryDeclaration,
     operator.BIM_FH_import_ifc,
+    operator.BIM_OT_apply_pending_opening_cuts,
+    operator.BIM_OT_dismiss_multi_instance_warning,
+    operator.BIM_OT_dismiss_pending_opening_cuts,
+    operator.BIM_OT_select_pending_opening_cuts,
     operator.BIM_OT_load_clipping_planes,
     operator.BIM_OT_save_clipping_planes,
     operator.ChangeLibraryElement,
@@ -82,6 +86,7 @@ classes = (
     prop.FilterCategory,
     prop.Link,
     prop.EditedObj,
+    prop.PendingOpeningRecut,
     prop.BIMProjectProperties,
     prop.MeasureToolSettings,
     ui.BIM_MT_new_project,

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

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 import datetime
 import json
@@ -61,6 +63,7 @@ import bonsai.core.project as core
 import bonsai.tool as tool
 from bonsai.bim import export_ifc, import_ifc
 from bonsai.bim.ifc import IfcStore
+from bonsai.bim.module.model import preview_base
 from bonsai.bim.module.model.decorator import FaceAreaDecorator, PolylineDecorator
 from bonsai.bim.module.model.polyline import PolylineOperator
 from bonsai.bim.module.project.data import LinksData, ProjectLibraryData
@@ -1220,6 +1223,19 @@ class LoadProjectElements(bpy.types.Operator):
         props = tool.Project.get_project_props()
         props.is_loading = False
 
+        # Stash elements the kernel skipped opening cuts on (HasOpenings > void_limit).
+        # The Project panel banner offers the user a one-click recut.
+        props.pending_opening_recut.clear()
+        if ifc_importer.gross_elements:
+            for element in ifc_importer.gross_elements:
+                item = props.pending_opening_recut.add()
+                item.ifc_definition_id = element.id()
+            self.report(
+                {"WARNING"},
+                f"{len(ifc_importer.gross_elements)} element(s) had too many openings and were loaded without cuts. "
+                f"Apply manually from the Project panel.",
+            )
+
         tool.Project.load_default_thumbnails()
         tool.Project.set_default_context()
         tool.Project.set_default_modeling_dimensions()
@@ -1903,11 +1919,11 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
 
         self.use_relative_path = tool.Project.get_project_props().use_relative_project_path
         props = tool.Blender.get_bim_props()
-        if (filepath := props.ifc_file) and not self.should_save_as:
-            self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(filepath)))
-            return self.execute(context)
-
-        return ExportHelper.invoke(self, context, event)
+        filepath = props.ifc_file
+        if not filepath or self.should_save_as:
+            return ExportHelper.invoke(self, context, event)
+        self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(filepath)))
+        return self.execute(context)
 
     def check(self, context):
         # ExportHelper is automatically adjusting suffix to `filename_ext`.
@@ -1933,6 +1949,20 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         return {"FINISHED"}
 
     def _execute(self, context):
+        committed, failed_commits = tool.Parametric.commit_pending_edits()
+        # Previews are session-transient — discard rather than commit. Sibling
+        # gizmo polls gate on each preview's is_active flag, and a stuck flag
+        # persisted through the save would silently hide them on reload.
+        preview_base.discard_pending_previews(context.scene)
+        # Suffix is appended to the IFC save-success report below so the auto-commit
+        # info isn't immediately overwritten by the success message in Blender's
+        # status bar (only the latest self.report({"INFO"}, ...) sticks).
+        commit_suffix = f" (auto-committed {committed} pending parametric edit(s))" if committed else ""
+        if failed_commits:
+            names = ", ".join(o.name for o in failed_commits)
+            msg = f"Auto-commit failed for {len(failed_commits)} object(s): {names}"
+            print(f"Bonsai: {msg} (their drafts are NOT saved to the IFC file).")
+            self.report({"ERROR"}, msg)
         start = time.time()
         logger = logging.getLogger("ExportIFC")
         path_log = tool.Blender.get_data_dir_path("process.log")
@@ -2001,7 +2031,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
                     blendmetadata_path = output_file + suffix
                 self.report(
                     {"INFO"},
-                    f'IFC Project "{os.path.basename(output_file)}" And Metadata File Saved to: {os.path.basename(blendmetadata_path)}',
+                    f'IFC Project "{os.path.basename(output_file)}" And Metadata File Saved to: {os.path.basename(blendmetadata_path)}{commit_suffix}',
                 )
             except Exception as e:
                 self.report({"ERROR"}, f"Failed to save blend metadata file: {e}")
@@ -2011,7 +2041,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
                 bpy.ops.wm.save_mainfile(filepath=bpy.data.filepath)
             self.report(
                 {"INFO"},
-                f'IFC Project "{os.path.basename(output_file)}" {"" if not save_blend_file else "And Current Blend File Are"} Saved',
+                f'IFC Project "{os.path.basename(output_file)}" {"" if not save_blend_file else "And Current Blend File Are"} Saved{commit_suffix}',
             )
 
         bonsai.bim.handler.refresh_ui_data()
@@ -3404,3 +3434,108 @@ class GenerateUVMap(bpy.types.Operator):
         tool.Loader.load_generated_uv_map(obj.data)
         self.report({"INFO"}, "Generated UV map for selected mesh.")
         return {"FINISHED"}
+
+
+class BIM_OT_apply_pending_opening_cuts(bpy.types.Operator, tool.Ifc.Operator):
+    """Recompute the wall mesh including opening subtractions for every host
+    that the load-time ``void_limit`` filter skipped. Clears the deferred
+    list on completion so the panel banner disappears."""
+
+    bl_idname = "bim.apply_pending_opening_cuts"
+    bl_label = "Apply Pending Opening Cuts"
+    bl_description = (
+        "Recompute meshes for elements whose openings were skipped at load because they had too many openings"
+    )
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        pending = tool.Project.get_project_props().pending_opening_recut
+        applied = 0
+        skipped = 0
+        failed = 0
+        for item in pending:
+            try:
+                element = tool.Ifc.get().by_id(item.ifc_definition_id)
+            except RuntimeError:
+                skipped += 1
+                continue
+            obj = tool.Ifc.get_object(element)
+            if obj is None:
+                skipped += 1
+                continue
+            body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+            if body is None:
+                skipped += 1
+                continue
+            try:
+                tool.Geometry.reimport_element_representations(obj, body, apply_openings=True)
+                applied += 1
+            except (RuntimeError, OSError, AttributeError) as exc:
+                # Programmer errors (TypeError, ValueError, etc.) must surface — don't swallow them.
+                failed += 1
+                print(f"apply_pending_opening_cuts: failed to recompute {element} ({exc})")
+
+        pending.clear()
+        message = f"Applied opening cuts to {applied} element(s)."
+        if skipped:
+            message += f" {skipped} entry/entries skipped (entity or object no longer available)."
+        if failed:
+            message += f" {failed} entry/entries failed (see system console)."
+            self.report({"WARNING"}, message)
+        else:
+            self.report({"INFO"}, message)
+        return {"FINISHED"}
+
+
+class BIM_OT_dismiss_pending_opening_cuts(bpy.types.Operator):
+    bl_idname = "bim.dismiss_pending_opening_cuts"
+    bl_label = "Dismiss Pending Opening Cuts"
+    bl_description = "Clear the pending opening-cut list without applying it. Walls stay solid where openings would have been subtracted."
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context: bpy.types.Context) -> set[str]:
+        tool.Project.get_project_props().pending_opening_recut.clear()
+        return {"FINISHED"}
+
+
+class BIM_OT_dismiss_multi_instance_warning(bpy.types.Operator):
+    bl_idname = "bim.dismiss_multi_instance_warning"
+    bl_label = "Dismiss Multi-Instance Warning"
+    bl_description = (
+        "Hide the warning that another Blender instance has this IFC file open. Sticky for the current session."
+    )
+    bl_options = {"REGISTER"}
+
+    def execute(self, context: bpy.types.Context) -> set[str]:
+        from bonsai.bim.ifc import dismiss_multi_instance_warning
+
+        dismiss_multi_instance_warning()
+        return {"FINISHED"}
+
+
+class BIM_OT_select_pending_opening_cuts(bpy.types.Operator):
+    bl_idname = "bim.select_pending_opening_cuts"
+    bl_label = "Select Elements With Skipped Opening Cuts"
+    bl_description = "Select the Blender objects whose openings were skipped at load. Useful for locating which elements need attention."
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context: bpy.types.Context) -> set[str]:
+        ifc_file = tool.Ifc.get()
+        if ifc_file is None:
+            self.report({"INFO"}, "No IFC file loaded.")
+            return {"CANCELLED"}
+        objects: list[bpy.types.Object] = []
+        for item in tool.Project.get_project_props().pending_opening_recut:
+            try:
+                element = ifc_file.by_id(item.ifc_definition_id)
+            except RuntimeError:
+                continue
+            obj = tool.Ifc.get_object(element)
+            if obj is not None:
+                objects.append(obj)
+        if not objects:
+            self.report({"INFO"}, "No matching Blender objects found for the pending list.")
+            return {"CANCELLED"}
+        tool.Blender.set_objects_selection(context, active_object=objects[0], selected_objects=objects)
+        self.report({"INFO"}, f"Selected {len(objects)} element(s).")
+        return {"FINISHED"}

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

@@ -295,6 +295,17 @@ class LibraryBreadcrumb(PropertyGroup):
         library_id: int
 
 
+class PendingOpeningRecut(PropertyGroup):
+    """One element whose ``HasOpenings`` exceeded ``void_limit`` at load time
+    and was imported without opening subtractions. The user can later apply
+    them on demand from the Project panel banner."""
+
+    ifc_definition_id: IntProperty(name="IFC Definition ID")
+
+    if TYPE_CHECKING:
+        ifc_definition_id: int
+
+
 class BIMProjectProperties(PropertyGroup):
     is_editing: BoolProperty(name="Is Editing", default=False)
     is_loading: BoolProperty(name="Is Loading", default=False)
@@ -360,6 +371,7 @@ class BIMProjectProperties(PropertyGroup):
         default=30,
         description="Maxium number of openings that object can have. If object has more openings, it will be loaded without openings",
     )
+    pending_opening_recut: CollectionProperty(name="Pending Opening Recut", type=PendingOpeningRecut)
     style_limit: IntProperty(
         name="Style Limit",
         default=300,
@@ -525,6 +537,7 @@ class BIMProjectProperties(PropertyGroup):
         deflection_tolerance: float
         angular_tolerance: float
         void_limit: int
+        pending_opening_recut: bpy.types.bpy_prop_collection_idprop[PendingOpeningRecut]
         style_limit: int
         distance_limit: float
         false_origin_mode: Literal["AUTOMATIC", "MANUAL", "DISABLED"]

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

@@ -28,8 +28,9 @@ from bpy.types import Menu, Panel, UIList
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import draw_attributes, prop_with_search
-from bonsai.bim.ifc import IfcStore
+from bonsai.bim.ifc import IfcStore, is_cache_locked_by_other_process
 from bonsai.bim.module.project.data import LinksData, ProjectData
+from bonsai.bim.ui import draw_multiline_text
 
 if TYPE_CHECKING:
     from bonsai.bim.module.project.prop import (
@@ -166,6 +167,20 @@ class BIM_PT_project(Panel):
         if pprops.is_loading:
             self.draw_advanced_loading_ui(context)
         elif self.file or props.ifc_file:
+            if is_cache_locked_by_other_process():
+                box = self.layout.box()
+                box.alert = True
+                row = box.row(align=True)
+                row.label(text="IFC Already Open in Another Blender Instance", icon="ERROR")
+                row.operator("bim.dismiss_multi_instance_warning", text="", icon="CANCEL")
+                draw_multiline_text(
+                    box.column(align=True),
+                    "This file is open in another Blender instance. Editing the same "
+                    "IFC from two instances at once can lose your work or display "
+                    "outdated geometry. Close the other Blender instances to continue safely.",
+                    context=context,
+                )
+
             if props.has_blend_warning:
                 box = self.layout.box()
                 box.alert = True
@@ -175,6 +190,21 @@ class BIM_PT_project(Panel):
                 op.uri = "https://docs.bonsaibim.org/guides/troubleshooting.html#saving-and-loading-blend-files"
                 row.operator("bim.close_blend_warning", text="", icon="CANCEL")
 
+            if pending := pprops.pending_opening_recut:
+                box = self.layout.box()
+                box.alert = True
+                box.label(text="Opening Cuts Skipped", icon="ERROR")
+                draw_multiline_text(
+                    box.column(align=True),
+                    f"{len(pending)} element(s) had too many openings to cut during load. "
+                    f"Apply to recompute their meshes, or dismiss to leave them as they are.",
+                    context=context,
+                )
+                row = box.row(align=True)
+                row.operator("bim.select_pending_opening_cuts", text="Select Elements", icon="RESTRICT_SELECT_OFF")
+                row.operator("bim.apply_pending_opening_cuts", text="Apply Openings", icon="PLAY")
+                row.operator("bim.dismiss_pending_opening_cuts", text="", icon="CANCEL")
+
             if props.ifc_file:
                 self.draw_loaded_project_ui(context)
             else:

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

@@ -302,6 +302,15 @@ class SelectSimilarContainer(bpy.types.Operator):
             is_recursive=self.is_recursive,
         )
         self.is_recursive = True  # <-- forcibly reset
+
+        element = tool.Ifc.get_entity(context.active_object)
+        if element:
+            container = tool.Spatial.get_container(element)
+            if container:
+                result = f'location="{container.Name}"'
+                bpy.context.window_manager.clipboard = result
+                self.report({"INFO"}, f"({result}) was copied to the clipboard.")
+
         return {"FINISHED"}
 
 

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

@@ -118,6 +118,19 @@ def update_shader_graph(self: Union["Texture", "BIMStylesProperties"], context:
     tool.Loader.create_surface_style_with_textures(material, shading_data, textures_data)
 
 
+def _make_clear_null_updater(null_prop: str):
+    def _update(self: "BIMStylesProperties", context: bpy.types.Context) -> None:
+        self[null_prop] = False
+        update_shader_graph(self, context)
+
+    return _update
+
+
+update_diffuse_colour = _make_clear_null_updater("is_diffuse_colour_null")
+update_specular_colour = _make_clear_null_updater("is_specular_colour_null")
+update_specular_highlight_value = _make_clear_null_updater("is_specular_highlight_null")
+
+
 UV_MODES = [
     ("UV", "UV", _("Actual UV data presented on the geometry")),
     ("Generated", "Generated", _("Automatically-generated UV from the vertex positions of the mesh")),
@@ -221,24 +234,29 @@ class BIMStylesProperties(PropertyGroup):
     transparency: bpy.props.FloatProperty(
         name="Transparency", default=0.0, min=0.0, max=1.0, update=update_shader_graph
     )
-    # TODO: do something on null?
-    is_diffuse_colour_null: BoolProperty(name="Is Null")
+    is_diffuse_colour_null: BoolProperty(name="Is Null", update=update_shader_graph)
     diffuse_colour_class: EnumProperty(
         items=[(x, x, "") for x in get_args(ColourClass)],
         name="Diffuse Colour Class",
-        update=update_shader_graph,
+        update=update_diffuse_colour,
     )
     diffuse_colour: bpy.props.FloatVectorProperty(
-        name="Diffuse Colour", subtype="COLOR", default=(1, 1, 1), min=0.0, max=1.0, size=3, update=update_shader_graph
+        name="Diffuse Colour",
+        subtype="COLOR",
+        default=(1, 1, 1),
+        min=0.0,
+        max=1.0,
+        size=3,
+        update=update_diffuse_colour,
     )
     diffuse_colour_ratio: bpy.props.FloatProperty(
-        name="Diffuse Ratio", default=0.0, min=0.0, max=1.0, update=update_shader_graph
+        name="Diffuse Ratio", default=0.0, min=0.0, max=1.0, update=update_diffuse_colour
     )
-    is_specular_colour_null: BoolProperty(name="Is Null")
+    is_specular_colour_null: BoolProperty(name="Is Null", update=update_shader_graph)
     specular_colour_class: EnumProperty(
         items=[(x, x, "") for x in get_args(ColourClass)],
         name="Specular Colour Class",
-        update=update_shader_graph,
+        update=update_specular_colour,
         default="IfcNormalisedRatioMeasure",
     )
     specular_colour: bpy.props.FloatVectorProperty(
@@ -248,7 +266,7 @@ class BIMStylesProperties(PropertyGroup):
         min=0.0,
         max=1.0,
         size=3,
-        update=update_shader_graph,
+        update=update_specular_colour,
     )
     specular_colour_ratio: bpy.props.FloatProperty(
         name="Specular Ratio",
@@ -256,16 +274,16 @@ class BIMStylesProperties(PropertyGroup):
         default=0.0,
         min=0.0,
         max=1.0,
-        update=update_shader_graph,
+        update=update_specular_colour,
     )
-    is_specular_highlight_null: BoolProperty(name="Is Null")
+    is_specular_highlight_null: BoolProperty(name="Is Null", update=update_shader_graph)
     specular_highlight: bpy.props.FloatProperty(
         name="Specular Highlight",
         description="Used as Roughness value in PHYSICAL Reflectance Method",
         default=0.0,
         min=0.0,
         max=1.0,
-        update=update_shader_graph,
+        update=update_specular_highlight_value,
     )
     reflectance_method: EnumProperty(
         name="Reflectance Method",

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

@@ -15,9 +15,10 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 
-import bmesh
 import bpy
 import gpu
 from bpy.app.handlers import persistent
@@ -78,15 +79,9 @@ class SystemDecorator:
         batch.draw(shader)
 
     def draw_faces(self, bm, vertices_coords):
-        """mutates original bm (triangulates it)
-        so the triangulation edges will be shown too
-        """
-        traingulated_bm = bm
-        bmesh.ops.triangulate(traingulated_bm, faces=traingulated_bm.faces)
-
-        face_indices = [[v.index for v in f.verts] for f in traingulated_bm.faces]
+        """Submit a non-mutating beauty-triangulated TRIS batch over ``bm``'s faces."""
         faces_color = transparent_color(self.addon_prefs.decorator_color_special)
-        self.draw_batch("TRIS", vertices_coords, faces_color, face_indices)
+        tool.Blender.draw_bmesh_face_tris(bm, vertices_coords, faces_color, self.draw_batch)
 
     def __call__(self, context, get_custom_bmesh=None, draw_faces=False, exit_edit_mode_callback=None):
         self.addon_prefs = tool.Blender.get_addon_preferences()

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

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

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

@@ -151,7 +151,8 @@ class BIM_PT_type_attributes(Panel):
                 row = layout.row(align=True)
                 row.label(text=attribute["name"])
                 value = get_display_value(attribute["value"])
-                row.label(text=value)
+                op = row.operator("bim.select_similar", text=value, icon="NONE", emboss=False)
+                op.key = "type." + attribute["name"]
 
 
 def add_object_button(self, context):

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

@@ -36,9 +36,17 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
     bl_description = (
         "Apply opening objects to an Element.\n\n"
         "The Element and the openings to be applied should be selected. The order of selection is not important.\n"
-        "Opening can be just a Blender mesh object."
+        "Opening can be just a Blender mesh object.\n\n"
+        "Shift+click: keep the filling at its current matrix_world — skip the wall-axis snap "
+        "and the rl1/rl2 Z-elevation default that the regular click applies."
     )
 
+    # Toggled by ``invoke`` when the user holds SHIFT during a gizmo / hotkey
+    # click. The filling-opening generator gates its snap-to-wall-axis block
+    # on this flag. HIDDEN + SKIP_SAVE so the flag doesn't surface in the F6
+    # redo panel or persist into saved keymaps.
+    preserve_placement: bpy.props.BoolProperty(default=False, options={"HIDDEN", "SKIP_SAVE"})
+
     @classmethod
     def poll(cls, context):
         if len(context.selected_objects) < 2:
@@ -46,6 +54,10 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
             return False
         return True
 
+    def invoke(self, context, event):
+        self.preserve_placement = bool(event.shift)
+        return self.execute(context)
+
     def _execute(self, context):
         selected_objects = context.selected_objects
         target_object = selected_objects[0]
@@ -68,7 +80,12 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
                 elif not element1.is_a("IfcOpeningElement") and not element2.is_a("IfcOpeningElement"):
                     if element1.is_a("IfcWindow") or element1.is_a("IfcDoor"):  # Add a fill to an element.
                         obj1, obj2 = obj2, obj1
-                    FilledOpeningGenerator().generate(obj2, obj1, target=obj2.matrix_world.translation)
+                    FilledOpeningGenerator().generate(
+                        obj2,
+                        obj1,
+                        target=obj2.matrix_world.translation,
+                        preserve_placement=self.preserve_placement,
+                    )
                     continue
                 elif element1.is_a("IfcOpeningElement") or element2.is_a("IfcOpeningElement"):
                     if element1.is_a("IfcOpeningElement"):  # Reassign an opening to another element.

src/bonsai/bonsai/bim/parametric_lifecycle.py

@@ -0,0 +1,656 @@
+# 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 operator mixins for parametric-edit operators.
+
+Edit-lifecycle mixins (Enable / Finish / Cancel):
+    `FeatureModifierEditMixin` — door, window (BBIM_<Type> pset; nested
+        lining/panel properties; Finish + Cancel route through
+        ``ifcopenshell.api.feature``).
+    `PathPreservingEditMixin` — railing, roof (path_data preserved across
+        edit; only general kwargs are user-editable).
+
+Pattern selection (which approach a new feature should adopt):
+    Every parametric edit lifecycle commits to one of three patterns. Pick by
+    answering "does the feature share the Enable→Finish→Cancel shape that
+    one of the existing mixins already encodes?":
+
+    A. Inherit one of the shared mixins below and route through
+       `tool.Parametric.build_edit_lifecycle`:
+
+       - `FeatureModifierEditMixin` when the feature stores its pset as
+         `{general fields} + {lining_properties: {...}} + {panel_properties: {...}}`
+         and Finish must call a per-type `update_<type>_modifier_representation`.
+
+       - `PathPreservingEditMixin` when the feature's pset carries a
+         `path_data` field that survives general-kwarg edits untouched, with
+         a separate Enable/Finish/Cancel lifecycle for path editing itself.
+
+    B. Write a per-feature mixin that subclasses `ParametricEditMixinBase`
+       and provides `_enable_targets` / `_finish_targets` / `_cancel_targets`,
+       then route through `build_edit_lifecycle`. Pick this when the
+       feature's pset roundtrip or representation handling diverges from the
+       shared mixins but the Enable→Finish→Cancel shape still fits.
+
+    C. Declare standalone Enable/Finish/Cancel Operator subclasses (no
+       factory) when the feature's parameter-change logic is sufficiently
+       unique that even a per-feature mixin would force optional hooks or
+       dead branches. Such operators MUST call the matrix_world drift
+       helpers (`tool.Geometry.commit_placement_if_moved` on Enable/Finish,
+       `tool.Geometry.restore_or_rebaseline_placement` on Cancel) — the
+       drift contract is enforced uniformly regardless of which pattern the
+       operators adopt.
+
+    The authoritative list of registered parametric types — and which use
+    `build_edit_lifecycle` vs. standalone operators — lives in
+    `tool/parametric.py`'s `EDIT_TYPES` and is enforced by the registry
+    contract tests.
+
+This module hosts operator-side mixins that import ``bonsai.tool`` freely.
+The lightweight parametric registry consumed at addon-enable time must stay
+free of such imports and lives separately in ``tool/parametric.py``."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import ClassVar, get_args
+
+import bpy
+import ifcopenshell.util.element
+from bpy.app.handlers import persistent
+from ifcopenshell import entity_instance
+
+import bonsai.core.geometry
+import bonsai.tool as tool
+
+
+class ParametricEditMixinBase:
+    """Common scaffolding for parametric edit-lifecycle mixins.
+
+    Each per-type subclass provides four hooks:
+
+        ``pset_name``: BBIM_<Type> pset identifier
+        ``_is_element_type(element)``: IFC element predicate
+        ``_get_props(obj)``: PropertyGroup accessor
+        ``_iter_targets(context)``: list of objects to act on (default: ``[active_object]``)
+
+    Drift handling is built in: pre-edit matrix_world drift commits to IFC on
+    Enable, in-edit drag commits on Finish, and Cancel restores the committed
+    IFC placement. This prevents an uncommitted drag from disappearing on
+    Finish or snapping back on Cancel.
+
+    Operator subclasses call one of ``_enable_targets`` / ``_finish_targets`` /
+    ``_cancel_targets`` from their ``_execute`` method."""
+
+    pset_name: ClassVar[str]
+
+    @classmethod
+    def _iter_targets(cls, context: bpy.types.Context) -> list[bpy.types.Object]:
+        obj = context.active_object
+        return [obj] if obj else []
+
+    @classmethod
+    def _is_element_type(cls, element: entity_instance) -> bool:
+        raise NotImplementedError
+
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        raise NotImplementedError
+
+    @classmethod
+    def _resolve(cls, obj: bpy.types.Object):
+        """Look up ``(element, props)`` for ``obj`` if it matches this type, else None.
+
+        Common predicate guard for every lifecycle method — collapses the
+        ``element = tool.Ifc.get_entity(obj); assert element; if not is_<type>(element): return``
+        triplet into one call."""
+        element = tool.Ifc.get_entity(obj)
+        if not element or not cls._is_element_type(element):
+            return None
+        return element, cls._get_props(obj)
+
+    @classmethod
+    def _handle_drift_on_enable(cls, obj: bpy.types.Object) -> None:
+        tool.Geometry.commit_placement_if_moved(obj, apply_scale=False)
+
+    @classmethod
+    def _handle_drift_on_finish(cls, obj: bpy.types.Object) -> None:
+        tool.Geometry.commit_placement_if_moved(obj)
+
+    @classmethod
+    def _handle_drift_on_cancel(cls, obj: bpy.types.Object, element: entity_instance) -> None:
+        tool.Geometry.restore_or_rebaseline_placement(obj, element)
+
+    @classmethod
+    def _mark_type_thumbnail_dirty(cls, element: entity_instance) -> None:
+        """Mark the element's type's preview thumbnail for refresh so the
+        property-panel preview reflects post-edit geometry. No-op for
+        occurrences without a backing type."""
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            tool.Model.mark_thumbnail_for_update(element_type)
+
+
+class FeatureModifierEditMixin(ParametricEditMixinBase):
+    """Lifecycle for door- and window-style parametric modifier operators.
+
+    Enable:
+        Read BBIM_<Type> pset JSON → unwrap ``lining_properties`` and
+        ``panel_properties`` → merge constituents data → set draft props →
+        ``is_editing = True``.
+
+    Finish:
+        Gather ``general / lining / panel`` kwargs (project units) → nest →
+        ``is_editing = False`` → call ``_update_modifier_representation`` →
+        mark thumbnail → write back to BBIM_<Type> pset via
+        ``ifcopenshell.api.pset.edit_pset``.
+
+    Cancel:
+        Read BBIM_<Type> pset JSON → unwrap → restore draft props →
+        ``switch_representation`` to the Body representation →
+        ``is_editing = False``."""
+
+    @classmethod
+    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Hook: call the per-type ``update_<type>_modifier_representation``."""
+        raise NotImplementedError
+
+    @classmethod
+    def _enable_one(cls, obj: bpy.types.Object) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        cls._handle_drift_on_enable(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, cls.pset_name, "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        data.update(tool.Model.get_constituents_props_data(element))
+        # required since the pset can be loaded from .ifc and the PropertyGroup
+        # would otherwise still hold its default values
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    @classmethod
+    def _finish_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        data = props.get_general_kwargs(convert_to_project_units=True)
+        data["lining_properties"] = props.get_lining_kwargs(convert_to_project_units=True)
+        data["panel_properties"] = props.get_panel_kwargs(convert_to_project_units=True)
+        cls._update_modifier_representation(obj, context)
+        cls._mark_type_thumbnail_dirty(element)
+        tool.Pset.write_bbim_data(element, cls.pset_name, data)
+        cls._handle_drift_on_finish(obj)
+        # Set only on success: if any IFC op above raised, the user's draft survives for retry.
+        props.is_editing = False
+
+    @classmethod
+    def _cancel_one(cls, obj: bpy.types.Object) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        # Cancel must always clear is_editing — leaving it True after a
+        # restore-failure would block the user from re-entering edit mode and
+        # the next save's stale-flag heal would silently roll back the
+        # cancellation. Wrap the restore in try/finally so the flag flips
+        # even on partial failure.
+        try:
+            data = json.loads(ifcopenshell.util.element.get_pset(element, cls.pset_name, "Data"))
+            data.update(data.pop("lining_properties"))
+            data.update(data.pop("panel_properties"))
+            props.set_props_kwargs_from_ifc_data(data)
+            body = tool.Geometry.get_body_representation(element)
+            bonsai.core.geometry.switch_representation(tool.Ifc, tool.Geometry, obj=obj, representation=body)
+            cls._handle_drift_on_cancel(obj, element)
+        finally:
+            props.is_editing = False
+
+    def _enable_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._enable_one(obj)
+        return {"FINISHED"}
+
+    def _finish_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._finish_one(obj, context)
+        return {"FINISHED"}
+
+    def _cancel_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._cancel_one(obj)
+        return {"FINISHED"}
+
+
+class PathPreservingEditMixin(ParametricEditMixinBase):
+    """Lifecycle for railing- and roof-style parametric modifier operators.
+
+    Distinctive: ``path_data`` is part of the BBIM_<Type> pset but is **not**
+    user-editable through this lifecycle — it survives the edit untouched, only
+    general kwargs are diffed. (Path editing has its own separate operator
+    pair, ``Enable/Finish/CancelEditing<Type>Path``, out of scope here.)
+
+    Enable:
+        Fetch pset data via ``tool.Model.get_modeling_bbim_pset_data`` → set
+        draft props → ``is_editing = True``. The subclass post-load hook
+        can reshape the dict to fit the PropertyGroup's storage layout
+        (e.g., pre-serialise a structured pset value to JSON for a
+        ``StringProperty`` field).
+
+    Finish:
+        Read fresh pset → keep ``path_data`` → gather ``general`` kwargs
+        (project units) → reassemble → ``is_editing = False`` → call
+        ``_update_pset`` (per-type pset writer) → call ``_update_modifier_ifc_data``
+        (per-type geometry commit).
+
+    Cancel:
+        Read fresh pset → restore draft props → call
+        ``_restore_viewport_after_cancel`` (per-type viewport restore — typically
+        rebuilds the bmesh preview, but subclasses may load a different
+        representation entirely) → ``is_editing = False``."""
+
+    @classmethod
+    def _post_load_data(cls, data: dict) -> dict:
+        """Hook: optionally transform the pset data dict after loading and before
+        passing to ``set_props_kwargs_from_ifc_data``. Default: pass-through.
+
+        Override when the PropertyGroup stores a structured pset field as a
+        serialised primitive — e.g., a list/dict value mapped onto a
+        ``StringProperty`` requires JSON-encoding here."""
+        return data
+
+    @classmethod
+    def _update_pset(cls, element: entity_instance, data: dict) -> None:
+        """Hook: per-type pset writer (``update_bbim_<type>_pset``)."""
+        raise NotImplementedError
+
+    @classmethod
+    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Hook: per-type ``update_<type>_modifier_ifc_data`` — commits the
+        modified geometry to IFC. Signature accepts ``(obj, context)`` so
+        subclasses can forward either argument to their existing helper."""
+        raise NotImplementedError
+
+    @classmethod
+    def _restore_viewport_after_cancel(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Hook: restore the viewport mesh to match the just-restored draft props.
+
+        Most subclasses rebuild a bmesh preview from props. Subclasses whose
+        committed IFC representation diverges from the preview may switch
+        the mesh back to the committed representation instead."""
+        raise NotImplementedError
+
+    @classmethod
+    def _enable_one(cls, obj: bpy.types.Object) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        _element, props = resolved
+        cls._handle_drift_on_enable(obj)
+        data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)["data_dict"]
+        data = cls._post_load_data(data)
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    @classmethod
+    def _finish_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        pset_data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)
+        stored = pset_data["data_dict"]
+        data = props.get_general_kwargs(convert_to_project_units=True)
+        data["path_data"] = stored["path_data"]
+        # Skip the pset commit when the draft is identical to the stored pset:
+        # an Enable → Finish-without-changes cycle should not pollute the
+        # representation list or burn an undo entry. Drift commit still runs
+        # unconditionally — matrix_world drift is independent of pset content.
+        if data != stored:
+            cls._update_pset(element, data)
+            cls._update_modifier_ifc_data(obj, context)
+            cls._mark_type_thumbnail_dirty(element)
+        cls._handle_drift_on_finish(obj)
+        # Set only on success: if any IFC op above raised, the user's draft survives for retry.
+        props.is_editing = False
+
+    @classmethod
+    def _cancel_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        try:
+            pset_data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)
+            stored = pset_data["data_dict"]
+            draft = props.get_general_kwargs(convert_to_project_units=True)
+            draft["path_data"] = stored["path_data"]
+            nothing_changed = draft == stored
+            data = cls._post_load_data(stored)
+            props.set_props_kwargs_from_ifc_data(data)
+            # Skip the viewport rebuild on a no-op cancel: the mesh on screen is
+            # still the committed representation, and the per-type viewport-restore
+            # hook may be expensive (some subclasses reload a high-poly IFC
+            # representation rather than rebuild a preview mesh).
+            if not nothing_changed:
+                cls._restore_viewport_after_cancel(obj, context)
+            cls._handle_drift_on_cancel(obj, element)
+        finally:
+            # Always clear the flag — see ``FeatureModifierEditMixin._cancel_one``
+            # for the rationale.
+            props.is_editing = False
+
+    def _enable_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._enable_one(obj)
+        return {"FINISHED"}
+
+    def _finish_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._finish_one(obj, context)
+        return {"FINISHED"}
+
+    def _cancel_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._cancel_one(obj, context)
+        return {"FINISHED"}
+
+
+# --- Type-selection mixins (Cycle / Pick) ------------------------------------
+
+
+class TypeAccessorBase:
+    """Shared contract for operators that resolve and write a Literal type
+    attribute on a Bonsai PropertyGroup.
+
+    Subclasses define ``element_checker``, ``props_getter``, ``type_literal``,
+    ``type_attr``; ``skip_element_check`` bypasses element validation. Concrete
+    subclasses (``CycleTypeMixin``, ``PickTypeMixin``) add the interaction
+    shape on top.
+
+    Test doubles must be set on the operator instance — the predicates are
+    bound at class-definition time, so patching the underlying tool module
+    has no effect."""
+
+    element_checker: Callable[[entity_instance], bool]
+    props_getter: Callable[[bpy.types.Object], bpy.types.PropertyGroup]
+    type_literal: type
+    type_attr: str
+    skip_element_check: bool = False
+
+    def _resolve_target(self, context: bpy.types.Context) -> bpy.types.Object | None:
+        """Return the active object iff it passes ``element_checker`` (or the
+        check is skipped). ``None`` signals the operator should bail with
+        ``{'CANCELLED'}``."""
+        obj = context.active_object
+        if not obj:
+            return None
+        if not self.skip_element_check:
+            element = tool.Ifc.get_entity(obj)
+            if not element or not self.element_checker(element):
+                return None
+        return obj
+
+
+class CycleTypeMixin(TypeAccessorBase):
+    """Operator mixin that cycles through ``type_literal``'s values.
+
+    Shift-click reverses direction."""
+
+    reverse: bpy.props.BoolProperty(name="Reverse", default=False, options={"HIDDEN", "SKIP_SAVE"})
+
+    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
+        self.reverse = event.shift
+        return self.execute(context)
+
+    def _cycle_type(self, context: bpy.types.Context) -> set[str]:
+        obj = self._resolve_target(context)
+        if obj is None:
+            return {"CANCELLED"}
+
+        props = self.props_getter(obj)
+        types = get_args(self.type_literal)
+        current = getattr(props, self.type_attr)
+        idx = types.index(current) if current in types else 0
+        direction = -1 if self.reverse else 1
+        setattr(props, self.type_attr, types[(idx + direction) % len(types)])
+
+        return {"FINISHED"}
+
+
+class PickTypeMixin(TypeAccessorBase):
+    """Operator mixin that opens a popup menu listing ``type_literal``'s values.
+
+    Empty ``value`` ⇒ ``invoke`` opens the popup; non-empty ⇒ the user picked
+    an item and ``_pick_type`` applies it.
+
+    When invoked mid-click (e.g. from a gizmo's ``target_set_operator``), the
+    menu opens only after the originating ``LEFTMOUSE`` releases. Otherwise
+    the still-pressed click flows straight into Blender's drag-through-pick
+    gesture and the menu commits whichever item the cursor drifts over on
+    release. Other invocation paths (command-palette / F3, EXEC_DEFAULT, F6
+    redo) bypass the wait and open the menu immediately.
+
+    The ``value`` StringProperty is declared on this mixin but registered via
+    the concrete Operator subclass's MRO scan — do not instantiate the mixin
+    standalone."""
+
+    # Carries the picked value through invoke→execute; empty default
+    # distinguishes "open popup" from "apply".
+    value: bpy.props.StringProperty(default="", options={"HIDDEN", "SKIP_SAVE"})
+
+    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
+        """Open the picker menu, or apply a value that was preset by a
+        menu-item click.
+
+        Routing through ``execute()`` keeps subclass IFC-transaction wrapping
+        in the loop and means F6 redo / ``EXEC_DEFAULT`` reach the apply path."""
+        if self.value:
+            return self.execute(context)
+
+        if self._resolve_target(context) is None:
+            return {"CANCELLED"}
+
+        if event.value == "PRESS":
+            context.window_manager.modal_handler_add(self)
+            return {"RUNNING_MODAL"}
+        return self._open_picker(context)
+
+    def modal(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
+        if event.type == "LEFTMOUSE" and event.value == "RELEASE":
+            self._open_picker(context)
+            # INTERFACE does not remove a modal handler; only FINISHED /
+            # CANCELLED do.
+            return {"CANCELLED"}
+        if event.type in {"RIGHTMOUSE", "ESC"}:
+            return {"CANCELLED"}
+        return {"RUNNING_MODAL"}
+
+    def _open_picker(self, context: bpy.types.Context) -> set[str]:
+        bl_idname = self.bl_idname
+        values = list(get_args(self.type_literal))
+
+        def draw(menu_self, _menu_context):
+            layout = menu_self.layout
+            for v in values:
+                op = layout.operator(bl_idname, text=v)
+                op.value = v
+
+        context.window_manager.popup_menu(draw, title=self.bl_label, icon="MENU_PANEL")
+        # The type change is a two-step interaction: this invocation just OPENS
+        # the menu (no state change yet); a SECOND invocation fires when the
+        # user clicks a menu item — that one writes ``props.<type_attr>`` and
+        # returns FINISHED. By returning INTERFACE here (and not FINISHED), the
+        # menu-open step is excluded from Blender's undo stack so the user
+        # gets exactly ONE undo entry per type change. If we returned FINISHED
+        # here too, the stack would gain a no-op "opened the menu" entry that
+        # Ctrl+Z would dismiss before reverting the actual type change —
+        # confusing UX where the first Ctrl+Z appears to do nothing.
+        return {"INTERFACE"}
+
+    def _pick_type(self, context: bpy.types.Context) -> set[str]:
+        if not self.value:
+            # No-op rather than re-open the menu, so command-palette misuse
+            # doesn't infinite-loop.
+            return {"CANCELLED"}
+
+        obj = self._resolve_target(context)
+        if obj is None:
+            return {"CANCELLED"}
+
+        if self.value not in get_args(self.type_literal):
+            self.report({"WARNING"}, f"Unknown {self.type_attr}: {self.value!r}")
+            return {"CANCELLED"}
+
+        props = self.props_getter(obj)
+        setattr(props, self.type_attr, self.value)
+        return {"FINISHED"}
+
+
+class IntegerInputDialogMixin:
+    """Operator mixin that mirrors a per-feature ``IntProperty`` on the
+    operator into a draft attribute on the active object's parametric props,
+    via Blender's ``invoke_props_dialog`` popup.
+
+    Subclasses declare:
+
+    - ``attr_name`` — name of the IntProperty on the subclass AND of the
+      attribute on the resolved props (same name on both sides).
+    - ``props_getter`` — ``staticmethod(tool.Model.get_<feature>_props)``.
+    - ``requires_editing`` — True iff the operator must no-op outside an
+      active edit lifecycle. Default False.
+    - ``value_min`` — minimum value to clamp to. Default 1."""
+
+    attr_name: ClassVar[str] = ""
+    props_getter: ClassVar[Callable[[bpy.types.Object], bpy.types.PropertyGroup]]
+    requires_editing: ClassVar[bool] = False
+    value_min: ClassVar[int] = 1
+
+    def _resolve_props(self, context: bpy.types.Context) -> bpy.types.PropertyGroup | None:
+        """Return the active object's parametric props if the operator is
+        allowed to fire, ``None`` otherwise (caller bails with ``CANCELLED``)."""
+        obj = context.active_object
+        if not obj:
+            return None
+        props = self.props_getter(obj)
+        if self.requires_editing and not props.is_editing:
+            return None
+        return props
+
+    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:  # noqa: ARG002
+        props = self._resolve_props(context)
+        if props is None:
+            return {"CANCELLED"}
+        setattr(self, self.attr_name, max(self.value_min, getattr(props, self.attr_name)))
+        return context.window_manager.invoke_props_dialog(self)
+
+    def execute(self, context: bpy.types.Context) -> set[str]:
+        props = self._resolve_props(context)
+        if props is None:
+            return {"CANCELLED"}
+        setattr(props, self.attr_name, max(self.value_min, getattr(self, self.attr_name)))
+        return {"FINISHED"}
+
+
+# --- Undo-resync registry ----------------------------------------------------
+#
+# Per-type regenerators called from ``resync_parametric_drafts_after_undo``
+# (wired into ``bim/handler.py:undo_post`` and ``redo_post``) so the preview
+# mesh of an in-progress parametric draft repaints after Ctrl+Z / Ctrl+Shift+Z.
+#
+# Each regenerator is a one-line lazy-import + call. Lazy imports because
+# ``bonsai.bim.parametric_lifecycle`` loads before ``bim/module/model/*``
+# at addon enable; a module-level import would cycle. Each function-local
+# import lands at first call, after the feature module has registered.
+#
+# Types with no entry — door, window, railing, etc. — are IFC-derived: undo
+# of an IFC mutation already restores the entity, and ``switch_representation``
+# repaints the mesh as a side effect of the next refresh. They don't need a
+# bespoke preview regenerator.
+
+
+def _wall_undo_regenerator(obj: bpy.types.Object) -> None:
+    from bonsai.bim.module.model.wall import regenerate_wall_mesh_from_props
+
+    regenerate_wall_mesh_from_props(obj)
+
+
+def _stair_undo_regenerator(obj: bpy.types.Object) -> None:
+    from bonsai.bim.module.model.stair import regenerate_stair_mesh
+
+    regenerate_stair_mesh(obj)
+
+
+def _roof_undo_regenerator(obj: bpy.types.Object) -> None:
+    from bonsai.bim.module.model.roof import update_roof_modifier_bmesh
+
+    update_roof_modifier_bmesh(obj)
+
+
+UNDO_REGENERATORS: dict[str, Callable[[bpy.types.Object], None]] = {
+    "wall": _wall_undo_regenerator,
+    "stair": _stair_undo_regenerator,
+    "roof": _roof_undo_regenerator,
+}
+
+
+def resync_parametric_drafts_after_undo() -> None:
+    """Re-render preview meshes for every parametric draft currently active.
+
+    Walks all objects, skips any not in a registered parametric edit,
+    dispatches to the per-type regenerator in ``UNDO_REGENERATORS``. A type
+    without an entry is left alone — its preview is either already correct
+    (IFC-derived) or has no draft preview mesh."""
+    for obj in bpy.data.objects:
+        feature = tool.Parametric.is_object_editing(obj)
+        if feature is None:
+            continue
+        regenerator = UNDO_REGENERATORS.get(feature.name)
+        if regenerator is None:
+            continue
+        regenerator(obj)
+    tool.Blender.update_all_viewports()
+
+
+@persistent
+def _resync_on_undo(scene: bpy.types.Scene) -> None:
+    resync_parametric_drafts_after_undo()
+
+
+def install_parametric_lifecycle_handlers() -> None:
+    """Append the undo-resync callback to undo_post and redo_post; idempotent.
+
+    Caller must invoke this AFTER appending the central undo/redo handlers so
+    regenerators see restored IFC state — bpy.app.handlers fire in append order."""
+    for hook in (bpy.app.handlers.undo_post, bpy.app.handlers.redo_post):
+        if _resync_on_undo not in hook:
+            hook.append(_resync_on_undo)
+
+
+def uninstall_parametric_lifecycle_handlers() -> None:
+    for hook in (bpy.app.handlers.undo_post, bpy.app.handlers.redo_post):
+        try:
+            hook.remove(_resync_on_undo)
+        except ValueError:
+            pass

src/bonsai/bonsai/bim/ui.py

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.
 
 import os
 import platform
@@ -273,130 +275,37 @@ class BIM_UL_panel_visibilities(bpy.types.UIList):
         row.prop(item, "is_bookmarked", text="", icon="SOLO_ON" if item.is_bookmarked else "SOLO_OFF", emboss=False)
 
 
-class GizmoPreferencesDoor(bpy.types.PropertyGroup):
-    """Property group for door gizmo visibility settings."""
-
-    overall_height: BoolProperty(name="Overall Height", default=True)
-    overall_width: BoolProperty(name="Overall Width", default=True)
-    threshold_thickness: BoolProperty(name="Threshold Thickness", default=True)
-    threshold_depth: BoolProperty(name="Threshold Depth", default=True)
-    threshold_offset: BoolProperty(name="Threshold Offset", default=True)
-    lining_offset: BoolProperty(name="Lining Offset", default=True)
-    lining_depth: BoolProperty(name="Lining Depth", default=True)
-    lining_thickness: BoolProperty(name="Lining Thickness", default=True)
-    transom_offset: BoolProperty(name="Transom Offset", default=True)
-    transom_thickness: BoolProperty(name="Transom Thickness", default=True)
-    casing_thickness: BoolProperty(name="Casing Thickness", default=True)
-    casing_depth: BoolProperty(name="Casing Depth", default=True)
-    swing_arc: BoolProperty(name="Swing Arc", default=True, description="Show door swing direction arc")
-    flip_arc: BoolProperty(name="Flip Arc", default=True, description="Show flip door orientation arc")
-
-    if TYPE_CHECKING:
-        overall_height: bool
-        overall_width: bool
-        threshold_thickness: bool
-        threshold_depth: bool
-        threshold_offset: bool
-        lining_offset: bool
-        lining_depth: bool
-        lining_thickness: bool
-        transom_offset: bool
-        transom_thickness: bool
-        casing_thickness: bool
-        casing_depth: bool
-        swing_arc: bool
-        flip_arc: bool
-
-
-class GizmoPreferencesWindow(bpy.types.PropertyGroup):
-    """Property group for window gizmo visibility settings."""
-
-    overall_height: BoolProperty(name="Overall Height", default=True)
-    overall_width: BoolProperty(name="Overall Width", default=True)
-    lining_offset: BoolProperty(name="Lining Offset", default=True)
-    lining_depth: BoolProperty(name="Lining Depth", default=True)
-    lining_thickness: BoolProperty(name="Lining Thickness", default=True)
-    lining_to_panel_offset_x: BoolProperty(name="Lining to Panel Offset X", default=True)
-    lining_to_panel_offset_y: BoolProperty(name="Lining to Panel Offset Y", default=True)
-    frame_depth: BoolProperty(name="Frame Depth", default=True)
-    frame_thickness: BoolProperty(name="Frame Thickness", default=True)
-    mullion_thickness: BoolProperty(name="Mullion Thickness", default=True)
-    first_mullion_offset: BoolProperty(name="First Mullion Offset", default=True)
-    second_mullion_offset: BoolProperty(name="Second Mullion Offset", default=True)
-    transom_thickness: BoolProperty(name="Transom Thickness", default=True)
-    first_transom_offset: BoolProperty(name="First Transom Offset", default=True)
-    second_transom_offset: BoolProperty(name="Second Transom Offset", default=True)
-
-    if TYPE_CHECKING:
-        overall_height: bool
-        overall_width: bool
-        lining_offset: bool
-        lining_depth: bool
-        lining_thickness: bool
-        lining_to_panel_offset_x: bool
-        lining_to_panel_offset_y: bool
-        frame_depth: bool
-        frame_thickness: bool
-        mullion_thickness: bool
-        first_mullion_offset: bool
-        second_mullion_offset: bool
-        transom_thickness: bool
-        first_transom_offset: bool
-        second_transom_offset: bool
-
-
-class GizmoPreferencesStair(bpy.types.PropertyGroup):
-    """Property group for stair gizmo visibility settings."""
-
-    width: BoolProperty(name="Width", default=True)
-    height: BoolProperty(name="Height", default=True)
-    tread_run: BoolProperty(name="Tread Run", default=True)
-    tread_depth: BoolProperty(name="Tread Depth", default=True)
-    riser_height: BoolProperty(name="Riser Height", default=True)
-    nosing_length: BoolProperty(name="Nosing Length", default=True)
-    nosing_depth: BoolProperty(name="Nosing Depth", default=True)
-    total_length_target: BoolProperty(name="Total Length Target", default=True)
-    base_slab_depth: BoolProperty(name="Base Slab Depth", default=True)
-    top_slab_depth: BoolProperty(name="Top Slab Depth", default=True)
-    lock: BoolProperty(name="Total Length Lock", default=True)
-    plus: BoolProperty(name="Add Tread (+)", default=True)
-    minus: BoolProperty(name="Remove Tread (-)", default=True)
-    cycle: BoolProperty(name="Cycle Stair Type", default=True)
-
-    if TYPE_CHECKING:
-        width: bool
-        height: bool
-        tread_run: bool
-        tread_depth: bool
-        riser_height: bool
-        nosing_length: bool
-        nosing_depth: bool
-        total_length_target: bool
-        base_slab_depth: bool
-        top_slab_depth: bool
-        lock: bool
-        plus: bool
-        minus: bool
-        cycle: bool
-
-
 class GizmoPreferences(bpy.types.PropertyGroup):
-    """Property group for all gizmo visibility settings."""
+    """Aggregator for parametric gizmo visibility settings. One flat bool per
+    parametric feature; controls whether that feature's gizmo group polls
+    visible in the viewport."""
 
     draw_gizmos_in_3d_viewport: BoolProperty(
         name="Draw Gizmos In 3D Viewport",
         default=True,
         description="Show interactive gizmos in the 3D viewport for parametric elements",
     )
-    door: bpy.props.PointerProperty(type=GizmoPreferencesDoor)
-    window: bpy.props.PointerProperty(type=GizmoPreferencesWindow)
-    stair: bpy.props.PointerProperty(type=GizmoPreferencesStair)
+    door: BoolProperty(name="Door", default=True)
+    window: BoolProperty(name="Window", default=True)
+    stair: BoolProperty(name="Stair", default=True)
+    railing: BoolProperty(name="Railing", default=True)
+    roof: BoolProperty(name="Roof", default=True)
+    array: BoolProperty(name="Array", default=True)
+    pipe_segment: BoolProperty(name="Pipe Segment", default=True)
+    duct_segment: BoolProperty(name="Duct Segment", default=True)
+    wall: BoolProperty(name="Wall", default=True)
 
     if TYPE_CHECKING:
         draw_gizmos_in_3d_viewport: bool
-        door: GizmoPreferencesDoor
-        window: GizmoPreferencesWindow
-        stair: GizmoPreferencesStair
+        door: bool
+        window: bool
+        stair: bool
+        railing: bool
+        roof: bool
+        array: bool
+        pipe_segment: bool
+        duct_segment: bool
+        wall: bool
 
 
 class DocPreferences(bpy.types.PropertyGroup):
@@ -844,54 +753,13 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
             )
 
     def draw_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        """Render one enabled-toggle per parametric feature."""
         layout.label(text="Toggle visibility of gizmos in editing mode")
         box = layout.box()
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Door", self.draw_door_gizmo_parameters)
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Window", self.draw_window_gizmo_parameters)
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Stair", self.draw_stair_gizmo_parameters)
-
-    def draw_door_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.door import GizmoDoorEdition
-
-        door_gizmos = self.gizmos.door
-        gizmo_prop_names = {p.attr_name for p in GizmoDoorEdition.dimension_gizmo_props}
-        # Add special gizmos not in dimension_gizmo_props
-        gizmo_prop_names.update(("swing_arc", "flip_arc"))
-        try:
-            annotations = door_gizmos.__annotations__
-        except AttributeError:
-            annotations = type(door_gizmos).__annotations__
-        for prop in annotations:
-            if prop in gizmo_prop_names:
-                layout.prop(door_gizmos, prop)
-
-    def draw_window_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.window import GizmoWindowEdition
-
-        window_gizmos = self.gizmos.window
-        gizmo_prop_names = {p.attr_name for p in GizmoWindowEdition.dimension_gizmo_props}
-        try:
-            annotations = window_gizmos.__annotations__
-        except AttributeError:
-            annotations = type(window_gizmos).__annotations__
-        for prop in annotations:
-            if prop in gizmo_prop_names:
-                layout.prop(window_gizmos, prop)
-
-    def draw_stair_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.stair import GizmoStairEdition
-
-        stair_gizmos = self.gizmos.stair
-        gizmo_prop_names = {p.attr_name for p in GizmoStairEdition.dimension_gizmo_props}
-        # Add special gizmos not in dimension_gizmo_props
-        special_gizmo_names = {"lock", "plus", "minus", "cycle"}
-        try:
-            annotations = stair_gizmos.__annotations__
-        except AttributeError:
-            annotations = type(stair_gizmos).__annotations__
-        for prop in annotations:
-            if prop in gizmo_prop_names or prop in special_gizmo_names:
-                layout.prop(stair_gizmos, prop)
+        annotations = type(self.gizmos).__annotations__
+        for feature in tool.Parametric.EDIT_TYPES:
+            if feature.name in annotations:
+                box.prop(self.gizmos, feature.name)
 
     def draw_model_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "occurrence_name_style")

src/bonsai/bonsai/core/aggregate.py

@@ -93,6 +93,8 @@ def enter_aggregate_mode(
     aggregator: type[tool.Aggregate],
     obj: bpy.types.Object,
 ):
+    if not aggregator.get_aggregate_props().in_aggregate_mode:
+        aggregator.save_previous_selection()
     aggregator.update_previous_aggregate_mode_state()
     if aggregator.get_higher_aggregate():
         aggregator.disable_aggregate_mode()
@@ -107,6 +109,7 @@ def exit_aggregate_mode(aggregator: type[tool.Aggregate]):
         aggregator.enable_aggregate_mode(new_obj)
     else:
         aggregator.disable_aggregate_mode()
+        aggregator.restore_previous_selection()
 
 
 class IncompatibleAggregateError(Exception):

src/bonsai/bonsai/core/model.py

@@ -15,10 +15,13 @@
 #
 # 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 __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, Optional
+import math
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 if TYPE_CHECKING:
     import bpy
@@ -31,6 +34,24 @@ if TYPE_CHECKING:
     OffsetType = Literal["CENTER", "EXTERIOR", "INTERIOR"]
 
 
+# Arc sample count for fillet preview polylines. 24 samples produces a visually
+# smooth arc at common viewport scales without bloating the GPU batch.
+FILLET_DEFAULT_ARC_RESOLUTION = 24
+# Dot-product floor for treating two wall-axis segments as parallel — below
+# this the projected intersection is too sensitive to floating-point noise
+# to be useful as a junction apex. Calibrated to ~2° from parallel.
+PARALLEL_DOT_THRESHOLD = 0.9994
+# Perpendicular distance (SI metres) under which two parallel wall axes are
+# considered to share the same infinite line. Calibrated to absorb sub-50mm
+# placement drift between authored-joined walls without merging genuinely
+# offset parallel walls.
+COLLINEAR_LINE_TOLERANCE = 0.05
+# Default proximity (SI metres) for classifying a layer offset against the
+# canonical EXTERIOR / CENTER / INTERIOR baselines. Tight enough that ordinary
+# millimetre-scale modelling intent always falls into the nearest baseline.
+BASELINE_OFFSET_TOLERANCE = 0.001
+
+
 def unjoin_walls(
     ifc: type[tool.Ifc],
     blender: type[tool.Blender],
@@ -140,23 +161,73 @@ def align_objects(
     model.align_objects(reference_obj, objs, align_type)
 
 
+def regenerate_wall_to_underside(
+    ifc: type[tool.Ifc],
+    geometry: type[tool.Geometry],
+    model: type[tool.Model],
+    wall_objs: list[bpy.types.Object],
+) -> None:
+    """Re-clip walls to their connected underside objects after the slab has moved."""
+    clipped_objs = []
+    for obj in wall_objs:
+        wall = ifc.get_entity(obj)
+        slab_objs = model.get_connected_slab_objs(wall)
+        if not slab_objs:
+            continue
+        if ifc.is_moved(obj):
+            geometry.run_edit_object_placement(obj=obj)
+        # Sync each slab's Blender mesh to its current IFC representation before
+        # reading face geometry, so a changed profile is picked up correctly.
+        model.reload_body_representation(slab_objs)
+        model.remove_wall_to_underside_booleans(wall)
+        for slab_obj in slab_objs:
+            clip = model.get_slab_clipping_bmesh(slab_obj)
+            if clip:
+                model.clip_wall_to_slab(wall, clip)
+        clipped_objs.append(obj)
+    if clipped_objs:
+        model.reload_body_representation(clipped_objs)
+
+
 def extend_wall_to_slab(
     ifc: type[tool.Ifc],
     geometry: type[tool.Geometry],
     model: type[tool.Model],
-    slab_obj: bpy.types.Object,
+    slab_objs: list[bpy.types.Object],
     wall_objs: list[bpy.types.Object],
 ) -> None:
-    if not (clip := model.get_slab_clipping_bmesh(slab_obj)):
-        return  # Nothing to clip?
-    slab = ifc.get_entity(slab_obj)
+    # If any wall is currently in item mode, exit it before modifying the
+    # representation. Leaving stale item objects around causes delete_ifc_item
+    # to later remove the extrusion (or other pre-boolean items) from inside
+    # the boolean chain, corrupting the IFC model.
+    geom_props = geometry.get_geometry_props()
+    if geom_props.representation_obj in wall_objs:
+        geometry.disable_item_mode()
+    clipped_walls = []
     for obj in wall_objs:
         if ifc.is_moved(obj):
             geometry.run_edit_object_placement(obj=obj)
         wall = ifc.get_entity(obj)
-        model.clip_wall_to_slab(wall, clip)
-        model.connect_wall_to_slab(wall, slab)
-    model.reload_body_representation(wall_objs)
+        # Merge previously connected slabs with newly requested ones so that
+        # re-running the operator never produces duplicate booleans and never
+        # silently discards clips that were applied in an earlier call.
+        existing = model.get_connected_slab_objs(wall)
+        seen = {id(s) for s in existing}
+        all_slab_objs = list(existing) + [s for s in slab_objs if id(s) not in seen]
+        # Remove stale booleans once, then re-clip against the full set.
+        model.remove_wall_to_underside_booleans(wall)
+        did_clip = False
+        for slab_obj in all_slab_objs:
+            clip = model.get_slab_clipping_bmesh(slab_obj)
+            if not clip:
+                continue
+            model.clip_wall_to_slab(wall, clip)
+            model.connect_wall_to_slab(wall, ifc.get_entity(slab_obj))
+            did_clip = True
+        if did_clip:
+            clipped_walls.append(obj)
+    if clipped_walls:
+        model.reload_body_representation(clipped_walls)
 
 
 class RequireTwoWallsError(Exception):
@@ -173,3 +244,438 @@ class RequireAtLeastTwoElements(Exception):
 
 class RequireLayeredElement(Exception):
     pass
+
+
+# --- Wall geometry math (pure) ------------------------------------------------
+# Tuple in / tuple out so these helpers run without ``bpy`` or ``mathutils``.
+# Callers convert ``mathutils.Vector`` at the boundary.
+
+
+def baseline_from_offset(offset: float, thickness: float, tolerance: float = BASELINE_OFFSET_TOLERANCE) -> str:
+    """Classify a numeric layer offset as EXTERIOR / CENTER / INTERIOR.
+
+    Handles both POSITIVE and NEGATIVE direction_sense walls. Returns the
+    closest canonical baseline; falls back to ``"CENTER"`` when nothing is
+    within ``tolerance``."""
+    candidates = (
+        ("EXTERIOR", 0.0),
+        ("CENTER", -thickness / 2),
+        ("INTERIOR", -thickness),
+        ("EXTERIOR", thickness),
+        ("CENTER", thickness / 2),
+        ("INTERIOR", 0.0),
+    )
+    best = min(candidates, key=lambda c: abs(offset - c[1]))
+    return best[0] if abs(offset - best[1]) < tolerance else "CENTER"
+
+
+def project_axis_intersection(
+    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
+    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
+    parallel_threshold: float,
+) -> Optional[tuple[float, float, float]]:
+    """Compute the 2D (X,Y plane) intersection of two world-space axis segments.
+
+    Each segment is a pair of 3-tuples. Returns the intersection as a 3-tuple
+    (Z is the average of the four input Zs, for visual placement) or ``None`` if
+    the segments are parallel within ``parallel_threshold`` (a dot-product magnitude
+    threshold — see ``PARALLEL_DOT_THRESHOLD`` for the calibrated value)."""
+    p1, p2 = seg_a
+    p3, p4 = seg_b
+    d1x, d1y = p2[0] - p1[0], p2[1] - p1[1]
+    d2x, d2y = p4[0] - p3[0], p4[1] - p3[1]
+    d1_len = (d1x * d1x + d1y * d1y) ** 0.5
+    d2_len = (d2x * d2x + d2y * d2y) ** 0.5
+    if d1_len < 1e-9 or d2_len < 1e-9:
+        return None
+    dot = (d1x * d2x + d1y * d2y) / (d1_len * d2_len)
+    if abs(dot) >= parallel_threshold:
+        return None
+    denom = d1x * d2y - d1y * d2x
+    if abs(denom) < 1e-9:
+        return None
+    t = ((p3[0] - p1[0]) * d2y - (p3[1] - p1[1]) * d2x) / denom
+    ix = p1[0] + t * d1x
+    iy = p1[1] + t * d1y
+    iz = (p1[2] + p2[2] + p3[2] + p4[2]) / 4
+    return (ix, iy, iz)
+
+
+def opening_is_past_cut(min_t: float, cut_percentage: float) -> bool:
+    """True when the opening's near edge sits past the cut on the t axis.
+
+    Strict inequality is load-bearing: a boundary touch or NaN keeps the
+    opening on both walls — the safe default when extent resolution fails."""
+    return min_t > cut_percentage
+
+
+def opening_is_before_cut(max_t: float, cut_percentage: float) -> bool:
+    """True when the opening's far edge sits before the cut on the t axis."""
+    return max_t < cut_percentage
+
+
+def opening_straddles_cut(min_t: float, max_t: float, cut_percentage: float) -> bool:
+    """True when the opening's extent crosses the cut on the t axis."""
+    return min_t < cut_percentage < max_t
+
+
+WallJoinState = Literal["joined", "collinear", "intersect", "none"]
+
+
+def classify_wall_join_state(
+    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
+    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
+    are_joined: bool,
+    parallel_threshold: float,
+    collinear_tolerance: float,
+) -> tuple[WallJoinState, Optional[tuple[float, float, float]]]:
+    """Classify a wall pair's geometric state — ``(state, intersection)``.
+
+    Priority: ``"joined"`` (caller-supplied flag) → ``"collinear"`` →
+    ``"intersect"`` (projected point returned) → ``"none"`` (parallel,
+    non-collinear)."""
+    if are_joined:
+        return "joined", None
+    if are_axes_collinear(seg_a, seg_b, parallel_threshold, collinear_tolerance):
+        return "collinear", None
+    intersection = project_axis_intersection(seg_a, seg_b, parallel_threshold)
+    if intersection is None:
+        return "none", None
+    return "intersect", intersection
+
+
+def wall_join_preview_lines(
+    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
+    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
+    intersection: tuple[float, float, float],
+) -> list[tuple[tuple[float, float, float], tuple[float, float, float]]]:
+    """Two segments showing each wall axis extending to ``intersection``.
+
+    Each segment runs from the input axis's nearest endpoint to the
+    intersection, held at that wall's own Z. Returned in input order
+    ``[floor_a, floor_b]``."""
+    ix, iy, _ = intersection
+
+    def _nearest(seg: tuple[tuple[float, float, float], tuple[float, float, float]]) -> tuple[float, float, float]:
+        return min(seg, key=lambda p: (p[0] - ix) ** 2 + (p[1] - iy) ** 2)
+
+    near_a = _nearest(seg_a)
+    near_b = _nearest(seg_b)
+    return [
+        (near_a, (ix, iy, near_a[2])),
+        (near_b, (ix, iy, near_b[2])),
+    ]
+
+
+def resolve_extend_walls_target(
+    target_obj: Any,
+    objs: list[Any],
+    reverse: bool,
+) -> tuple[Any, list[Any]]:
+    """Pick which object is the extend-target and which are extended.
+
+    Default direction: ``objs`` are extended to meet ``target_obj``.
+    Reversed direction (``reverse=True``) swaps the pair — equivalent to
+    having passed them in the opposite order. The swap is well-defined only
+    for the 1+1 case (one target + one other); for ``n>1`` it would be
+    ambiguous, so the default direction is preserved instead."""
+    if reverse and target_obj is not None and len(objs) == 1:
+        return objs[0], [target_obj]
+    return target_obj, objs
+
+
+def displacement_from_x_angle(height: float, x_angle: float) -> float:
+    """Top-edge horizontal displacement for a wall of given vertical ``height``
+    and slope ``x_angle`` (radians). Inverse of ``x_angle_from_displacement``."""
+    return height * math.tan(x_angle)
+
+
+def x_angle_from_displacement(height: float, displacement: float) -> float:
+    """Recover slope ``x_angle`` (radians) from a top-edge horizontal displacement.
+
+    ``height`` is clamped to ``max(height, 1e-6)`` so zero-height walls map
+    cleanly to ``±π/2`` instead of dividing by zero."""
+    return math.atan2(displacement, max(height, 1e-6))
+
+
+def vertical_height_from_extrusion_depth(extrusion_depth: float, x_angle: float) -> float:
+    """Vertical height of a wall given its slanted extrusion depth and slope.
+
+    ``IfcExtrudedAreaSolid.Depth`` measures along the (possibly slanted) extrusion
+    direction. The vertical height the user thinks of is ``depth * cos(x_angle)``.
+    Unit-agnostic: the result is in the same units as ``extrusion_depth``."""
+    return extrusion_depth * abs(math.cos(x_angle))
+
+
+def extrusion_depth_from_vertical_height(vertical_height: float, x_angle: float) -> float:
+    """``vertical_height / cos(x_angle)`` with ``cos`` clamped at ``1e-6`` to
+    stay finite near ``±π/2``."""
+    return vertical_height / max(abs(math.cos(x_angle)), 1e-6)
+
+
+def length_and_height_from_extrusion(
+    extrusion_depth: float,
+    x_angle: float,
+    reference_line_x_extent: float,
+    unit_scale: float,
+) -> tuple[float, float]:
+    """SI ``(length, vertical_height)`` of a LAYER2 wall.
+
+    Height is the *vertical* projection of the slanted depth, not the
+    slanted depth itself."""
+    length = reference_line_x_extent * unit_scale
+    height = vertical_height_from_extrusion_depth(extrusion_depth * unit_scale, x_angle)
+    return length, height
+
+
+def are_axes_collinear(
+    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
+    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
+    parallel_threshold: float = PARALLEL_DOT_THRESHOLD,
+    line_tolerance: float = COLLINEAR_LINE_TOLERANCE,
+) -> bool:
+    """True if both axis segments lie on the same infinite line in plan.
+
+    Two conditions: directions must be (anti-)parallel within ``parallel_threshold``,
+    AND any endpoint of B must lie on A's infinite line within ``line_tolerance``.
+    Plan-only (Z ignored)."""
+    d1x, d1y = seg_a[1][0] - seg_a[0][0], seg_a[1][1] - seg_a[0][1]
+    d2x, d2y = seg_b[1][0] - seg_b[0][0], seg_b[1][1] - seg_b[0][1]
+    d1_len = (d1x * d1x + d1y * d1y) ** 0.5
+    d2_len = (d2x * d2x + d2y * d2y) ** 0.5
+    if d1_len < 1e-9 or d2_len < 1e-9:
+        return False
+    if abs((d1x * d2x + d1y * d2y) / (d1_len * d2_len)) < parallel_threshold:
+        return False
+    # Project seg_b[0] onto the infinite line through seg_a; the perpendicular
+    # distance to the original point tells us how far off the line B sits.
+    nx, ny = d1x / d1_len, d1y / d1_len
+    dx, dy = seg_b[0][0] - seg_a[0][0], seg_b[0][1] - seg_a[0][1]
+    t = dx * nx + dy * ny
+    proj_x = seg_a[0][0] + nx * t
+    proj_y = seg_a[0][1] + ny * t
+    perp_x = seg_b[0][0] - proj_x
+    perp_y = seg_b[0][1] - proj_y
+    return (perp_x * perp_x + perp_y * perp_y) ** 0.5 < line_tolerance
+
+
+def closest_endpoint_midpoint(
+    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
+    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
+) -> tuple[float, float, float]:
+    """Midpoint of the closest endpoint pair between two segments."""
+    endpoints_a = (seg_a[0], seg_a[1])
+    endpoints_b = (seg_b[0], seg_b[1])
+
+    def _distance_sq(p: tuple[float, float, float], q: tuple[float, float, float]) -> float:
+        return (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + (p[2] - q[2]) ** 2
+
+    closest_pair = min(((a, b) for a in endpoints_a for b in endpoints_b), key=lambda pair: _distance_sq(*pair))
+    a, b = closest_pair
+    return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2)
+
+
+def compute_path_connection_location(
+    seg_self: tuple[tuple[float, float, float], tuple[float, float, float]],
+    self_conn_type: str,
+    seg_other: tuple[tuple[float, float, float], tuple[float, float, float]],
+    other_conn_type: str,
+    parallel_threshold: float = PARALLEL_DOT_THRESHOLD,
+) -> tuple[float, float, float]:
+    """World-space location of a single ``IfcRelConnectsPathElements`` between
+    two wall axes.
+
+    Priority: ``self``'s ATSTART/ATEND endpoint → ``other``'s ATSTART/ATEND
+    endpoint → axis intersection → closest-endpoint midpoint fallback."""
+    if self_conn_type == "ATSTART":
+        return seg_self[0]
+    if self_conn_type == "ATEND":
+        return seg_self[1]
+    if other_conn_type == "ATSTART":
+        return seg_other[0]
+    if other_conn_type == "ATEND":
+        return seg_other[1]
+    intersection = project_axis_intersection(seg_self, seg_other, parallel_threshold)
+    if intersection is not None:
+        return intersection
+    return closest_endpoint_midpoint(seg_self, seg_other)
+
+
+def _vec_sub(a: tuple[float, float, float], b: tuple[float, float, float]) -> tuple[float, float, float]:
+    return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+
+def _vec_dot(a: tuple[float, float, float], b: tuple[float, float, float]) -> float:
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+
+def _vec_cross(a: tuple[float, float, float], b: tuple[float, float, float]) -> tuple[float, float, float]:
+    return (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0])
+
+
+def _vec_length(v: tuple[float, float, float]) -> float:
+    return (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) ** 0.5
+
+
+def _rotate_around_axis(
+    v: tuple[float, float, float],
+    axis: tuple[float, float, float],
+    angle: float,
+) -> tuple[float, float, float]:
+    """Rotate ``v`` around unit-length ``axis`` by ``angle`` radians."""
+    cos_a = math.cos(angle)
+    sin_a = math.sin(angle)
+    dot = _vec_dot(axis, v)
+    cross = _vec_cross(axis, v)
+    k = 1.0 - cos_a
+    return (
+        v[0] * cos_a + cross[0] * sin_a + axis[0] * dot * k,
+        v[1] * cos_a + cross[1] * sin_a + axis[1] * dot * k,
+        v[2] * cos_a + cross[2] * sin_a + axis[2] * dot * k,
+    )
+
+
+def compute_fillet_polylines(
+    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
+    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
+    radius: float,
+    arc_resolution: int = FILLET_DEFAULT_ARC_RESOLUTION,
+    parallel_threshold: float = PARALLEL_DOT_THRESHOLD,
+) -> dict:
+    """Preview polylines for a circular fillet at the junction of two axes.
+
+    Returns a dict with ``valid``, ``reason``, ``intersection``, ``tangent_a``
+    / ``tangent_b``, ``arc`` (``arc_resolution + 1`` samples), ``arc_center``,
+    ``arc_radius``, ``sweep_angle``, ``sweep_axis``, ``tangent_offset``,
+    ``wall_a_join_side`` / ``wall_b_join_side`` (ATSTART/ATEND/None),
+    ``invalid_radius`` (tangent overshoots — arc + tangents still populated
+    for warning rendering), and ``invalid_axes`` (set on parallel)."""
+    blank: dict = {
+        "valid": False,
+        "reason": None,
+        "intersection": None,
+        "tangent_a": None,
+        "tangent_b": None,
+        "arc": [],
+        "arc_center": None,
+        "arc_radius": radius,
+        "sweep_angle": 0.0,
+        "sweep_axis": None,
+        "tangent_offset": 0.0,
+        "wall_a_join_side": None,
+        "wall_b_join_side": None,
+        "invalid_radius": False,
+        "invalid_axes": None,
+    }
+
+    intersection = project_axis_intersection(seg_a, seg_b, parallel_threshold)
+    if intersection is None:
+        return {**blank, "reason": "parallel", "invalid_axes": [seg_a, seg_b]}
+
+    def _classify(seg, ipt):
+        d0 = (seg[0][0] - ipt[0]) ** 2 + (seg[0][1] - ipt[1]) ** 2 + (seg[0][2] - ipt[2]) ** 2
+        d1 = (seg[1][0] - ipt[0]) ** 2 + (seg[1][1] - ipt[1]) ** 2 + (seg[1][2] - ipt[2]) ** 2
+        if d0 <= d1:
+            return seg[0], seg[1], "ATSTART"
+        return seg[1], seg[0], "ATEND"
+
+    near_a, far_a, side_a = _classify(seg_a, intersection)
+    near_b, far_b, side_b = _classify(seg_b, intersection)
+
+    # Direction along each segment AWAY from the corner. ``far - intersection``
+    # handles both the shared-corner and extended-axes cases uniformly.
+    dir_a_raw = _vec_sub(far_a, intersection)
+    dir_b_raw = _vec_sub(far_b, intersection)
+    far_len_a = _vec_length(dir_a_raw)
+    far_len_b = _vec_length(dir_b_raw)
+    if far_len_a < 1e-9 or far_len_b < 1e-9:
+        return {**blank, "reason": "near_collinear", "intersection": intersection}
+    dir_a = (dir_a_raw[0] / far_len_a, dir_a_raw[1] / far_len_a, dir_a_raw[2] / far_len_a)
+    dir_b = (dir_b_raw[0] / far_len_b, dir_b_raw[1] / far_len_b, dir_b_raw[2] / far_len_b)
+
+    cos_angle = max(-1.0, min(1.0, _vec_dot(dir_a, dir_b)))
+    angle = math.acos(cos_angle)
+    sweep_angle = math.pi - angle
+    if sweep_angle < 1e-3 or sweep_angle > math.pi - 1e-3:
+        return {
+            **blank,
+            "reason": "near_collinear",
+            "intersection": intersection,
+            "sweep_angle": sweep_angle,
+            "wall_a_join_side": side_a,
+            "wall_b_join_side": side_b,
+        }
+
+    tangent_offset = radius * math.tan(sweep_angle / 2)
+    tangent_a = (
+        intersection[0] + dir_a[0] * tangent_offset,
+        intersection[1] + dir_a[1] * tangent_offset,
+        intersection[2] + dir_a[2] * tangent_offset,
+    )
+    tangent_b = (
+        intersection[0] + dir_b[0] * tangent_offset,
+        intersection[1] + dir_b[1] * tangent_offset,
+        intersection[2] + dir_b[2] * tangent_offset,
+    )
+
+    plane_normal_raw = _vec_cross(dir_a, dir_b)
+    pn_len = _vec_length(plane_normal_raw)
+    if pn_len < 1e-9:
+        return {**blank, "reason": "near_collinear", "intersection": intersection}
+    plane_normal = (
+        plane_normal_raw[0] / pn_len,
+        plane_normal_raw[1] / pn_len,
+        plane_normal_raw[2] / pn_len,
+    )
+
+    perp_a = _vec_cross(plane_normal, dir_a)
+    if _vec_dot(perp_a, dir_b) < 0:
+        perp_a = (-perp_a[0], -perp_a[1], -perp_a[2])
+
+    arc_center = (
+        tangent_a[0] + perp_a[0] * radius,
+        tangent_a[1] + perp_a[1] * radius,
+        tangent_a[2] + perp_a[2] * radius,
+    )
+
+    v_a = _vec_sub(tangent_a, arc_center)
+    v_b = _vec_sub(tangent_b, arc_center)
+    sweep_axis = plane_normal
+    if _vec_dot(_vec_cross(v_a, v_b), plane_normal) < 0:
+        sweep_axis = (-plane_normal[0], -plane_normal[1], -plane_normal[2])
+
+    arc_points: list[tuple[float, float, float]] = []
+    for i in range(arc_resolution + 1):
+        t = i / arc_resolution
+        rotated = _rotate_around_axis(v_a, sweep_axis, sweep_angle * t)
+        arc_points.append(
+            (
+                arc_center[0] + rotated[0],
+                arc_center[1] + rotated[1],
+                arc_center[2] + rotated[2],
+            )
+        )
+
+    # Overshoot check only for convex fillets (positive ``tangent_offset``);
+    # the inverted-fillet case puts tangents past the intersection.
+    invalid_radius = tangent_offset > 0 and (tangent_offset > far_len_a or tangent_offset > far_len_b)
+
+    return {
+        "valid": not invalid_radius,
+        "reason": "invalid_radius" if invalid_radius else None,
+        "intersection": intersection,
+        "tangent_a": tangent_a,
+        "tangent_b": tangent_b,
+        "arc": arc_points,
+        "arc_center": arc_center,
+        "arc_radius": radius,
+        "sweep_angle": sweep_angle,
+        "sweep_axis": sweep_axis,
+        "tangent_offset": tangent_offset,
+        "wall_a_join_side": side_a,
+        "wall_b_join_side": side_b,
+        "leg_a_available": far_len_a,
+        "leg_b_available": far_len_b,
+        "invalid_radius": invalid_radius,
+        "invalid_axes": None,
+    }

src/bonsai/bonsai/core/product.py

@@ -0,0 +1,64 @@
+# 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.
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+import bonsai.core.geometry
+
+if TYPE_CHECKING:
+    import bpy
+
+    import bonsai.tool as tool
+
+
+Z_ROTATION_ALIGNMENT_TOLERANCE = 1e-9
+
+
+def _z_rotation_diff(target_z: float, source_z: float) -> float:
+    """Signed Z-Euler difference wrapped to [-π, π]."""
+    return (target_z - source_z + math.pi) % (2 * math.pi) - math.pi
+
+
+def copy_z_rotation_to_selected(
+    ifc: type[tool.Ifc],
+    geometry: type[tool.Geometry],
+    surveyor: type[tool.Surveyor],
+    *,
+    active: bpy.types.Object,
+    targets: Iterable[bpy.types.Object],
+    flip: bool = False,
+) -> int:
+    """Apply ``active``'s Z-Euler rotation to each target."""
+    source_z = surveyor.get_z_rotation(active)
+    if flip:
+        source_z += math.pi
+    rotated = 0
+    for obj in targets:
+        if abs(_z_rotation_diff(surveyor.get_z_rotation(obj), source_z)) < Z_ROTATION_ALIGNMENT_TOLERANCE:
+            continue
+        surveyor.set_z_rotation(obj, source_z)
+        rotated += 1
+        if ifc.get_entity(obj) is not None:
+            bonsai.core.geometry.edit_object_placement(ifc, geometry, surveyor, obj=obj)
+    return rotated

src/bonsai/bonsai/core/root.py

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

src/bonsai/bonsai/core/spatial.py

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

src/bonsai/bonsai/core/tool.py

@@ -415,6 +415,17 @@ class Drawing:
     def update_embedded_svg_location(cls, uri, old_location, new_location): pass
 
 
+@interface
+class Duplicate:
+    def get_decomposition_relationships(cls, objs): pass
+    def get_connection_relationships(cls, objs): pass
+    def get_port_connection_relationships(cls, objs): pass
+    def recreate_decompositions(cls, relationships, old_to_new): pass
+    def recreate_connections(cls, relationship, old_to_new): pass
+    def recreate_port_connections(cls, snapshot, old_to_new): pass
+    def consume_warnings(cls): pass
+
+
 @interface
 class Feature:
     def add_feature(cls, featured_obj, featured_objs): pass
@@ -445,6 +456,7 @@ class Geometry:
     def get_representation_name(cls, representation): pass
     def get_styles(cls, obj): pass
     def get_total_representation_items(cls, obj): pass
+    def has_axis_representation(cls, element): pass
     def has_data_users(cls, data): pass
     def has_material_style_override(cls, obj): pass
     def import_representation_parameters(cls, data): pass
@@ -668,6 +680,9 @@ class Model:
     def export_profile(cls, obj, position=None): pass
     def generate_occurrence_name(cls, element_type, ifc_class): pass
     def get_extrusion(cls, representation): pass
+    def get_connected_slab_objs(cls, wall): pass
+    def get_connected_wall_objs(cls, slab): pass
+    def has_underside_connection(cls, element): pass
     def get_manual_booleans(cls, element): pass
     def get_material_layer_parameters(cls, element): pass
     def get_slab_clipping_bmesh(cls, obj): pass
@@ -683,6 +698,7 @@ class Model:
     def regenerate_profile(cls, obj): pass
     def regenerate_slab(cls, obj): pass
     def reload_body_representation(cls, obj_or_objects): pass
+    def remove_wall_to_underside_booleans(cls, wall): pass
     def replace_object_ifc_representation(cls, ifc_file, ifc_context, obj, new_representation): pass
 
 
@@ -776,6 +792,12 @@ class Profile:
     def get_profile(cls, element): pass
 
 
+@interface
+class Parametric:
+    def get_geom_generation(cls) -> int: pass
+    def refresh_post_commit(cls, operator) -> None: pass
+
+
 @interface
 class Pset:
     def add_proposed_property(cls, name, value, props): pass
@@ -859,13 +881,13 @@ class Root:
     def assign_body_styles(cls, element, obj): pass
     def copy_representation(cls, source, dest): pass
     def does_type_have_representations(cls, element): pass
-    def get_decomposition_relationships(cls, objs): pass
     def get_default_container(cls): pass
     def get_element_representation(cls, element, context): pass
     def get_element_type(cls, element): pass
     def get_object_name(cls, obj): pass
     def get_object_representation(cls, obj): pass
     def get_representation_context(cls, representation): pass
+    def has_material_styles(cls, element): pass
     def is_containable(cls, element): pass
     def is_drawing_annotation(cls, element): pass
     def is_element_a(cls, element, ifc_class): pass
@@ -873,7 +895,6 @@ class Root:
     def is_in_nest_mode(cls, element): pass
     def is_spatial_element(cls, element): pass
     def link_object_data(cls, source_obj, destination_obj): pass
-    def recreate_decompositions(cls, relationships, old_to_new): pass
     def run_geometry_add_representation(cls, obj=None, context=None, ifc_representation_class=None, profile_set_usage=None): pass
     def set_object_name(cls, obj, element): pass
 
@@ -1017,6 +1038,8 @@ class Spatial:
     def get_container(cls, element): pass
     def get_decomposed_elements(cls, container, recursive): pass
     def get_decomposition(cls, element): pass
+    def get_host_element(cls, filling): pass
+    def get_host_wall(cls, filling): pass
     def get_object_matrix(cls, obj): pass
     def get_relative_object_matrix(cls, target_obj, relative_to_obj): pass
     def get_root_element(cls, element): pass
@@ -1137,6 +1160,8 @@ class Style:
 @interface
 class Surveyor:
     def get_absolute_matrix(cls, obj): pass
+    def get_z_rotation(cls, obj): pass
+    def set_z_rotation(cls, obj, z): pass
 
 
 @interface
@@ -1203,6 +1228,42 @@ class Voider:
     def void(cls, opening_obj, building_obj): pass
 
 
+@interface
+class Array:
+    def bake_children_transform(cls, parent_element, item): pass
+    def constrain_children_to_parent(cls, parent_element): pass
+    def get_all_children_objects(cls, parent_element): pass
+    def get_all_objects(cls, parent_element): pass
+    def get_child_layer_index(cls, child_element): pass
+    def get_children_objects(cls, modifier_data): pass
+    def get_modifiers_data(cls, parent_element): pass
+    def get_parent_element(cls, element): pass
+    def get_parent_object(cls, element): pass
+    def remove_constraints(cls, parent_element): pass
+    def set_children_lock_state(cls, parent_element, item, lock_state): pass
+
+
+@interface
+class Slab:
+    def read_geometry(cls, obj): pass
+
+
+@interface
+class Wall:
+    def collinear_boundary_world(cls, seg_a, seg_b): pass
+    def compute_wall_fillet_geometry(cls, wall_a_obj, wall_b_obj, radius, arc_resolution): pass
+    def get_axis_local_extent(cls, wall): pass
+    def get_length_and_height(cls, wall): pass
+    def get_world_reference_line(cls, obj): pass
+    def get_x_angle(cls, wall): pass
+    def has_layer2_usage(cls, wall): pass
+    def is_straight_axis(cls, wall): pass
+    def path_connection_location_world(cls, seg_self, self_conn_type, seg_other, other_conn_type, parallel_threshold): pass
+    def read_geometry(cls, obj): pass
+    def validate_for_parametric_edit(cls, obj): pass
+    def walk_connected_walls(cls, start_element, node_cap): pass
+
+
 @interface
 class Web:
     pass

src/bonsai/bonsai/tool/__init__.py

@@ -20,6 +20,7 @@
 # ruff: noqa: F401
 
 from bonsai.tool.aggregate import Aggregate
+from bonsai.tool.array import Array
 from bonsai.tool.attribute import Attribute
 from bonsai.tool.bcf import Bcf
 from bonsai.tool.blender import Blender
@@ -37,6 +38,7 @@ from bonsai.tool.debug import Debug
 from bonsai.tool.demo import Demo
 from bonsai.tool.document import Document
 from bonsai.tool.drawing import Drawing
+from bonsai.tool.duplicate import Duplicate
 from bonsai.tool.feature import Feature
 from bonsai.tool.geometry import Geometry
 from bonsai.tool.georeference import Georeference
@@ -51,6 +53,7 @@ from bonsai.tool.misc import Misc
 from bonsai.tool.model import Model
 from bonsai.tool.nest import Nest
 from bonsai.tool.owner import Owner
+from bonsai.tool.parametric import Parametric
 from bonsai.tool.patch import Patch
 from bonsai.tool.polyline import Polyline
 from bonsai.tool.profile import Profile
@@ -63,6 +66,7 @@ from bonsai.tool.resource import Resource
 from bonsai.tool.root import Root
 from bonsai.tool.search import Search
 from bonsai.tool.sequence import Sequence
+from bonsai.tool.slab import Slab
 from bonsai.tool.snap import Snap
 from bonsai.tool.spatial import Spatial
 from bonsai.tool.structural import Structural
@@ -72,4 +76,5 @@ from bonsai.tool.system import System
 from bonsai.tool.tester import Tester
 from bonsai.tool.type import Type
 from bonsai.tool.unit import Unit
+from bonsai.tool.wall import Wall
 from bonsai.tool.web import Web

src/bonsai/bonsai/tool/aggregate.py

@@ -205,6 +205,27 @@ class Aggregate(bonsai.core.tool.Aggregate):
         props.in_aggregate_mode = True
         return {"FINISHED"}
 
+    @classmethod
+    def save_previous_selection(cls) -> None:
+        props = cls.get_aggregate_props()
+        props.previously_selected_objects.clear()
+        for obj in bpy.context.selected_objects:
+            entry = props.previously_selected_objects.add()
+            entry.obj = obj
+
+    @classmethod
+    def restore_previous_selection(cls) -> None:
+        props = cls.get_aggregate_props()
+        for obj in bpy.context.selected_objects:
+            obj.select_set(False)
+        for entry in props.previously_selected_objects:
+            if entry.obj:
+                try:
+                    entry.obj.select_set(True)
+                except Exception:
+                    pass
+        props.previously_selected_objects.clear()
+
     @classmethod
     def disable_aggregate_mode(cls):
         context = bpy.context

src/bonsai/bonsai/tool/array.py

@@ -0,0 +1,207 @@
+# 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.
+
+"""Bonsai parametric array service.
+
+Top-level array-domain helpers. The ``BBIM_Array`` pset on a parent ``IfcElement``
+holds the list of layers; each layer holds the GUIDs of its child replicas. These
+helpers navigate that graph and manage the Blender-side CHILD_OF constraint that
+pins children to the parent's matrix_world."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any
+
+import bpy
+import ifcopenshell
+import ifcopenshell.util.element
+
+import bonsai.core.tool
+import bonsai.tool as tool
+
+if TYPE_CHECKING:
+    from ifcopenshell import entity_instance
+
+
+class Array(bonsai.core.tool.Array):
+    @classmethod
+    def bake_children_transform(cls, parent_element: entity_instance, item: int) -> None:
+        modifier_data = list(cls.get_modifiers_data(parent_element))[item]
+        children = cls.get_children_objects(modifier_data)
+        for child in children:
+            constraint = next((c for c in child.constraints if c.type == "CHILD_OF"), None)
+            if constraint:
+                with bpy.context.temp_override(object=child):
+                    bpy.ops.constraint.apply(constraint=constraint.name, owner="OBJECT")
+
+    @classmethod
+    def constrain_children_to_parent(cls, parent_element: ifcopenshell.entity_instance) -> None:
+        if not (parent_obj := tool.Ifc.get_object(parent_element)):
+            return  # Filtered out, arrayed void, etc
+        assert isinstance(parent_obj, bpy.types.Object)
+        children = cls.get_all_children_objects(parent_element)
+        for child in children:
+            constraint = next((c for c in child.constraints if c.type == "CHILD_OF"), None)
+            if constraint:
+                child.constraints.remove(constraint)
+            constraint = child.constraints.new("CHILD_OF")
+            constraint.name = "BBIM_Array_CHILD_OF"
+            assert isinstance(constraint, bpy.types.ChildOfConstraint)
+            constraint.target = parent_obj
+
+    @classmethod
+    def set_children_lock_state(
+        cls, parent_element: ifcopenshell.entity_instance, item: int, lock_state: bool = True
+    ) -> None:
+        modifier_data = list(cls.get_modifiers_data(parent_element))[item]
+        children = cls.get_children_objects(modifier_data)
+        for child_obj in children:
+            tool.Blender.lock_transform(child_obj, lock_state)
+
+    @classmethod
+    def remove_constraints(cls, parent_element: ifcopenshell.entity_instance) -> None:
+        children = cls.get_all_children_objects(parent_element)
+        for child in children:
+            constraint = next((c for c in child.constraints if c.type == "CHILD_OF"), None)
+            if constraint:
+                child.constraints.remove(constraint)
+
+    @classmethod
+    def get_all_objects(cls, parent_element: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
+        parent_obj = tool.Ifc.get_object(parent_element)
+        assert isinstance(parent_obj, bpy.types.Object)
+        children_objects = list(cls.get_all_children_objects(parent_element))
+        array_objects = [parent_obj] + children_objects  # We ensure the parent is at index 0
+        return array_objects
+
+    @classmethod
+    def get_all_children_objects(
+        cls, parent_element: ifcopenshell.entity_instance
+    ) -> Generator[bpy.types.Object, None, None]:
+        for array_modifier in cls.get_modifiers_data(parent_element):
+            yield from cls.get_children_objects(array_modifier)
+
+    @classmethod
+    def get_parent_element(cls, element: entity_instance) -> entity_instance | None:
+        """Inverse of ``get_all_children_objects``: resolve an array element
+        back to its parent entity. Returns ``None`` when the element isn't
+        part of a Bonsai parametric array, or the stored Parent GUID does
+        not resolve in the current file (this is a data-integrity warning
+        and is logged to the console)."""
+        pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
+        if not pset:
+            return None
+        parent_guid = pset["Parent"]
+        try:
+            return tool.Ifc.get().by_guid(parent_guid)
+        except RuntimeError:
+            print(
+                f"BBIM_Array.Parent GUID {parent_guid!r} on {element} does not resolve "
+                f"in the current file — array integrity may be broken."
+            )
+            return None
+
+    @classmethod
+    def get_parent_object(cls, element: entity_instance) -> bpy.types.Object | None:
+        parent_element = cls.get_parent_element(element)
+        if parent_element is None:
+            return None
+        return tool.Ifc.get_object(parent_element)
+
+    @classmethod
+    def get_modifiers_data(cls, parent_element: ifcopenshell.entity_instance) -> Generator[dict[str, Any], None, None]:
+        array_pset = ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array")
+        yield from json.loads(array_pset["Data"])
+
+    @classmethod
+    def get_children_objects(cls, modifier_data: dict[str, Any]) -> Generator[bpy.types.Object, None, None]:
+        child_guid: str
+        for child_guid in modifier_data["children"]:
+            child_obj = tool.Blender.get_object_from_guid(child_guid)
+            if child_obj:
+                yield child_obj
+
+    @classmethod
+    def get_array_root_guid(cls, element: entity_instance) -> str:
+        """Walk ``BBIM_Array.Parent`` upwards and return the topmost ancestor's
+        GlobalId. For an element with no ``BBIM_Array`` pset (independent
+        window, never arrayed, or former-child after the apply path), returns
+        the element's own GlobalId — its "family" is just itself."""
+        current = element
+        seen: set[str] = set()
+        while True:
+            pset = ifcopenshell.util.element.get_pset(current, "BBIM_Array")
+            parent_guid = pset.get("Parent") if pset else None
+            if not parent_guid or parent_guid == current.GlobalId or parent_guid in seen:
+                return current.GlobalId
+            seen.add(parent_guid)
+            try:
+                current = tool.Ifc.get().by_guid(parent_guid)
+            except RuntimeError:
+                return current.GlobalId
+
+    @classmethod
+    def get_parametric_propagation_targets(cls, element: entity_instance) -> list[entity_instance]:
+        """Type-occurrences that should receive parametric updates when
+        ``element`` is edited.
+
+        Returns occurrences in ``element``'s Bonsai array family. When
+        ``element`` is not part of any array, returns the type-occurrence
+        peers that are likewise free of ``BBIM_Array`` (preserving the
+        bulk-edit-by-type UX for standalone parametric elements). An
+        occurrence whose ``BBIM_Array`` root differs from ``element``'s root
+        is excluded — that is the "independent former child" case the array
+        apply path produces."""
+        occurrences = tool.Ifc.get_all_element_occurrences(element)
+        element_pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
+        if not element_pset:
+            return [o for o in occurrences if not ifcopenshell.util.element.get_pset(o, "BBIM_Array")]
+        element_root = cls.get_array_root_guid(element)
+        return [o for o in occurrences if cls.get_array_root_guid(o) == element_root]
+
+    @classmethod
+    def get_child_layer_index(cls, child_element: entity_instance) -> int | None:
+        """Index of the layer that produced ``child_element``, or ``None``
+        if the child is unparented, missing from the parent's data, or the
+        parent's pset is unreadable. Total: never raises."""
+        pset = ifcopenshell.util.element.get_pset(child_element, "BBIM_Array")
+        if not pset:
+            return None
+        parent_guid = pset.get("Parent")
+        if not parent_guid or parent_guid == child_element.GlobalId:
+            return None
+        try:
+            parent_element = tool.Ifc.get().by_guid(parent_guid)
+        except RuntimeError:
+            return None
+        data_text = ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array", "Data")
+        if not data_text:
+            return None
+        try:
+            layers = json.loads(data_text)
+        except (ValueError, TypeError):
+            return None
+        child_guid = child_element.GlobalId
+        for i, layer in enumerate(layers):
+            if child_guid in layer.get("children", []):
+                return i
+        return None

src/bonsai/bonsai/tool/blender.py

@@ -15,12 +15,14 @@
 #
 # 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 __future__ import annotations
 
 import contextlib
 import importlib
-import json
+import math
 import os
 import platform
 import subprocess
@@ -28,7 +30,7 @@ import sys
 import tempfile
 import traceback
 import types
-from collections.abc import Callable, Generator, Iterable, Sequence, Sized
+from collections.abc import Callable, Generator, Iterable, Mapping, Sequence, Sized
 from datetime import datetime
 from functools import cache, lru_cache
 from pathlib import Path
@@ -45,7 +47,6 @@ from typing import (
 
 import bmesh
 import bpy
-import ifcopenshell.api
 import ifcopenshell.util.element
 import numpy as np
 import numpy.typing as npt
@@ -55,12 +56,12 @@ from mathutils import Matrix, Vector
 import bonsai.bim
 import bonsai.core.tool
 import bonsai.tool as tool
-from bonsai.bim.ifc import IFC_CONNECTED_TYPE
 
 if TYPE_CHECKING:
     import bpy.stub_internal.rna_enums as rna_enums
     from sun_position.properties import SunPosProperties
 
+    from bonsai.bim.ifc import IFC_CONNECTED_TYPE
     from bonsai.bim.module.attribute.prop import BIMAttributeProperties
     from bonsai.bim.module.constraint.prop import (
         BIMConstraintProperties,
@@ -97,6 +98,19 @@ VIEWPORT_ATTRIBUTES = [
 
 OBJECT_DATA_TYPE = Union[bpy.types.Mesh, bpy.types.Curve, bpy.types.Camera]
 
+_RAILING_MODIFIER_IFC_CLASSES = ("IfcRailing", "IfcRailingType")
+_STAIR_MODIFIER_IFC_CLASSES = (
+    "IfcStairFlight",
+    "IfcStairFlightType",
+    "IfcMember",
+    "IfcMemberType",
+    "IfcStair",
+    "IfcStairType",
+)
+_WINDOW_MODIFIER_IFC_CLASSES = ("IfcWindow", "IfcWindowType", "IfcWindowStyle")
+_DOOR_MODIFIER_IFC_CLASSES = ("IfcDoor", "IfcDoorType", "IfcDoorStyle")
+_ROOF_MODIFIER_IFC_CLASSES = ("IfcRoof", "IfcRoofType")
+
 
 class Blender(bonsai.core.tool.Blender):
     OBJECT_TYPES_THAT_SUPPORT_EDIT_MODE = ("MESH", "CURVE", "SURFACE", "META", "FONT", "LATTICE", "ARMATURE")
@@ -216,15 +230,22 @@ class Blender(bonsai.core.tool.Blender):
 
     @classmethod
     def get_active_object(cls, is_selected: bool = False) -> Union[bpy.types.Object, None]:
-        """Gets the active object
+        """Return the active object, or ``None`` when the current context
+        exposes neither ``active_object`` nor a ``view_layer`` (stripped
+        operator contexts).
 
         :param is_selected: If true, the active object also needs to be selected.
         """
-        if obj := (getattr(bpy.context, "active_object", None) or bpy.context.view_layer.objects.active):
-            if not is_selected:
-                return obj
-            if obj.select_get():
-                return obj
+        obj = getattr(bpy.context, "active_object", None)
+        if obj is None:
+            view_layer = getattr(bpy.context, "view_layer", None)
+            if view_layer is not None:
+                obj = view_layer.objects.active
+        if obj is None:
+            return None
+        if is_selected and not obj.select_get():
+            return None
+        return obj
 
     @classmethod
     def get_selected_objects(cls, include_active: bool = True) -> set[bpy.types.Object]:
@@ -415,6 +436,189 @@ class Blender(bonsai.core.tool.Blender):
         with bpy.context.temp_override(**cls.get_viewport_context()):
             bpy.ops.wm.tool_set_by_id(name=tool_name)
 
+    @classmethod
+    def are_viewport_gizmos_enabled(cls) -> bool:
+        """Central gate every Bonsai gizmo poll / decorator draw checks before
+        rendering. Centralises the read of
+        ``gizmos.draw_gizmos_in_3d_viewport`` from addon preferences."""
+        return cls.get_addon_preferences().gizmos.draw_gizmos_in_3d_viewport
+
+    class DecoratorColors(NamedTuple):
+        selected: tuple
+        unselected: tuple
+        special: tuple
+        error: tuple
+        background: tuple
+
+    @classmethod
+    def get_decorator_colors(cls) -> Blender.DecoratorColors:
+        """The five ``decorator_color_*`` fields read together so each viewport
+        decorator's draw callback resolves them in one call instead of five."""
+        prefs = cls.get_addon_preferences()
+        return cls.DecoratorColors(
+            selected=prefs.decorator_color_selected,
+            unselected=prefs.decorator_color_unselected,
+            special=prefs.decorator_color_special,
+            error=prefs.decorator_color_error,
+            background=prefs.decorator_color_background,
+        )
+
+    class ViewportDecorator:
+        """Shared ``SpaceView3D.draw_handler_add`` lifecycle for feature decorators.
+
+        Single-handler subclasses set ``draw_method`` (default ``"draw"``); the
+        handler binds at ``POST_VIEW``. Multi-handler subclasses set
+        ``draw_methods`` to a tuple of ``(method_name, phase)`` pairs; when it
+        is non-``None`` it supersedes ``draw_method``.
+
+        Decorators whose ``install`` must accept extra arguments (e.g. a callback
+        or a precomputed bmesh) override ``install`` themselves."""
+
+        draw_method: str = "draw"
+        draw_methods: tuple[tuple[str, str], ...] | None = None
+
+        def __init_subclass__(cls, **kwargs):
+            super().__init_subclass__(**kwargs)
+            cls.handlers = []
+            cls.is_installed = False
+            # Fail loudly at class-definition time if draw_method / draw_methods
+            # names an attribute the class doesn't expose. Without this, a typo
+            # only surfaces on the first redraw — as a silent missing-attribute
+            # handler — which may be far from the offending declaration.
+            method_names = (
+                tuple(name for name, _phase in cls.draw_methods) if cls.draw_methods is not None else (cls.draw_method,)
+            )
+            for name in method_names:
+                if getattr(cls, name, None) is None:
+                    raise TypeError(f"{cls.__name__}: draw method {name!r} is declared but not defined on the class")
+
+        @classmethod
+        def install(cls, context: bpy.types.Context) -> None:
+            if cls.is_installed:
+                cls.uninstall()
+            handler = cls()
+            bindings = cls.draw_methods if cls.draw_methods is not None else ((cls.draw_method, "POST_VIEW"),)
+            # Rollback partial registrations on any draw_handler_add failure, so
+            # cls.handlers never ends up holding a half-installed set.
+            added: list = []
+            try:
+                for method_name, phase in bindings:
+                    added.append(
+                        bpy.types.SpaceView3D.draw_handler_add(
+                            getattr(handler, method_name), (context,), "WINDOW", phase
+                        )
+                    )
+            except Exception:
+                for h in added:
+                    try:
+                        bpy.types.SpaceView3D.draw_handler_remove(h, "WINDOW")
+                    except ValueError:
+                        pass
+                raise
+            cls.handlers = added
+            cls.is_installed = True
+
+        @classmethod
+        def uninstall(cls) -> None:
+            for h in cls.handlers:
+                try:
+                    bpy.types.SpaceView3D.draw_handler_remove(h, "WINDOW")
+                except ValueError:
+                    pass
+            cls.handlers.clear()
+            cls.is_installed = False
+
+        @staticmethod
+        def _lookup_active_instance(gizmo_cls: type, context: bpy.types.Context) -> Optional[Any]:
+            """Return the live ``GizmoGroup`` instance registered under
+            ``context.region``, or ``None`` if there isn't one. The per-region
+            weakref dict on the gizmo class is populated by ``setup()``; multi-
+            viewport setups put one entry per region in it so each region's
+            decorator sees only its own region's hover state."""
+            instances = getattr(gizmo_cls, "_active_instances", None)
+            if not instances:
+                return None
+            region = getattr(context, "region", None)
+            if region is None:
+                return None
+            ref = instances.get(region.as_pointer())
+            if ref is None:
+                return None
+            return ref()
+
+        def _cursor_icon_hovered(self, gizmo_cls: type, attr_name: str, context: bpy.types.Context) -> bool:
+            """True iff the gizmo group instance in the current region exposes a gizmo
+            under ``attr_name`` that reports as highlighted. Any access exception is
+            swallowed so a transient bpy-state hiccup never breaks the draw loop."""
+            inst = self._lookup_active_instance(gizmo_cls, context)
+            if inst is None:
+                return False
+            try:
+                return bool(getattr(inst, attr_name).is_highlight)
+            except (AttributeError, ReferenceError):
+                return False
+
+        @classmethod
+        def sync_all(
+            cls,
+            context: bpy.types.Context,
+            enabled: Mapping[type[Blender.ViewportDecorator], bool],
+        ) -> None:
+            """Drive each listed decorator to its desired install state in one call.
+
+            Each entry whose value is ``True`` ends up installed; each entry whose
+            value is ``False`` ends up uninstalled. Pass ``True`` for always-on
+            overlays so they survive subsequent file loads."""
+            for decorator_cls, should_install in enabled.items():
+                if should_install:
+                    decorator_cls.install(context)
+                else:
+                    decorator_cls.uninstall()
+
+    @classmethod
+    def is_view_top_down(cls, context: bpy.types.Context, threshold: float = 0.9659) -> bool:
+        """True when the viewport camera is looking ~straight down (or up) the world Z axis.
+
+        Default threshold of 0.9659 = cos(15°) — a 15° tilt cone around ±world Z.
+        Above the threshold the world-Z axis projects to a small fraction of its
+        true length on screen, so callers that lay icons or markers out along
+        world Z should switch to a screen-space offset and any gizmo whose intent
+        is specifically "vertical" loses its visual cue. The cone is kept narrow
+        so vertical-intent gizmos stay visible across the typical orbit range of
+        3D viewport work and drop out only near genuine plan view."""
+        rv3d = context.region_data
+        if rv3d is None:
+            return False
+        view_forward = Vector(rv3d.view_matrix.inverted().col[2][:3]).normalized()
+        return abs(view_forward.z) > threshold
+
+    @classmethod
+    def top_down_factor(cls, context: bpy.types.Context, threshold: float = 0.9659) -> float:
+        """Continuous 0–1 ramp matching ``is_view_top_down``'s cone: 0 outside the
+        cone, ramping linearly to 1 at strict alignment with world Z. Callers that
+        want a proportional effect (an icon-stack lift growing as the view
+        approaches plan) use this in place of the boolean to avoid a one-frame
+        visual jump as the camera crosses the threshold."""
+        rv3d = context.region_data
+        if rv3d is None:
+            return 0.0
+        view_forward = Vector(rv3d.view_matrix.inverted().col[2][:3]).normalized()
+        alignment = abs(view_forward.z)
+        if alignment <= threshold:
+            return 0.0
+        return (alignment - threshold) / (1.0 - threshold)
+
+    @classmethod
+    def get_screen_up_world(cls, context: bpy.types.Context) -> Vector:
+        """World-space direction corresponding to the camera's up axis (screen-vertical).
+
+        Returns ``+Y`` when region data is unavailable so callers can compute an
+        offset without a guard branch."""
+        rv3d = context.region_data
+        if rv3d is None:
+            return Vector((0.0, 1.0, 0.0))
+        return Vector(rv3d.view_matrix.inverted().col[1][:3]).normalized()
+
     @classmethod
     def get_shader_editor_context(cls) -> Union[dict[str, Any], None]:
         for screen in bpy.data.screens:
@@ -484,9 +688,13 @@ class Blender(bonsai.core.tool.Blender):
 
     @classmethod
     def update_all_viewports(cls, context: bpy.types.Context | None = None) -> None:
+        """Tag every visible 3D viewport for redraw. Silent no-op when no
+        screen attached (background mode, plug-out, mid-load_post)."""
         context = context or bpy.context
-        assert context.screen
-        for area in context.screen.areas:
+        screen = getattr(context, "screen", None)
+        if screen is None:
+            return
+        for area in screen.areas:
             if area.type == "VIEW_3D":
                 area.tag_redraw()
 
@@ -635,10 +843,11 @@ class Blender(bonsai.core.tool.Blender):
         op_text = "" if ui_context == "TOOL_HEADER" else text
         modifier_icon, modifier_str = cls.KEY_MODIFIERS.get(modifier, ("NONE", ""))
 
-        row = layout if ui_context == "TOOL_HEADER" else layout.row(align=True)
         module = sys.modules[module_name]
         icon_previews: Union[bpy.utils.previews.ImagePreviewCollection, None]
         icon_previews = getattr(module, "custom_icon_previews", None)
+
+        row = layout if ui_context == "TOOL_HEADER" else layout.row(align=True)
         if icon_previews:
             custom_icon = icon_previews.get(text.upper().replace(" ", "_"), icon_previews["IFC"]).icon_id
             op = row.operator(operator_to_use, text=op_text, icon_value=custom_icon)
@@ -646,6 +855,7 @@ class Blender(bonsai.core.tool.Blender):
             op = row.operator(operator_to_use, text=op_text)
         if ui_context != "TOOL_HEADER":
             row.label(text="", icon=modifier_icon)
+            row.separator(factor=1)
             row.label(text="", icon=f"EVENT_{key}")
 
         if operator_to_use == hotkey_operator:
@@ -678,19 +888,57 @@ class Blender(bonsai.core.tool.Blender):
         #     ( 1.0,  1.0, -1.0),        # 7
         # ]
         bound_box = obj.bound_box
+        min_pt = Vector(bound_box[0])
+        max_pt = Vector(bound_box[6])
         bbox_dict = {
-            "min_x": bound_box[0][0],
-            "max_x": bound_box[6][0],
-            "min_y": bound_box[0][1],
-            "max_y": bound_box[6][1],
-            "min_z": bound_box[0][2],
-            "max_z": bound_box[6][2],
-            "min_point": Vector(bound_box[0]),
-            "max_point": Vector(bound_box[6]),
-            "center": (Vector(bound_box[6]) + Vector(bound_box[0])) / 2,
+            "min_x": min_pt.x,
+            "max_x": max_pt.x,
+            "min_y": min_pt.y,
+            "max_y": max_pt.y,
+            "min_z": min_pt.z,
+            "max_z": max_pt.z,
+            "min_point": min_pt,
+            "max_point": max_pt,
+            "center": (max_pt + min_pt) / 2,
+            # Intrinsic per-axis size in object-local space. Distinct from
+            # ``obj.dimensions``, which folds object-level scale into its
+            # output; this is the raw mesh bbox extent.
+            "dimensions": (max_pt.x - min_pt.x, max_pt.y - min_pt.y, max_pt.z - min_pt.z),
         }
         return bbox_dict
 
+    @classmethod
+    def get_object_world_bounding_box(cls, obj: bpy.types.Object) -> dict[str, Union[float, Vector]]:
+        """Same shape as ``get_object_bounding_box`` but with ``matrix_world``
+        applied — extents are computed across the 8 transformed corners, so
+        a rotated or scaled object reports its actual world-axis AABB rather
+        than the misleading transform of the local-space corners.
+
+        ``bound_box[0]`` / ``bound_box[6]`` are the local min/max corners but
+        do NOT correspond to the world AABB extremes once the object is
+        rotated, so min/max must be taken per-axis across all 8 corners."""
+        corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
+        xs = [c.x for c in corners]
+        ys = [c.y for c in corners]
+        zs = [c.z for c in corners]
+        min_point = Vector((min(xs), min(ys), min(zs)))
+        max_point = Vector((max(xs), max(ys), max(zs)))
+        return {
+            "min_x": min_point.x,
+            "max_x": max_point.x,
+            "min_y": min_point.y,
+            "max_y": max_point.y,
+            "min_z": min_point.z,
+            "max_z": max_point.z,
+            "min_point": min_point,
+            "max_point": max_point,
+            "center": (min_point + max_point) / 2,
+            # World-axis-aligned per-axis size. For rotated objects this is
+            # the AABB extent, not the intrinsic mesh size (use the local
+            # variant for that).
+            "dimensions": (max_point.x - min_point.x, max_point.y - min_point.y, max_point.z - min_point.z),
+        }
+
     @classmethod
     def select_and_activate_single_object(cls, context: bpy.types.Context, active_object: bpy.types.Object) -> None:
         for obj in context.selected_objects:
@@ -1137,20 +1385,18 @@ class Blender(bonsai.core.tool.Blender):
 
             :return: True if an action was taken, False otherwise
             """
-            if cls.is_roof(element):
-                if cls.is_editing_roof_parameters(obj):
-                    bpy.ops.bim.finish_editing_roof()
+            # roof and railing both finalize then drop into path-edit mode — handle
+            # them before the generic finish dispatch so the path transition runs.
+            if tool.Parametric.is_roof(element):
+                if tool.Parametric.ROOF.is_editing(obj):
+                    tool.Parametric.run_bim_op(tool.Parametric.ROOF.finish_op)
                 bpy.ops.bim.enable_editing_roof_path()
-            elif cls.is_railing(element):
-                if cls.is_editing_railing_parameters(obj):
-                    bpy.ops.bim.finish_editing_railing()
+            elif tool.Parametric.is_railing(element):
+                if tool.Parametric.RAILING.is_editing(obj):
+                    tool.Parametric.run_bim_op(tool.Parametric.RAILING.finish_op)
                 bpy.ops.bim.enable_editing_railing_path()
-            elif cls.is_editing_stair_parameters(obj):
-                bpy.ops.bim.finish_editing_stair()
-            elif cls.is_editing_door_parameters(obj):
-                bpy.ops.bim.finish_editing_door()
-            elif cls.is_editing_window_parameters(obj):
-                bpy.ops.bim.finish_editing_window()
+            elif feature := tool.Parametric.is_object_editing(obj):
+                tool.Parametric.run_bim_op(feature.finish_op)
             else:
                 return False
             return True
@@ -1161,68 +1407,112 @@ class Blender(bonsai.core.tool.Blender):
 
             :return: True if an action was taken, False otherwise
             """
+            # Path-edit modes are distinct from parametric draft modes; handle them first.
             if cls.is_editing_railing_path(obj):
                 bpy.ops.bim.cancel_editing_railing_path()
             elif cls.is_editing_roof_path(obj):
                 bpy.ops.bim.cancel_editing_roof_path()
-            elif cls.is_editing_railing_parameters(obj):
-                bpy.ops.bim.cancel_editing_railing()
-            elif cls.is_editing_door_parameters(obj):
-                bpy.ops.bim.cancel_editing_door()
-            elif cls.is_editing_window_parameters(obj):
-                bpy.ops.bim.cancel_editing_window()
-            elif cls.is_editing_roof_parameters(obj):
-                bpy.ops.bim.cancel_editing_roof()
-            elif cls.is_editing_stair_parameters(obj):
-                bpy.ops.bim.cancel_editing_stair()
+            elif feature := tool.Parametric.is_object_editing(obj):
+                tool.Parametric.run_bim_op(feature.cancel_op)
             else:
                 return False
             return True
 
         @classmethod
         def is_eligible_for_railing_modifier(cls, obj: bpy.types.Object) -> bool:
-            return tool.Blender.is_object_an_ifc_class(obj, ("IfcRailing", "IfcRailingType"))
+            return tool.Blender.is_object_an_ifc_class(obj, _RAILING_MODIFIER_IFC_CLASSES)
 
         @classmethod
         def is_eligible_for_stair_modifier(cls, obj: bpy.types.Object) -> bool:
-            return tool.Blender.is_object_an_ifc_class(
-                obj, ("IfcStairFlight", "IfcStairFlightType", "IfcMember", "IfcMemberType", "IfcStair", "IfcStairType")
-            )
+            return tool.Blender.is_object_an_ifc_class(obj, _STAIR_MODIFIER_IFC_CLASSES)
 
         @classmethod
         def is_eligible_for_window_modifier(cls, obj: bpy.types.Object) -> bool:
-            return tool.Blender.is_object_an_ifc_class(obj, ("IfcWindow", "IfcWindowType", "IfcWindowStyle"))
+            return tool.Blender.is_object_an_ifc_class(obj, _WINDOW_MODIFIER_IFC_CLASSES)
 
         @classmethod
         def is_eligible_for_door_modifier(cls, obj: bpy.types.Object) -> bool:
-            return tool.Blender.is_object_an_ifc_class(obj, ("IfcDoor", "IfcDoorType", "IfcDoorStyle"))
+            return tool.Blender.is_object_an_ifc_class(obj, _DOOR_MODIFIER_IFC_CLASSES)
 
         @classmethod
         def is_eligible_for_roof_modifier(cls, obj: bpy.types.Object) -> bool:
-            return tool.Blender.is_object_an_ifc_class(obj, ("IfcRoof", "IfcRoofType"))
+            return tool.Blender.is_object_an_ifc_class(obj, _ROOF_MODIFIER_IFC_CLASSES)
 
         @classmethod
-        def is_railing(cls, element: entity_instance) -> bool:
-            return tool.Pset.get_element_pset(element, "BBIM_Railing")
+        def is_array_child(cls, element: entity_instance) -> bool:
+            """True if element is a CHILD of a Bonsai parametric array.
+
+            Children are managed replicas regenerated from the parent's pset —
+            their parametric attributes (door dimensions, wall lengths, …) are
+            overwritten on the next ``regenerate_array``. Parametric gizmo
+            groups skip children via this predicate in ``poll``.
+
+            This sits on a different axis from ``tool.Parametric.is_array``:
+            cardinality (parent vs child) is orthogonal to feature kind, and
+            an arrayed wall fires both ``is_wall`` and ``is_array`` on the
+            same element."""
+            if element is None:
+                return False
+            pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
+            if not pset:
+                return False
+            parent_guid = pset.get("Parent")
+            return parent_guid is not None and parent_guid != element.GlobalId
 
         @classmethod
-        def is_roof(cls, element: entity_instance) -> bool:
-            return tool.Pset.get_element_pset(element, "BBIM_Roof")
+        def any_selected_is_array_child(cls) -> bool:
+            """True if any selected IFC-linked object is a Bonsai array child.
+
+            Multi-object wall topology gizmos (merge / join / extend / unjoin
+            / fillet) and their bound operators gate on this: any mutation
+            applied to a child is overwritten on the next
+            ``regenerate_array``, and merge specifically would leave the
+            parent's ``BBIM_Array.Data`` list pointing at a deleted GUID.
+
+            Memoised against (selection signature, IFC geometry generation)
+            so gizmo polls that fire per input event don't re-walk the pset
+            for every selected object every frame. Identity-keyed so plain
+            Python objects (used by tests) work alongside real Blender
+            ``bpy_struct`` wrappers."""
+            selected = tool.Blender.get_selected_objects()
+            selection_sig = frozenset(id(obj) for obj in selected)
+            current_gen = tool.Parametric.get_geom_generation()
+            cached = cls._any_selected_array_child_memo
+            if cached is not None and cached[0] == selection_sig and cached[1] == current_gen:
+                return cached[2]
+            result = False
+            for obj in selected:
+                element = tool.Ifc.get_entity(obj)
+                if element is not None and cls.is_array_child(element):
+                    result = True
+                    break
+            cls._any_selected_array_child_memo = (selection_sig, current_gen, result)
+            return result
+
+        _any_selected_array_child_memo: tuple[frozenset[int], int, bool] | None = None
 
         @classmethod
-        def is_window(cls, element: entity_instance) -> bool:
-            return tool.Pset.get_element_pset(element, "BBIM_Window")
+        def is_slab(cls, element: entity_instance) -> bool:
+            """A slab is host-eligible for the parametric add-opening gizmo if
+            it is an IfcSlab with LAYER3 usage.
+
+            Slabs carry no proprietary BBIM_Slab pset — their parametric state
+            lives in standard IFC (extrusion depth, IfcMaterialLayerSetUsage
+            with LayerSetDirection AXIS3). Any LAYER3 slab qualifies."""
+            if element is None or not element.is_a("IfcSlab"):
+                return False
+            return tool.Model.get_usage_type(element) == "LAYER3"
 
         @classmethod
-        def is_door(cls, element: entity_instance) -> bool:
-            return tool.Pset.get_element_pset(element, "BBIM_Door")
+        def is_pipe_segment(cls, element: entity_instance) -> bool:
+            return element is not None and element.is_a("IfcPipeSegment")
 
         @classmethod
-        def is_stair(cls, element: entity_instance) -> bool:
-            return tool.Pset.get_element_pset(element, "BBIM_Stair")
+        def is_duct_segment(cls, element: entity_instance) -> bool:
+            return element is not None and element.is_a("IfcDuctSegment")
 
         @classmethod
-        def is_editing_railing_path(cls, obj: bpy.types.Object):
+        def is_editing_railing_path(cls, obj: bpy.types.Object) -> bool:
             props = tool.Model.get_railing_props(obj)
             return props.is_editing_path
 
@@ -1231,107 +1521,10 @@ class Blender(bonsai.core.tool.Blender):
             props = tool.Model.get_roof_props(obj)
             return props.is_editing_path
 
-        @classmethod
-        def is_editing_railing_parameters(cls, obj: bpy.types.Object) -> bool:
-            props = tool.Model.get_railing_props(obj)
-            return props.is_editing
-
-        @classmethod
-        def is_editing_roof_parameters(cls, obj: bpy.types.Object) -> bool:
-            props = tool.Model.get_roof_props(obj)
-            return props.is_editing
-
-        @classmethod
-        def is_editing_window_parameters(cls, obj: bpy.types.Object) -> bool:
-            props = tool.Model.get_window_props(obj)
-            return props.is_editing
-
-        @classmethod
-        def is_editing_door_parameters(cls, obj: bpy.types.Object) -> bool:
-            props = tool.Model.get_door_props(obj)
-            return props.is_editing
-
-        @classmethod
-        def is_editing_stair_parameters(cls, obj: bpy.types.Object) -> bool:
-            props = tool.Model.get_stair_props(obj)
-            return props.is_editing
-
         @classmethod
         def is_modifier_with_non_editable_path(cls, element: entity_instance) -> bool:
-            return cls.is_stair(element) or cls.is_door(element) or cls.is_window(element)
-
-        class Array:
-            @classmethod
-            def bake_children_transform(cls, parent_element: entity_instance, item: int) -> None:
-                modifier_data = list(cls.get_modifiers_data(parent_element))[item]
-                children = cls.get_children_objects(modifier_data)
-                for child in children:
-                    constraint = next((c for c in child.constraints if c.type == "CHILD_OF"), None)
-                    if constraint:
-                        with bpy.context.temp_override(object=child):
-                            bpy.ops.constraint.apply(constraint=constraint.name, owner="OBJECT")
-
-            @classmethod
-            def constrain_children_to_parent(cls, parent_element: ifcopenshell.entity_instance) -> None:
-                if not (parent_obj := tool.Ifc.get_object(parent_element)):
-                    return  # Filtered out, arrayed void, etc
-                assert isinstance(parent_obj, bpy.types.Object)
-                children = cls.get_all_children_objects(parent_element)
-                for child in children:
-                    constraint = next((c for c in child.constraints if c.type == "CHILD_OF"), None)
-                    if constraint:
-                        child.constraints.remove(constraint)
-                    constraint = child.constraints.new("CHILD_OF")
-                    constraint.name = "BBIM_Array_CHILD_OF"
-                    assert isinstance(constraint, bpy.types.ChildOfConstraint)
-                    constraint.target = parent_obj
-
-            @classmethod
-            def set_children_lock_state(
-                cls, parent_element: ifcopenshell.entity_instance, item: int, lock_state: bool = True
-            ) -> None:
-                modifier_data = list(cls.get_modifiers_data(parent_element))[item]
-                children = cls.get_children_objects(modifier_data)
-                for child_obj in children:
-                    Blender.lock_transform(child_obj, lock_state)
-
-            @classmethod
-            def remove_constraints(cls, parent_element: ifcopenshell.entity_instance) -> None:
-                children = cls.get_all_children_objects(parent_element)
-                for child in children:
-                    constraint = next((c for c in child.constraints if c.type == "CHILD_OF"), None)
-                    if constraint:
-                        child.constraints.remove(constraint)
-
-            @classmethod
-            def get_all_objects(cls, parent_element: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
-                parent_obj = tool.Ifc.get_object(parent_element)
-                assert isinstance(parent_obj, bpy.types.Object)
-                children_objects = list(cls.get_all_children_objects(parent_element))
-                array_objects = [parent_obj] + children_objects  # We ensure the parent is at index 0
-                return array_objects
-
-            @classmethod
-            def get_all_children_objects(
-                cls, parent_element: ifcopenshell.entity_instance
-            ) -> Generator[bpy.types.Object, None, None]:
-                for array_modifier in cls.get_modifiers_data(parent_element):
-                    yield from cls.get_children_objects(array_modifier)
-
-            @classmethod
-            def get_modifiers_data(
-                cls, parent_element: ifcopenshell.entity_instance
-            ) -> Generator[dict[str, Any], None, None]:
-                array_pset = ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array")
-                yield from json.loads(array_pset["Data"])
-
-            @classmethod
-            def get_children_objects(cls, modifier_data: dict[str, Any]) -> Generator[bpy.types.Object, None, None]:
-                child_guid: str
-                for child_guid in modifier_data["children"]:
-                    child_obj = tool.Blender.get_object_from_guid(child_guid)
-                    if child_obj:
-                        yield child_obj
+            feature = tool.Parametric.find_for_element(element)
+            return bool(feature and feature.has_non_editable_path)
 
     class Attribute:
         @classmethod
@@ -1835,6 +2028,18 @@ class Blender(bonsai.core.tool.Blender):
         dct = {cls.bl_idname: cls.ifc_element_type for cls in (BimTool.__subclasses__())}
         return types.MappingProxyType(dct)
 
+    @classmethod
+    @lru_cache
+    def get_property_header_tools(cls) -> frozenset[str]:
+        """``BimTool`` plus its parametric subclasses — the workspace
+        tools whose 3D-view / N-panel header surfaces BIM Tool property
+        floats (extrusion_depth, length, x_angle). ``AnnotationTool``
+        and the non-``BimTool`` workspace tools (spatial / structural /
+        cad / covering) are excluded by construction."""
+        from bonsai.bim.module.model.workspace import BimTool
+
+        return frozenset(cls.bl_idname for cls in (BimTool.__subclasses__() + [BimTool]))
+
     @classmethod
     def get_object_constraint_props(cls, obj: bpy.types.Object) -> BIMObjectConstraintProperties:
         return obj.BIMObjectConstraintProperties  # pyright: ignore[reportAttributeAccessIssue]
@@ -1888,7 +2093,7 @@ class Blender(bonsai.core.tool.Blender):
     @classmethod
     def get_radiance_exporter_props(cls) -> RadianceExporterProperties:
         assert (scene := bpy.context.scene)
-        return scene.BIMRadianceExporterProperties  # pyright: ignore[reportAttributeAccessIssue]
+        return scene.BIMRadianceExporeterProperies  # pyright: ignore[reportAttributeAccessIssue]
 
     @classmethod
     def get_fm_props(cls) -> BIMFMProperties:
@@ -2055,6 +2260,65 @@ class Blender(bonsai.core.tool.Blender):
             return False
         return True
 
+    @classmethod
+    def draw_bmesh_face_tris(
+        cls,
+        bm: bmesh.types.BMesh,
+        world_vert_coords: list,
+        color: Any,
+        draw_batch: Callable[[str, list, Any, list], None],
+    ) -> None:
+        """Submit a non-mutating beauty-triangulated TRIS batch for ``bm``'s faces.
+
+        ``world_vert_coords`` must be indexed by ``bm.verts`` index. Never call
+        ``bmesh.ops.triangulate`` on a live bmesh to compute draw indices — it
+        mutates the input and produces ear-clip fans that render as visible
+        streaks at low alpha.
+        """
+        tris = [[loop.vert.index for loop in tri] for tri in bm.calc_loop_triangles()]
+        draw_batch("TRIS", world_vert_coords, color, tris)
+
+    @classmethod
+    def build_dashed_line_segments(
+        cls,
+        world_verts: Sequence[Sequence[float]],
+        edges_indices: Sequence[Sequence[int]],
+        dash_period: float,
+        dash_width: float,
+    ) -> tuple[list[tuple[float, float, float]], list[tuple[int, int]]]:
+        """Pre-segment edges into world-space dash chunks for a vanilla LINES batch.
+
+        Each input edge is sliced into segments of length ``dash_width`` spaced
+        ``dash_period`` apart (dash phase resets per-edge). The result is a fresh
+        ``(verts, edges)`` pair that draws as dashes through any standard line
+        shader — letting both passes of a visible/occluded outline reuse the
+        same shader so depth values match exactly across passes.
+        """
+        new_verts: list[tuple[float, float, float]] = []
+        new_edges: list[tuple[int, int]] = []
+        if dash_period <= 0 or dash_width <= 0:
+            return new_verts, new_edges
+        n = len(world_verts)
+        for i, j in edges_indices:
+            if not (0 <= i < n and 0 <= j < n) or i == j:
+                continue
+            v0 = world_verts[i]
+            v1 = world_verts[j]
+            dx, dy, dz = v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]
+            edge_length = math.sqrt(dx * dx + dy * dy + dz * dz)
+            if edge_length == 0.0:
+                continue
+            ux, uy, uz = dx / edge_length, dy / edge_length, dz / edge_length
+            t = 0.0
+            while t < edge_length:
+                t_end = min(t + dash_width, edge_length)
+                idx = len(new_verts)
+                new_verts.append((v0[0] + ux * t, v0[1] + uy * t, v0[2] + uz * t))
+                new_verts.append((v0[0] + ux * t_end, v0[1] + uy * t_end, v0[2] + uz * t_end))
+                new_edges.append((idx, idx + 1))
+                t += dash_period
+        return new_verts, new_edges
+
     @classmethod
     def extract_error_reports(cls, exception: RuntimeError) -> list[str]:
         """Extracts error report lines from a runtime exception during operator execution.
@@ -2205,7 +2469,7 @@ class Blender(bonsai.core.tool.Blender):
 
         See https://projects.blender.org/blender/blender/issues/149283
         """
-        if len(bytedata) == (n * 2):
+        if len(bytedata) == (n * 8):  # float64 has 8 bytes per element
             return np.frombuffer(bytedata, dtype=np.float64).astype(np.float32)
         return np.frombuffer(bytedata, dtype=np.float32)
 

src/bonsai/bonsai/tool/cad.py

@@ -32,6 +32,7 @@ from __future__ import annotations
 
 import math
 import sys
+from collections.abc import Sequence
 from typing import TYPE_CHECKING, Union
 
 import bmesh
@@ -45,6 +46,13 @@ if TYPE_CHECKING:
 
 
 VTX_PRECISION = 1.0e-5
+# Tolerances below are in Blender units (SI metres).
+# Looser than VTX_PRECISION because regen-time numeric drift exceeds CAD snap precision.
+WELD_TOLERANCE = 1.0e-4
+# How close a vertex must be to the cut plane to count as on it.
+BISECT_TOLERANCE = 1.0e-4
+# Strict weld for cleaning up exactly-coincident vertices.
+WELD_EPSILON = 1.0e-6
 
 
 class Cad:
@@ -169,6 +177,14 @@ class Cad:
             return False
         return (x + tolerance) > value > (x - tolerance)
 
+    @classmethod
+    def is_multiple_of_pi(cls, value: float) -> bool:
+        """True when ``value`` is an integer multiple of π within tolerance —
+        the parallelism / anti-parallelism check rotation-difference logic
+        reaches for (segments aligned modulo a 180° flip)."""
+        n = round(value / math.pi)
+        return cls.is_x(abs(value - n * math.pi), 0)
+
     @classmethod
     def normalise_angle(cls, angle: float) -> float:
         """Normalise an angle between -179 and 180"""
@@ -996,3 +1012,106 @@ class Cad:
             y = height_half + height_half * (prj[1] / w)
             return Vector((float(x), float(y)))
         return default
+
+    @classmethod
+    def sweep_disk_along_polyline(
+        cls,
+        bm: bmesh.types.BMesh,
+        points: Sequence[Vector],
+        radius: float,
+        arc_indices: Sequence[int] = (),
+        profile_segments: int = 8,
+    ) -> None:
+        """Append a tube of ``radius`` along the polyline ``points`` to ``bm``.
+
+        Viewport-quality approximation of an IFC ``IfcSweptDiskSolid``: each
+        consecutive pair of points becomes a capped cylinder. The cylinders
+        overlap at joints rather than being mitered — the visual artifact is
+        negligible at typical handrail radii (~25mm) and acceptable for
+        live parametric-edit preview.
+
+        ``arc_indices`` is accepted for API symmetry with the IFC builder
+        (which receives the same data structure), but is currently unused —
+        arcs are visualised as polyline kinks. Tessellating each arc with a
+        Lagrange or circular interpolation would smooth the joints; deferred
+        until profile fidelity becomes a concern.
+
+        :param bm: target bmesh, mutated in place.
+        :param points: polyline vertices.
+        :param radius: tube radius (project units).
+        :param arc_indices: indices of arc midpoints (currently ignored).
+        :param profile_segments: sides on each cylinder cross-section.
+        """
+        del arc_indices  # accepted for forward compatibility; see docstring
+        if len(points) < 2:
+            return
+        for p0, p1 in zip(points, points[1:]):
+            cls._add_capped_cylinder(bm, Vector(p0), Vector(p1), radius, profile_segments)
+
+    @classmethod
+    def add_disk_extrusion(
+        cls,
+        bm: bmesh.types.BMesh,
+        position: Vector,
+        radius: float,
+        depth: float,
+        axis_rotation_z: float,
+        profile_segments: int = 12,
+    ) -> None:
+        """Append a flat cylinder (disk extrusion) to ``bm``.
+
+        A disk of ``radius`` extruded by ``depth`` along the +Y axis rotated
+        by ``axis_rotation_z`` radians around Z. ``position`` is the disk's
+        base, not its centre.
+
+        :param bm: target bmesh, mutated in place.
+        :param position: base of the extrusion in object-local coordinates.
+        :param radius: disk radius.
+        :param depth: extrusion depth along the (rotated) Y axis.
+        :param axis_rotation_z: rotation around Z applied to the +Y axis to
+            obtain the extrusion direction.
+        :param profile_segments: sides on the disk's edge.
+        """
+        # The +Y axis rotated by axis_rotation_z around Z gives the extrusion
+        # direction: (-sin(θ), cos(θ), 0). The disk axis points along it.
+        axis = Vector((-math.sin(axis_rotation_z), math.cos(axis_rotation_z), 0.0))
+        end = position + axis * depth
+        cls._add_capped_cylinder(bm, position, end, radius, profile_segments)
+
+    @classmethod
+    def _add_capped_cylinder(
+        cls,
+        bm: bmesh.types.BMesh,
+        p0: Vector,
+        p1: Vector,
+        radius: float,
+        segments: int,
+    ) -> None:
+        """Append one capped cylinder of ``radius`` from ``p0`` to ``p1`` to ``bm``."""
+        direction = p1 - p0
+        length = direction.length
+        if length < 1e-9:
+            return
+        direction = direction / length
+
+        z_axis = Vector((0.0, 0.0, 1.0))
+        dot = direction.dot(z_axis)
+        if dot > 1.0 - 1e-6:
+            rotation = Matrix.Identity(4)
+        elif dot < -1.0 + 1e-6:
+            # Anti-parallel: rotate 180° around X so the cone flips bottom-to-top.
+            rotation = Matrix.Rotation(math.pi, 4, "X")
+        else:
+            rotation = z_axis.rotation_difference(direction).to_matrix().to_4x4()
+
+        matrix = Matrix.Translation((p0 + p1) * 0.5) @ rotation
+        bmesh.ops.create_cone(
+            bm,
+            cap_ends=True,
+            cap_tris=False,
+            segments=segments,
+            radius1=radius,
+            radius2=radius,
+            depth=length,
+            matrix=matrix,
+        )

src/bonsai/bonsai/tool/collector.py

@@ -135,6 +135,7 @@ class Collector(bonsai.core.tool.Collector):
 
         if element.is_a("IfcFeatureElementSubtraction"):
             obj.display_type = "WIRE"
+            obj.display.show_shadows = False
 
     @classmethod
     def _create_project_child_collection(cls, name: str) -> bpy.types.Collection:

src/bonsai/bonsai/tool/cost.py

@@ -987,7 +987,8 @@ class Cost(bonsai.core.tool.Cost):
     def disable_editing_cost_item_parent(cls) -> None:
         props = cls.get_cost_props()
         props.active_cost_item_id = 0
-        props.change_cost_item_parent = False
+        if props.change_cost_item_parent == True:
+            props.change_cost_item_parent = False
 
     @classmethod
     def load_cost_item_quantities(cls, cost_item: Optional[ifcopenshell.entity_instance] = None) -> None:

src/bonsai/bonsai/tool/drawing.py

@@ -1756,6 +1756,10 @@ class Drawing(bonsai.core.tool.Drawing):
             # For section/elevation views, elevate the segment vertically
             if not (points := helper.elevate_segment(bounds, [v1, v2])):
                 return
+        elif target_view == "MODEL_VIEW":
+            # For model views, clip to XY bounds and keep Z (3D line at true elevation)
+            if not (points := helper.clip_segment(bounds, [v1, v2])):
+                return
         else:
             return
 

src/bonsai/bonsai/tool/duplicate.py

@@ -0,0 +1,328 @@
+# Bonsai - OpenBIM Blender Add-on
+# Copyright (C) 2021 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 dataclasses import dataclass, field
+from typing import Any, Literal
+
+import bpy
+import ifcopenshell
+import ifcopenshell.util.element
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
+
+import bonsai.core.geometry
+import bonsai.core.tool
+import bonsai.tool as tool
+
+
+@dataclass
+class DecompositionRecord:
+    type: Literal["fill"]
+    element: ifcopenshell.entity_instance
+
+
+@dataclass
+class ConnectionRecord:
+    type: Literal["path"]
+    relating_element: ifcopenshell.entity_instance
+    related_element: ifcopenshell.entity_instance
+    relating_connection_type: str
+    related_connection_type: str
+    relating_priorities: list[int]
+    related_priorities: list[int]
+
+
+@dataclass
+class PortConnectionRecord:
+    relating_port_index: int
+    related_element: ifcopenshell.entity_instance
+    related_port_index: int
+    direction: str
+
+
+@dataclass
+class PortConnectionSnapshot:
+    """Port-to-port connections and per-element port counts captured before duplication."""
+
+    by_element: dict[ifcopenshell.entity_instance, list[PortConnectionRecord]] = field(default_factory=dict)
+    port_counts: dict[ifcopenshell.entity_instance, int] = field(default_factory=dict)
+
+
+class Duplicate(bonsai.core.tool.Duplicate):
+
+    _pending_warnings: list[str] = []
+
+    @classmethod
+    def _emit_warning(cls, message: str) -> None:
+        """Buffer a warning for later retrieval by an operator. Falling through
+        to a print keeps the message in the Blender console for the headless /
+        no-operator code path."""
+        cls._pending_warnings.append(message)
+        print(f"Bonsai: WARNING — {message}")
+
+    @classmethod
+    def consume_warnings(cls) -> list[str]:
+        """Return and clear the buffered warnings — operators call this after
+        ``tool.Geometry.duplicate_ifc_objects`` to forward each to ``self.report``."""
+        warnings = cls._pending_warnings
+        cls._pending_warnings = []
+        return warnings
+
+    @classmethod
+    def get_decomposition_relationships(
+        cls, objs: list[bpy.types.Object]
+    ) -> dict[ifcopenshell.entity_instance, DecompositionRecord]:
+        relationships: dict[ifcopenshell.entity_instance, DecompositionRecord] = {}
+        for obj in objs:
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            if building := tool.Spatial.get_host_element(element):
+                relationships[element] = DecompositionRecord(type="fill", element=building)
+        return relationships
+
+    @classmethod
+    def get_connection_relationships(
+        cls, objs: list[bpy.types.Object]
+    ) -> dict[ifcopenshell.entity_instance, ConnectionRecord]:
+        relationships: dict[ifcopenshell.entity_instance, ConnectionRecord] = {}
+        for obj in objs:
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            if hasattr(element, "ConnectedTo") and element.ConnectedTo:
+                paths = [
+                    connection for connection in element.ConnectedTo if connection.is_a("IfcRelConnectsPathElements")
+                ]
+                for path in paths:
+                    relationships[element] = ConnectionRecord(
+                        type="path",
+                        relating_element=path.RelatingElement,
+                        related_element=path.RelatedElement,
+                        relating_connection_type=path.RelatingConnectionType,
+                        related_connection_type=path.RelatedConnectionType,
+                        relating_priorities=list(path.RelatingPriorities or []),
+                        related_priorities=list(path.RelatedPriorities or []),
+                    )
+        return relationships
+
+    @classmethod
+    def get_port_connection_relationships(cls, objs: list[bpy.types.Object]) -> PortConnectionSnapshot:
+        """Snapshot ``IfcRelConnectsPorts`` among MEP elements in ``objs``, indexed for positional-port replay onto duplicates."""
+        # Function-local: top-level import would trigger a partial-init cycle.
+        from bonsai.tool.system import direction_from_port_pair
+
+        snapshot = PortConnectionSnapshot()
+        elements_in_set: set[ifcopenshell.entity_instance] = set()
+        for obj in objs:
+            element = tool.Ifc.get_entity(obj)
+            if element is not None and tool.System.is_mep_element(element):
+                elements_in_set.add(element)
+        if not elements_in_set:
+            return snapshot
+
+        ordered_elements = sorted(elements_in_set, key=lambda e: e.id())
+        for element in ordered_elements:
+            snapshot.port_counts[element] = len(tool.System.get_ports(element))
+
+        seen: set[tuple[tuple[int, int], tuple[int, int]]] = set()
+        for element in ordered_elements:
+            ports = tool.System.get_ports(element)
+            for port_index, port in enumerate(ports):
+                connected_port = tool.System.get_connected_port(port)
+                if connected_port is None:
+                    continue
+                other_element = tool.System.get_port_relating_element(connected_port)
+                if other_element is None or other_element not in elements_in_set:
+                    continue
+                other_ports = tool.System.get_ports(other_element)
+                try:
+                    other_port_index = other_ports.index(connected_port)
+                except ValueError:
+                    continue
+                pair_key = tuple(
+                    sorted(
+                        [
+                            (element.id(), port_index),
+                            (other_element.id(), other_port_index),
+                        ]
+                    )
+                )
+                if pair_key in seen:
+                    continue
+                seen.add(pair_key)
+
+                snapshot.by_element.setdefault(element, []).append(
+                    PortConnectionRecord(
+                        relating_port_index=port_index,
+                        related_element=other_element,
+                        related_port_index=other_port_index,
+                        direction=direction_from_port_pair(port, connected_port),
+                    )
+                )
+        return snapshot
+
+    @classmethod
+    def recreate_decompositions(
+        cls,
+        relationships: dict[ifcopenshell.entity_instance, DecompositionRecord],
+        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
+    ) -> None:
+        for subelement, data in relationships.items():
+            new_subelements = old_to_new.get(subelement)
+            new_elements = old_to_new.get(data.element)
+            if not new_subelements or not new_elements:
+                continue
+            for i, new_subelement in enumerate(new_subelements):
+                new_element = new_elements[i]
+                if data.type == "fill":
+                    element = new_element
+                    filling = new_subelement
+                    voided_obj = tool.Ifc.get_object(new_element)
+                    filling_obj = tool.Ifc.get_object(new_subelement)
+
+                    existing_opening_occurrence = subelement.FillsVoids[0].RelatingOpeningElement
+                    opening = tool.Ifc.run("root.copy_class", product=existing_opening_occurrence)
+                    tool.Ifc.run(
+                        "geometry.edit_object_placement",
+                        product=opening,
+                        matrix=ifcopenshell.util.placement.get_local_placement(opening.ObjectPlacement),
+                        is_si=False,
+                    )
+
+                    representation = ifcopenshell.util.representation.get_representation(
+                        existing_opening_occurrence, "Model", "Body", "MODEL_VIEW"
+                    )
+                    representation = ifcopenshell.util.representation.resolve_representation(representation)
+                    mapped_representation = tool.Ifc.run("geometry.map_representation", representation=representation)
+                    tool.Ifc.run(
+                        "geometry.assign_representation",
+                        product=opening,
+                        representation=mapped_representation,
+                    )
+                    tool.Ifc.run("feature.add_feature", feature=opening, element=element)
+                    tool.Ifc.run("feature.add_filling", opening=opening, element=filling)
+
+                    voided_objs = [voided_obj]
+                    # Openings affect all subelements of an aggregate
+                    for child_subelement in ifcopenshell.util.element.get_decomposition(element):
+                        subobj = tool.Ifc.get_object(child_subelement)
+                        if subobj:
+                            voided_objs.append(subobj)
+
+                    for voided_obj in voided_objs:
+                        if mesh_data := voided_obj.data:
+                            representation = tool.Ifc.get().by_id(
+                                tool.Geometry.get_mesh_props(mesh_data).ifc_definition_id
+                            )
+                            bonsai.core.geometry.switch_representation(
+                                tool.Ifc,
+                                tool.Geometry,
+                                obj=voided_obj,
+                                representation=representation,
+                            )
+
+    @classmethod
+    def recreate_connections(
+        cls,
+        relationship: dict[ifcopenshell.entity_instance, ConnectionRecord],
+        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
+    ) -> None:
+        for element, data in relationship.items():
+            try:
+                new_relating_element = old_to_new.get(data.relating_element)[0]
+                new_related_element = old_to_new.get(data.related_element)[0]
+            except (KeyError, IndexError, TypeError):
+                continue
+            new_rel = tool.Ifc.run(
+                "geometry.connect_path",
+                relating_element=new_relating_element,
+                related_element=new_related_element,
+                relating_connection=data.relating_connection_type,
+                related_connection=data.related_connection_type,
+            )
+            # connect_path hardcodes priorities to []; restore them post-hoc.
+            priority_attrs: dict[str, Any] = {}
+            if data.relating_priorities:
+                priority_attrs["RelatingPriorities"] = data.relating_priorities
+            if data.related_priorities:
+                priority_attrs["RelatedPriorities"] = data.related_priorities
+            if new_rel is not None and priority_attrs:
+                try:
+                    tool.Ifc.run("attribute.edit_attributes", product=new_rel, attributes=priority_attrs)
+                except (RuntimeError, ifcopenshell.Error) as e:
+                    cls._emit_warning(
+                        f"connection priority restore failed for {new_rel}; "
+                        f"duplicate has empty RelatingPriorities/RelatedPriorities: {e}"
+                    )
+
+    @classmethod
+    def recreate_port_connections(
+        cls,
+        snapshot: PortConnectionSnapshot,
+        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
+    ) -> None:
+        """Recreate ``IfcRelConnectsPorts`` between duplicates; skip records whose duplicate's port count diverges from the snapshot."""
+        for relating_element, records in snapshot.by_element.items():
+            for record in records:
+                related_element = record.related_element
+                try:
+                    new_relating = old_to_new[relating_element][0]
+                    new_related = old_to_new[related_element][0]
+                except (KeyError, IndexError):
+                    continue
+
+                new_relating_ports = tool.System.get_ports(new_relating)
+                new_related_ports = tool.System.get_ports(new_related)
+
+                expected_relating = snapshot.port_counts.get(relating_element)
+                if expected_relating is not None and len(new_relating_ports) != expected_relating:
+                    cls._emit_warning(
+                        f"port reconnect skipped — duplicate has {len(new_relating_ports)} ports, "
+                        f"snapshot had {expected_relating}"
+                    )
+                    continue
+                expected_related = snapshot.port_counts.get(related_element)
+                if expected_related is not None and len(new_related_ports) != expected_related:
+                    cls._emit_warning(
+                        f"port reconnect skipped — duplicate has {len(new_related_ports)} ports, "
+                        f"snapshot had {expected_related}"
+                    )
+                    continue
+
+                try:
+                    new_port_a = new_relating_ports[record.relating_port_index]
+                    new_port_b = new_related_ports[record.related_port_index]
+                except IndexError:
+                    cls._emit_warning(
+                        f"port reconnect skipped — record references port index past the duplicate's port list"
+                    )
+                    continue
+                try:
+                    tool.Ifc.run(
+                        "system.connect_port",
+                        port1=new_port_a,
+                        port2=new_port_b,
+                        direction=record.direction or "NOTDEFINED",
+                    )
+                except (RuntimeError, ifcopenshell.Error) as e:
+                    cls._emit_warning(f"port reconnect failed between duplicates: {e}")

src/bonsai/bonsai/tool/geometry.py

@@ -73,7 +73,7 @@ import bonsai.core.style
 import bonsai.core.system
 import bonsai.core.tool
 import bonsai.tool as tool
-from bonsai.bim.ifc import IfcStore
+from bonsai.bim.ifc import IfcStore, get_cache_or_detect_lock
 
 if TYPE_CHECKING:
     from bonsai.bim.module.geometry.prop import (
@@ -115,10 +115,42 @@ class Geometry(bonsai.core.tool.Geometry):
 
     @classmethod
     def clear_cache(cls, element: ifcopenshell.entity_instance) -> None:
-        cache = IfcStore.get_cache()
+        # Cache acquisition can fail if the HDF5 file is locked by another
+        # process — degrade gracefully rather than aborting the caller's
+        # reimport flow. A stale cache entry is harmless; a raised exception
+        # prevents the actual mesh swap. The wrapper sets the project-panel
+        # warning flag on lock so the user sees one prominent notice instead
+        # of per-element log spam.
+        try:
+            cache = get_cache_or_detect_lock()
+        except Exception as exc:
+            print(f"clear_cache: skipping cache invalidation for {element} ({exc})")
+            return
         if cache and hasattr(element, "GlobalId"):
             cache.remove(element.GlobalId)
 
+    @classmethod
+    def has_axis_representation(cls, element: ifcopenshell.entity_instance) -> bool:
+        """True if the element carries a shape representation whose
+        RepresentationIdentifier is 'Axis'. Elements without one cannot be
+        projected to an unambiguous 1D path; callers that draw schematic axis
+        overlays must skip them rather than fall back to mesh-derived geometry."""
+        product_rep = getattr(element, "Representation", None)
+        if product_rep is None:
+            return False
+        for rep in product_rep.Representations:
+            if getattr(rep, "RepresentationIdentifier", None) == "Axis":
+                return True
+        return False
+
+    @classmethod
+    def get_body_representation(cls, element: ifcopenshell.entity_instance) -> ifcopenshell.entity_instance | None:
+        """The element's ``Model/Body/MODEL_VIEW`` representation, or ``None``.
+        Single source for the ``(context, identifier, target_view)`` triple used
+        by every body-geometry reader across walls, slabs, doors, openings, and
+        feature decorators."""
+        return ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+
     @classmethod
     def clear_modifiers(cls, obj: bpy.types.Object) -> None:
         for modifier in obj.modifiers:
@@ -225,7 +257,13 @@ class Geometry(bonsai.core.tool.Geometry):
                 break
         mesh = obj.data
         assert isinstance(mesh, bpy.types.Mesh)
-        item = tool.Ifc.get().by_id(tool.Geometry.get_mesh_props(mesh).ifc_definition_id)
+        item_id = tool.Geometry.get_mesh_props(mesh).ifc_definition_id
+        try:
+            item = tool.Ifc.get().by_id(item_id)
+        except RuntimeError:
+            # Entity already deleted (e.g. removed as part of a sibling boolean collapse).
+            bpy.data.objects.remove(obj)
+            return
         rep_obj = props.representation_obj
         assert (rep_obj := props.representation_obj) and (rep_element := tool.Ifc.get_entity(rep_obj))
         cls.remove_representation_item(item, rep_element)
@@ -389,6 +427,29 @@ class Geometry(bonsai.core.tool.Geometry):
             bm.free()
             del mesh["ios_edges"]
 
+    @classmethod
+    def get_dissolved_edges(
+        cls,
+        mesh: bpy.types.Mesh,
+        angle_limit: float = radians(1.0),
+    ) -> tuple[list[Vector], list[tuple[int, int]]]:
+        # Read-only on `mesh`: builds a throwaway bmesh, dissolves coplanar
+        # edges while preserving material seams, returns wire-overlay data.
+        bm = bmesh.new()
+        bm.from_mesh(mesh)
+        bmesh.ops.dissolve_limit(
+            bm,
+            angle_limit=angle_limit,
+            verts=bm.verts,
+            edges=bm.edges,
+            delimit={"MATERIAL"},
+        )
+        bm.verts.index_update()
+        verts = [v.co.copy() for v in bm.verts]
+        edges = [(e.verts[0].index, e.verts[1].index) for e in bm.edges]
+        bm.free()
+        return verts, edges
+
     @classmethod
     def apply_item_ids_as_vertex_groups(cls, obj: bpy.types.Object) -> None:
         """Save mesh-object item_ids as vertex groups in format 'ios_item_id_xxxx'.
@@ -1093,11 +1154,16 @@ class Geometry(bonsai.core.tool.Geometry):
     @classmethod
     def get_representation_item(cls, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
         data = obj.data
-        if (
-            isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES)
-            and (ifc_id := tool.Geometry.get_mesh_props(data).ifc_definition_id)
-            and ((item := tool.Ifc.get().by_id(ifc_id)).is_a("IfcRepresentationItem"))
-        ):
+        if not isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES):
+            return None
+        ifc_id = tool.Geometry.get_mesh_props(data).ifc_definition_id
+        if not ifc_id:
+            return None
+        try:
+            item = tool.Ifc.get().by_id(ifc_id)
+        except RuntimeError:
+            return None
+        if item.is_a("IfcRepresentationItem"):
             return item
         return None
 
@@ -1154,6 +1220,53 @@ class Geometry(bonsai.core.tool.Geometry):
         props.location_checksum = repr(tool.Blender.np_array_legacy(obj.matrix_world.translation).tobytes())
         props.rotation_checksum = repr(tool.Blender.np_array_legacy(obj.matrix_world.to_3x3()).tobytes())
 
+    @classmethod
+    def commit_placement_if_moved(cls, obj: bpy.types.Object, *, apply_scale: bool = True) -> None:
+        """Write ``obj.matrix_world`` back to its IFC ``ObjectPlacement`` when the
+        object has drifted since its last placement commit.
+
+        Scope: drop-in only when the gate is exactly ``is_moved(obj)``. Call sites
+        whose gate is wider (e.g. ``is_moved OR is_scaled``) or already enforced
+        upstream (inside an ``if is_moved:`` block) should call
+        ``edit_object_placement`` directly to avoid the redundant inner check."""
+        if not tool.Ifc.is_moved(obj):
+            return
+        bonsai.core.geometry.edit_object_placement(
+            tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj, apply_scale=apply_scale
+        )
+
+    @classmethod
+    def restore_placement_from_ifc(cls, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
+        """Snap ``obj.matrix_world`` back to ``element``'s committed IFC placement,
+        then re-baseline the drift checksum so ``tool.Ifc.is_moved(obj)`` returns
+        False afterwards.
+
+        Precondition: ``element.ObjectPlacement`` must not be None. Callers in a
+        cancel-style flow that want a "restore-or-clear-drift" semantic must gate
+        on ObjectPlacement themselves and call ``record_object_position`` directly
+        in the no-placement branch."""
+        assert element.ObjectPlacement is not None, (
+            "restore_placement_from_ifc requires ObjectPlacement — gate the caller "
+            "or use restore_or_rebaseline_placement for the restore-or-clear-drift semantic"
+        )
+        matrix_np = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement).copy()
+        unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        matrix_np[:3, 3] *= unit_scale
+        obj.matrix_world = tool.Loader.apply_blender_offset_to_matrix_world(obj, matrix_np)
+        cls.record_object_position(obj)
+
+    @classmethod
+    def restore_or_rebaseline_placement(cls, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
+        """Cancel-flow placement restore: revert ``obj.matrix_world`` to the committed
+        IFC placement; when the element has no ObjectPlacement, re-baseline the drift
+        checksum instead so a subsequent edit does not silently commit the discarded drag."""
+        if not tool.Ifc.is_moved(obj):
+            return
+        if element.ObjectPlacement is None:
+            cls.record_object_position(obj)
+            return
+        cls.restore_placement_from_ifc(obj, element)
+
     @classmethod
     def remove_connection(cls, connection: ifcopenshell.entity_instance) -> None:
         tool.Ifc.get().remove(connection)
@@ -1205,11 +1318,27 @@ class Geometry(bonsai.core.tool.Geometry):
         bpy.data.objects.remove(obj)
         return new_obj
 
+    @classmethod
+    def detach_representation(cls, product: ifcopenshell.entity_instance) -> None:
+        """Replace ``product.Representation`` with a deep copy so the product
+        no longer shares its representation tree (mapped or direct) with any
+        other entity. The ``IfcGeometricRepresentationContext`` is excluded
+        from the copy so contexts stay file-singletons. No-op when the
+        product has no ``Representation`` attribute or it is unset."""
+        rep = getattr(product, "Representation", None)
+        if rep is None:
+            return
+        product.Representation = ifcopenshell.util.element.copy_deep(
+            tool.Ifc.get(), rep, exclude=["IfcGeometricRepresentationContext"]
+        )
+
     @classmethod
     def resolve_mapped_representation(
         cls, representation: ifcopenshell.entity_instance
     ) -> ifcopenshell.entity_instance:
         if representation.RepresentationType == "MappedRepresentation":
+            if not representation.Items:
+                return representation
             return cls.resolve_mapped_representation(representation.Items[0].MappingSource.MappedRepresentation)
         return representation
 
@@ -2132,8 +2261,11 @@ class Geometry(bonsai.core.tool.Geometry):
 
         new_active_obj = None
         # Track decompositions so they can be recreated after the operation
-        decomposition_relationships = tool.Root.get_decomposition_relationships(objects_to_duplicate)
-        connection_relationships = tool.Root.get_connection_relationships(objects_to_duplicate)
+        decomposition_relationships = tool.Duplicate.get_decomposition_relationships(objects_to_duplicate)
+        connection_relationships = tool.Duplicate.get_connection_relationships(objects_to_duplicate)
+        # Snapshot port-to-port connections — copy_class disconnects new ports
+        # by default, leaving Shift+D duplicates unconnected.
+        port_connection_snapshot = tool.Duplicate.get_port_connection_relationships(objects_to_duplicate)
         old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]] = {}
         old_obj_name_to_new_obj_name: dict[str, str] = {}
 
@@ -2155,10 +2287,7 @@ class Geometry(bonsai.core.tool.Geometry):
             keep_data_linked = linked and not element and not is_tracked_opening
 
             # Prior to duplicating, sync the object placement to make decomposition recreation more stable.
-            if tool.Ifc.is_moved(obj):
-                bonsai.core.geometry.edit_object_placement(
-                    tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj, apply_scale=False
-                )
+            cls.commit_placement_if_moved(obj, apply_scale=False)
 
             new_obj = obj.copy()
             temp_data = None
@@ -2212,7 +2341,7 @@ class Geometry(bonsai.core.tool.Geometry):
                 array_data = arrays_to_duplicate.get(obj, None)
                 tool.Model.handle_array_on_copied_element(new, array_data)
                 if array_data:
-                    for child in tool.Blender.Modifier.Array.get_all_children_objects(new):
+                    for child in tool.Array.get_all_children_objects(new):
                         child.select_set(True)
 
                 # TODO: add new array children to recreate their decomposition too
@@ -2240,10 +2369,11 @@ class Geometry(bonsai.core.tool.Geometry):
 
         # Remove connections with old objects and recreates paths
         cls.remove_old_connections(old_to_new)
-        tool.Root.recreate_connections(connection_relationships, old_to_new)
+        tool.Duplicate.recreate_connections(connection_relationships, old_to_new)
+        tool.Duplicate.recreate_port_connections(port_connection_snapshot, old_to_new)
 
         # Recreate decompositions
-        tool.Root.recreate_decompositions(decomposition_relationships, old_to_new)
+        tool.Duplicate.recreate_decompositions(decomposition_relationships, old_to_new)
         cls.remove_linked_aggregate_data(old_to_new)
         bonsai.bim.handler.refresh_ui_data()
         tool.Root.reload_grid_decorator()
@@ -2308,8 +2438,8 @@ class Geometry(bonsai.core.tool.Geometry):
                 continue
 
             array_data = []
-            for modifier_data in tool.Blender.Modifier.Array.get_modifiers_data(array_parent):
-                children = set(tool.Blender.Modifier.Array.get_children_objects(modifier_data))
+            for modifier_data in tool.Array.get_modifiers_data(array_parent):
+                children = set(tool.Array.get_children_objects(modifier_data))
                 if children.issubset(selected_objects):
                     modifier_data["children"] = []
                     array_data.append(modifier_data)

src/bonsai/bonsai/tool/loader.py

@@ -1216,7 +1216,7 @@ class Loader(bonsai.core.tool.Loader):
     ) -> bool:
         items = [i["item"] for i in ifcopenshell.util.representation.resolve_items(representation)]
         if len(items) == 1 and items[0].is_a("IfcSweptDiskSolid"):
-            if tool.Blender.Modifier.is_railing(element):
+            if tool.Parametric.is_railing(element):
                 return False
             return True
         elif len(items) and (  # See #2508 why we accommodate for invalid IFCs here
@@ -1224,7 +1224,7 @@ class Loader(bonsai.core.tool.Loader):
             and len({i.is_a() for i in items}) == 1
             and len({i.Radius for i in items}) == 1
         ):
-            if tool.Blender.Modifier.is_railing(element):
+            if tool.Parametric.is_railing(element):
                 return False
             return True
         return False

src/bonsai/bonsai/tool/misc.py

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

src/bonsai/bonsai/tool/model.py

@@ -15,12 +15,14 @@
 #
 # 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 __future__ import annotations
 
 import collections.abc
 import json
-from collections.abc import Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
 from copy import deepcopy
 from math import atan, cos, degrees, pi, radians
 from typing import (
@@ -37,9 +39,11 @@ from typing import (
 import bmesh
 import bpy
 import ifcopenshell
+import ifcopenshell.api.feature
 import ifcopenshell.api.geometry
 import ifcopenshell.api.grid
 import ifcopenshell.api.pset
+import ifcopenshell.api.root
 import ifcopenshell.geom
 import ifcopenshell.ifcopenshell_wrapper as W
 import ifcopenshell.util.element
@@ -58,6 +62,7 @@ import bonsai.core.geometry
 import bonsai.core.tool
 import bonsai.tool as tool
 from bonsai.bim import import_ifc
+from bonsai.tool.cad import VTX_PRECISION, WELD_TOLERANCE
 
 T = TypeVar("T")
 V_ = tool.Blender.V_
@@ -70,13 +75,16 @@ if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import (
         BIMArrayProperties,
         BIMDoorProperties,
+        BIMDuctSegmentProperties,
         BIMExternalParametricGeometryProperties,
         BIMModelProperties,
+        BIMPipeSegmentProperties,
         BIMPolylineProperties,
         BIMRailingProperties,
         BIMRoofProperties,
         BIMStairProperties,
         BIMSverchokProperties,
+        BIMWallProperties,
         BIMWindowProperties,
     )
 
@@ -98,6 +106,10 @@ class Model(bonsai.core.tool.Model):
     def get_stair_props(cls, obj: bpy.types.Object) -> BIMStairProperties:
         return obj.BIMStairProperties  # pyright: ignore[reportAttributeAccessIssue]
 
+    @classmethod
+    def get_wall_props(cls, obj: bpy.types.Object) -> BIMWallProperties:
+        return obj.BIMWallProperties  # pyright: ignore[reportAttributeAccessIssue]
+
     @classmethod
     def get_roof_props(cls, obj: bpy.types.Object) -> BIMRoofProperties:
         return obj.BIMRoofProperties  # pyright: ignore[reportAttributeAccessIssue]
@@ -106,6 +118,14 @@ class Model(bonsai.core.tool.Model):
     def get_railing_props(cls, obj: bpy.types.Object) -> BIMRailingProperties:
         return obj.BIMRailingProperties  # pyright: ignore[reportAttributeAccessIssue]
 
+    @classmethod
+    def get_pipe_segment_props(cls, obj: bpy.types.Object) -> BIMPipeSegmentProperties:
+        return obj.BIMPipeSegmentProperties  # pyright: ignore[reportAttributeAccessIssue]
+
+    @classmethod
+    def get_duct_segment_props(cls, obj: bpy.types.Object) -> BIMDuctSegmentProperties:
+        return obj.BIMDuctSegmentProperties  # pyright: ignore[reportAttributeAccessIssue]
+
     @classmethod
     def get_sverchok_props(cls, obj: bpy.types.Object) -> BIMSverchokProperties:
         return obj.BIMSverchokProperties  # pyright: ignore[reportAttributeAccessIssue]
@@ -123,6 +143,35 @@ class Model(bonsai.core.tool.Model):
         assert (scene := bpy.context.scene)
         return scene.BIMPolylineProperties  # pyright: ignore[reportAttributeAccessIssue]
 
+    @classmethod
+    def resolve_active_props_for_edit(
+        cls,
+        context: bpy.types.Context,
+        props_getter: Callable[[bpy.types.Object], Any],
+        *,
+        subtype: Optional[tuple[str, Any]] = None,
+    ) -> Optional[tuple[bpy.types.Object, Any]]:
+        """Resolve ``(obj, props)`` for an operator that acts on the active
+        object only while a parametric edit is active.
+
+        Returns ``None`` (the operator should ``return {"CANCELLED"}``) when
+        any of these fail:
+        - no active object,
+        - ``props.is_editing`` is False,
+        - ``subtype`` is given as ``(attr, value)`` and ``props.<attr> != value``.
+        """
+        obj = context.active_object
+        if not obj:
+            return None
+        props = props_getter(obj)
+        if not getattr(props, "is_editing", False):
+            return None
+        if subtype is not None:
+            attr, value = subtype
+            if getattr(props, attr, None) != value:
+                return None
+        return obj, props
+
     @classmethod
     def convert_si_to_unit(cls, value: T) -> T:
         if isinstance(value, (tuple, list)):
@@ -312,6 +361,8 @@ class Model(bonsai.core.tool.Model):
     @classmethod
     def get_extrusion(cls, representation: ifcopenshell.entity_instance) -> Union[ifcopenshell.entity_instance, None]:
         """Return first found IfcExtrudedAreaSolid"""
+        if not representation.Items:
+            return None
         item = representation.Items[0]
         while True:
             if item.is_a("IfcExtrudedAreaSolid"):
@@ -321,6 +372,28 @@ class Model(bonsai.core.tool.Model):
             else:
                 break
 
+    @classmethod
+    def get_sibling_occurrence_count(cls, element: ifcopenshell.entity_instance) -> int:
+        """Number of *other* products sharing this element's body representation.
+
+        Returns the count of products bound to the same resolved body rep, minus
+        ``element`` itself and minus its type (if any). Zero when the element has
+        no body rep, no resolved rep, or no siblings. A non-zero result means a
+        parametric edit on ``element`` will silently mutate other instances'
+        geometry."""
+        body_rep = tool.Geometry.get_body_representation(element)
+        if not body_rep:
+            return 0
+        resolved = ifcopenshell.util.representation.resolve_representation(body_rep)
+        if not resolved:
+            return 0
+        elements = tool.Geometry.get_elements_by_representation(resolved)
+        elements.discard(element)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type is not None:
+            elements.discard(element_type)
+        return len(elements)
+
     unit_scale: float
     vertices: list[Vector]
     edges: list[Sequence[int]]
@@ -792,7 +865,7 @@ class Model(bonsai.core.tool.Model):
         assert element or representation, "Either element or representation must be provided."
         if representation is None:
             assert element
-            representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+            representation = tool.Geometry.get_body_representation(element)
             if not representation:
                 return []
         booleans = []
@@ -804,6 +877,57 @@ class Model(bonsai.core.tool.Model):
                 items.append(item.FirstOperand)
         return booleans
 
+    @classmethod
+    def get_connected_slab_objs(cls, wall: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
+        """Return Blender objects for slabs connected to wall via IfcRelConnectsElements(TOP)."""
+        result = []
+        for rel in wall.ConnectedFrom:
+            if rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP":
+                slab_obj = tool.Ifc.get_object(rel.RelatingElement)
+                if slab_obj:
+                    result.append(slab_obj)
+        return result
+
+    @classmethod
+    def get_connected_wall_objs(cls, slab: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
+        """Return Blender objects for LAYER2 walls connected to slab via IfcRelConnectsElements(TOP)."""
+        result = []
+        for rel in slab.ConnectedTo:
+            if rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP":
+                wall_obj = tool.Ifc.get_object(rel.RelatedElement)
+                if wall_obj:
+                    result.append(wall_obj)
+        return result
+
+    @classmethod
+    def has_underside_connection(cls, element: ifcopenshell.entity_instance) -> bool:
+        """Return True if element has an IfcRelConnectsElements(TOP) relationship."""
+        return any(rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP" for rel in element.ConnectedFrom)
+
+    @classmethod
+    def remove_wall_to_underside_booleans(cls, wall: ifcopenshell.entity_instance) -> None:
+        """Remove all IfcBooleanResult items previously added by extend_walls_to_underside."""
+        manual_booleans = cls.get_manual_booleans(wall)
+        if not manual_booleans:
+            return
+        ifc_file = tool.Ifc.get()
+        for b in manual_booleans:
+            sec = b.SecondOperand
+            if sec is None:
+                # The IfcPolygonalFaceSet was already deleted externally.  Splice the
+                # orphaned IfcBooleanResult out of the chain so the representation stays valid.
+                parents = list(ifc_file.get_inverse(b))
+                for parent in parents:
+                    if parent.is_a("IfcBooleanResult") and parent.FirstOperand == b:
+                        parent.FirstOperand = b.FirstOperand
+                    elif parent.is_a("IfcShapeRepresentation"):
+                        new_items = tuple((set(parent.Items) - {b}) | {b.FirstOperand})
+                        parent.Items = new_items
+                cls.unmark_manual_booleans(wall, [b.id()])
+                ifc_file.remove(b)
+            elif sec.is_a("IfcTessellatedFaceSet"):
+                tool.Geometry.remove_representation_item(sec, wall)
+
     @classmethod
     def get_manual_booleans(
         cls, element: ifcopenshell.entity_instance, representation: Optional[ifcopenshell.entity_instance] = None
@@ -813,10 +937,11 @@ class Model(bonsai.core.tool.Model):
             return []
         boolean_ids = json.loads(pset["Data"])
         if representation is None:
-            representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+            representation = tool.Geometry.get_body_representation(element)
             if not representation:
                 return []
-        booleans = [b for b in cls.get_booleans(element, representation) if b.id() in boolean_ids]
+        all_chain_booleans = cls.get_booleans(element, representation)
+        booleans = [b for b in all_chain_booleans if b.id() in boolean_ids]
         return booleans
 
     @classmethod
@@ -902,7 +1027,7 @@ class Model(bonsai.core.tool.Model):
                 # Revolved area check should happen inside bim.enable_editing_extrusion_axis
                 # but keep it here to trigger import_representation_items,
                 # so users will be able to at least move IfcRevolvedAreaSolid, until there will be a full support.
-                body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+                body = tool.Geometry.get_body_representation(element)
                 if body and any(
                     i.is_a("IfcRevolvedAreaSolid") for i in ifcopenshell.util.representation.resolve_base_items(body)
                 ):
@@ -1015,7 +1140,14 @@ class Model(bonsai.core.tool.Model):
     def handle_array_on_copied_element(
         cls, element: ifcopenshell.entity_instance, array_data: Optional[dict[str, Any]] = None
     ) -> None:
-        """if no `array_data` is provided then an array will be removed from the element"""
+        """Post-copy hook: decide what to do with the BBIM_Array pset a copy
+        inherits from its source.
+
+        - ``array_data=None`` — detach the copy from any array. Removes the
+          inherited BBIM_Array pset and any CHILD_OF constraint.
+        - ``array_data`` provided — promote the copy to a fresh array parent
+          with an empty children list, using the provided layer config.
+        """
 
         if array_data is None:
             array_pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
@@ -1059,8 +1191,8 @@ class Model(bonsai.core.tool.Model):
             ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=array_pset, properties={"Data": json_data})
 
             for i in range(len(array_data)):
-                tool.Blender.Modifier.Array.set_children_lock_state(element, i, True)
-            tool.Blender.Modifier.Array.constrain_children_to_parent(element)
+                tool.Array.set_children_lock_state(element, i, True)
+            tool.Array.constrain_children_to_parent(element)
 
     @classmethod
     def regenerate_array(
@@ -1097,12 +1229,17 @@ class Model(bonsai.core.tool.Model):
                 offset = base_offset * i
 
                 for obj in obj_stack:
+                    # IndexError when child_i is past the recorded children list
+                    # (count grew); RuntimeError when by_guid finds no entity (the
+                    # child was deleted outside the array op); AssertionError when
+                    # the IFC entity exists but its Blender object was unlinked.
+                    # All three fall through to duplication.
                     try:
                         global_id = array["children"][child_i]
                         child_element = tool.Ifc.get().by_guid(global_id)
                         child_obj = tool.Ifc.get_object(child_element)
                         assert child_obj
-                    except:
+                    except (IndexError, RuntimeError, AssertionError):
                         old_to_new, _ = tool.Geometry.duplicate_ifc_objects([parent_obj])
                         child_element = next(iter(old_to_new.values()))[0]
                         child_obj = tool.Ifc.get_object(child_element)
@@ -1139,14 +1276,24 @@ class Model(bonsai.core.tool.Model):
             removed_children = set(existing_children) - set(array["children"])
             for removed_child in removed_children:
                 element = tool.Ifc.get().by_guid(removed_child)
+                # Strip any wall/slab opening cut by this child before deletion,
+                # so the host's HasOpenings shrinks symmetrically with count.
+                if getattr(element, "FillsVoids", None):
+                    ifcopenshell.api.feature.remove_feature(
+                        tool.Ifc.get(), feature=element.FillsVoids[0].RelatingOpeningElement
+                    )
                 obj = tool.Ifc.get_object(element)
                 if obj:
                     tool.Geometry.delete_ifc_object(obj)
 
+            if array.get("per_child_opening", array.get("mirror_to_host", True)) and children_elements:
+                cls.mirror_parent_void_fillings_to_children(parent_element, children_elements)
+
             if array_i in array_layers_to_apply:
                 for child_element in children_elements:
                     pset = tool.Pset.get_element_pset(child_element, "BBIM_Array")
                     ifcopenshell.api.pset.remove_pset(tool.Ifc.get(), product=child_element, pset=pset)
+                    cls.unshare_opening_representation(child_element)
 
                 array["children"] = []
                 array["count"] = 1
@@ -1159,6 +1306,112 @@ class Model(bonsai.core.tool.Model):
             tool.Ifc.get(), pset=pset, properties={"Data": json_data, "Parent": parent_element.GlobalId}
         )
 
+        # Post-condition: parent is selected on return. duplicate_ifc_objects
+        # deselects the source on every call inside the regen loop; without
+        # this restore, callers get a deselected parent for arrays with N >= 2.
+        # TODO: batch the per-child duplicate_ifc_objects([parent]) calls into
+        # a single N-way duplicate — N depsgraph churns + N select/deselect
+        # flips is wasteful, and a batched duplicate would also remove the
+        # need for this restore.
+        parent_obj.select_set(True)
+
+    @classmethod
+    def mirror_parent_void_fillings_to_children(
+        cls,
+        parent_element: ifcopenshell.entity_instance,
+        children_elements: Sequence[ifcopenshell.entity_instance],
+    ) -> None:
+        """Replicate the parent's FillsVoids → host chain onto each array child.
+
+        For each child, tears down any stale opening, creates a new
+        IfcOpeningElement at the child's current placement, reuses the parent's
+        opening representation as a MappedRepresentation, and adds the
+        void + filling pair so the host element is cut once per child.
+
+        No-op when the parent is not a filling, when the host element cannot
+        be resolved, or when the children list is empty. Opt out via the
+        per-layer ``per_child_opening`` flag on ``BBIM_Array.Data`` (legacy
+        key ``mirror_to_host`` still honoured for round-trip with older files).
+        """
+        host = tool.Spatial.get_host_element(parent_element)
+        if host is None or not children_elements:
+            return
+
+        ifc_file = tool.Ifc.get()
+        parent_opening = parent_element.FillsVoids[0].RelatingOpeningElement
+        parent_opening_rep = ifcopenshell.util.representation.get_representation(
+            parent_opening, "Model", "Body", "MODEL_VIEW"
+        )
+        if parent_opening_rep is None:
+            return
+        parent_opening_rep = ifcopenshell.util.representation.resolve_representation(parent_opening_rep)
+
+        for child in children_elements:
+            if getattr(child, "FillsVoids", None):
+                ifcopenshell.api.feature.remove_feature(ifc_file, feature=child.FillsVoids[0].RelatingOpeningElement)
+            child_obj = tool.Ifc.get_object(child)
+            if child_obj is None:
+                continue
+
+            new_opening = ifcopenshell.api.root.create_entity(
+                ifc_file,
+                ifc_class="IfcOpeningElement",
+                predefined_type="OPENING",
+                name="Opening",
+            )
+            ifcopenshell.api.geometry.edit_object_placement(
+                ifc_file,
+                product=new_opening,
+                matrix=np.array(child_obj.matrix_world),
+                is_si=True,
+            )
+            mapped_representation = ifcopenshell.api.geometry.map_representation(
+                ifc_file, representation=parent_opening_rep
+            )
+            ifcopenshell.api.geometry.assign_representation(
+                ifc_file, product=new_opening, representation=mapped_representation
+            )
+            ifcopenshell.api.feature.add_feature(ifc_file, feature=new_opening, element=host)
+            ifcopenshell.api.feature.add_filling(ifc_file, opening=new_opening, element=child)
+
+        # Openings affect every sub-element of an aggregate, not just the named host.
+        voided_objs: list[bpy.types.Object] = []
+        host_obj = tool.Ifc.get_object(host)
+        if host_obj is not None:
+            voided_objs.append(host_obj)
+        for subelement in tool.Aggregate.get_parts_recursively(host):
+            subobj = tool.Ifc.get_object(subelement)
+            if subobj is not None:
+                voided_objs.append(subobj)
+
+        for voided_obj in voided_objs:
+            if not voided_obj.data:
+                continue
+            voided_element = tool.Ifc.get_entity(voided_obj)
+            if voided_element is None:
+                continue
+            context = tool.Geometry.get_active_representation_context(voided_obj)
+            representation = tool.Geometry.get_representation_by_context(voided_element, context)
+            if representation is None:
+                continue
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc, tool.Geometry, obj=voided_obj, representation=representation
+            )
+
+    @classmethod
+    def unshare_opening_representation(cls, filling: ifcopenshell.entity_instance) -> None:
+        """Detach a filling's opening representation from any shared mapped body.
+
+        Required when a Bonsai array child is promoted to an independent
+        object: the array's per-child opening mirror builds each child's
+        opening representation as an ``IfcMappedRepresentation`` over the
+        parent opening's body. Without this detach, a later edit replacing
+        the parent body rewrites the shared ``IfcRepresentationMap`` and
+        reshapes the former-child's opening too."""
+        if not getattr(filling, "FillsVoids", None):
+            return
+        tool.Geometry.detach_representation(filling.FillsVoids[0].RelatingOpeningElement)
+
     @classmethod
     def replace_object_ifc_representation(
         cls,
@@ -1305,8 +1558,8 @@ class Model(bonsai.core.tool.Model):
         return [obj for obj in tool.Blender.get_selected_objects() if tool.Ifc.get_entity(obj)]
 
     @classmethod
-    def has_selected_ifc_objects(cls) -> bool:
-        return any(tool.Ifc.get_entity(obj) for obj in tool.Blender.get_selected_objects())
+    def has_selected_ifc_objects(cls, include_active: bool = True) -> bool:
+        return any(tool.Ifc.get_entity(obj) for obj in tool.Blender.get_selected_objects(include_active=include_active))
 
     @classmethod
     def get_selected_mesh_objects(cls) -> list[bpy.types.Object]:
@@ -1335,8 +1588,7 @@ class Model(bonsai.core.tool.Model):
         element = tool.Ifc.get_entity(object)
         if not element:
             return
-        psets = ifcopenshell.util.element.get_psets(element)
-        pset_data = psets.get(pset_name, None)
+        pset_data = ifcopenshell.util.element.get_pset(element, pset_name)
         if not pset_data:
             return
         pset_data["data_dict"] = json.loads(pset_data.get("Data", "[]") or "[]")
@@ -1355,8 +1607,7 @@ class Model(bonsai.core.tool.Model):
     @classmethod
     def sync_object_ifc_position(cls, obj: bpy.types.Object) -> None:
         """make sure IFC position will be in sync with the Blender object position, if object was moved in Blender"""
-        if tool.Ifc.is_moved(obj):
-            bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+        tool.Geometry.commit_placement_if_moved(obj)
 
     @classmethod
     def get_element_matrix(cls, element: ifcopenshell.entity_instance, keep_local: bool = False) -> Matrix:
@@ -1388,7 +1639,7 @@ class Model(bonsai.core.tool.Model):
             if not obj.data:
                 continue
             element = tool.Ifc.get_entity(obj)
-            body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+            body = tool.Geometry.get_body_representation(element)
             bonsai.core.geometry.switch_representation(
                 tool.Ifc,
                 tool.Geometry,
@@ -1505,6 +1756,10 @@ class Model(bonsai.core.tool.Model):
         "TRIPLE_PANEL_VERTICAL",
     ]
 
+    RoofGenerationMethod = Literal["HEIGHT", "ANGLE"]
+
+    RailingType = Literal["FRAMELESS_PANEL", "WALL_MOUNTED_HANDRAIL"]
+
     @classmethod
     def generate_stair_2d_profile(
         cls,
@@ -1756,7 +2011,7 @@ class Model(bonsai.core.tool.Model):
         from bonsai.bim.module.model.opening import FilledOpeningGenerator
 
         ifc_file = tool.Ifc.get()
-        fillings = {e: tool.Ifc.get_object(e) for e in tool.Ifc.get_all_element_occurrences(element)}
+        fillings = {e: tool.Ifc.get_object(e) for e in tool.Array.get_parametric_propagation_targets(element)}
 
         voided_objs = set()
         has_replaced_opening_representation = False
@@ -1898,7 +2153,9 @@ class Model(bonsai.core.tool.Model):
 
         bm = bmesh.new()
         bm.from_mesh(mesh)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-4)
+        # Looser than auto_detect_curves' VTX_PRECISION: profiles must close into
+        # a single loop, so nearly-coincident endpoints should snap together.
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=WELD_TOLERANCE)
         bmesh.ops.delete(bm, geom=bm.faces, context="FACES_ONLY")
 
         # https://docs.blender.org/api/blender_python_api_2_63_8/bmesh.html#CustomDataAccess
@@ -2126,7 +2383,7 @@ class Model(bonsai.core.tool.Model):
 
         bm = bmesh.new()
         bm.from_mesh(mesh)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=VTX_PRECISION)
         bmesh.ops.delete(bm, geom=bm.faces, context="FACES_ONLY")
 
         # https://docs.blender.org/api/blender_python_api_2_63_8/bmesh.html#CustomDataAccess
@@ -2345,6 +2602,12 @@ class Model(bonsai.core.tool.Model):
 
     @classmethod
     def get_existing_x_angle(cls, extrusion: ifcopenshell.entity_instance) -> float:
+        """Signed slope of the extrusion's direction in the y-z plane (radians).
+
+        Assumes extrusion directions lie in the y-z plane (LAYER2 wall and
+        LAYER3 slab convention). For inverted extrusions (z ≤ 0), adds π to
+        preserve angular continuity for callers consuming the angle via
+        cos/sin."""
         x, y, z = extrusion.ExtrudedDirection.DirectionRatios
         vector = Vector((0, 1))
         x_angle = vector.angle_signed(Vector((y, z)))
@@ -2379,12 +2642,15 @@ class Model(bonsai.core.tool.Model):
         clipping_bm = bmesh.new()
         vertex_map = {}
 
+        kept = 0
         for face in bm.faces:
             face.normal_update()
             normal = face.normal.to_4d()
             normal.w = 0
-            if (obj.matrix_world @ normal).z >= -0.5:
+            world_normal_z = (obj.matrix_world @ normal).z
+            if world_normal_z >= -0.5:
                 continue
+            kept += 1
             new_verts = []
             for vert in face.verts:
                 if not (new_vert := vertex_map.get(vert.index, None)):
@@ -2397,6 +2663,7 @@ class Model(bonsai.core.tool.Model):
             return
 
         bmesh.ops.recalc_face_normals(clipping_bm, faces=clipping_bm.faces)
+        clipping_bm.faces.ensure_lookup_table()
         return clipping_bm  # clipping_bm is in project units
 
     @classmethod
@@ -2410,17 +2677,53 @@ class Model(bonsai.core.tool.Model):
         min_z = min(zs)
         max_z = max(zs)
 
-        operand = None
-        if (z := max_z - min_z) and not np.isclose(z, 0.0):
-            builder = ifcopenshell.util.shape_builder.ShapeBuilder(tool.Ifc.get())
+        ifc_file = tool.Ifc.get()
+        builder = ifcopenshell.util.shape_builder.ShapeBuilder(ifc_file)
 
-            result = bmesh.ops.extrude_face_region(bm, geom=bm.faces)
-            extruded_verts = [elem for elem in result["geom"] if isinstance(elem, bmesh.types.BMVert)]
-            bmesh.ops.translate(bm, verts=extruded_verts, vec=(0, 0, z))
+        # Build one IfcPolygonalFaceSet clip solid per clipping face.
+        # Each solid uses a rectangle on the slope plane rather than the exact face
+        # footprint.  The original approach (exact footprint) caused a kissing-solid /
+        # boundary-coincidence bug when the operator is called twice for a ridge roof: the
+        # two slope solids share an exact ridge edge, and OCCT produces spurious extra
+        # vertices.  Extending each solid slightly past the ridge (by margin) creates a
+        # volumetric overlap instead of a kissing boundary — OCCT handles overlapping
+        # DIFFERENCE operands correctly.
+        margin = 1.0  # project units past the face edge — enough to ensure overlap at ridge
+        operands = []
+        for face in bm.faces:
+            face.normal_update()
+            normal = Vector(face.normal).normalized()
 
-            verts = [v.co for v in bm.verts]
-            faces = [[v.index for v in p.verts] for p in bm.faces]
-            operand = builder.mesh(verts, faces)
+            # Orthonormal basis spanning the slope plane.
+            ref = Vector((0, 0, 1)) if abs(normal.z) < 0.9 else Vector((1, 0, 0))
+            tangent1 = normal.cross(ref).normalized()
+            tangent2 = normal.cross(tangent1).normalized()
+
+            centroid = sum((v.co for v in face.verts), Vector()) / len(face.verts)
+
+            # Tight bounding rectangle in slope-plane coords, plus a small margin.
+            t1_coords = [(v.co - centroid).dot(tangent1) for v in face.verts]
+            t2_coords = [(v.co - centroid).dot(tangent2) for v in face.verts]
+            half1 = max(abs(c) for c in t1_coords) + margin
+            half2 = max(abs(c) for c in t2_coords) + margin
+
+            # Rectangle on the slope plane, extruded upward in wall-local Z.
+            clip_bm = bmesh.new()
+            v0 = clip_bm.verts.new(centroid + half1 * tangent1 + half2 * tangent2)
+            v1 = clip_bm.verts.new(centroid - half1 * tangent1 + half2 * tangent2)
+            v2 = clip_bm.verts.new(centroid - half1 * tangent1 - half2 * tangent2)
+            v3 = clip_bm.verts.new(centroid + half1 * tangent1 - half2 * tangent2)
+            bottom_face = clip_bm.faces.new([v0, v1, v2, v3])
+            result = bmesh.ops.extrude_face_region(clip_bm, geom=[bottom_face])
+            top_verts = [e for e in result["geom"] if isinstance(e, bmesh.types.BMVert)]
+            bmesh.ops.translate(clip_bm, verts=top_verts, vec=Vector((0, 0, max_z - min_z)))
+            clip_bm.verts.ensure_lookup_table()
+
+            clip_verts = [v.co for v in clip_bm.verts]
+            clip_faces = [[v.index for v in f.verts] for f in clip_bm.faces]
+            operand = builder.mesh(clip_verts, clip_faces)
+            clip_bm.free()
+            operands.append(operand)
 
         for extrusion in ifcopenshell.util.shape.get_base_extrusions(wall) or []:
             if extrusion.Position:
@@ -2437,10 +2740,9 @@ class Model(bonsai.core.tool.Model):
 
             extrusion.Depth = max_z / direction[2]
 
-            if operand:
-                booleans = ifcopenshell.api.geometry.add_boolean(
-                    tool.Ifc.get(), first_item=extrusion, second_items=[operand]
-                )
+            if operands:
+                body_repr = ifcopenshell.util.representation.get_representation(wall, "Model", "Body", "MODEL_VIEW")
+                booleans = ifcopenshell.api.geometry.add_boolean(ifc_file, first_item=extrusion, second_items=operands)
                 tool.Model.mark_manual_booleans(wall, booleans)
 
     @classmethod
@@ -2672,7 +2974,7 @@ class Model(bonsai.core.tool.Model):
     def offset_wall(cls, wall: bpy.types.Object, baseline: Literal["EXTERIOR", "INTERIOR", "CENTER"]) -> None:
         element = tool.Ifc.get_entity(wall)
         usage = ifcopenshell.util.element.get_material(element)
-        if not usage.is_a("IfcMaterialLayerSetUsage"):
+        if usage is None or not usage.is_a("IfcMaterialLayerSetUsage"):
             return
         layer_set = usage.ForLayerSet
         if baseline == "CENTER":
@@ -2693,6 +2995,20 @@ class Model(bonsai.core.tool.Model):
 
     @classmethod
     def recreate_wall(cls, element: ifcopenshell.entity_instance, obj: bpy.types.Object) -> None:
+        # Curved fillet-corner walls own a hand-built banana body that
+        # ``regenerate_wall_representation`` would flatten — it reads the axis
+        # as a 2-point reference line and builds a straight extrusion. Rebuild
+        # the curve in place instead: ``regenerate_fillet_corner_wall`` keeps
+        # radius + placement from the pset / current ``ObjectPlacement`` while
+        # picking up new thickness / height from the wall type, which is what
+        # we want when a type-property edit triggered this call.
+        if tool.Parametric.is_fillet_corner_wall(element):
+            # Lazy import: ``tool.Model`` loads before ``bim/module/model`` at
+            # addon enable; a module-level import would cycle.
+            from bonsai.bim.module.model.wall import regenerate_fillet_corner_wall
+
+            regenerate_fillet_corner_wall(element, obj)
+            return
         rep = ifcopenshell.api.geometry.regenerate_wall_representation(tool.Ifc.get(), element)
         bonsai.core.geometry.switch_representation(
             tool.Ifc,
@@ -2713,28 +3029,29 @@ class Model(bonsai.core.tool.Model):
         queue: set[tuple[ifcopenshell.entity_instance, bpy.types.Object]] = set()
         for wall in walls:
             element = tool.Ifc.get_entity(wall)
-            if tool.Ifc.is_moved(wall):
-                bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=wall)
+            tool.Geometry.commit_placement_if_moved(wall)
             queue.add((element, wall))
             for rel in getattr(element, "ConnectedTo", []):
                 obj = tool.Ifc.get_object(rel.RelatedElement)
-                if tool.Ifc.is_moved(obj):
-                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+                tool.Geometry.commit_placement_if_moved(obj)
                 queue.add((rel.RelatedElement, obj))
             for rel in getattr(element, "ConnectedFrom", []):
                 obj = tool.Ifc.get_object(rel.RelatingElement)
-                if tool.Ifc.is_moved(obj):
-                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+                tool.Geometry.commit_placement_if_moved(obj)
                 queue.add((rel.RelatingElement, obj))
         for element, wall in queue:
-            if tool.Model.get_usage_type(element) == "LAYER2" and wall:
-                # Use layer custom offset
+            if not wall:
+                continue
+            is_layer2_usage = tool.Model.get_usage_type(element) == "LAYER2"
+            is_fillet_corner = tool.Parametric.is_fillet_corner_wall(element)
+            if not (is_layer2_usage or is_fillet_corner):
+                continue
+            if is_layer2_usage:
                 custom_offset = tool.Model.get_material_layer_custom_offset(element, wall)
                 material = ifcopenshell.util.element.get_material(element)
                 if material.is_a("IfcMaterialLayerSetUsage") and custom_offset is not None:
                     material.OffsetFromReferenceLine = custom_offset
-
-                cls.recreate_wall(element, wall)
+            cls.recreate_wall(element, wall)
 
     @classmethod
     def regenerate_slab(cls, obj: bpy.types.Object) -> None:

src/bonsai/bonsai/tool/parametric.py

@@ -0,0 +1,621 @@
+# 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.
+
+"""Registry and save-time auto-commit for parametric draft edits.
+
+The registry is consumed along two orthogonal axes:
+
+- **Predicate axis**: every entry carries an ``is_<name>`` total predicate. Used
+  by ``find_for_element``, save-flow auto-commit, and per-feature gizmo polls.
+- **Lifecycle axis**: a subset of entries flagged ``supports_build_edit_lifecycle=True``
+  share the ``Enable/Finish/CancelEditing<Type>`` operator shape and are wired
+  through ``build_edit_lifecycle``. The remainder declare their edit operators
+  directly because their lifecycle (per-attribute diff dispatch, layer-stack
+  editing, mid-spline gizmo drag, …) does not fit the shared mixin contract.
+
+Adding a new parametric element type is a single entry in ``EDIT_TYPES``;
+flag ``supports_build_edit_lifecycle`` only if the type's edit lifecycle matches
+one of the shared mixins in ``bim/parametric_lifecycle.py``."""
+
+from __future__ import annotations
+
+import logging
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
+
+import bpy
+
+import bonsai.core.tool
+import bonsai.tool as tool
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from ifcopenshell import entity_instance
+
+
+# Lowercase ASCII snake_case token; each segment a non-empty letter/digit
+# sequence starting with a letter. ``"pipe_segment"`` → ``"BIMPipeSegmentProperties"``.
+_VALID_NAME_RE = re.compile(r"^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$")
+
+
+def _camel_case(name: str) -> str:
+    return "".join(part.capitalize() for part in name.split("_"))
+
+
+@dataclass(frozen=True)
+class ParametricObject:
+    """One parametric element type's draft + enable + finish + cancel edit lifecycle.
+
+    The ``name`` token drives every derived identifier: the
+    ``BIM<Name>Properties`` attribute on ``bpy.types.Object``, the
+    ``bim.enable_editing_<name>`` / ``bim.finish_editing_<name>`` /
+    ``bim.cancel_editing_<name>`` operator ``bl_idname``s, and the
+    ``tool.Parametric.is_<name>`` runtime predicate.
+
+    The predicate is part of the contract and MUST be total — accept any IFC
+    entity, return a bool, never raise. A raising predicate breaks the save
+    path for every parametric type, not just its own.
+
+    ``supports_build_edit_lifecycle`` marks entries whose edit lifecycle fits the
+    shared mixin contract (``_enable_targets`` / ``_finish_targets`` /
+    ``_cancel_targets``) and that therefore wire their operators through
+    ``build_edit_lifecycle``. Entries with bespoke edit lifecycles (per-attribute
+    diff dispatch, layer-stack editing, mid-spline gizmo drag) leave this
+    False and declare their operator classes directly."""
+
+    name: str
+    has_non_editable_path: bool = False
+    supports_build_edit_lifecycle: bool = False
+
+    def __post_init__(self) -> None:
+        if not _VALID_NAME_RE.match(self.name):
+            raise ValueError(
+                f"ParametricObject name {self.name!r} must match "
+                f"{_VALID_NAME_RE.pattern!r} — lowercase letters / digits, "
+                f"optionally split by single underscores (e.g. ``door`` or "
+                f"``pipe_segment``). Leading / trailing underscores and "
+                f"consecutive underscores are rejected because they produce "
+                f"empty CamelCase segments in derived class names."
+            )
+
+    @property
+    def props_attr(self) -> str:
+        return f"BIM{_camel_case(self.name)}Properties"
+
+    @property
+    def enable_op(self) -> str:
+        return f"bim.enable_editing_{self.name}"
+
+    @property
+    def finish_op(self) -> str:
+        return f"bim.finish_editing_{self.name}"
+
+    @property
+    def cancel_op(self) -> str:
+        return f"bim.cancel_editing_{self.name}"
+
+    def is_editing(self, obj: bpy.types.Object) -> bool:
+        props = getattr(obj, self.props_attr, None)
+        return bool(props and getattr(props, "is_editing", False))
+
+
+class Parametric(bonsai.core.tool.Parametric):
+    class GenerationKeyedCache:
+        """A dict-keyed cache stamped with the parametric generation counter
+        at fill time. Reads at a later generation drop the whole dict and
+        re-run the loader. Any IFC commit bumps the generation, invalidating
+        all entries en bloc.
+
+        ``None`` values are stored verbatim; only "key not in dict" counts as
+        a miss."""
+
+        def __init__(self) -> None:
+            self._gen: int | None = None
+            self._data: dict = {}
+
+        def get_or_compute(self, key, loader):
+            current = Parametric.get_geom_generation()
+            if self._gen != current:
+                self._data.clear()
+                self._gen = current
+            if key not in self._data:
+                self._data[key] = loader()
+            return self._data[key]
+
+        def clear(self) -> None:
+            """Explicit drop. Use from ``load_post`` so a fresh file starts clean."""
+            self._data.clear()
+            self._gen = None
+
+    EDIT_TYPES: list[ParametricObject] = [
+        ParametricObject("door", has_non_editable_path=True, supports_build_edit_lifecycle=True),
+        ParametricObject("window", has_non_editable_path=True, supports_build_edit_lifecycle=True),
+        ParametricObject("stair", has_non_editable_path=True, supports_build_edit_lifecycle=True),
+        ParametricObject("railing", supports_build_edit_lifecycle=True),
+        ParametricObject("roof", supports_build_edit_lifecycle=True),
+        ParametricObject("array", supports_build_edit_lifecycle=True),
+        ParametricObject("pipe_segment", supports_build_edit_lifecycle=True),
+        ParametricObject("duct_segment", supports_build_edit_lifecycle=True),
+        ParametricObject("wall"),
+    ]
+
+    # Annotations for the uppercase constants populated from ``EDIT_TYPES`` by
+    # the binding loop at module bottom. Declared here so IDEs and type
+    # checkers see the attributes without running the loop.
+    DOOR: ClassVar[ParametricObject]
+    WINDOW: ClassVar[ParametricObject]
+    STAIR: ClassVar[ParametricObject]
+    RAILING: ClassVar[ParametricObject]
+    ROOF: ClassVar[ParametricObject]
+    ARRAY: ClassVar[ParametricObject]
+    PIPE_SEGMENT: ClassVar[ParametricObject]
+    DUCT_SEGMENT: ClassVar[ParametricObject]
+    WALL: ClassVar[ParametricObject]
+
+    _geom_generation: int = 0
+
+    @classmethod
+    def get_geom_generation(cls) -> int:
+        return cls._geom_generation
+
+    @classmethod
+    def refresh_post_commit(cls, operator: bpy.types.Operator) -> None:
+        """Post-commit hook for ``tool.Ifc.Operator``: bumps the geometry
+        generation counter so caches keyed off it drop stale entries on
+        the next draw, and tags viewports for redraw.
+
+        Additionally refreshes the BIM Tool header floats for the
+        validate-gizmo path — operators whose ``bl_idname`` is the
+        ``finish_op`` of an entry in ``EDIT_TYPES``. That is the only
+        commit class where selection didn't change but the header
+        values displayed did. Other operators skip the refresh: they
+        don't target an active-object header edit, and their commit
+        context may lack the view-layer attributes the refresh reads."""
+        cls._geom_generation += 1
+        tool.Blender.update_all_viewports()
+        if operator.bl_idname in {feature.finish_op for feature in cls.EDIT_TYPES}:
+            import bonsai.bim.handler  # late import: bim.handler imports tool.*
+
+            bonsai.bim.handler.refresh_bim_tool_headers()
+
+    @classmethod
+    def find_by_name(cls, name: str) -> Optional[ParametricObject]:
+        return next((f for f in cls.EDIT_TYPES if f.name == name), None)
+
+    @classmethod
+    def _safe_predicate(cls, feature: ParametricObject, element: entity_instance) -> bool:
+        """Resolve and invoke ``is_<feature.name>`` defensively. The contract is
+        that predicates are total (see ``ParametricObject`` docstring); a
+        regression that turns one predicate raising would otherwise break the
+        save path for every parametric type, not just its own."""
+        predicate = getattr(cls, f"is_{feature.name}", None)
+        if predicate is None:
+            return False
+        try:
+            return bool(predicate(element))
+        except Exception:
+            logger.warning(
+                "parametric predicate is_%s raised on %r",
+                feature.name,
+                element,
+                exc_info=True,
+            )
+            return False
+
+    @classmethod
+    def find_for_element(cls, element: entity_instance) -> Optional[ParametricObject]:
+        """Return the registry entry whose IFC type predicate matches ``element``."""
+        for feature in cls.EDIT_TYPES:
+            if cls._safe_predicate(feature, element):
+                return feature
+        return None
+
+    @classmethod
+    def is_object_editing(cls, obj: bpy.types.Object, skip_name: Optional[str] = None) -> Optional[ParametricObject]:
+        """Return the registry entry whose edit lifecycle is active on ``obj``, or None.
+
+        ``skip_name`` excludes one entry from the scan, for callers that want
+        to know if a *different* type is editing."""
+        for feature in cls.EDIT_TYPES:
+            if feature.name == skip_name:
+                continue
+            if feature.is_editing(obj):
+                return feature
+        return None
+
+    @classmethod
+    def _validated_editing_feature(cls, obj: bpy.types.Object) -> Optional[ParametricObject]:
+        """Return the active registry entry on ``obj``, validated against the
+        per-type predicate. Returns None when no ``is_editing`` flag is set
+        or when the flag is stale.
+
+        Self-heals: a predicate mismatch clears the flag in place so the
+        finish dispatch never re-picks up a phantom edit."""
+        feature = cls.is_object_editing(obj)
+        if feature is None:
+            return None
+        element = tool.Ifc.get_entity(obj)
+        if element is None or not cls._safe_predicate(feature, element):
+            getattr(obj, feature.props_attr).is_editing = False
+            return None
+        return feature
+
+    @classmethod
+    def heal_stale_edit_flags(cls) -> None:
+        """Validate every scene object's ``is_editing`` flag against the
+        per-type predicate, clearing stale flags in place.
+
+        Run from ``load_post`` so a ``.blend`` saved with phantom flags
+        (e.g. a save that bypassed the auto-commit flush) is consistent the
+        moment it opens."""
+        for obj in bpy.data.objects:
+            cls._validated_editing_feature(obj)
+
+    @classmethod
+    def on_load_post(cls, scene: bpy.types.Scene) -> None:
+        """Drain load-transient parametric state on a freshly opened scene
+        so no draft edit flag, preview flag, or cache entry persists from
+        the saved file."""
+        from bonsai.bim.module.model import wall_offset_gizmos
+        from bonsai.bim.module.model.preview_base import discard_pending_previews
+
+        cls.heal_stale_edit_flags()
+        discard_pending_previews(scene)
+        wall_offset_gizmos.clear_caches()
+
+    @classmethod
+    def get_pending_edits(cls) -> list[tuple[bpy.types.Object, str]]:
+        """``(object, finish_operator_bl_idname)`` pairs for every object
+        with an in-progress parametric draft. Stale flags are cleared in
+        place and excluded."""
+        pending: list[tuple[bpy.types.Object, str]] = []
+        for obj in bpy.data.objects:
+            feature = cls._validated_editing_feature(obj)
+            if feature is not None:
+                pending.append((obj, feature.finish_op))
+        return pending
+
+    @classmethod
+    def run_bim_op(cls, bl_idname: str) -> None:
+        """Invoke a ``bim.*`` operator by ``bl_idname``.
+
+        Asserts the operator is a ``tool.Ifc.Operator`` subclass — bypassing
+        that wrap would mutate IFC outside Bonsai's transaction system."""
+        verb = bl_idname.removeprefix("bim.")
+        op_cls = getattr(bpy.types, f"BIM_OT_{verb}", None)
+        if op_cls is None or not issubclass(op_cls, tool.Ifc.Operator):
+            raise RuntimeError(
+                f"{bl_idname!r} must be a registered tool.Ifc.Operator subclass for undo-safe IFC mutation"
+            )
+        getattr(bpy.ops.bim, verb)()
+
+    @classmethod
+    def commit_object_draft(cls, obj: bpy.types.Object, finish_op: str) -> bool:
+        """Run ``finish_op`` scoped to ``obj`` alone. Returns False (with
+        traceback printed) if the operator raised.
+
+        Both ``temp_override`` and ``view_layer.objects.active`` are set:
+        ``temp_override`` does not rebind ``objects.active``, and some finish
+        operators read it directly."""
+        view_layer = bpy.context.view_layer
+        original_active = view_layer.objects.active
+        try:
+            with bpy.context.temp_override(active_object=obj, selected_objects=[obj]):
+                view_layer.objects.active = obj
+                try:
+                    cls.run_bim_op(finish_op)
+                    return True
+                except Exception:
+                    logger.warning(
+                        "commit of %r via %s failed",
+                        obj.name,
+                        finish_op,
+                        exc_info=True,
+                    )
+                    return False
+        finally:
+            view_layer.objects.active = original_active
+
+    @classmethod
+    def commit_pending_edits(cls) -> tuple[int, list[bpy.types.Object]]:
+        """Run each pending draft's finish operator scoped to its object.
+
+        A per-object failure does not abort the loop — remaining drafts
+        still flush, otherwise the auto-commit would ship the exact silent
+        desync it exists to prevent."""
+        committed = 0
+        failed: list[bpy.types.Object] = []
+        for obj, finish_op in cls.get_pending_edits():
+            if cls.commit_object_draft(obj, finish_op):
+                committed += 1
+            else:
+                failed.append(obj)
+        return committed, failed
+
+    @classmethod
+    def commit_pending_edits_for_selection(
+        cls, names: Optional[tuple[str, ...]] = None
+    ) -> tuple[int, list[bpy.types.Object]]:
+        """Selection-scoped variant. ``names`` filters which registry entries
+        to consider; ``None`` considers every type."""
+        committed = 0
+        failed: list[bpy.types.Object] = []
+        for obj in tool.Blender.get_selected_objects():
+            feature = cls._validated_editing_feature(obj)
+            if feature is None:
+                continue
+            if names is not None and feature.name not in names:
+                continue
+            if cls.commit_object_draft(obj, feature.finish_op):
+                committed += 1
+            else:
+                failed.append(obj)
+        return committed, failed
+
+    @classmethod
+    def _assert_predicates_registered(cls) -> None:
+        """Loud at addon-enable if any ``EDIT_TYPES`` entry has no matching
+        ``is_<name>`` classmethod. Without this, a typo in the registry entry
+        produces a silent-False predicate that never matches — every
+        parametric draft of that type bypasses save-flow auto-commit."""
+        missing = [feature.name for feature in cls.EDIT_TYPES if not callable(getattr(cls, f"is_{feature.name}", None))]
+        if missing:
+            raise RuntimeError(
+                f"tool.Parametric.EDIT_TYPES has entries with no is_<name> predicate: {missing}. "
+                f"Add `is_<name>(cls, element) -> bool` classmethods on tool.Parametric, "
+                f"or remove the entries from EDIT_TYPES."
+            )
+
+    @classmethod
+    def register_object_properties(cls, prop_module) -> None:
+        """Attach ``bpy.types.Object.BIM<Name>Properties`` for every registered
+        parametric type. Skips entries whose ``PropertyGroup`` is absent."""
+        cls._assert_predicates_registered()
+        for feature in cls.EDIT_TYPES:
+            prop_cls = getattr(prop_module, feature.props_attr, None)
+            if prop_cls is None:
+                continue
+            setattr(bpy.types.Object, feature.props_attr, bpy.props.PointerProperty(type=prop_cls))
+
+    @classmethod
+    def unregister_object_properties(cls) -> None:
+        for feature in cls.EDIT_TYPES:
+            if hasattr(bpy.types.Object, feature.props_attr):
+                delattr(bpy.types.Object, feature.props_attr)
+
+    # --- Feature-kind predicates ------------------------------------------------
+    # One predicate per registered parametric type. Each is total: accepts any
+    # IFC entity (or None), returns a bool, never raises. Predicates live with
+    # the registry rather than ``tool.Blender.Modifier`` because they ARE the
+    # registry contract — ``find_for_element`` and ``_validated_editing_feature``
+    # resolve them by name. Coupling them on the same class makes a typo at
+    # registration time an immediate AttributeError instead of a silent None
+    # predicate that never matches.
+
+    @classmethod
+    def is_array(cls, element: entity_instance) -> bool:
+        """True if element is the PARENT of a Bonsai parametric array.
+
+        Array children also carry a ``BBIM_Array`` pset (their ``Parent``
+        field points back to the original), so checking pset presence alone
+        would falsely match them. The parent is distinguished by
+        ``pset.Parent == element.GlobalId``."""
+        import ifcopenshell.util.element
+
+        if element is None:
+            return False
+        pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
+        if not pset:
+            return False
+        return pset.get("Parent") == element.GlobalId
+
+    @classmethod
+    def is_railing(cls, element: entity_instance) -> bool:
+        if element is None:
+            return False
+        return tool.Pset.get_element_pset(element, "BBIM_Railing") is not None
+
+    @classmethod
+    def is_roof(cls, element: entity_instance) -> bool:
+        if element is None:
+            return False
+        return tool.Pset.get_element_pset(element, "BBIM_Roof") is not None
+
+    @classmethod
+    def is_window(cls, element: entity_instance) -> bool:
+        if element is None:
+            return False
+        return tool.Pset.get_element_pset(element, "BBIM_Window") is not None
+
+    @classmethod
+    def is_door(cls, element: entity_instance) -> bool:
+        if element is None:
+            return False
+        return tool.Pset.get_element_pset(element, "BBIM_Door") is not None
+
+    @classmethod
+    def is_stair(cls, element: entity_instance) -> bool:
+        if element is None:
+            return False
+        return tool.Pset.get_element_pset(element, "BBIM_Stair") is not None
+
+    @classmethod
+    def is_wall(cls, element: entity_instance) -> bool:
+        """A wall is editable by the parametric gizmo if it is an IfcWall with LAYER2 usage.
+
+        Unlike doors/windows/stairs, walls do not carry a proprietary BBIM_Wall pset —
+        their parametric state lives in standard IFC (axis polyline, IfcMaterialLayerSetUsage,
+        IfcExtrudedAreaSolid). Any LAYER2 wall qualifies."""
+        if element is None or not element.is_a("IfcWall"):
+            return False
+        return tool.Model.get_usage_type(element) == "LAYER2"
+
+    @classmethod
+    def is_path_connectable_wall(cls, element: entity_instance) -> bool:
+        """An IfcWall that may participate in IfcRelConnectsPathElements joins —
+        either a LAYER2 parametric wall, or a fillet-corner wall whose body is
+        hand-built but whose axis still drives path connections.
+
+        Distinct from ``is_wall``: that predicate gates parametric edits that
+        would regenerate the body and flatten a curved fillet. Unjoin / join
+        gizmo polls and path-connection partner enumeration use this looser
+        predicate so fillet corners (which have no LAYER2 usage by spec) still
+        surface their join icons."""
+        if element is None or not element.is_a("IfcWall"):
+            return False
+        if tool.Model.get_usage_type(element) == "LAYER2":
+            return True
+        return cls.is_fillet_corner_wall(element)
+
+    @classmethod
+    def is_fillet_corner_wall(cls, element: entity_instance) -> bool:
+        """``True`` if the wall carries the ``BBIM_Wall.IsFilletCorner`` flag,
+        marking it as a curved corner whose banana body is hand-built rather
+        than regenerated from the wall's axis + layer set."""
+        import ifcopenshell.util.element
+
+        return bool(ifcopenshell.util.element.get_pset(element, "BBIM_Wall", "IsFilletCorner"))
+
+    @classmethod
+    def is_pipe_segment(cls, element: entity_instance) -> bool:
+        return element is not None and element.is_a("IfcPipeSegment")
+
+    @classmethod
+    def is_duct_segment(cls, element: entity_instance) -> bool:
+        return element is not None and element.is_a("IfcDuctSegment")
+
+    @classmethod
+    def build_edit_lifecycle(
+        cls,
+        feature_name: str,
+        mixin: type,
+        labels: tuple[tuple[str, str], tuple[str, str], tuple[str, str]],
+        bl_options: Optional[set[str]] = None,
+        enable_extra_props: Optional[dict[str, Any]] = None,
+        enable_extra_kwargs: Optional[Callable[[Any], dict[str, Any]]] = None,
+        module_name: Optional[str] = None,
+    ) -> tuple[type, type, type]:
+        """Generate (Enable, Finish, Cancel) operator classes for a parametric type.
+
+        ``mixin`` provides ``_enable_targets`` / ``_finish_targets`` /
+        ``_cancel_targets`` (i.e. inherits from ``ParametricEditMixinBase`` or
+        a sibling). ``labels`` is ``((enable_label, enable_desc), …)`` in
+        Enable / Finish / Cancel order.
+
+        ``bl_idname`` and the Python class name come from the registry entry —
+        ``feature_name`` MUST already be in ``EDIT_TYPES``, otherwise a typo
+        produces an unregistered operator. Anchoring bl_idnames to the registry
+        eliminates the silent-mismatch failure mode where a hand-typed
+        ``bl_idname = "bim.enable_editing_dor"`` produces a class that
+        ``find_for_element`` never resolves to.
+
+        ``enable_extra_props`` declares extra ``bpy.props.*`` descriptors to
+        attach to the Enable class only (e.g. array's ``item: IntProperty``
+        carrying the target layer index across redo). When set,
+        ``enable_extra_kwargs`` must also be supplied: it receives the Enable
+        operator instance and returns a kwargs dict forwarded to
+        ``_enable_targets`` so the mixin's enable phase sees the extras.
+
+        ``module_name`` sets ``__module__`` on the generated classes — pass
+        ``__name__`` from the calling feature module so Blender's right-click
+        → Edit Source resolves to the feature module rather than the factory
+        site. Defaults to the factory's module, which is sub-optimal for
+        debugging but harmless."""
+        import bonsai.tool as _tool  # late import: tool/__init__.py wires this module last
+
+        feature = cls.find_by_name(feature_name)
+        if feature is None:
+            raise RuntimeError(
+                f"build_edit_lifecycle: {feature_name!r} not in EDIT_TYPES — add a "
+                f"ParametricObject entry before declaring its operators"
+            )
+        if not feature.supports_build_edit_lifecycle:
+            raise RuntimeError(
+                f"build_edit_lifecycle: {feature_name!r} has supports_build_edit_lifecycle=False — "
+                f"its edit lifecycle is bespoke. Either declare "
+                f"Enable/Finish/CancelEditing{_camel_case(feature_name)} as direct Operator "
+                f"subclasses, or flip the flag on the EDIT_TYPES entry if the type does fit "
+                f"the shared mixin contract."
+            )
+        if (enable_extra_props is None) != (enable_extra_kwargs is None):
+            raise RuntimeError(
+                f"build_edit_lifecycle({feature_name!r}): enable_extra_props and "
+                f"enable_extra_kwargs must be supplied together — extras with no "
+                f"kwargs builder are unreachable, kwargs with no extras have nothing to forward"
+            )
+        options = bl_options if bl_options is not None else {"REGISTER", "UNDO"}
+        base_classes = (mixin, bpy.types.Operator, _tool.Ifc.Operator)
+        capitalised = _camel_case(feature_name)
+
+        def _build(
+            action: str, bl_idname: str, label: str, desc: str, target_method: str, extras: Optional[dict]
+        ) -> type:
+            if extras and target_method == "_enable_targets":
+                assert enable_extra_kwargs is not None
+                kwargs_builder = enable_extra_kwargs
+
+                def _execute(self, context: bpy.types.Context) -> set[str]:
+                    return getattr(self, target_method)(context, **kwargs_builder(self))
+
+            else:
+
+                def _execute(self, context: bpy.types.Context) -> set[str]:
+                    return getattr(self, target_method)(context)
+
+            attrs: dict[str, Any] = {
+                "bl_idname": bl_idname,
+                "bl_label": label,
+                "bl_description": desc,
+                "bl_options": options,
+                "_execute": _execute,
+            }
+            if module_name is not None:
+                attrs["__module__"] = module_name
+            if extras:
+                # Blender's PropertyGroup machinery reads __annotations__ for bpy.props descriptors.
+                attrs["__annotations__"] = dict(extras)
+            return type(f"{action}Editing{capitalised}", base_classes, attrs)
+
+        return (
+            _build("Enable", feature.enable_op, labels[0][0], labels[0][1], "_enable_targets", enable_extra_props),
+            _build("Finish", feature.finish_op, labels[1][0], labels[1][1], "_finish_targets", None),
+            _build("Cancel", feature.cancel_op, labels[2][0], labels[2][1], "_cancel_targets", None),
+        )
+
+
+_edit_type_names = [entry.name for entry in Parametric.EDIT_TYPES]
+if len(set(_edit_type_names)) != len(_edit_type_names):
+    raise RuntimeError(
+        f"EDIT_TYPES name collision: {_edit_type_names}. Each name is the primary key "
+        f"for derived bl_idnames, BIM<Name>Properties attributes, is_<name> predicates, "
+        f"and the uppercase constant — a duplicate silently shadows the first entry."
+    )
+del _edit_type_names
+
+# Bind every registered ParametricObject as an uppercase class attribute so
+# call sites can reference ``tool.Parametric.ROOF`` directly. Renaming a
+# registry entry renames the constant; a typo at the call site surfaces as
+# AttributeError at module load.
+for _entry in Parametric.EDIT_TYPES:
+    setattr(Parametric, _entry.name.upper(), _entry)
+del _entry

src/bonsai/bonsai/tool/pset.py

@@ -18,10 +18,12 @@
 
 from __future__ import annotations
 
+import json
 from typing import TYPE_CHECKING, Any, Literal, Union, assert_never
 
 import bpy
 import ifcopenshell
+import ifcopenshell.api.pset
 import ifcopenshell.util.attribute
 import ifcopenshell.util.element
 
@@ -74,6 +76,34 @@ class Pset(bonsai.core.tool.Pset):
         if pset:
             return tool.Ifc.get().by_id(pset["id"])
 
+    @classmethod
+    def upsert_pset(
+        cls,
+        element: ifcopenshell.entity_instance,
+        pset_name: str,
+        properties: dict[str, Any],
+    ) -> ifcopenshell.entity_instance:
+        """Get or create ``pset_name`` on ``element``, write ``properties``, return the pset.
+        Centralises the get-element-pset → add-pset-if-missing → edit-pset idiom."""
+        ifc_file = tool.Ifc.get()
+        pset = cls.get_element_pset(element, pset_name)
+        if not pset:
+            pset = ifcopenshell.api.pset.add_pset(ifc_file, product=element, name=pset_name)
+        ifcopenshell.api.pset.edit_pset(ifc_file, pset=pset, properties=properties)
+        return pset
+
+    @classmethod
+    def write_bbim_data(
+        cls,
+        element: ifcopenshell.entity_instance,
+        pset_name: str,
+        data: dict[str, Any],
+    ) -> ifcopenshell.entity_instance:
+        """Get or create the BBIM_<Type> pset and write ``data`` as the IfcText-serialised
+        JSON ``Data`` property. Canonical writer for parametric-modifier pset state."""
+        data_text = tool.Ifc.get().createIfcText(json.dumps(data, default=list))
+        return cls.upsert_pset(element, pset_name, {"Data": data_text})
+
     @classmethod
     def get_pset_props(cls, obj: str, obj_type: tool.Ifc.OBJECT_TYPE) -> PsetProperties:
         if obj_type == "Object":

src/bonsai/bonsai/tool/raycast.py

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