Interface mockup 17

Adds VisibilityState, a CPU-only sibling to SelectionState.  It owns
the canonical hidden-id set plus a flat per-object_id byte vector that
the cull's hot path queries inline (bounds check + byte load + compare
per surviving instance).  Hidden elements never reach the visible[]
SSBO so they don't draw or pick — matching Blender/CAD convention.

ViewportWindow registers every streamed and sidecar-cached object_id
with the new state, resets it on clearScene, and connects the changed
signal to invalidate cached cull state.  Three convenience verbs:
hideSelectedElements (union into hidden), isolateSelectedElements
(replace hidden with live-object_ids minus selection, skipping
model-hidden models so element-hide doesn't pile on top of model-hide),
and showAllElements (clears the override; model-hidden models stay
hidden, per the user's spec).

Bound in the View menu: H hide, Shift+H isolate, Alt+H show all.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

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

@@ -1,95 +0,0 @@
-#!/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.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: mac-${{ matrix.arch }}
 
@@ -110,7 +110,20 @@ jobs:
         run: |
           VERSION=v`cat VERSION`
           cd ./build/`uname`/*/10.15/install/ifcopenshell
-          mkdir ~/output
+          mkdir -p ~/output
+          install_root="$PWD"
+
+          stage_runtime_payload() {
+              dest="$1"
+              while IFS= read -r runtime_file; do
+                  cp -L "$runtime_file" "$dest/"
+              done < <(
+                  for runtime_dir in "$install_root/bin" "$install_root/lib" "$install_root/lib64"; do
+                      [ -d "$runtime_dir" ] || continue
+                      find "$runtime_dir" -type f \( -name "*.so" -o -name "*.so.*" -o -name "*.dylib" -o -name "*.dll" \)
+                  done
+              )
+          }
 
           ls -d python-* | while read py_version; do
               postfix=`echo ${py_version: -1} | sed s/[0-9]//`
@@ -125,18 +138,25 @@ jobs:
               fi
               [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
               find ifcopenshell -name "*.pyc" -delete
-              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip ifcopenshell/*
+              stage_runtime_payload ifcopenshell
+              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip ifcopenshell
               mv *.zip ~/output
               popd > /dev/null
           done
 
-          cd bin
-          rm *.zip || true
-          ls | while read exe; do
-              zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip $exe
+          rm -f "$install_root"/bin/*.zip
+          find "$install_root/bin" -maxdepth 1 -type f -perm /111 ! -name "*.zip" ! -name "*.so" ! -name "*.so.*" ! -name "*.dylib" ! -name "*.dll" | while read exe_path; do
+              exe=`basename "$exe_path"`
+              package_dir="$install_root/.package-${exe}"
+              rm -rf "$package_dir"
+              mkdir -p "$package_dir"
+              cp "$exe_path" "$package_dir/"
+              stage_runtime_payload "$package_dir"
+              pushd "$package_dir" > /dev/null
+              zip -qq -r "$HOME/output/${exe}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip" .
+              popd > /dev/null
+              rm -rf "$package_dir"
           done
-          mv *.zip ~/output
-          cd ..
 
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v6

.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.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}
 

.github/workflows/build_rocky.yml

@@ -9,13 +9,6 @@ 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
@@ -24,6 +17,7 @@ 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
@@ -51,10 +45,10 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py unpack
+          python3 ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 
@@ -62,7 +56,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          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
+          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
 
       - name: Upload Build Logs
         if: always()
@@ -77,7 +71,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py pack
+          python3 ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |
@@ -92,7 +86,20 @@ jobs:
         run: |
           VERSION=v`cat VERSION`
           cd ./build/`uname`/*/install/ifcopenshell
-          mkdir ~/output
+          mkdir -p ~/output
+          install_root="$PWD"
+
+          stage_runtime_payload() {
+              dest="$1"
+              while IFS= read -r runtime_file; do
+                  cp -L "$runtime_file" "$dest/"
+              done < <(
+                  for runtime_dir in "$install_root/bin" "$install_root/lib" "$install_root/lib64"; do
+                      [ -d "$runtime_dir" ] || continue
+                      find "$runtime_dir" -type f \( -name "*.so" -o -name "*.so.*" -o -name "*.dylib" -o -name "*.dll" \)
+                  done
+              )
+          }
 
           ls -d python-* | while read py_version; do
               postfix=`echo ${py_version: -1} | sed s/[0-9]//`
@@ -107,18 +114,24 @@ jobs:
               fi
               [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
               find ifcopenshell -name "*.pyc" -delete
-              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip ifcopenshell/*
+              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip ifcopenshell
               mv *.zip ~/output
               popd > /dev/null
           done
 
-          cd bin
-          rm *.zip || true
-          ls | while read exe; do
-              zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip $exe
+          rm -f "$install_root"/bin/*.zip
+          find "$install_root/bin" -maxdepth 1 -type f -perm /111 ! -name "*.zip" ! -name "*.so" ! -name "*.so.*" ! -name "*.dylib" ! -name "*.dll" | while read exe_path; do
+              exe=`basename "$exe_path"`
+              package_dir="$install_root/.package-${exe}"
+              rm -rf "$package_dir"
+              mkdir -p "$package_dir"
+              cp "$exe_path" "$package_dir/"
+              stage_runtime_payload "$package_dir"
+              pushd "$package_dir" > /dev/null
+              zip -qq -r "$HOME/output/${exe}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip" .
+              popd > /dev/null
+              rm -rf "$package_dir"
           done
-          mv *.zip ~/output
-          cd ..
 
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v6

.github/workflows/build_rocky_arm.yml

@@ -9,13 +9,6 @@ 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
@@ -24,6 +17,7 @@ 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
@@ -51,10 +45,10 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py unpack
+          python3 ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 
@@ -62,7 +56,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          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
+          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
 
       - name: Upload Build Logs
         if: always()
@@ -77,7 +71,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py pack
+          python3 ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |
@@ -92,7 +86,20 @@ jobs:
         run: |
           VERSION=v`cat VERSION`
           cd ./build/`uname`/*/install/ifcopenshell
-          mkdir ~/output
+          mkdir -p ~/output
+          install_root="$PWD"
+
+          stage_runtime_payload() {
+              dest="$1"
+              while IFS= read -r runtime_file; do
+                  cp -L "$runtime_file" "$dest/"
+              done < <(
+                  for runtime_dir in "$install_root/bin" "$install_root/lib" "$install_root/lib64"; do
+                      [ -d "$runtime_dir" ] || continue
+                      find "$runtime_dir" -type f \( -name "*.so" -o -name "*.so.*" -o -name "*.dylib" -o -name "*.dll" \)
+                  done
+              )
+          }
 
           ls -d python-* | while read py_version; do
               postfix=`echo ${py_version: -1} | sed s/[0-9]//`
@@ -107,18 +114,25 @@ jobs:
               fi
               [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
               find ifcopenshell -name "*.pyc" -delete
-              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip ifcopenshell/*
+              stage_runtime_payload ifcopenshell
+              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip ifcopenshell
               mv *.zip ~/output
               popd > /dev/null
           done
 
-          cd bin
-          rm *.zip || true
-          ls | while read exe; do
-              zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip $exe
+          rm -f "$install_root"/bin/*.zip
+          find "$install_root/bin" -maxdepth 1 -type f -perm /111 ! -name "*.zip" ! -name "*.so" ! -name "*.so.*" ! -name "*.dylib" ! -name "*.dll" | while read exe_path; do
+              exe=`basename "$exe_path"`
+              package_dir="$install_root/.package-${exe}"
+              rm -rf "$package_dir"
+              mkdir -p "$package_dir"
+              cp "$exe_path" "$package_dir/"
+              stage_runtime_payload "$package_dir"
+              pushd "$package_dir" > /dev/null
+              zip -qq -r "$HOME/output/${exe}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip" .
+              popd > /dev/null
+              rm -rf "$package_dir"
           done
-          mv *.zip ~/output
-          cd ..
 
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v6

.github/workflows/build_win.yml

@@ -52,7 +52,7 @@ jobs:
           }
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: win-${{ matrix.arch }}
           # Windows ccache needs ~1GB
@@ -68,6 +68,64 @@ jobs:
           cd win
           python build-all-win.py
 
+      - name: Repack .zip Archives With Runtime Plugins
+        shell: powershell
+        run: |
+          $version = (Get-Content VERSION | Select-Object -First 1).Trim()
+          $sha = $env:GITHUB_SHA.Substring(0, 7)
+          $outputDir = Join-Path $env:USERPROFILE "output"
+          $installDir = Get-ChildItem -Path . -Directory | Where-Object { $_.Name -like "_installed*" } | Select-Object -First 1
+          if (-not $installDir) {
+            throw "Install directory not found."
+          }
+
+          $runtimeFiles = @()
+          foreach ($runtimeDir in @((Join-Path $installDir.FullName "bin"), (Join-Path $installDir.FullName "lib"))) {
+            if (Test-Path $runtimeDir) {
+              $runtimeFiles += Get-ChildItem -Path $runtimeDir -Recurse -File | Where-Object { $_.Extension -ieq ".dll" }
+            }
+          }
+          $runtimeFiles = $runtimeFiles | Sort-Object FullName -Unique
+
+          Get-ChildItem -Path $outputDir -Filter *.zip -ErrorAction SilentlyContinue | Remove-Item -Force
+
+          $binDir = Join-Path $installDir.FullName "bin"
+          foreach ($exe in Get-ChildItem -Path $binDir -File -Filter *.exe) {
+            $stageDir = Join-Path $env:RUNNER_TEMP ("package-" + $exe.BaseName)
+            Remove-Item -Path $stageDir -Recurse -Force -ErrorAction SilentlyContinue
+            New-Item -ItemType Directory -Path $stageDir | Out-Null
+            Copy-Item -Path $exe.FullName -Destination $stageDir
+            foreach ($runtimeFile in $runtimeFiles) {
+              Copy-Item -Path $runtimeFile.FullName -Destination $stageDir -Force
+            }
+            $zipPath = Join-Path $outputDir ("{0}-v{1}-{2}-win64.zip" -f $exe.BaseName, $version, $sha)
+            Compress-Archive -Path (Join-Path $stageDir '*') -DestinationPath $zipPath -Force
+          }
+
+          $depsRoot = Join-Path (Get-Location) "_deps"
+          if (Test-Path $depsRoot) {
+            foreach ($pythonRoot in Get-ChildItem -Path $depsRoot -Directory | Where-Object { $_.Name -like "python.*" }) {
+              $pythonVersion = $pythonRoot.Name.Substring("python.".Length)
+              $pythonVersionMajorMinor = ($pythonVersion.Split(".")[0..1] -join "")
+              $sitePackages = Join-Path $pythonRoot.FullName "tools\\Lib\\site-packages"
+              $packagePath = Join-Path $sitePackages "ifcopenshell"
+              if (!(Test-Path $packagePath)) {
+                continue
+              }
+              Get-ChildItem -Path $packagePath -Recurse -Filter *.pyc -ErrorAction SilentlyContinue | Remove-Item -Force
+              foreach ($runtimeFile in $runtimeFiles) {
+                Copy-Item -Path $runtimeFile.FullName -Destination $packagePath -Force
+              }
+              $zipPath = Join-Path $outputDir ("ifcopenshell-python-{0}-v{1}-{2}-win64.zip" -f $pythonVersionMajorMinor, $version, $sha)
+              Push-Location $sitePackages
+              try {
+                Compress-Archive -Path "ifcopenshell" -DestinationPath $zipPath -Force
+              } finally {
+                Pop-Location
+              }
+            }
+          }
+
       - name: Pack Dependencies
         run: |
           cd ${{ matrix.deps_dir }}

.github/workflows/ci-bonsai-daily.yml

@@ -109,7 +109,7 @@ jobs:
           # Ensure Bonsai and ifcsverchok enable/disable works before uploading to extensions repo.
 
           # Download Blender.
-          wget -q -O blender.tar.xz https://download.blender.org/release/Blender5.2/blender-5.2.0-linux-x64.tar.xz
+          wget -q -O blender.tar.xz https://download.blender.org/release/Blender5.1/blender-5.1.0-linux-x64.tar.xz
           tar -xf blender.tar.xz
 
           # Setup Blender.
@@ -179,7 +179,8 @@ jobs:
           blender --online-mode --command extension install --enable --sync sun_position
 
           cd IfcOpenShell/src/bonsai
-          pip install -r requirements-dev.txt
+          pip install pytest-blender
+          pip install pytest-bdd
           blender --background --python scripts/setup_pytest.py
           blender --python-expr "import bonsai; print(bonsai.bbim_semver); import ifcopenshell; print(ifcopenshell.version)" --background
           make test

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

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

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

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

.github/workflows/ci-lint.yaml

@@ -27,7 +27,10 @@ jobs:
       - name: Install dependencies
         run: |
           curl -LsSf https://astral.sh/uv/install.sh | sh
-          cat requirements-tools.txt | xargs -L1 uv tool install
+          uv tool install ruff
+          uv tool install black
+          uv tool install poethepoet
+          uv tool install ty
 
       # black doesn't catch all syntax errors, so we check them explicitly.
       - name: Check syntax errors
@@ -55,17 +58,11 @@ jobs:
           black --diff --check . | black-codeclimate | python .github/workflows/black_to_github_annotations.py
         continue-on-error: true
 
-      - name: ty check (venv setup)
-        run: poe ty-venv
-
-      - name: ty check (bonsai)
-        id: ty-bonsai
-        run: poe ty-bonsai
-        continue-on-error: true
-
-      - name: ty check (ios)
-        id: ty-ios
-        run: poe ty-ios
+      - name: ty check
+        id: ty
+        run: |
+          poe ty-venv
+          poe ty
         continue-on-error: true
 
       - name: Ruff check
@@ -98,7 +95,8 @@ jobs:
             echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
           }
 
-          run_check poe ruff
+          run_check poe ruff-main
+          run_check poe ruff-old
 
           exit $ERROR
         continue-on-error: true
@@ -115,10 +113,7 @@ jobs:
           if [ "${{ steps.ruff.outcome }}" != "success" ]; then
             echo "::error::Ruff check failed, see Summary or 'ruff' step for the details." && ERROR=1
           fi
-          if [ "${{ steps.ty-bonsai.outcome }}" != "success" ]; then
-            echo "::error::ty check (bonsai) failed, see 'ty check (bonsai)' step for the details." && ERROR=1
-          fi
-          if [ "${{ steps.ty-ios.outcome }}" != "success" ]; then
-            echo "::error::ty check (ios) failed, see 'ty check (ios)' step for the details." && ERROR=1
+          if [ "${{ steps.ty.outcome }}" != "success" ]; then
+            echo "::error::ty check failed, see 'ty check' step for the details." && ERROR=1
           fi
           exit $ERROR

.github/workflows/ci.yml

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

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

@@ -1,16 +0,0 @@
-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 }}

.gitignore

@@ -4,8 +4,6 @@
 /_deps-vs*-x*-installed/
 /_installed-vs*-x*/
 /build/
-/build.log
-/output/
 /src/examples/build/
 # ifctester docs output
 /src/ifctester/test/build/
@@ -24,14 +22,12 @@
 __pycache__
 *.py.bak
 venv
-uv.lock
 
 # Visual Studio Code files
 .vscode
 !.vscode/launch.json
 !.vscode/tasks.json
 .vs
-/*.code-workspace
 
 # PyCharm files
 .idea
@@ -130,7 +126,5 @@ src/ifcopenshell-python/ifcopenshell/express/*.exp.cache.dat
 
 # temp files from AI coding tools
 *.claude
-CLAUDE.local.md
 *.py.tmp*
 *.json.tmp*
-

build.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+set -e
+
+mkdir -p build && cd build
+
+cmake ../cmake \
+  -G Ninja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DPython_EXECUTABLE=/home/dion/Projects/env/bin/python3.11 \
+  -DPython_INCLUDE_DIR=/usr/include/python3.11 \
+  -DBUILD_IFCPYTHON=ON \
+  -DBUILD_IFCGEOM=ON \
+  -DBUILD_CONVERT=ON \
+  -DBUILD_GEOMSERVER=OFF \
+  -DBUILD_EXAMPLES=OFF \
+  -DWITH_OPENCASCADE=ON \
+  -DWITH_CGAL=ON \
+  -DWITH_MANIFOLD=ON \
+  -DHDF5_SUPPORT=OFF \
+  -DGLTF_SUPPORT=ON \
+  -DIFCXML_SUPPORT=OFF \
+  -DCOLLADA_SUPPORT=OFF \
+  -DSCHEMA_VERSIONS="2x3;4;4x3_add2" \
+  -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+  -DOCC_LIBRARY_DIR=/usr/lib64/opencascade
+
+ninja
+
+cp ifcwrap/_ifcopenshell_wrapper*.so ifcwrap/ifcopenshell_wrapper.py \
+   ../src/ifcopenshell-python/ifcopenshell/

cmake/CMakeLists.txt

@@ -18,29 +18,19 @@
 ################################################################################
 
 cmake_minimum_required(VERSION 3.21)
-if(NOT DEFINED CMAKE_CXX_STANDARD)
+if (NOT DEFINED CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 17)
 endif()
-if(CMAKE_CXX_STANDARD LESS 17)
+if (CMAKE_CXX_STANDARD LESS 17)
     message(FATAL_ERROR "C++17 or newer is required.")
 endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON) # not necessary, but encouraged
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-# The VERSION file in the repository root is the single source of truth for the
-# release version. Read it unconditionally so a plain source build reports the
-# real version through buildinfo.cpp instead of the stale hardcoded 0.8.0
-# fallback (see #8164). VERSION_OVERRIDE still controls the branch name used
-# when ADD_COMMIT_SHA embeds a commit sha.
-file(READ "../VERSION" "RELEASE_VERSION_")
-string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
-message(STATUS "Detected version '${RELEASE_VERSION}'")
-
 add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
 
 if(POLICY CMP0141) # 3.25+
-    # Has to be set before `project` to take effect.
-    cmake_policy(SET CMP0141 NEW) # Support for `CMAKE_MSVC_DEBUG_INFORMATION_FORMAT`.
+  cmake_policy(SET CMP0141 NEW) # Support for `CMAKE_MSVC_DEBUG_INFORMATION_FORMAT`.
 endif()
 if(POLICY CMP0144) # 3.27
     cmake_policy(SET CMP0144 NEW) # find_package() uses upper-case <PACKAGENAME>_ROOT variables.
@@ -49,8 +39,6 @@ if(POLICY CMP0167) # 3.30
     cmake_policy(SET CMP0167 OLD)
 endif()
 
-project(IfcOpenShell VERSION ${RELEASE_VERSION})
-
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release")
 endif()
@@ -66,64 +54,59 @@ endif()
 option(MINIMAL_BUILD "The build is to make a minimal version of IFC converter from OCCT into IFC." OFF)
 option(WASM_BUILD "Build a WebAssembly binary." OFF)
 
-option(
-    ENABLE_BUILD_OPTIMIZATIONS
-    "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds."
-    OFF
-)
-option(BUILD_SHARED_LIBS "Build IfcParse and IfcGeom as shared libs (SO/DLL)." OFF)
+option(ENABLE_BUILD_OPTIMIZATIONS "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds." OFF)
+option(BUILD_SHARED_LIBS "Build IfcOpenShell as shared libraries (required)." ON)
 option(MSVC_PARALLEL_BUILD "Multi-threaded compilation in Microsoft Visual Studio (/MP)" OFF)
 option(USE_VLD "Use Visual Leak Detector for debugging memory leaks, MSVC-only." OFF)
 option(USE_MMAP "Adds a command line options to parse IFC files from memory mapped files using Boost.Iostreams" OFF)
 option(NO_WARN "Disable all warnings" OFF)
+option(CREATE_BUNDLE "Copy .so files and don't create RPATHS or SOVERSION symlinks" )
 
 option(BUILD_IFCGEOM "Build IfcGeom." ON)
 option(BUILD_IFCPYTHON "Build IfcPython." ON)
+option(BUILD_IFCPARSE_EXPERIMENTAL_WRAPPER "Build the experimental Clang-generated ifcparse Python wrapper." OFF)
 option(BUILD_CONVERT "Build IfcConvert executable." ON)
 option(BUILD_DOCUMENTATION "Build IfcOpenShell Documentation." OFF)
-option(BUILD_EXAMPLES "Build example applications." OFF)
+option(BUILD_EXAMPLES "Build example applications." ON)
 option(BUILD_GEOMSERVER "Build IfcGeomServer executable (Open CASCADE is required)." ON)
 option(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." OFF)
 option(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer" OFF) # QtViewer requires Qt6
+option(BUILD_IFCVIEWER "Build IfcViewer, a high-performance IFC viewer" OFF) # Requires Qt6 + OpenGL 4.5
+option(BUILD_IFCVIEWER_TESTS "Build unit tests for IfcViewer (fetches Catch2 v3)" OFF)
 option(BUILD_PACKAGE "" OFF)
-# Most users probably need just common schemas,
-# but we're keeping it `OFF` by default to avoid disruption
-# (e.g. all Python distribution would need to adapt this option to be set).
-option(
-    BUILD_ONLY_COMMON_SCHEMAS
-    "Build only common IFC schemas (2x3, 4, 4x3_add2). By default all schemas will be built."
-    OFF
-)
-option(SCHEMA_VERSIONS "Explicitly specify schemas to build." "")
 
 option(WITH_OPENCASCADE "Enable geometry interpretation using Open CASCADE" ON)
 option(WITH_CGAL "Enable geometry interpretation using CGAL" ON)
+option(WITH_MANIFOLD "Enable geometry interpretation using Manifold" OFF)
 option(COLLADA_SUPPORT "Build IfcConvert with COLLADA support (requires OpenCOLLADA)." ON)
 option(GLTF_SUPPORT "Build IfcConvert with glTF support (requires json.hpp)." OFF)
 option(HDF5_SUPPORT "Enable HDF5 support (requires HDF5, zlib)" ON)
 option(WITH_PROJ "Enable output of Earth-Centered Earth-Fixed glTF output using the PROJ library" OFF)
-option(IFCXML_SUPPORT "Build IfcParse with ifcXML support (requires libxml2)." ON)
 option(USD_SUPPORT "Build IfcConvert with USD support (requires pixar's USD library)." OFF)
-option(WITH_RELATIONSHIP_VALIDATION "Build IfcConvert with option to validate geometrical relationships." OFF)
 option(WITH_ROCKSDB "Support a RocksDB key-value store as a file backend in IfcOpenShell" OFF)
 option(WITH_ZSTD "Use Zstd compression in RocksDB writes" OFF)
 
 option(USERSPACE_PYTHON_PREFIX "Installs IfcPython for the current user only instead of system-wide." OFF)
 option(USE_DEBUG_PYTHON "Use debug binaries when building Debug IfcPython on Windows." OFF)
 option(ADD_COMMIT_SHA "Add commit sha and branch in version number, requires git" OFF)
-option(
-    VERSION_OVERRIDE
-    "Override the version defined in buildinfo.cpp with the file VERSION in the repository root"
-    OFF
-)
-option(USE_CCACHE "Enable use of ccache if it's available from PATH." ON)
+option(VERSION_OVERRIDE "Override the version defined in buildinfo.cpp with the file VERSION in the repository root" OFF)
 
-set(PYTHON_MODULE_INSTALL_DIR
-    ""
-    CACHE PATH
+set(
+    PYTHON_MODULE_INSTALL_DIR
+    "" CACHE PATH
     "Directory to install IfcPython package to. By default package is installed in found Python's site-packages."
 )
 
+if (VERSION_OVERRIDE)
+    file(READ "../VERSION" "RELEASE_VERSION_")
+    string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
+    message(STATUS "Detected version '${RELEASE_VERSION}'")
+else()
+    set(RELEASE_VERSION "0.8.0")
+endif()
+
+project(IfcOpenShell VERSION ${RELEASE_VERSION})
+
 # Make sure CMake modules in this project are found first
 list(PREPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR})
 
@@ -135,17 +118,20 @@ if(MINIMAL_BUILD)
     set(COLLADA_SUPPORT OFF)
     set(GLTF_SUPPORT OFF)
     set(HDF5_SUPPORT OFF)
-    set(IFCXML_SUPPORT OFF)
     set(USD_SUPPORT OFF)
 endif()
 
-if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND (NOT BUILD_IFCGEOM))
+if(NOT BUILD_SHARED_LIBS)
+    message(FATAL_ERROR "BUILD_SHARED_LIBS=OFF is not supported. Configure with -DBUILD_SHARED_LIBS=ON.")
+endif()
+
+if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND(NOT BUILD_IFCGEOM))
     message(STATUS "'IfcGeom' is required with current outputs")
     set(BUILD_IFCGEOM ON)
 endif()
 
 find_program(CCACHE_FOUND ccache)
-if(USE_CCACHE AND CCACHE_FOUND)
+if(CCACHE_FOUND)
     message(STATUS "`ccache` is found, using it as a compiler launcher.")
     set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_FOUND}")
     if(MSVC)
@@ -154,15 +140,17 @@ if(USE_CCACHE AND CCACHE_FOUND)
         set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<$<CONFIG:Debug,RelWithDebInfo>:Embedded>")
         # Not needed for Ninja.
         if(CMAKE_GENERATOR MATCHES "Visual Studio")
-            file(COPY_FILE ${CCACHE_FOUND} ${CMAKE_BINARY_DIR}/cl.exe ONLY_IF_DIFFERENT)
-            set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "UseMultiToolTask=true")
+            file(COPY_FILE
+                ${CCACHE_FOUND} ${CMAKE_BINARY_DIR}/cl.exe
+                ONLY_IF_DIFFERENT)
+            set(CMAKE_VS_GLOBALS
+                "CLToolExe=cl.exe"
+                "CLToolPath=${CMAKE_BINARY_DIR}"
+                "UseMultiToolTask=true"
+            )
         endif()
     endif()
 endif()
-mark_as_advanced(CCACHE_FOUND)
-
-# Variable to accumulate swig definitions from various submodules.
-set(SWIG_DEFINES "")
 
 if(MSVC AND MSVC_PARALLEL_BUILD)
     add_definitions("/MP")
@@ -178,28 +166,23 @@ endif()
 
 include(GNUInstallDirs)
 
-set(IFCOPENSHELL_EXPORT_TARGETS "${PROJECT_NAME}Targets")
-
-# On Windows Release and Debug binaries are not compatible.
-# So we add a postfix to avoid issues and allow release and debug installations to coexist.
-if(WIN32)
-    set(CMAKE_DEBUG_POSTFIX "_d")
+if(NOT INCLUDEDIR)
+    set(INCLUDEDIR include)
 endif()
+if(NOT IS_ABSOLUTE ${INCLUDEDIR})
+    set(INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR})
+endif()
+message(STATUS "INCLUDEDIR: ${INCLUDEDIR}")
 
-if(BUILD_SHARED_LIBS)
-    add_definitions(-DIFC_SHARED_BUILD)
-    if(MSVC)
-        message(
-            WARNING
-            "Building DLLs against the static VC run-time. This is not recommended if the DLLs are to be redistributed."
-        )
-        # C4521: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
-        # There will be couple hundreds of these so suppress them away, https://msdn.microsoft.com/en-us/library/esew7y1w.aspx
-        add_definitions(-wd4251)
-    endif()
+if(MSVC)
+    message(WARNING "Building DLLs against the static VC run-time. This is not recommended if the DLLs are to be redistributed.")
+    # C4521: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
+    # There will be couple hundreds of these so suppress them away, https://msdn.microsoft.com/en-us/library/esew7y1w.aspx
+    add_definitions(-wd4251)
 endif()
 
 UNIFY_ENVVARS_AND_CACHE(BOOST_ROOT)
+UNIFY_ENVVARS_AND_CACHE(BOOST_LIBRARYDIR)
 
 if(NOT MINIMAL_BUILD)
     UNIFY_ENVVARS_AND_CACHE(PYTHON_INCLUDE_DIR)
@@ -215,75 +198,75 @@ foreach(option_flag IN LISTS option_flags)
     convert_env_var_to_bool("${option_flag}")
 endforeach()
 
+if(WITH_CGAL)
+    find_package(CGAL REQUIRED)
+    set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_CGAL)
+    list(APPEND GEOMETRY_KERNELS cgal)
+endif()
+
 if(BUILD_IFCGEOM AND WITH_OPENCASCADE)
     find_package(OpenCASCADE REQUIRED)
-    add_definitions(-DIFOPSH_WITH_OPENCASCADE)
+    # Map OpenCASCADE_LIBRARIES variable from OpenCASCADEConfig.cmake to OpenCASCADE_LIBRARIES used by kernel generic cmake file
+    set(OpenCASCADE_LIBRARIES ${OpenCASCADE_LIBRARIES})
     set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_OPENCASCADE)
     list(APPEND GEOMETRY_KERNELS opencascade)
 endif()
 
-set(GLTF_LIBRARIES "")
+message(STATUS "BUILD_IFCGEOM WITH_MANIFOLD: ${BUILD_IFCGEOM} ${WITH_MANIFOLD}")
+
+if(BUILD_IFCGEOM AND WITH_MANIFOLD)
+    find_package(manifold CONFIG REQUIRED)
+    if(TARGET manifold::manifold)
+        set(MANIFOLD_LIBRARIES manifold::manifold)
+    elseif(TARGET manifold)
+        set(MANIFOLD_LIBRARIES manifold)
+    else()
+        message(FATAL_ERROR "Unable to determine manifold target")
+    endif()
+    list(APPEND GEOMETRY_KERNELS manifold)
+endif()
+
+if(BUILD_IFCGEOM)
+    list(APPEND GEOMETRY_KERNELS passthrough)
+endif()
+
 if(GLTF_SUPPORT)
     find_package(nlohmann_json REQUIRED)
-    set(GLTF_LIBRARIES nlohmann_json::nlohmann_json)
-    add_definitions(-DWITH_GLTF)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_GLTF)
 endif()
 
 # Add USD support to serializers
-set(USD_LIBRARIES "")
 if(USD_SUPPORT)
     find_package(USD REQUIRED)
-    set(USD_LIBRARIES pxr::USD)
 endif(USD_SUPPORT)
 
-set(ROCKSDB_LIBRARIES "")
-if(WITH_ROCKSDB)
+if (WITH_ROCKSDB)
     # Temporaily mess with CMAKE_FIND_PACKAGE_PREFER_CONFIG to help RocksDB
     # find it's zstd dependency on Windows.
     # Only do it on Windows, otherwise it might create problems as
     # findzstd and zstd-config target names do not match.
-    # https://github.com/facebook/rocksdb/pull/13975
     if(WIN32)
         set(TEMP CMAKE_FIND_PACKAGE_PREFER_CONFIG)
         set(CMAKE_FIND_PACKAGE_PREFER_CONFIG TRUE)
     endif()
     find_package(RocksDB CONFIG REQUIRED)
-    mark_as_advanced(RocksDB_DIR)
     if(WIN32)
         set(CMAKE_FIND_PACKAGE_PREFER_CONFIG ${TEMP})
     endif()
 
     message(STATUS "RocksDB: found at '${RocksDB_DIR}'.")
-    add_library(IFCOPENSHELL_RocksDB INTERFACE)
-    set(ROCKSDB_LIBRARIES "IFCOPENSHELL_RocksDB")
-    target_compile_definitions(IFCOPENSHELL_RocksDB INTERFACE IFOPSH_WITH_ROCKSDB)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_ROCKSDB)
-    # See https://github.com/facebook/rocksdb/issues/981.
-    if(TARGET RocksDB::rocksdb)
-        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
-    elseif(TARGET RocksDB::rocksdb-shared)
-        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb-shared)
-    else()
-        message(FATAL_ERROR "RocksDB found but neither RocksDB::rocksdb nor RocksDB::rocksdb-shared target exists")
-    endif()
 
-    if(WITH_ZSTD)
+    if (WITH_ZSTD)
         # @todo do we actually need the zstd include dir or rather just pass
         # the libzstd.a along with the rocksdb library when needed and feature
         # detect based on rocksdb API?
         find_package(zstd CONFIG REQUIRED)
-        mark_as_advanced(zstd_DIR)
         message(STATUS "zstd: found at '${zstd_DIR}'.")
-        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE zstd::libzstd_static)
     endif()
-
-    install(TARGETS IFCOPENSHELL_RocksDB EXPORT ${IFCOPENSHELL_EXPORT_TARGETS})
 endif()
 
 # Find Boost: On win32 the (hardcoded) default is to use static libraries and
 # runtime, when doing running conda-build we pick what conda prepared for us.
-if(WIN32 AND NOT DEFINED ENV{CONDA_BUILD})
+if(WIN32 AND("$ENV{CONDA_BUILD}" STREQUAL ""))
     set(Boost_USE_STATIC_LIBS ON)
     set(Boost_USE_STATIC_RUNTIME OFF)
     set(Boost_USE_MULTITHREADED ON)
@@ -314,18 +297,8 @@ if(WASM_BUILD)
 else()
     # @todo review this, shouldn't this be all possible header-only now?
     # ... or rewritten using C++17 features?
-    # Boost.System has been header-only since 1.69 and its compiled stub library
-    # was dropped in newer Boost, so requesting it as a component makes
-    # find_package fail on Boost 1.70 and up (for example Boost 1.90). It is
-    # still pulled in transitively by thread / iostreams where needed, so do not
-    # request it explicitly.
-    set(BOOST_COMPONENTS
-        program_options
-        regex
-        thread
-        date_time
-        iostreams
-    )
+    # set(BOOST_COMPONENTS system program_options regex thread date_time iostreams)
+    set(BOOST_COMPONENTS program_options regex thread date_time iostreams)
 endif()
 
 if(USE_MMAP)
@@ -335,17 +308,6 @@ if(USE_MMAP)
     else()
         set(BOOST_COMPONENTS ${BOOST_COMPONENTS} iostreams)
     endif()
-
-    add_definitions(-DUSE_MMAP)
-endif()
-
-# Handle CGAL after Boost settings are set, since CGAL will use them too.
-# Do `find_package(Boost)` only after this, to make sure `FindBoost` finds correct components.
-# Otherwise it will find components needed for CGAL and we might some libraries.
-if(WITH_CGAL)
-    find_package(CGAL REQUIRED)
-    set(CGAL_LIBRARIES IFCOPENSHELL_CGAL)
-    list(APPEND GEOMETRY_KERNELS cgal)
 endif()
 
 find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
@@ -354,15 +316,10 @@ message(STATUS "Boost libraries found in ${Boost_LIBRARY_DIRS}")
 
 if(COLLADA_SUPPORT)
     find_package(OpenCOLLADA REQUIRED)
-    add_definitions(-DWITH_OPENCOLLADA)
 endif()
 
 if(HDF5_SUPPORT)
     find_package(HDF5 REQUIRED COMPONENTS C CXX)
-    set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} hdf5::hdf5_cpp)
-
-    add_definitions(-DWITH_HDF5)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_HDF5)
 endif(HDF5_SUPPORT)
 
 if(ENABLE_BUILD_OPTIMIZATIONS)
@@ -377,20 +334,12 @@ if(ENABLE_BUILD_OPTIMIZATIONS)
 
         # Linker
         # /OPT:REF enables also /OPT:ICF and disables INCREMENTAL
-        set(LINKER_FLAGS_RELEASE "/LTCG /OPT:REF")
-        # /OPT:NOICF is recommended when /DEBUG is used (http://msdn.microsoft.com/en-us/library/xe4t6fc1.aspx)
-        set(LINKER_FLAGS_RELWITHDEBINFO "/DEBUG /OPT:NOICF")
+        set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF")
 
-        set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELEASE}")
-        set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
-            "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELWITHDEBINFO}"
-        )
-        set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELEASE}")
-        set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELWITHDEBINFO}")
-        set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELEASE}")
-        set(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
-            "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELWITHDEBINFO}"
-        )
+        # /OPT:NOICF is recommended when /DEBUG is used (http://msdn.microsoft.com/en-us/library/xe4t6fc1.aspx)
+        set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:NOICF")
+        set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF")
+        set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:NOICF")
     else()
         # GCC-like: Release should use O3 but RelWithDebInfo 02 so enforce 03. Anything other useful that could be added here?
         set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
@@ -439,7 +388,7 @@ if(MSVC)
     endif()
 
     # Enforce standards-conformance on VS > 2015, older Boost versions fail to compile with this
-    if(MSVC_VERSION GREATER 1900 AND (Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 66))
+    if(MSVC_VERSION GREATER 1900 AND(Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 66))
         add_definitions(-permissive-)
     endif()
 
@@ -458,11 +407,11 @@ if(MSVC)
     #     endforeach()
     # endif()
 
-    add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
-    # See #5158.
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.40)
-        add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
-    endif()
+	add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
+	# See #5158.
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.40)
+		add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+	endif()
 else()
     add_definitions(-Wall -Wextra)
 
@@ -472,10 +421,7 @@ else()
         add_definitions(-Wno-maybe-uninitialized)
     endif()
 
-    if(
-        CMAKE_CXX_COMPILER_ID MATCHES "GNU"
-        AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 9.0)
-    )
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 9.0))
         # OpenCascade spews a lot of deprecated-copy warnings
         add_definitions(-Wno-deprecated-copy)
     endif()
@@ -486,45 +432,35 @@ else()
     endif()
 endif(MSVC)
 
-include_directories(${OPENCOLLADA_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${HDF5_INCLUDE_DIR})
+include_directories(${INCLUDE_DIRECTORIES}
+	${Boost_INCLUDE_DIRS} ${HDF5_INCLUDE_DIR}
+    ${CGAL_INCLUDE_DIR} ${GMP_INCLUDE_DIR} ${MPFR_INCLUDE_DIR}
+)
 
 if(NOT SCHEMA_VERSIONS)
-    # `WASM_BUILD` - super arbitrarily try to keep size down at least a little bit
-    if(BUILD_ONLY_COMMON_SCHEMAS OR WASM_BUILD)
+    if(WASM_BUILD)
+        # super arbitrarily try to keep size down at least a little bit
         set(SCHEMA_VERSIONS "2x3" "4" "4x3_add2")
     else()
-        set(SCHEMA_VERSIONS
-            "2x3"
-            "4"
-            "4x1"
-            "4x2"
-            "4x3"
-            "4x3_tc1"
-            "4x3_add1"
-            "4x3_add2"
-        )
+        set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3" "4x3_tc1" "4x3_add1" "4x3_add2")
     endif()
 endif()
 
 message(STATUS "IFC SCHEMA_VERSIONS that will be used for the build: ${SCHEMA_VERSIONS}.")
 
-set(SCHEMA_DEFINITIONS "")
 foreach(schema ${SCHEMA_VERSIONS})
-    list(APPEND SCHEMA_DEFINITIONS "-DHAS_SCHEMA_${schema}")
+    add_definitions(-DHAS_SCHEMA_${schema})
 endforeach()
 
 string(REPLACE ";" ")(" schema_version_seq "(${SCHEMA_VERSIONS})")
-list(APPEND SCHEMA_DEFINITIONS "-DSCHEMA_SEQ=${schema_version_seq}")
+add_definitions(-DSCHEMA_SEQ=${schema_version_seq})
 
 if(COMPILE_SCHEMA)
     # @todo, this appears to be untested at the moment
     find_package(PythonInterp)
 
     if(NOT PYTHONINTERP_FOUND)
-        message(
-            FATAL_ERROR
-            "A Python interpreter is necessary when COMPILE_SCHEMA is enabled. Disable COMPILE_SCHEMA or fix Python paths to proceed."
-        )
+        message(FATAL_ERROR "A Python interpreter is necessary when COMPILE_SCHEMA is enabled. Disable COMPILE_SCHEMA or fix Python paths to proceed.")
     endif()
 
     set(IFC_RELEASE_NOT_USED ${SCHEMA_VERSIONS})
@@ -544,10 +480,7 @@ if(COMPILE_SCHEMA)
 
     if("${PYPARSING_FOUND}" STREQUAL "-1")
         message(STATUS "Installing pyparsing")
-        execute_process(
-            COMMAND ${PYTHON_EXECUTABLE} -m pip "install" --user pyparsing
-            RESULT_VARIABLE SUCCESS
-        )
+        execute_process(COMMAND ${PYTHON_EXECUTABLE} -m pip "install" --user pyparsing RESULT_VARIABLE SUCCESS)
 
         if(NOT "${SUCCESS}" STREQUAL "0")
             execute_process(COMMAND pip "install" --user pyparsing RESULT_VARIABLE SUCCESS)
@@ -562,23 +495,19 @@ if(COMPILE_SCHEMA)
 
     # Bootstrap the parser
     message(STATUS "Compiling schema, this will take a while...")
-    execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py
-        WORKING_DIRECTORY ../src/ifcopenshell-python/ifcopenshell/express
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf
+        WORKING_DIRECTORY ../src/ifcexpressparser
         OUTPUT_FILE express_parser.py
-        RESULT_VARIABLE SUCCESS
-    )
+        RESULT_VARIABLE SUCCESS)
 
     if(NOT "${SUCCESS}" STREQUAL "0")
         message(FATAL_ERROR "Failed to bootstrap parser. Make sure pyparsing is installed")
     endif()
 
     # Generate code
-    execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} ../ifcopenshell-python/ifcopenshell/express/express_parser.py ../../${COMPILE_SCHEMA}
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
         WORKING_DIRECTORY ../src/ifcparse
-        OUTPUT_VARIABLE COMPILED_SCHEMA_NAME
-    )
+        OUTPUT_VARIABLE COMPILED_SCHEMA_NAME)
 
     # Prevent the schema that had just been compiled from being excluded
     foreach(schema ${SCHEMA_VERSIONS})
@@ -593,16 +522,39 @@ if(NOT Boost_VERSION LESS 105800)
     add_definitions(-DBOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE)
 endif()
 
+add_subdirectory(../src/plugin plugin)
+
 add_subdirectory(../src/ifcparse ifcparse)
 set(IFCOPENSHELL_LIBRARIES IfcParse)
 
+if(BUILD_IFCPARSE_EXPERIMENTAL_WRAPPER)
+    add_subdirectory(../src/wrappergen wrappergen)
+endif()
+
 if(BUILD_IFCGEOM)
+    # CGAL::CGAL target already has dependencies resolved.
+    if(WITH_CGAL AND CGAL_DIR)
+        set(CGAL_LIBRARIES CGAL::CGAL)
+        message(STATUS "Using found CGAL package at '${CGAL_DIR}'")
+    elseif(WITH_CGAL AND NOT CGAL_DIR)
+        find_library(libGMP NAMES gmp mpir PATHS ${GMP_LIBRARY_DIR} NO_DEFAULT_PATH)
+        find_library(libMPFR NAMES mpfr PATHS ${MPFR_LIBRARY_DIR} NO_DEFAULT_PATH)
+        if(NOT libGMP)
+            message(FATAL_ERROR "Unable to find GMP library files, aborting")
+        endif()
+        if(NOT libMPFR)
+            message(FATAL_ERROR "Unable to find MPFR library files, aborting")
+        endif()
+
+        list(APPEND CGAL_LIBRARIES "${libMPFR}")
+        list(APPEND CGAL_LIBRARIES "${libGMP}")
+    endif()
+
     add_subdirectory(../src/ifcgeom ifcgeom)
 endif(BUILD_IFCGEOM)
 
 if(BUILD_CONVERT OR BUILD_IFCPYTHON)
     add_subdirectory(../src/serializers serializers)
-    set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} ${SERIALIZER_SCHEMA_LIBRARIES})
 endif(BUILD_CONVERT OR BUILD_IFCPYTHON)
 
 if(BUILD_CONVERT)
@@ -622,8 +574,8 @@ if(ADD_COMMIT_SHA)
     endif()
 
     if(GIT_FOUND)
-        if(VERSION_OVERRIDE)
-            set(git_branch ${RELEASE_VERSION})
+        if (VERSION_OVERRIDE)
+            set (git_branch ${RELEASE_VERSION})
         else()
             message("git found: ${GIT_EXECUTABLE} with version ${GIT_VERSION_STRING}")
             execute_process(
@@ -635,8 +587,8 @@ if(ADD_COMMIT_SHA)
             string(REPLACE "\n" ";" git_branch_list "${git_branches}")
 
             foreach(git_branch_candidate IN ITEMS ${git_branch_list})
-                string(REPLACE "*" "" git_branch_candidate_temp "${git_branch_candidate}")
-                string(STRIP "${git_branch_candidate_temp}" git_branch_candidate_2)
+		        string(REPLACE "*" "" git_branch_candidate_temp "${git_branch_candidate}")
+		        string(STRIP "${git_branch_candidate_temp}" git_branch_candidate_2)
                 if(NOT git_branch_candidate_2 MATCHES "^HEAD$")
                     string(REPLACE "/" ";" git_branch_candidate_2_list "${git_branch_candidate_2}")
                     list(GET git_branch_candidate_2_list -1 git_branch)
@@ -654,22 +606,17 @@ if(ADD_COMMIT_SHA)
         message(STATUS "IfcOpenShell branch: \"${git_branch}\"")
         message(STATUS "IfcOpenShell commit: \"${git_sha}\"")
 
-        if("${git_branch}" STREQUAL "" OR "${git_sha}" STREQUAL "")
+        if ("${git_branch}" STREQUAL "" OR "${git_sha}" STREQUAL "")
             message(FATAL_ERROR "Unable to determine commit sha and/or branch")
         endif()
 
-        target_compile_definitions(
-            IfcParse
-            PRIVATE -DIFCOPENSHELL_BRANCH=${git_branch} -DIFCOPENSHELL_COMMIT=${git_sha}
+        target_compile_definitions(IfcParse PRIVATE
+            -DIFCOPENSHELL_BRANCH=${git_branch}
+            -DIFCOPENSHELL_COMMIT=${git_sha}
         )
     endif()
 endif(ADD_COMMIT_SHA)
 
-# Always expose the release version (from the VERSION file) to buildinfo.cpp so
-# that a build without commit-sha info reports the correct version instead of a
-# stale hardcoded fallback. See #8164.
-target_compile_definitions(IfcParse PRIVATE IFCOPENSHELL_VERSION_STRING=${RELEASE_VERSION})
-
 if(MSVC)
     # @todo still needs to be understood better, but the cgal and cgal-simple kernel cause multiply defined boost lambda placeholders _1 ... _3
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /FORCE:MULTIPLE")
@@ -683,10 +630,6 @@ if(BUILD_DOCUMENTATION)
     add_subdirectory(../docs docs)
 endif()
 
-if(BUILD_IFCPYTHON)
-    add_subdirectory(../src/ifcwrap ifcwrap)
-endif()
-
 if(BUILD_EXAMPLES)
     add_subdirectory(../src/examples examples)
 endif()
@@ -699,32 +642,82 @@ if(BUILD_IFCPYTHON AND WITH_CGAL)
     add_subdirectory(../src/svgfill svgfill)
 endif()
 
+if(BUILD_IFCPYTHON)
+    add_subdirectory(../src/ifcwrap ifcwrap)
+endif()
+
 if(BUILD_QTVIEWER)
     add_subdirectory(../src/qtviewer qtviewer)
 endif()
 
+if(BUILD_IFCGEOM)
+    # install(FILES ${IFCGEOM_H_FILES}
+    #     DESTINATION ${INCLUDEDIR}/ifcgeom
+    # )
+
+    install(FILES ${SCHEMA_AGNOSTIC_H_FILES}
+        DESTINATION ${INCLUDEDIR}/ifcgeom
+    )
+
+    file(GLOB SERIALIZATION_H_FILES ../src/ifcgeom/serialization/*.h)
+    install(FILES ${SERIALIZATION_H_FILES}
+        DESTINATION ${INCLUDEDIR}/ifcgeom/serialization
+    )
+
+    foreach(kernel ${GEOMETRY_KERNELS})
+        file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/kernels/${kernel}/*.h)
+         install(FILES ${IFCGEOM_H_FILES}
+            DESTINATION ${INCLUDEDIR}/ifcgeom/kernels/${kernel}
+        )
+    endforeach()
+
+    install(TARGETS ${IFCGEOM_SCHEMA_LIBRARIES} ${kernel_libraries} IfcGeom)
+endif(BUILD_IFCGEOM)
+if(BUILD_IFCVIEWER)
+    if(BUILD_IFCVIEWER_TESTS)
+        # Catch2 v3 — fetched on demand. Test option is OFF by default so the
+        # default build remains offline-capable.
+        include(FetchContent)
+        FetchContent_Declare(
+            Catch2
+            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+            GIT_TAG        v3.5.4
+            GIT_SHALLOW    TRUE
+        )
+        FetchContent_MakeAvailable(Catch2)
+        list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
+        include(CTest)
+        include(Catch)
+        enable_testing()
+    endif()
+
+    add_subdirectory(../src/ifcviewer ifcviewer)
+    add_subdirectory(../src/ifcviewer-minimal ifcviewer-minimal)
+    add_subdirectory(../src/ifcviewer-full ifcviewer-full)
+endif()
+
 # Cmake uninstall target
 if(NOT TARGET uninstall)
     configure_file(
         "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
         "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-        IMMEDIATE
-        @ONLY
-    )
+        IMMEDIATE @ONLY)
 
-    add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+    add_custom_target(uninstall
+        COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
 endif()
 
 # Packaging
-list(APPEND CPACK_SOURCE_IGNORE_FILES "/\\\\.git" "/build/" "/.pytest_cache/" "/__pycache__/")
+list(APPEND CPACK_SOURCE_IGNORE_FILES
+    "/\\\\.git"
+    "/build/"
+    "/.pytest_cache/"
+    "/__pycache__/"
+)
 set(CPACK_SOURCE_INSTALLED_DIRECTORIES "${CMAKE_SOURCE_DIR}/..;/")
-set(CPACK_PACKAGE_NAME
-    "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}"
-)
+set(CPACK_PACKAGE_NAME "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}")
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}${EXTRA_VERSION}")
-set(CPACK_PACKAGE_FILE_NAME
-    "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}-${CMAKE_SYSTEM_NAME}"
-)
+SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}-${CMAKE_SYSTEM_NAME}")
 set(CPACK_PACKAGE_DIRECTORY "${PROJECT_BINARY_DIR}/assets")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "IfcOpenShell")
 set(CPACK_PACKAGE_DESCRIPTION "IfcOpenShell.")
@@ -737,7 +730,6 @@ set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
 set(CPACK_GENERATOR "TGZ;DEB")
 set(CPACK_SOURCE_GENERATOR "TGZ")
 
-set(BOOST_DEPS "")
 foreach(COMPONENT IN ITEMS ${BOOST_COMPONENTS})
     string(REPLACE "_" "-" COMP ${COMPONENT})
     set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}-dev")
@@ -745,19 +737,13 @@ endforeach(COMPONENT)
 
 set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_CONTACT}")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS
-    "python3, libxml2, libocct-foundation-dev, libocct-modeling-algorithms-dev, libocct-modeling-data-dev, libocct-ocaf-dev, libocct-visualization-dev, libocct-data-exchange-dev, libhdf5-serial-dev, libpython3-dev, python3-pytest ${BOOST_DEPS}"
-)
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, libocct-foundation-dev, libocct-modeling-algorithms-dev, libocct-modeling-data-dev, libocct-ocaf-dev, libocct-visualization-dev, libocct-data-exchange-dev, libhdf5-serial-dev, libpython3-dev, python3-pytest ${BOOST_DEPS}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION_SUMMARY "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 set(CPACK_DEBIAN_PACKAGE_SECTION "science")
-set(CPACK_DEBIAN_PACKAGE_VERSION
-    "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}${EXTRA_VERSION}"
-)
+set(CPACK_DEBIAN_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}${EXTRA_VERSION}")
 set(CPACK_DEBIAN_ARCHITECTURE "${CMAKE_SYSTEM_PROCESSOR}")
 # set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/debian/postinst")
 
 include(CPack)
-
-include(package_export.cmake)

cmake/FindHDF5.cmake

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

cmake/FindIfcOpenShell.cmake

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

cmake/FindOpenCOLLADA.cmake

@@ -139,7 +139,8 @@ if(NOT OpenCOLLADA_DIR)
     endif()
 endif(NOT OpenCOLLADA_DIR)
 
-if(OPENCOLLADA_FOUND)
-    add_definitions(-DWITH_OPENCOLLADA)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_OPENCOLLADA)
+if(OPENCOLLADA_FOUND AND NOT TARGET OpenCOLLADA::OpenCOLLADA)
+    add_library(OpenCOLLADA::OpenCOLLADA INTERFACE IMPORTED)
+    target_include_directories(OpenCOLLADA::OpenCOLLADA INTERFACE ${OPENCOLLADA_INCLUDE_DIRS})
+    target_link_libraries(OpenCOLLADA::OpenCOLLADA INTERFACE ${OPENCOLLADA_LIBRARIES})
 endif()

cmake/FindPROJ.cmake

@@ -6,7 +6,7 @@
 # Input variables could also be provided as environment variables.
 #
 # Output targets:
-# - `PROJ::proj`
+# - `proj::proj`
 #
 
 # To avoid cyclic calls to this file
@@ -34,10 +34,12 @@ if((NOT PROJ_INCLUDE_DIR AND NOT PROJ_LIBRARIES))
             message(FATAL_ERROR "Unable to find PROJ libraries in: ${PROJ_LIBRARY_DIR}")
         endif()
 
-        add_library(PROJ::proj INTERFACE IMPORTED)
-        target_include_directories(PROJ::proj INTERFACE "${PROJ_INCLUDE_DIR}")
-        target_link_libraries(PROJ::proj INTERFACE ${PROJ_LIBRARIES})
-        target_link_directories(PROJ::proj INTERFACE "${PROJ_LIBRARY}")
+        if(NOT TARGET proj::proj)
+            add_library(proj::proj INTERFACE IMPORTED)
+            target_include_directories(proj::proj INTERFACE "${PROJ_INCLUDE_DIR}")
+            target_link_libraries(proj::proj INTERFACE ${PROJ_LIBRARIES})
+            target_link_directories(proj::proj INTERFACE "${PROJ_LIBRARY}")
+        endif()
     endif()
 else()
     find_library(PROJ_LIBRARY NAMES proj PATHS ${PROJ_LIBRARY_DIR})
@@ -50,7 +52,11 @@ else()
 
     set(PROJ_INCLUDE_DIR ${PROJ_INCLUDE_DIR} CACHE FILEPATH "PROJ header files")
     message(STATUS "Looking for PROJ include files in: ${PROJ_INCLUDE_DIR}")
-    include_directories(${PROJ_INCLUDE_DIR})
+    if(NOT TARGET proj::proj)
+        add_library(proj::proj INTERFACE IMPORTED)
+        target_include_directories(proj::proj INTERFACE "${PROJ_INCLUDE_DIR}")
+        target_link_libraries(proj::proj INTERFACE ${PROJ_LIBRARIES})
+    endif()
 endif()
 
 list(PREPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})

cmake/FindUSD.cmake

@@ -64,7 +64,6 @@ set(USD_LIBRARIES
 find_library(USD_LIBRARY NAMES ${USD_LIBRARIES} PATHS ${USD_LIBRARY_DIR})
 if(USD_LIBRARY)
     message(STATUS "USD libraries ${USD_LIBRARIES} found in: ${USD_LIBRARY_DIR}")
-    link_directories(${USD_LIBRARY_DIR})
 else()
     message(FATAL_ERROR "Unable to find USD libraries in: ${USD_LIBRARY_DIR}")
 endif()
@@ -82,5 +81,3 @@ if(MSVC)
 endif()
 
 target_compile_definitions(pxr::USD INTERFACE PXR_STATIC WITH_USD)
-
-set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_USD)

cmake/IfcOpenShellConfig.cmake.in

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

conda/build.bat

@@ -37,7 +37,6 @@ cmake -G "Ninja" ^
  -D GLTF_SUPPORT:BOOL=ON ^
  -D BUILD_CONVERT:BOOL=ON ^
  -D BUILD_IFCMAX:BOOL=OFF ^
- -D IFCXML_SUPPORT:BOOL=ON ^
  -D Boost_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
  -D Boost_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
  -D Boost_USE_STATIC_LIBS:BOOL=OFF ^

conda/build.sh

@@ -34,7 +34,6 @@ cmake ${CMAKE_ARGS} -G Ninja \
  -DEIGEN_DIR:FILEPATH=$PREFIX/include/eigen3 \
  -DCOLLADA_SUPPORT:BOOL=OFF \
  -DBUILD_EXAMPLES:BOOL=OFF \
- -DIFCXML_SUPPORT:BOOL=ON \
  -DGLTF_SUPPORT:BOOL=ON \
  -DBUILD_CONVERT:BOOL=ON \
  -DBUILD_IFCPYTHON:BOOL=ON \

docker/.dockerignore

@@ -1,3 +0,0 @@
-.env
-*.pyc
-__pycache__

docker/.gitignore

@@ -1,3 +0,0 @@
-.env
-*.pyc
-__pycache__

docker/.ifcos_env

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# .ifcos_env
-# register autocompletes. just source the file in your shell, i.e. 
-# source .ifcos_env
-
-.ifcos_env() {
-    local cur prev opts
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    prev="${COMP_WORDS[COMP_CWORD-1]}"
-
-    opts="create update up down restart build attach logs ps config remove help"
-
-    # Basic static completion
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-
-    return 0
-}
-
-# Register the completion for the command "ifcos_env"
-complete -F .ifcos_env ./ifcos_env

docker/Dockerfile

@@ -1,67 +0,0 @@
-FROM rockylinux:9
-
-# Update system, enable CRB (needed by some EPEL packages) and install EPEL,
-# then install required packages + some common tools for a bit of command
-# line comfort. Combined into one layer so a later `create` always installs
-# against packages from the same dnf update, rather than layering fresh
-# installs on top of a stale cached "update" layer.
-RUN dnf update -y && \
-    dnf install -y epel-release && \
-    dnf config-manager --set-enabled crb && \
-    dnf install -y --allowerasing --setopt=install_weak_deps=False --setopt=tsflags=nodocs \
-                   bash-completion vim git curl wget which tree htop sudo   \
-                   gcc gcc-c++ autoconf automake bison make zip cmake      \
-                   python3 python3-pip                                    \
-                   bzip2 patch mesa-libGL-devel libffi-devel fontconfig-devel \
-                   sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel \
-                   readline-devel ncurses-devel libuuid-devel git-lfs      \
-                   findutils xz byacc ccache && \
-    git lfs install --system && \
-    dnf clean all && \
-    rm -rf /var/cache/dnf
-
-# Trust bind-mounted repos regardless of which user (root or builder) or host
-# UID owns them, rather than a per-user config that only one of them sees.
-RUN git config --system --add safe.directory '*'
-
-# Configure ccache. CCACHE_MAXSIZE (not `ccache -M`) because /ccache is a
-# volume mount point at runtime - anything `ccache -M` writes to a config
-# file under it during this build gets shadowed once the real volume is
-# mounted, so the size cap only actually takes effect via the env var.
-# 2G is generous: a full build (IfcParse+IfcGeom+IfcConvert+wrapper, one
-# Python version) measures ~300MB, and the volume is now shared across all
-# checkouts (see compose.yaml), so this covers several diverging branches.
-ENV CCACHE_DIR=/ccache
-ENV CCACHE_MAXSIZE=2G
-ENV PATH="/usr/lib/ccache:$PATH"
-
-# Non-root user matching the host UID/GID that bind-mounts the repo (default
-# 1000:1000, the common single-user-Linux-box case), so files the build
-# creates under the mount keep sane, non-root ownership on the host side.
-# Override with --build-arg USER_UID=$(id -u) --build-arg USER_GID=$(id -g)
-# if your host user has a different UID/GID.
-ARG USER_UID=1000
-ARG USER_GID=1000
-# groupadd fails outright if USER_GID is already taken by an existing
-# system group - which happens whenever a host's primary GID collides with
-# one baked into the rockylinux9 base image. The main real-world case is
-# macOS, where the default user's primary group is "staff" at GID 20, and
-# GID 20 is "games" on RHEL-family images. Only create the "builder" group
-# when that GID is actually free; otherwise useradd just attaches to
-# whichever group already owns it. Either way the builder user ends up
-# with the right GID for bind-mount ownership, which is all that matters.
-RUN (getent group "${USER_GID}" >/dev/null || groupadd -g "${USER_GID}" builder) \
-    && useradd -m -u "${USER_UID}" -g "${USER_GID}" -s /bin/bash builder \
-    && echo "builder ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/builder
-
-# Copied while still root: /bin is not writable by the builder user.
-COPY --from=ghcr.io/astral-sh/uv:0.11.27 /uv /uvx /bin/
-
-USER builder
-WORKDIR /__w/IfcOpenShell/IfcOpenShell
-
-# Installed as builder so managed Python interpreters land under builder's
-# $HOME, matching the user that actually runs the build.
-RUN uv python install
-
-CMD ["sleep", "infinity"]

docker/README.md

@@ -1,78 +0,0 @@
-Docker build environment
-========================
-
-This is a small utility to make it easy to compile a perfect `_ifcopenshell_wrapper.cpython-*-x86_64-linux-gnu.so`
-files.
-
-The reason for this tool is that I was trying to follow the web page directions, and my build was behaving differently
-to the release builds. Eventually I concluded that the differences between toolchains on the RHEL based rocky9 image
-and Ubuntu were just too great. Getting the build setup was already a lot of trial and error, so I thought I'd spend
-more time trying to reuse the github actions that perform the build, using a utility called `act`. I learnt a lot, in
-particular how much time, energy, and bandwidth Github waste. I also realised I was most of the way to a regular docker
-setup anyway, so I might as well just do that. So I've deconstructed all the github action steps, and turned it into
-a local docker build environment that uses the exact same base, tools, libraries, and build command/flags etc.
-
-Right now a Github action will:
-- launch the rocky9 base
-- upgrade all the packages
-- install a bunch of extra tools
-- do a recursive checkout of your repo
-- checkout the build repository
-- unpack dependencies
-- run the build script, making all python versions (5? right now I think)
-- create the .zip release files
-
-And it does _all_ of that _every_ time. This is not a fault of the action writers - it's just how Github seems to work.
-
-These dockers tools do the following differently, and it's actually a bit more powerful too:
-- build the base image once.
-- update the packages once.
-- install the extra tools once.
-- the repository is the one on your host, that gets bind mounted in the container as the working directory.
-- by adding an environment variable to .env, restricts to compiling for just a single python version.
-- when the build is finished the created files are right there under your local repositry (but not added to git) for
-  ease of access
-- each repository can have it's own build environment container.
-- the image is shared between those environments.
-- the containers share the ccache, so additional envs should get a helping hand.
-- it has a simple set of user friendly commands to drive it all.
-
-For example:
-``` bash
-# To see the commands (a superset of docker compose commands)
-./ifcos_env
-
-# Enable autocomplete of commands
-source .ifcos_env
-
-# First time commands
-./ifcos_env create
-./ifcos_env up
-./ifcos_env build
-
-# install and test library
-# find an issue
-# edit code
-./ifcos_env build
-
-# and so on. When done stop and optionally delete the container
-./ifcos_env stop
-./ifcos_env remove
-```
-
-To limit the build to one python version just add
-``` bash
-PY_TGT=py-311
-```
-or whichever version your Blender requires.
-
-You might see UNIQUE_ID in the .env file too. This keeps containers for separate folders, separate.
-
-System requirements
-1. Linux-x64 only at this time.
-2. Docker and docker-compose need to be installed.
-3. Have a good amount of disk space. (image is in /var (typically the root partition) and will be about 1.7 GB)
-4. The build action will create about 10GB in your repository folder. Make sure this partition is spacious
-   particularly if you intent on having multiple clones building.
-5. ... I think that covers most of it.
-

docker/SKILL.md

@@ -1,186 +0,0 @@
----
-name: ifcopenshell-docker-build
-description: >-
-  Build a real ifcopenshell_wrapper (.so + .py) and IfcConvert locally via
-  the docker/ifcos_env toolchain, then wire them into a checkout for
-  running C++-dependent parts of the test suite (geometry, the SWIG
-  wrapper stub, the C++ parser). Use whenever a task needs to compile
-  IfcOpenShell's C++ core rather than just read/patch source - e.g.
-  reproducing or fixing a bug in src/ifcgeom, src/ifcparse, src/ifcwrap,
-  or validating util/scripts/validate_stub.py against the actual
-  generated wrapper.
----
-
-# Building IfcOpenShell locally with docker/ifcos_env
-
-`docker/` mirrors the project's GitHub Actions build environment locally,
-in a persistent, non-root container with ccache so repeat builds are fast.
-See `docker/README.md` for the design rationale. Pure-Python changes don't
-need any of this - only reach for it when you need a real compiled
-`_ifcopenshell_wrapper*.so` or `IfcConvert` binary.
-
-## Placement
-
-This `docker/` folder must live as a direct child of the repo root you want
-to build (sibling of `src/`, `cmake/`, etc.) - `compose.yaml` and
-`ifcos_env` resolve the repo via `../` relative to wherever `docker/`
-itself sits, and bind-mount it into the container. If you're setting this
-up in a fresh clone, copy the whole `docker/` directory there first.
-
-## Setup
-
-```bash
-cd docker
-./ifcos_env create   # build the image (shared by name across all your clones/checkouts, so usually instant after the first time anywhere)
-./ifcos_env up        # create + start the container, clone/unpack the third-party dependency cache (~10GB, one-time per container)
-./ifcos_env build     # full build: all deps + IfcParse + IfcGeom + IfcConvert + the Python wrapper, for one Python version
-```
-
-`PY_TGT` and `UNIQUE_ID` live in `docker/.env` - `PY_TGT` (e.g. `py-311`)
-restricts the build to one Python version instead of building five;
-`UNIQUE_ID` is a hash of the folder path, recalculated on every `up`, so
-each checkout gets its own container/volumes automatically.
-
-A full first build takes ~1.5 hours (mostly compiling IfcOpenShell's own
-C++, not the cached third-party deps). After that, ccache makes incremental
-rebuilds of a couple of touched `.cpp` files **under a minute**.
-
-## Container lifecycle
-
-The container is long-lived (`sleep infinity`) so exec'd commands and
-ccache state persist between builds. Commands map directly onto Docker
-Compose's own container-vs-image distinction:
-
-```bash
-./ifcos_env up         # create the container if it doesn't exist, then start it (runs ready_repo too)
-./ifcos_env stop       # stop the container, keep it around
-./ifcos_env start      # start it back up (same container, same filesystem layer)
-./ifcos_env restart    # stop, then start
-./ifcos_env down       # remove the container (and its network) entirely
-./ifcos_env recreate   # down, then up - a fresh container
-```
-
-Named volumes (`ccache`) and the bind-mounted repo/`build/` are unaffected
-by `down`/`recreate` - only the container itself goes away, and `up`
-recreates it from the image.
-
-## Fast iteration
-
-Pass a target to `build` to skip the parts you don't need:
-
-```bash
-./ifcos_env build IfcConvert           # only the executables (IfcConvert, IfcGeomServer) - skips the Python wrapper entirely
-./ifcos_env build IfcOpenShell-Python  # only the SWIG Python wrapper - skips executables entirely
-./ifcos_env build                      # no target = everything (needed the first time, or after touching shared headers)
-```
-
-Use this to keep the edit -> rebuild -> test loop fast when debugging: if
-you're only touching `src/ifcgeom/`, build `IfcConvert`; if you're only
-exercising the Python API, build `IfcOpenShell-Python`.
-
-## Where the artifacts land
-
-Build output goes to `<repo_root>/build/Linux/x86_64/install/` on the host
-(bind-mounted, not just inside the container), owned by you (see
-"Container user" below):
-
-- `ifcopenshell/bin/IfcConvert` - the CLI binary
-- `python-<version>/lib/python<X.Y>/site-packages/ifcopenshell/_ifcopenshell_wrapper*.so`
-  and `ifcopenshell_wrapper.py` - the compiled wrapper + its generated
-  Python glue
-
-## Testing against a checkout (automated / AI-driven)
-
-`_ifcopenshell_wrapper*.so` and `ifcopenshell_wrapper.py` are already
-gitignored under `src/ifcopenshell-python/ifcopenshell/`, which is exactly
-where a normal in-tree build would put them - copy the two files there:
-
-```bash
-SRC=build/Linux/x86_64/install/python-3.11.8/lib/python3.11/site-packages/ifcopenshell
-cp "$SRC/_ifcopenshell_wrapper.cpython-311-x86_64-linux-gnu.so" src/ifcopenshell-python/ifcopenshell/
-cp "$SRC/ifcopenshell_wrapper.py" src/ifcopenshell-python/ifcopenshell/
-```
-
-Then, to run the test suite against it:
-
-```bash
-export PATH="$PWD/build/Linux/x86_64/install/ifcopenshell/bin:$PATH"   # for IfcConvert-dependent tests
-cd src/ifcopenshell-python/test
-PYTHONPATH="$PWD/.." python3.11 -m pytest -p no:pytest-blender .
-```
-
-(`-p no:pytest-blender` avoids the pytest-blender plugin trying to find a
-`blender` executable and failing collection entirely, even for non-Blender
-tests.) You'll need the matching Python version's `pip install`s too
-(numpy, shapely, isodate, lark, tabulate, pytest, ... - whatever the
-modules under test import) since this is a bare interpreter, not the
-project's pixi env.
-
-**This is the pattern to use for automated or AI-driven verification.**
-Don't use `try` (below) for that - it overwrites files in a real, live
-Blender installation, which isn't something an automated/AI workflow
-should ever do without the human explicitly asking for it in the moment.
-
-## Testing in Blender itself (human only)
-
-`try` copies the built wrapper straight into your actual Blender/Bonsai
-extension install, for manual in-Blender testing:
-
-```bash
-./ifcos_env try
-```
-
-It reads `BLENDER_USER_RESOURCE` from `.env` - set this to wherever
-Blender's user resource folder for the Bonsai extension actually lives on
-your system, which depends on your own Blender setup:
-
-```bash
-# in docker/.env
-BLENDER_USER_RESOURCE=~/.config/blender/bonsai/
-```
-
-`try` figures out the built Python version from `build/.../install/`
-(disambiguating with `PY_TGT` if more than one version was built) and
-copies the wrapper to
-`$BLENDER_USER_RESOURCE/extensions/.local/lib/python<X.Y>/site-packages/ifcopenshell/`.
-
-## Container user
-
-The image runs as a non-root `builder` user, UID/GID matching your host
-account (passed as `--build-arg` by `create` from `id -u`/`id -g`, so it
-adjusts automatically - no manual flag needed even if you're not 1000:1000).
-Files the build creates under the bind mount come out owned by you, not
-root. Passwordless `sudo` is available inside the container (e.g. via
-`attach`) for the rare case you need root for something ad hoc.
-
-If you're picking up an existing checkout that was previously built with
-an older, root-based image, you may hit `Permission denied` the first time
-you run `up`/`build` under the new image - `build/`, `.git/modules/`, the
-`ccache` volume, `output/`, and `build.log` can all be left root-owned from
-before. Fix it once via the container's own root (no host `sudo` needed):
-
-```bash
-docker exec -u root -w /__w/IfcOpenShell/IfcOpenShell <container-name> \
-    chown -R "$(id -u)":"$(id -g)" .git/modules build output build.log /ccache
-```
-
-(`<container-name>` is `ifcopenshell-<UNIQUE_ID>` - see `docker ps -a`.)
-
-## Other things worth knowing
-
-- **Linux x64 only.** `compose.yaml` pins `platform: linux/amd64`; on an
-  ARM host (e.g. Apple Silicon) this build isn't available.
-- **The final "Package .zip archives" step of `build()` has a pre-existing
-  bash syntax error**, unrelated to compilation - the actual build already
-  succeeded by that point (look for `Built IfcOpenShell...` in the output),
-  so this is safe to ignore if you only need the raw artifacts under
-  `build/.../install/`, not packaged release zips.
-- **`test_mmaped_stream` and similar `USE_MMAP`-dependent tests will fail**
-  against this build - `nix/build-all.py` is invoked with `USE_MMAP=OFF`
-  here. Not a bug in your code if you see it fail.
-- Only the bind-mounted `<repo>/build` lives on the host filesystem your
-  repo is checked out on. Anything the container writes *outside* that
-  mount lives in the container's own writable layer under Docker's data
-  root (commonly `/var/lib/docker`, i.e. usually your root partition) -
-  keep an eye on `df -h /` if you're running several of these containers
-  at once.

docker/compose.yaml

@@ -1,15 +0,0 @@
-name: ifcopenshell-${UNIQUE_ID}
-services:
-  ifcopenshell:
-    container_name: ifcopenshell-${UNIQUE_ID}
-    image: ifcopenshell-build-env:updated
-    platform: linux/amd64
-    volumes:
-      - type: bind
-        source: ../
-        target: /__w/IfcOpenShell/IfcOpenShell
-      - ccache:/ccache
-
-volumes:
-  ccache:
-    name: ifcopenshell-ccache-shared

docker/ifcos_env

@@ -1,339 +0,0 @@
-#!/bin/bash
-
-# ================== CONFIG ==================
-SCRIPT_NAME=$(basename "$0")
-ENV_FILE=".env"
-WORKDIR="/__w/IfcOpenShell/IfcOpenShell"
-NAMEPREFIX=ifcopenshell
-
-function set_env() {
-    # Load .env file if it exists
-    if [[ -f "$ENV_FILE" ]]; then
-        set -a
-        source "$ENV_FILE"
-        set +a
-        echo "✅ Loaded environment variables from $ENV_FILE"
-    else
-        echo "⚠️  No $ENV_FILE found, proceeding without it."
-    fi
-}
-
-set_env
-
-# ================ FUNCTIONS =================
-
-function create() {
-    echo "⭐ Creating image: ifcopenshell-build-env"
-    docker build -f Dockerfile \
-        --build-arg USER_UID="$(id -u)" --build-arg USER_GID="$(id -g)" \
-        -t ifcopenshell-build-env:updated .
-}
-
-function update() {
-    # The Dockerfile always builds FROM a clean rockylinux:9 and does
-    # `dnf update -y` as its first step, so re-running create() is enough
-    # to get fresh packages.
-    echo "⚡ Updating image: ifcopenshell-build-env"
-    create
-}
-
-function up() {
-    # Creates the container if it doesn't exist yet (and starts it either
-    # way) - this is the one that needs ready_repo, since a freshly created
-    # container has no submodules/dependency cache in place yet.
-    echo "🚀 Creating/starting stack: ifcopenshell-${UNIQUE_ID}"
-    unique          # Update UNIQUE_ID first
-    docker compose up -d "$@"   # Container must exist before ready_repo can exec into it.
-    ready_repo      # Ensure repo is recursive, and the build repo is in place.
-}
-
-function down() {
-    # Removes the container (and its network) entirely. Named volumes
-    # (ccache) and the bind-mounted repo/build/ survive; up() will recreate
-    # the container from scratch next time.
-    echo "🔥 Removing stack: ifcopenshell-${UNIQUE_ID}"
-    docker compose down "$@"
-}
-
-function stop() {
-    # Stops the existing container without removing it - the container,
-    # its filesystem layer, and its exec history all remain intact.
-    echo "🛑 Stopping stack: ifcopenshell-${UNIQUE_ID}"
-    docker compose stop "$@"
-}
-
-function start() {
-    # Starts a previously-stopped container back up. Does nothing (and
-    # won't create anything) if the container doesn't exist - use up() for
-    # that.
-    echo "▶️  Starting stack: ifcopenshell-${UNIQUE_ID}"
-    docker compose start "$@"
-}
-
-function restart() {
-    echo "🔄 Restarting stack (stop, then start)..."
-    stop
-    start
-}
-
-function recreate() {
-    echo "♻️  Recreating stack (down, then up)..."
-    down
-    up
-}
-
-function logs() {
-    echo "📜 Showing logs..."
-    docker compose logs -f "$@"
-}
-
-function ps() {
-    docker compose ps
-}
-
-function config() {
-    echo "🔍 Validated compose configuration:"
-    docker compose config
-}
-
-function remove() {
-    # Lower-level than down(): removes already-stopped containers without
-    # touching the compose network. Mostly useful after a plain stop().
-    echo "🗑️  Removing stopped containers: ifcopenshell-${UNIQUE_ID}"
-    docker compose rm "$@"
-}
-
-function unique() {
-    echo "🔧 Making stack name folder specific..."
-
-    REGEX="^UNIQUE_ID="
-
-    if [[ ! -f "$ENV_FILE" ]] || ! grep -qE "$REGEX" "$ENV_FILE"; then
-        echo -e "\nUNIQUE_ID=dummy\n" >> "$ENV_FILE"
-    fi
-
-    export UNIQUE_ID="$(pwd | sha256sum | cut -c -8)"
-
-    # `sed -i` takes incompatible syntax between GNU sed (Linux) and BSD sed
-    # (macOS) - `-si` is GNU-only and errors as "illegal option -- s" under
-    # BSD/macOS sed. Avoid -i altogether and do the in-place edit via a temp
-    # file + mv instead, which behaves identically with either sed.
-    local tmp_file
-    tmp_file="$(mktemp "${ENV_FILE}.XXXXXX")"
-    sed "s/^UNIQUE_ID=.*$/UNIQUE_ID=${UNIQUE_ID}/" "$ENV_FILE" > "$tmp_file"
-    mv "$tmp_file" "$ENV_FILE"
-
-    set_env
-}
-
-function ready_repo() {
-    echo "👍 Getting the repo ready to build..."
-    docker exec -i -w "${WORKDIR}" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        set -euo pipefail   # Recommended for robustness
-
-        git submodule update --init --recursive
-
-        if [[ ! -d "build" ]]; then
-            git clone -b rockylinux9-x64 https://github.com/IfcOpenShell/build-outputs.git build
-        else
-            cd build
-            git pull
-            cd ..
-        fi
-
-        if [[ ! -d "build/Linux/x86_64/install/boost-1.86.0/" ]]; then
-            cd build
-            uv run ../nix/cache_dependencies.py unpack
-            cd ..
-        fi
-    '
-}
-
-function build() {
-    echo "☕ Execute the build, go make yourself a cuppa... I'll be a while"
-    local BUILD_TARGET="$1"
-    
-    docker exec -i -w "${WORKDIR}" -e PY_TGT="${PY_TGT}" -e BUILD_TARGET="${BUILD_TARGET}" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        set -o pipefail
-        CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v ${PY_TGT:+-$PY_TGT} --diskcleanup ${BUILD_TARGET} 2>&1 | tee build.log
-    '
-    echo "🎒 Pack Dependencies"
-    docker exec -i -w "${WORKDIR}" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        cd build
-        uv run ../nix/cache_dependencies.py pack
-    '
-
-    echo "🎁 Package .zip archives"
-    docker exec -i -w "${WORKDIR}" -e GITHUB_SHA="$(git rev-parse HEAD)" "${NAMEPREFIX}-${UNIQUE_ID}" bash -c '
-        OUTPUT_DIR=${PWD}/output
-        VERSION=v`cat VERSION`
-        mkdir -p ${OUTPUT_DIR}
-        cd ./build/`uname`/*/install/ifcopenshell
-
-        ls -d python-* | while read py_version; do
-            postfix=`echo ${py_version: -1} | sed s/[0-9]//`
-            numbers=`echo $py_version | grep -oE "[0-9]+\.[0-9]+" | tr -d "."`
-            py_version_major=python-${numbers}$postfix
-            pushd . > /dev/null
-            cd $py_version
-            if [ ! -d ifcopenshell ]; then
-                mkdir ../ifcopenshell_
-                mv * ../ifcopenshell_
-                mv ../ifcopenshell_ ifcopenshell
-            fi
-            [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
-            find ifcopenshell -name "*.pyc" -delete
-            zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip ifcopenshell/*
-            mv *.zip ${OUTPUT_DIR}/
-            popd > /dev/null
-        done
-
-        cd bin
-        if compgen -G "./*.zip" > /dev/null; then
-            rm *.zip 2>&1 >/dev/null || true
-        ls | while read exe; do
-            zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip $exe
-        done
-        mv *.zip ${OUTPUT_DIR}/
-        cd ..
-      '
-}
-
-function attach() {
-    echo "🔦 Connect to interactive shell"
-    docker exec -it  -w "${WORKDIR}" "${NAMEPREFIX}-${UNIQUE_ID}" /bin/bash
-}
-
-function try() {
-    # Copies the freshly built wrapper into your actual Blender/Bonsai
-    # installation for manual, in-Blender testing. This is a human-only
-    # convenience: it overwrites files in your live Blender setup, so it's
-    # not something that should run unattended as part of an automated or
-    # AI-driven build/test loop (which should instead copy the wrapper into
-    # the repo's own src/ifcopenshell-python/ifcopenshell/ - see SKILL.md).
-    echo "🚴 Copying build artifacts into your Blender resource folder for testing"
-
-    if [[ -z "${BLENDER_USER_RESOURCE:-}" ]]; then
-        echo "❌ BLENDER_USER_RESOURCE is not set in .env."
-        echo "   Add a line pointing at wherever Blender's user resource folder for"
-        echo "   the Bonsai extension actually is on your system, e.g.:"
-        echo "     BLENDER_USER_RESOURCE=~/.config/blender/bonsai/"
-        return 1
-    fi
-
-    # Normalise: expand a leading ~ (in case it was quoted in .env and so
-    # never went through shell tilde-expansion when set_env sourced it),
-    # then resolve to an absolute, symlink-free path.
-    local resource="${BLENDER_USER_RESOURCE/#\~/$HOME}"
-    resource="$(realpath -m "$resource")"
-
-    local install_dir="../build/Linux/x86_64/install"
-    local py_dirs=("$install_dir"/python-*)
-    if [[ ${#py_dirs[@]} -gt 1 && -n "${PY_TGT:-}" ]]; then
-        # PY_TGT is compact (py-311); the install dirs are dotted
-        # (python-3.11.8) - reinsert the dot (assumes a single-digit major
-        # version, true for the Python 3.x line) before matching.
-        local py_tgt_digits="${PY_TGT#py-}"
-        local py_tgt_dotted="${py_tgt_digits:0:1}.${py_tgt_digits:1}"
-        local filtered=() d
-        for d in "${py_dirs[@]}"; do
-            [[ "$(basename "$d")" == "python-${py_tgt_dotted}."* ]] && filtered+=("$d")
-        done
-        [[ ${#filtered[@]} -gt 0 ]] && py_dirs=("${filtered[@]}")
-    fi
-    if [[ ${#py_dirs[@]} -ne 1 || ! -d "${py_dirs[0]}" ]]; then
-        echo "❌ Expected exactly one built python-* dir under $install_dir, found ${#py_dirs[@]}."
-        echo "   Run 'build' first, or set PY_TGT in .env to disambiguate a multi-version build."
-        return 1
-    fi
-
-    local py_minor
-    py_minor="$(basename "${py_dirs[0]}" | grep -oE '[0-9]+\.[0-9]+')"
-    local wrapper_dir="${py_dirs[0]}/lib/python${py_minor}/site-packages/ifcopenshell"
-    if [[ ! -f "$wrapper_dir/ifcopenshell_wrapper.py" ]]; then
-        echo "❌ Built wrapper not found at $wrapper_dir - run 'build' first."
-        return 1
-    fi
-
-    local target="$resource/extensions/.local/lib/python${py_minor}/site-packages/ifcopenshell"
-    mkdir -p "$target"
-    cp "$wrapper_dir"/_ifcopenshell_wrapper*.so "$target/"
-    cp "$wrapper_dir"/ifcopenshell_wrapper.py "$target/"
-    echo "✅ Copied wrapper into $target"
-}
-
-function clean() {
-    # Host-side only - doesn't touch the container, image, or ccache volume.
-    echo "💎 Clean the build and output folder up"
-    if [[ -d "../build" ]]; then
-        rm -rf ../build
-    fi
-    if [[ -d "../output" ]]; then
-        rm -rf ../output
-    fi
-}
-
-
-function help() {
-    cat <<EOF
-Usage: ./$SCRIPT_NAME <command>
-
-Available commands:
-  create      Build the rocky9-based image
-  update      Rebuild the image fresh, picking up OS package updates
-  up          Create the container if it doesn't exist yet, and start it
-  down        Remove the container entirely (docker compose down)
-  stop        Stop the container without removing it
-  start       Start a previously-stopped container
-  restart     stop, then start (same container, no recreation)
-  recreate    down, then up (fresh container)
-  build       Execute the IfcOpenShell build
-  attach      Connect to an interactive shell in the container
-  try         Copy the built wrapper into your Blender resource folder
-              (human-only - see BLENDER_USER_RESOURCE below, and SKILL.md
-              for the AI/automated-testing equivalent)
-  clean       Remove the build and output folders
-  logs        Follow container logs
-  ps          Show running containers
-  config      Validate and show compose config
-  remove      Remove stopped containers (docker compose rm)
-  help        Show this help
-
-Environment variables from .env are automatically loaded, including:
-  PY_TGT                  Restrict the build to one Python version, e.g. py-311
-  UNIQUE_ID               Recalculated automatically on every 'up', don't set by hand
-  BLENDER_USER_RESOURCE   Where 'try' copies the wrapper for manual testing, e.g.
-                          ~/.config/blender/bonsai/
-EOF
-}
-
-# ================= MAIN =================
-
-case "$1" in
-    create)         create ;;
-    update)         update ;;
-    up)             up "${@:2}" ;;
-    down)           down "${@:2}" ;;
-    stop)           stop "${@:2}" ;;
-    start)          start "${@:2}" ;;
-    restart)        restart ;;
-    recreate)       recreate ;;
-    build)          build "${@:2}" ;;
-    attach)         attach ;;
-    try)            try ;;
-    clean)          clean ;;
-    logs)           logs "${@:2}" ;;
-    ps)             ps ;;
-    config)         config ;;
-    remove)         remove ;;
-    help|-h|--help) help ;;
-    "")
-        echo "❌ No command provided."
-        help
-        ;;
-    *)
-        echo "❌ Unknown command: $1"
-        echo "Type './$SCRIPT_NAME help' for available commands."
-        exit 1
-        ;;
-esac

findings.md

@@ -0,0 +1,317 @@
+# Build fix: remove `boost_system` from CMake components
+
+`Boost.System` became header-only in Boost 1.69. Boost 1.90.0 no longer ships a compiled library or CMake config for it, so `find_package(Boost REQUIRED COMPONENTS system ...)` fails.
+
+## Fix
+
+`cmake/CMakeLists.txt`:
+
+```diff
+-    set(BOOST_COMPONENTS system program_options regex thread date_time iostreams)
++    set(BOOST_COMPONENTS program_options regex thread date_time iostreams)
+```
+
+The headers are still available; no linking is needed.
+
+# Build fix: add `template` keyword for dependent template member calls
+
+Calling a template member function through a dependent expression (e.g. `storage->has_attribute_value<T>(...)` where `storage`'s type depends on a template parameter) requires the `template` keyword to disambiguate from a less-than comparison.
+
+## Error
+
+```
+src/ifcparse/IfcParse.cpp:1856:67: error: expected primary-expression before '>' token
+ 1856 |                     if (storage->has_attribute_value<express::Base>(attr_index)) {
+      |                                                                   ^
+```
+
+Six identical errors at lines 1856, 1865, 1896, 1905, 1934, 1943.
+
+## Fix
+
+`src/ifcparse/IfcParse.cpp`:
+
+```diff
+-storage->has_attribute_value<express::Base>(attr_index)
++storage->template has_attribute_value<express::Base>(attr_index)
+
+-storage->has_attribute_value<Blank>(attr_index)
++storage->template has_attribute_value<Blank>(attr_index)
+```
+
+Applied at all six call sites in `in_memory_file_storage::read_from_stream`.
+
+# Linker fix: missing explicit template instantiations for `InstanceStreamer`
+
+`InstanceStreamer` is a class template with methods defined in `IfcParse.cpp`, not the header. Without explicit instantiations, the linker can't find the symbols when the SWIG wrapper loads.
+
+## Error
+
+```
+ImportError: undefined symbol: _ZN8IfcParse16InstanceStreamerINS_10FileReaderINS_14FullBufferImplEEEEC1EPS3_PNS_7IfcFileE
+  (IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(FileReader<FullBufferImpl>*, IfcFile*))
+```
+
+## Fix
+
+Cannot use `template class InstanceStreamer<...>` because some constructors have `static_assert` guards that reject certain reader types. Instead, instantiate each member function individually per reader type, only including the constructors valid for that type.
+
+`src/ifcparse/IfcParse.cpp` (after the last `InstanceStreamer` method definition):
+
+```cpp
+// FullBufferImpl
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(IfcParse::IfcFile*);
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(const std::string&, bool, IfcParse::IfcFile*);
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(void*, int, IfcParse::IfcFile*);
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(FileReader<FullBufferImpl>*, IfcParse::IfcFile*);
+// ... plus ensure_header, initialize_header, hasSemicolon, semicolonCount,
+//     pushPage, bypassTypes, readInstance
+
+// PushedSequentialImpl — same pattern, different valid constructors
+
+// MMapFileReader (ifdef USE_MMAP) — same pattern
+```
+
+# Linker fix: `FullBufferImpl` missing buffer constructor
+
+SWIG's `stream_from_string` calls `InstanceStreamer<FileReader<FullBufferImpl>>(void*, int, IfcFile*)`, but the `(void*, int)` constructor previously hit a `static_assert` for `FullBufferImpl` — it only allowed `PushedSequentialImpl`.
+
+## Error
+
+```
+ImportError: undefined symbol: _ZN8IfcParse16InstanceStreamerINS_10FileReaderINS_14FullBufferImplEEEEC1EPviPNS_7IfcFileE
+  (InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(void*, int, IfcFile*))
+```
+
+## Fix
+
+Three changes to make `FullBufferImpl` support buffer-based and default construction:
+
+`src/ifcparse/FileReader.h` — add buffer constructor to `FullBufferImpl`:
+
+```diff
+ class IFC_PARSE_API FullBufferImpl {
+ public:
+     explicit FullBufferImpl(const std::string& fn);
++    FullBufferImpl(void* data, size_t length);
+```
+
+`src/ifcparse/FileReader.h` — add `FileReader(void*, size_t)` forwarding constructor:
+
+```diff
++    FileReader(void* data, size_t length)
++        : cursor_(0) {
++        if constexpr (std::is_same_v<Impl, FullBufferImpl>) {
++            impl_ = std::make_shared<Impl>(data, length);
++        } else {
++            static_assert(...);
++        }
++    }
+```
+
+`src/ifcparse/FileReader.cpp` — implement the constructor:
+
+```cpp
+FullBufferImpl::FullBufferImpl(void* data, size_t length)
+    : buf_(static_cast<char*>(data), static_cast<char*>(data) + length)
+    , size_(length) {
+}
+```
+
+`src/ifcparse/IfcParse.cpp` — extend the two `InstanceStreamer` constructors to accept `FullBufferImpl`:
+
+```diff
+ // InstanceStreamer(IfcFile*):
++    } else if constexpr (std::is_same_v<Reader, FileReader<FullBufferImpl>>) {
++        owned_stream_ = std::make_unique<Reader>(nullptr, (size_t)0);
+
+ // InstanceStreamer(void*, int, IfcFile*):
++    } else if constexpr (std::is_same_v<Reader, FileReader<FullBufferImpl>>) {
++        owned_stream_ = std::make_unique<Reader>(data, (size_t)length);
+```
+
+# Runtime fix: segfault in `parse_context::push()` due to vector reallocation
+
+`parse_context_pool` stores nodes in a `std::vector<parse_context>`. During parsing, `load()` takes a `parse_context&` parameter and calls `context.push()`, which calls `pool_->make()`. If the pool's vector reallocates (via `emplace_back`), all existing references into the vector — including the `context` reference held by the caller — become dangling. Subsequent access through the dangling reference causes a segfault.
+
+Triggered by larger IFC files (e.g. `ISSUE_159_kleine_Wohnung_R22.ifc`, 9.5 MB) that cause enough pool growth to trigger reallocation.
+
+## Error
+
+```
+Thread 1 received signal SIGSEGV, Segmentation fault.
+0x... in IfcParse::parse_context::push()
+  #1  in_memory_file_storage::load(...)   // context& is dangling after reallocation
+  #2  in_memory_file_storage::load(...)   // parent call
+  #3  InstanceStreamer::readInstance()
+```
+
+## Fix
+
+`src/ifcparse/storage.h` — change the pool container from `std::vector` to `std::deque`, which does not invalidate references on `push_back`/`emplace_back`:
+
+```diff
++#include <deque>
+
+ struct parse_context_pool {
+-    std::vector<parse_context> nodes_;
++    std::deque<parse_context> nodes_;
+```
+
+# Runtime fix: `express::Base` comparison operators throw on null/expired instances
+
+`express::Base::operator<` and `operator==` called `data()`, which throws `std::runtime_error("Trying to access deleted instance reference")` when the internal `weak_ptr` is expired. A default-constructed `express::Base` (the value-type equivalent of a null pointer) always has an expired `weak_ptr`.
+
+## Why this model triggers it
+
+The bug requires two conditions to coincide:
+
+1. A representation is shared by **more than one product** (via `IfcRepresentationMap` / `IfcMappedItem`).
+2. At least one of those products has **no material association**, so `get_single_material_association()` returns `express::Base{}` (the null equivalent).
+
+In `advanced_model.ifc`, Body representations like `#449` (Body/Brep) have a single `IfcRepresentationMap` (`#453`) with 13 `IfcMappedItem` usages, meaning 13 products share the geometry. Some of those products (e.g. `IfcFlowTerminal` instances) have no `IfcRelAssociatesMaterial`, so `get_single_material_association` returns `express::Base{}`.
+
+Smaller or simpler models don't hit this because either:
+- Every representation maps to only 1 product → `reuse_ok_` short-circuits at `products.size() == 1` before reaching the material check.
+- Every product has a material association → no null `express::Base` is ever inserted into the set.
+
+## Exact call sequence
+
+```
+Iterator::initialize()
+  try {
+    mapping::get_representations(reps, filters_)
+      addRepresentationsFromDefaultContexts(representations)
+        → collects reps from subcontexts in order:
+          Axis (#115): 143 reps
+          Body (#117): 7550 reps
+          FootPrint (#119): 12 reps
+
+      for (auto representation : representations):
+
+        ── Axis reps (indices 0–142) ──────────────────────────
+        products_represented_by(rep, rmap)
+          → OfProductRepresentation: 1 product each
+        filter_products(products, filters)   → 1 product
+        reuse_ok_(ifcproducts)
+          → products.size() == 1 → return true  ← SHORT-CIRCUIT, no material check
+        representation_mapped_to(rep)        → null (no MappedItem)
+        → task created.  143 tasks accumulated.
+
+        ── First Body rep #449 (Body/Brep) ────────────────────
+        products_represented_by(#449, rmap)
+          → OfProductRepresentation: empty
+          → RepresentationMap: 1 map (#453)
+          → MapUsage: 13 MappedItems → traces through to 13 IfcProducts
+        filter_products(products, filters)   → 13 products
+        reuse_ok_(ifcproducts)               ← CRASH HERE
+          → products.size() == 1?  NO (13 products)
+          → for each product:
+              find_openings(product)          → OK
+              get_single_material_association(product)
+                → some products have no IfcRelAssociatesMaterial
+                → returns express::Base{}     (expired weak_ptr)
+              associated_single_materials.insert(result)
+                → std::set::insert calls operator<
+                → operator< calls data()
+                → data() calls data_.lock() → expired → THROWS
+                  "Trying to access deleted instance reference"
+
+  } catch (const std::exception& e) {
+    Logger::Error(e)       ← exception caught here, get_representations aborted
+  }
+
+  → reps contains only the 143 Axis tasks created before the throw
+  → all 143 Axis reps have Curve2D geometry → map(representation) returns null
+  → no valid elements produced → initialize() returns false
+```
+
+In the old pointer-based code, `reuse_ok_` used `std::set<const IfcUtil::IfcBaseEntity*>` and `get_single_material_association` returned `nullptr`. Inserting `nullptr` into a `std::set<T*>` is a plain pointer comparison — no dereference, no throw. The refactoring to `std::set<express::Base>` changed the comparison from pointer comparison to `express::Base::operator<`, which unconditionally dereferences through `data()`.
+
+## Error
+
+```
+[Error] Trying to access deleted instance reference
+[Notice] Created 143 tasks for 143 products    ← only Axis reps; all Body reps lost
+initialize() returned: False
+```
+
+## Fix
+
+`src/ifcparse/express.h` — use `weak_ptr::lock().get()` instead of `data()` so that expired pointers compare as `nullptr` (matching old raw-pointer semantics):
+
+```diff
+     bool operator<(const Base& other) const {
+-        return data() < other.data();
++        auto a = data_.lock();
++        auto b = other.data_.lock();
++        return a.get() < b.get();
+     }
+
+     bool operator==(const Base& other) const {
+-        return data() == other.data();
++        auto a = data_.lock();
++        auto b = other.data_.lock();
++        return a.get() == b.get();
+     }
+```
+
+# Runtime fix: `entity_instance` missing `get_inverse` due to SWIG `%rename` collision
+
+Accessing inverse attributes (e.g. `element.IsDecomposedBy`) on any entity raises `AttributeError: entity instance of type 'IFC2X3.IfcProject' has no attribute 'get_inverse'`.
+
+## Why
+
+`entity_instance_mixin.__getattr__` (line 106 of `entity_instance.py`) calls `self.get_inverse(name)` when it detects an inverse attribute. Since the mixin inherits into the SWIG-generated `entity_instance` class (via the `object = custom_base` hack in `IfcParseWrapper.i:936`), `self.get_inverse` must resolve to a method on the SWIG class.
+
+However, `IfcParseWrapper.i:70` has a global rename:
+
+```
+%rename("get_inverses_by_declaration") get_inverse;
+```
+
+This was intended for `ifcopenshell::file::get_inverse` (which takes an entity + declaration and returns instances by reference), but SWIG `%rename` is global — it also renames the `%extend express::Base` method `get_inverse(const std::string& a)` at line 551. So the Python-side `entity_instance` class exposes the method as `get_inverses_by_declaration`, not `get_inverse`.
+
+The old code (`v0.8.0`) didn't hit this because `__getattr__` called `self.wrapped_data.get_inverse(name)` on an inner `ifcopenshell_wrapper.entity_instance` object — but in that old layout, the inner object was constructed differently and the rename didn't apply the same way (or the method had a different path). In the new mixin approach, `self` **is** the SWIG object, so the rename is directly visible.
+
+## Fix
+
+`src/ifcwrap/IfcParseWrapper.i` — override the global rename specifically for `express::Base::get_inverse`, restoring the original name on entity instances:
+
+```diff
++%rename("get_inverse") express::Base::get_inverse;
+ %rename("get_inverses_by_declaration") get_inverse;
+```
+
+Add this line **before** the global rename (or anywhere before the `%extend express::Base` block). This scoped rename takes precedence for `express::Base`, so:
+- `entity_instance.get_inverse(name)` works as the mixin expects
+- `file.get_inverses_by_declaration(...)` keeps its intended name
+
+## Python-side workaround
+
+`entity_instance.py:106` — call the method by its SWIG-renamed name:
+
+```diff
+-            vs = self.get_inverse(name)
++            vs = self.get_inverses_by_declaration(name)
+```
+
+# Runtime fix: `entity_instance` class no longer importable from `entity_instance` module
+
+The class rename from `entity_instance` to `entity_instance_mixin` broke external code that does `from ifcopenshell.entity_instance import entity_instance`.
+
+## Error
+
+```
+ImportError: cannot import name 'entity_instance' from 'ifcopenshell.entity_instance'
+```
+
+Triggered at import time via `ifcopenshell.util.pset` (and likely other modules).
+
+## Fix
+
+`src/ifcopenshell-python/ifcopenshell/entity_instance.py` — add a backwards-compatible alias at the bottom of the module:
+
+```python
+entity_instance = entity_instance_mixin
+```

nix/build-all.py

@@ -1,6 +1,4 @@
 #!/usr/bin/python
-# /// script
-# ///
 ###############################################################################
 #                                                                             #
 # This file is part of IfcOpenShell.                                          #
@@ -50,7 +48,7 @@ Used environment variables:
     - ``NO_CLEAN`` - do not clean `ifcopenshell` build directories but continue working on current build
     (installed dependencies are never cleared).
     By default option is disabled, to enable pass any value from `1`, `on`, `true`.
-    - ``IFCOS_SCHEMAS`` - schemas to be built; defaults to cmake default (8 schemas), to be supplied as `2x3;4;4x3_add2`
+    - ``IFCOS_SCHEMAS`` - schemas to be built; defaults to cmake default (IFC2X3; IFC4; IFC4X3_ADD2) - to be supplied as `2x3;4`
     - ``USE_OCCT`` - whether to use official Open CASCADE instead of Community Edition
     (`true` by default, any other value is considered `false`)
     - ``WASM_PYTHON_PATH`` - path to WASM Python installation,
@@ -126,9 +124,16 @@ 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()
@@ -155,8 +160,10 @@ MPFR_VERSION = "3.1.6"  # latest is 4.1.0
 CGAL_VERSION = "v5.6.3"
 USD_VERSION = "23.05"
 TBB_VERSION = "2021.9.0"
-ROCKSDB_VERSION = "10.4.2"
+ROCKSDB_VERSION = "9.11.2"
 ZSTD_VERSION = "1.5.7"
+MANIFOLD_VERSION = "3.2.1"
+
 # binaries
 cp = "cp"
 bash = "bash"
@@ -325,7 +332,7 @@ cecho(""" - IFC Schemas to compile. If not provided, fallback to default provide
 
 dependency_tree: "dict[str, tuple[str, ...]]" = {
     "IfcParse": ("boost", "libxml2", "hdf5", "rocksdb"),
-    "IfcGeom": ("IfcParse", "occ", "json", "cgal", "eigen", "OpenCOLLADA"),
+    "IfcGeom": ("IfcParse", "occ", "manifold", "json", "cgal", "eigen", "OpenCOLLADA"),
     "IfcConvert": ("IfcGeom",),
     "OpenCOLLADA": ("libxml2", "pcre"),
     "IfcGeomServer": ("IfcGeom",),
@@ -342,6 +349,7 @@ dependency_tree: "dict[str, tuple[str, ...]]" = {
     "eigen": (),
     "rocksdb": ("zstd",),
     "zstd": (),
+    "manifold": (),
     # 'usd': ('boost', 'oneTBB')
 }
 
@@ -578,6 +586,11 @@ def run_cmake(arg1, cmake_args: "list[str]", cmake_dir: Union[str, None] = None,
             ]
         )
 
+    if not any("BUILD_SHARED_LIBS" in f for f in cmake_args):
+        cmake_flags.append(
+            f"-DBUILD_SHARED_LIBS={OFF_ON[not BUILD_STATIC]}",
+        )
+
     run(
         [
             *wasm,
@@ -586,7 +599,6 @@ def run_cmake(arg1, cmake_args: "list[str]", cmake_dir: Union[str, None] = None,
             *cmake_flags,
             *cmake_args,
             f"-DCMAKE_BUILD_TYPE={BUILD_CFG}",
-            f"-DBUILD_SHARED_LIBS={OFF_ON[not BUILD_STATIC]}",
             f"-DCMAKE_SHARED_LINKER_FLAGS={os.environ['LDFLAGS']}",
         ],
         cwd=cwd,
@@ -627,10 +639,9 @@ def build_dependency(
     build_tool_args: "list[str]",
     download_url: str,
     download_name: str,
-    *,
     download_tool: Literal["py", "git"] = download_tool_default,
     revision: "Union[str, None]" = None,
-    patch: list[str] | None = None,
+    patch: "Union[str, list[str], None]" = None,
     shell=None,
     pre_compile_subs: "Sequence[tuple[str, str, str]]" = (),
     additional_files: "Union[dict[str, str], None]" = None,
@@ -715,6 +726,8 @@ def build_dependency(
                 urlretrieve(url, os.path.join(extract_dir, path))
 
     if patch is not None:
+        if isinstance(patch, str):
+            patch = [patch]
         for p in patch:
             patch_abs = (SCRIPT_PATH / p).absolute().__str__()
             if os.path.exists(patch_abs):
@@ -723,8 +736,6 @@ def build_dependency(
                 except Exception as e:
                     # Assert that the patch has already been applied
                     run(["patch", "-p1", "--batch", "--reverse", "--dry-run", "-i", patch_abs], cwd=extract_dir)
-            else:
-                raise FileNotFoundError(patch_abs)
 
     if shell is not None:
         sp.run(shell, shell=True, check=True, cwd=extract_dir)
@@ -990,6 +1001,29 @@ elif "occ" in targets:
         download_name=f"OCE-{OCE_VERSION}.tar.gz",
     )
 
+if "manifold" in targets:
+    dependency_name = f"manifold-{MANIFOLD_VERSION}"
+    build_dependency(
+        name=dependency_name,
+        mode="cmake",
+        build_tool_args=[
+            f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/{dependency_name}",
+            "-DMANIFOLD_PAR=OFF",
+            "-DMANIFOLD_CROSS_SECTION=OFF",
+            "-DMANIFOLD_PYBIND=OFF",
+            "-DMANIFOLD_JSBIND=OFF",
+            "-DMANIFOLD_CBIND=OFF",
+            "-DMANIFOLD_TEST=OFF",
+            "-DMANIFOLD_EXPORT=OFF",
+            "-DMANIFOLD_DOWNLOADS=OFF",
+            *MAC_CROSS_COMPILE_INTEL_ARGS,
+        ],
+        download_url="https://github.com/elalish/manifold.git",
+        download_name="manifold",
+        download_tool=download_tool_git,
+        revision=f"v{MANIFOLD_VERSION}",
+    )
+
 if "libxml2" in targets:
     OLD_CC = ""
     if MAC_CROSS_COMPILE_INTEL:
@@ -1172,14 +1206,6 @@ if "cgal" in targets:
         os.environ["CC"] = MAC_CROSS_COMPILE_INTEL_CC
         gmp_args.extend(MAC_CROSS_COMPILE_INTEL_AUTOCONF_HOST_ARGS)
 
-    # Fixes configure failing to find a working compiler under GCC 15's default -std=gnu23.
-    # Issue presumably will be resolved in any next gmp version, but currently the last one is 6.3.0.
-    # Patch is just applying fix from upstream meantion below:
-    # https://gmplib.org/list-archives/gmp-bugs/2025-February/005561.html
-    gmp_patches = ["./patches/gmp/001-fix-std23.patch"]
-    if GMP_VERSION != "6.3.0":
-        raise Exception(f"GMP_VERSION changed to {GMP_VERSION}, check whether {gmp_patches} is still needed.")
-
     build_dependency(
         name=f"gmp-{GMP_VERSION}",
         mode="autoconf",
@@ -1187,7 +1213,6 @@ if "cgal" in targets:
         pre_compile_subs=(
             [("build/config.h", "HAVE_OBSTACK_VPRINTF 1", "HAVE_OBSTACK_VPRINTF 0")] if "wasm" in flags else []
         ),
-        patch=gmp_patches,
         # Sometimes ftp.gnu.org is very slow, use ftpmirror.gnu.org as a workaround.
         download_url="https://ftpmirror.gnu.org/gnu/gmp/",
         download_name=f"gmp-{GMP_VERSION}.tar.bz2",
@@ -1309,16 +1334,17 @@ if os.environ.get("NO_CLEAN", "").lower() not in {"1", "on", "true"}:
     if os.path.exists(IFCOS_DIR):
         shutil.rmtree(IFCOS_DIR)
 os.makedirs(IFCOS_DIR, exist_ok=True)
-executables_dir = os.path.join(IFCOS_DIR, "executables")
-os.makedirs(executables_dir, exist_ok=True)
+ifcos_build_dir = os.path.join(IFCOS_DIR, "build")
+os.makedirs(ifcos_build_dir, exist_ok=True)
 
 
 cmake_args = [
     "-DUSE_MMAP=OFF",
     "-DBUILD_EXAMPLES=OFF",
-    "-DBUILD_SHARED_LIBS=" + OFF_ON[not BUILD_STATIC],
+    "-DBUILD_SHARED_LIBS=ON",
     "-DGLTF_SUPPORT=ON",
     "-DBoost_NO_BOOST_CMAKE=On",
+    "-DCREATE_BUNDLE=On",
     "-DADD_COMMIT_SHA=" + ("On" if ADD_COMMIT_SHA else "Off"),
     "-DVERSION_OVERRIDE=" + ("On" if ADD_COMMIT_SHA else "Off"),
     *MAC_CROSS_COMPILE_INTEL_ARGS,
@@ -1368,6 +1394,10 @@ elif "occ" in targets:
     occ_library_dir = f"{DEPS_DIR}/install/oce-{OCE_VERSION}/lib"
     cmake_args.extend(["-DOCC_INCLUDE_DIR=" + occ_include_dir, "-DOCC_LIBRARY_DIR=" + occ_library_dir])
 
+if "manifold" in targets:
+    cmake_args_prefix_path.append(f"{DEPS_DIR}/install/manifold-{MANIFOLD_VERSION}")
+    cmake_args.append("-DWITH_MANIFOLD=On")
+
 if "OpenCOLLADA" in targets:
     # pcre is a dependency of OpenCOLLADA, but since we `find_package`,
     # we don't need to add it explicitly here as cmake will find it from the config.
@@ -1413,40 +1443,33 @@ if "rocksdb" in targets:
 if "swig" in targets:
     cmake_args_prefix_path.append(f"{DEPS_DIR}/install/swig-{SWIG_VERSION}")
 
+ifcos_build_args = [
+    f"-DBUILD_IFCGEOM={OFF_ON['IfcGeom' in targets]}",
+    f"-DBUILD_GEOMSERVER={OFF_ON['IfcGeomServer' in targets]}",
+    f"-DBUILD_CONVERT={OFF_ON['IfcConvert' in targets]}",
+    f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell",
+]
+
 if not WASM and (not explicit_targets or {"IfcGeom", "IfcConvert", "IfcGeomServer"} & set(explicit_targets)):
     logger.info("\rConfiguring executables...")
 
     exec_args = [
-        f"-DBUILD_IFCGEOM={OFF_ON['IfcGeom' in targets]}",
-        f"-DBUILD_GEOMSERVER={OFF_ON['IfcGeomServer' in targets]}",
-        f"-DBUILD_CONVERT={OFF_ON['IfcConvert' in targets]}",
+        *ifcos_build_args,
         f"-DBUILD_IFCPYTHON=OFF",
-        f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell",
     ]
 
-    run_cmake("", exec_args + cmake_args + get_cmake_args_prefix_path(), cmake_dir=CMAKE_DIR, cwd=executables_dir)
+    run_cmake("", exec_args + cmake_args + get_cmake_args_prefix_path(), cmake_dir=CMAKE_DIR, cwd=ifcos_build_dir)
 
     logger.info("\rBuilding executables...   ")
 
-    run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "VERBOSE=1"], cwd=executables_dir)
-    run([make, "install/strip" if BUILD_CFG == "Release" else "install"], cwd=executables_dir)
+    run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "VERBOSE=1"], cwd=ifcos_build_dir)
+    run([make, "install/strip" if BUILD_CFG == "Release" else "install"], cwd=ifcos_build_dir)
 
 if "IfcOpenShell-Python" in targets:
-    # On OSX the actual Python library is not linked against.
-    ADDITIONAL_ARGS = ""
+    wrapper_ldflags = ""
     if platform.system() == "Darwin":
-        ADDITIONAL_ARGS = "-Wl,-undefined,dynamic_lookup"
-
-    # NOTE: We don't use `CXXFLAGS` for wrappers, so wrapper is compiled with different flags
-    # (e.g. ` -fdata-sections` is missing, which is set by default for executables)
-    # So cache doesn't match and running build-all.py builds most of ifcopenshell libraries twice.
-    os.environ["CPPFLAGS"] = f"{CXXFLAGS_MINIMAL} {ADDITIONAL_ARGS}"
-    os.environ["CXXFLAGS"] = f"{CXXFLAGS_MINIMAL} {ADDITIONAL_ARGS}"
-    os.environ["CFLAGS"] = f"{CFLAGS_MINIMAL} {ADDITIONAL_ARGS}"
-    os.environ["LDFLAGS"] = f"{LDFLAGS} {ADDITIONAL_ARGS}"
-
-    python_dir = os.path.join(IFCOS_DIR, "pythonwrapper")
-    os.makedirs(python_dir, exist_ok=True)
+        # On OSX the actual Python library is not linked against.
+        wrapper_ldflags = "-Wl,-undefined,dynamic_lookup"
 
     def compile_python_wrapper(
         python_version: str,
@@ -1461,10 +1484,6 @@ if "IfcOpenShell-Python" in targets:
 
         logger.info(f"\rConfiguring python {python_version} wrapper...")
 
-        cache_path = os.path.join(python_dir, "CMakeCache.txt")
-        if os.path.exists(cache_path):
-            os.remove(cache_path)
-
         if python_path:
             # We couldn't just prefix PATH and have to provide all variables explicitly,
             # see ifcwrap/cmake for the details.
@@ -1478,27 +1497,38 @@ if "IfcOpenShell-Python" in targets:
             )
 
         assert python_include
-        run_cmake(
-            "",
-            cmake_args
-            + get_cmake_args_prefix_path()
-            + [
-                *([f"-DPYTHON_EXECUTABLE={python_executable}"] if python_executable else []),
-                # Needed because pyodide is expecting setup.py to be in the root.
-                *([f"-DPYTHON_MODULE_INSTALL_DIR={REPO_PATH}"] * WASM),
-                f"-DPYTHON_INCLUDE_DIR={python_include}",
-                f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell/tmp",
-                "-DUSERSPACE_PYTHON_PREFIX="
-                + ["Off", "On"][os.environ.get("PYTHON_USER_SITE", "").lower() in {"1", "on", "true"}],
-            ],
-            cmake_dir=CMAKE_DIR,
-            cwd=python_dir,
-        )
+        old_ldflags = os.environ["LDFLAGS"]
+        if wrapper_ldflags:
+            os.environ["LDFLAGS"] = f"{old_ldflags} {wrapper_ldflags}"
+
+        try:
+            run_cmake(
+                "",
+                ifcos_build_args
+                + [
+                    "-DBUILD_IFCPYTHON=ON",
+                ]
+                + cmake_args
+                + get_cmake_args_prefix_path()
+                + [
+                    *([f"-DPYTHON_EXECUTABLE={python_executable}"] if python_executable else []),
+                    # Needed because pyodide is expecting setup.py to be in the root.
+                    *([f"-DPYTHON_MODULE_INSTALL_DIR={REPO_PATH}"] * WASM),
+                    f"-DPYTHON_INCLUDE_DIR={python_include}",
+                    f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell/tmp",
+                    "-DUSERSPACE_PYTHON_PREFIX="
+                    + ["Off", "On"][os.environ.get("PYTHON_USER_SITE", "").lower() in {"1", "on", "true"}],
+                ],
+                cmake_dir=CMAKE_DIR,
+                cwd=ifcos_build_dir,
+            )
+        finally:
+            os.environ["LDFLAGS"] = old_ldflags
 
         logger.info(f"\rBuilding python {python_version} wrapper...   ")
 
-        run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "ifcopenshell_wrapper", "VERBOSE=1"], cwd=python_dir)
-        run([make, "install/local"], cwd=os.path.join(python_dir, "ifcwrap"))
+        run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "ifcopenshell_wrapper", "VERBOSE=1"], cwd=ifcos_build_dir)
+        run([make, "install/local"], cwd=os.path.join(ifcos_build_dir, "ifcwrap"))
 
         if python_executable:
             run([python_executable, "-m", "ensurepip"])

nix/cache_dependencies.py

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

nix/patches/gmp/001-fix-std23.patch

@@ -1,27 +0,0 @@
-Fixes configure failing to find a working compiler under GCC 15's default
--std=gnu23 (upstream fix: https://gmplib.org/repo/gmp/rev/8e7bb4ae7a18).
-
-Upstream fix is patching `acinclude.m4`, but since in the release tarball
-all macros are already expanded to `configure` script, so we're patching
-all occurrences of that macro.
-
---- a/configure
-+++ b/configure
-@@ -6568,7 +6568,7 @@
-
- #if defined (__GNUC__) && ! defined (__cplusplus)
- typedef unsigned long long t1;typedef t1*t2;
--void g(){}
-+void g(int,t1 const*,t1,t2,t1 const*,int){}
- void h(){}
- static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
- {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}
-@@ -8187,7 +8187,7 @@
-
- #if defined (__GNUC__) && ! defined (__cplusplus)
- typedef unsigned long long t1;typedef t1*t2;
--void g(){}
-+void g(int,t1 const*,t1,t2,t1 const*,int){}
- void h(){}
- static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
- {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}

nix/patches/occt/88af392.patch

@@ -0,0 +1,32 @@
+http://git.dev.opencascade.org/gitweb/?p=occt.git;a=commitdiff;h=0ab4e621833f4eae945a3762c9a29ee12e2eec53#patch1
+diff --git a/src/HLRBRep/HLRBRep_InternalAlgo.cxx b/src/HLRBRep/HLRBRep_InternalAlgo.cxx
+index ca885ca..c13cb06 100644 (file)
+--- a/src/HLRBRep/HLRBRep_InternalAlgo.cxx
++++ b/src/HLRBRep/HLRBRep_InternalAlgo.cxx
+@@ -165,7 +165,7 @@ void HLRBRep_InternalAlgo::Update ()
+       SB.Bounds(v1,v2,e1,e2,f1,f2);
+ 
+       for (Standard_Integer e = e1; e <= e2; e++) {
+-        HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
++        HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
+         HLRAlgo::DecodeMinMax(ed.MinMax(), TheMin, TheMax);
+        if (FirstTime) {
+          FirstTime = Standard_False;
+@@ -307,7 +307,7 @@ void HLRBRep_InternalAlgo::InitEdgeStatus ()
+   Standard_Integer nf = myDS->NbFaces();
+ 
+   for (Standard_Integer e = 1; e <= ne; e++) {
+-    HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
++    HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
+     if (ed.Selected()) ed.Status().ShowAll();
+   }
+ //  for (Standard_Integer f = 1; f <= nf; f++) {
+@@ -368,7 +368,7 @@ void HLRBRep_InternalAlgo::Select ()
+     Standard_Integer nf = myDS->NbFaces();
+     
+     for (Standard_Integer e = 1; e <= ne; e++) {
+-      HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
++      HLRBRep_EdgeData& ed = aEDataArray.ChangeValue(e);
+       ed.Selected(Standard_True);
+     }
+     

nix/patches/pr622.patch

@@ -0,0 +1,22 @@
+From a0deb4ce8b43cf3c8b8c0a4225c6be5296446dbd Mon Sep 17 00:00:00 2001
+From: Adam Eri <adam.eri@blackmirror.media>
+Date: Tue, 3 Sep 2019 23:30:20 +0200
+Subject: [PATCH] Resolves compile error on macOS
+
+Resolves "no member named 'isnan' in namespace 'std'" on macOS
+---
+ GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp b/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+index 1f9a3eef..dd6f5c59 100644
+--- a/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
++++ b/GeneratedSaxParser/src/GeneratedSaxParserUtils.cpp
+@@ -10,6 +10,7 @@
+ 
+ #include "GeneratedSaxParserUtils.h"
+ #include <math.h>
++#include <cmath>
+ #include <memory>
+ #include <string.h>
+ #include <limits>

pyodide/build_pyodide.sh

@@ -1,11 +1,6 @@
 #!/usr/bin/bash
 set -ex
 
-PYODIDE_VERSION=0.29.3
-PYODIDE_BUILD_VERSION=0.33.0
-PYODIDE_XBUILDENV_ROOT="${HOME}/.cache/.pyodide-xbuildenv-${PYODIDE_BUILD_VERSION}"
-PYODIDE_XBUILDENV="${PYODIDE_XBUILDENV_ROOT}/${PYODIDE_VERSION}"
-
 # Script is assuming that it will be possible to execute it multiple times
 # therefore we're clearing venv each time and ignoring existing 'emsdk' folder.
 
@@ -16,15 +11,14 @@ source .venv/bin/activate
 
 # Install pyodide cross build environment.
 # Instructions: https://pyodide.org/en/stable/development/building-packages.html
-uv pip install "pyodide-build==${PYODIDE_BUILD_VERSION}"
+uv pip install pyodide-build
 # `uv run` is required, so xbuildenv would skip using `pip`.
-uv run pyodide xbuildenv install "${PYODIDE_VERSION}"
+uv run pyodide xbuildenv install
 uv run pyodide xbuildenv install-emscripten
 
-EMSDK_ROOT="${PYODIDE_XBUILDENV}/emsdk"
-source "${EMSDK_ROOT}/emsdk_env.sh"
+EMSDK_ROOT=$(pyodide config get emscripten_dir)
+source ${EMSDK_ROOT}/emsdk_env.sh
 which emcc
-emcc --version
 
 mkdir -p packages/ifcopenshell
 VERSION=`cat IfcOpenShell/VERSION`

pyproject.toml

@@ -1,8 +1,13 @@
 [project]
 name = "IfcOpenShell"
 version = "0.0.0"
-# Don't provide requires-python explicitly
-# allowing pyprojects to set their own (e.g. bonsai and general ifcopenshell version differ).
+dependencies = [
+    "black==26.3.1",
+    "ruff==0.15.9",
+    "poethepoet",
+    "ty==0.0.29",
+    "gersemi==0.26.1",
+]
 
 [tool.black]
 line-length = 120
@@ -38,7 +43,6 @@ exclude = [
 # then they will be inherited by projects' .toml files.
 # This allows using assuming different Python version for different projects.
 [tool.ruff]
-line-length = 120
 exclude = [
     # Submodules.
     "src/ifcopenshell-python/ifcopenshell/express",
@@ -79,39 +83,92 @@ ignore = [
 ]
 
 [tool.ty.rules]
-all = "error"
+all = "ignore"
 
 # Structural rules (no deep type inference needed, easier to adapt).
+abstract-method-in-final-class = "error"
+ambiguous-protocol-member = "error"
+conflicting-declarations = "error"
+conflicting-metaclass = "error"
+cyclic-class-definition = "error"
+cyclic-type-alias-definition = "error"
+dataclass-field-order = "error"
+duplicate-base = "error"
+duplicate-kw-only = "error"
+empty-body = "error"
+escape-character-in-forward-annotation = "error"
+final-on-non-method = "error"
+final-without-value = "error"
+ignore-comment-unknown-rule = "error"
+implicit-concatenated-string-type-annotation = "error"
+inconsistent-mro = "error"
+ineffective-final = "error"
+instance-layout-conflict = "error"
+invalid-dataclass = "error"
+invalid-dataclass-override = "error"
+invalid-enum-member-annotation = "error"
+invalid-explicit-override = "error"
+invalid-frozen-dataclass-subclass = "error"
+invalid-generic-class = "error"
+invalid-generic-enum = "error"
+invalid-ignore-comment = "error"
+invalid-legacy-positional-parameter = "error"
+invalid-legacy-type-variable = "error"
+invalid-named-tuple = "error"
+invalid-newtype = "error"
+invalid-overload = "error"
+invalid-paramspec = "error"
+invalid-protocol = "error"
+invalid-syntax-in-forward-annotation = "error"
+invalid-total-ordering = "error"
+invalid-type-alias-type = "error"
+invalid-type-checking-constant = "error"
+invalid-type-guard-definition = "error"
+invalid-type-variable-bound = "error"
+invalid-type-variable-constraints = "error"
+invalid-typed-dict-header = "error"
+invalid-typed-dict-statement = "error"
+override-of-final-method = "error"
+override-of-final-variable = "error"
+possibly-missing-import = "error"
+possibly-missing-submodule = "error"
 # Has false positives due to ty walrus operator bug.
-possibly-unresolved-reference = "ignore"
-# Maybe later, requires to specify element types for all generics.
-missing-type-argument = "ignore"
-# Conflicts with `bpy` props defined using annotations.
-invalid-type-form = "ignore"
+# possibly-unresolved-reference = "error"
+raw-string-type-annotation = "error"
+redundant-final-classvar = "error"
+shadowed-type-variable = "error"
+subclass-of-final-class = "error"
+super-call-in-named-tuple-method = "error"
+unavailable-implicit-super-arguments = "error"
+unbound-type-variable = "error"
+undefined-reveal = "error"
+unresolved-global = "error"
+unresolved-import = "error"
+unresolved-reference = "error"
+unused-ignore-comment = "error"
+unused-type-ignore-comment = "error"
+useless-overload-body = "error"
 
 # Non-structural rules:
+deprecated = "error"
+zero-stepsize-in-slice = "error"
+possibly-missing-implicit-call = "error"
+unused-awaitable = "error"
+
+# Function argument rules:
 # Conflicts with `ifcopenshell.api.geometry.add_representation` type of callables we have, confusing them with a module.
-call-non-callable = "ignore"
-# bpy is missing some context manager implementations.
-invalid-context-manager = "ignore"
-# Doesn't go well with `bpy.ops.xxx.yyy`.
-unresolved-attribute = "ignore"
+# call-non-callable = "error"
+conflicting-argument-forms = "error"
 # Too many false positives.
-invalid-argument-type = "ignore"
-invalid-method-override = "ignore"
-invalid-assignment = "ignore"
-invalid-parameter-default = "ignore"
-missing-override-decorator = "ignore"
-invalid-yield = "ignore"
-invalid-return-type = "ignore"
-non-callable-init-subclass = "ignore"
-not-iterable = "ignore"
-possibly-missing-attribute = "ignore"
-no-matching-overload = "ignore"
-not-subscriptable = "ignore"
-unsupported-dynamic-base = "ignore"
-unsupported-operator = "ignore"
-type-assertion-failure = "ignore"
+# invalid-argument-type = "error"
+missing-argument = "error"
+parameter-already-assigned = "error"
+positional-only-parameter-as-kwarg = "error"
+too-many-positional-arguments = "error"
+unknown-argument = "error"
+# Has a lot of warnings due to current ty walrus operator issues.
+# index-out-of-bounds = "error"
+# unresolved-attribute = "error"
 
 [tool.ty.environment]
 extra-paths = [
@@ -158,19 +215,10 @@ exclude = [
 
 [tool.poe.tasks]
 
-dev-setup.sequence = [
-    {cmd = "uv sync"},
-    {cmd = "uv pip install -e ./src/bsdd/"},
-    {cmd = "uv pip install -e ./src/ifcopenshell-python/[advanced,dev]"},
-    {cmd = "uv pip install -e ./src/ifcedit/"},
-    {cmd = "uv pip install -e ./src/ifcpatch/"},
-    {cmd = "uv pip install -e ./src/ifcquery/"},
-    {cmd = "uv pip install -e './src/ifcmcp/[mcp]'"},
-    {cmd = "uv pip install -r src/bonsai/requirements-dev.txt"},
-]
-dev-setup.help = "Install repo packages in editable mode"
-
-ruff = "ruff check"
+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"]
 
 black = "black ."
 
@@ -190,7 +238,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"]
+format.sequence = ["black", "ruff-main", "ruff-old"]
 
 cmake-format = "gersemi . --in-place"
 
@@ -198,7 +246,6 @@ cmake-format = "gersemi . --in-place"
 # --ignore unresolved-reference: walrus operator false positives in ty.
 cmd = """
     ty check
-    nix/
     src/bcf
     src/bsdd
     src/ifc2ca

requirements-tools.txt

@@ -1,5 +0,0 @@
-black==26.3.1
-ruff==0.15.12
-poethepoet
-ty==0.0.59
-gersemi==0.26.1

src/bcf/bcf/v2/visinfo.py

@@ -316,7 +316,7 @@ def build_viewpoint(element: entity_instance) -> mdl.VisualizationInfo:
     Returns:
         The BCF viewpoint definition.
     """
-    ifc_file = element.wrapped_data.file
+    ifc_file = element.file
     unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
     elem_placement = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
     elem_placement[:3, 3] *= unit_scale

src/bcf/bcf/v3/visinfo.py

@@ -316,7 +316,7 @@ def build_viewpoint(element: entity_instance) -> mdl.VisualizationInfo:
     Returns:
         The BCF viewpoint definition.
     """
-    ifc_file = element.wrapped_data.file
+    ifc_file = element.file
     unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
     elem_placement = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
     elem_placement[:3, 3] *= unit_scale

src/bonsai/Makefile

@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 SHELL := sh
-PYTHON:=python3
-PIP:=pip3
+PYTHON:=python3.11
+PIP:=pip3.11
 PATCH:=patch
 SED:=sed -i
 VENV_ACTIVATE:=bin/activate
@@ -106,7 +106,7 @@ endif
 endif # def PLATFORM
 
 # Current build commit hash.
-OLD:=3e7b739
+OLD:=1c5b825
 .PHONY: bump
 bump:
 ifndef NEW
@@ -192,11 +192,7 @@ endif
 	# Provides networkx graph analysis for project dependency calculations
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download networkx --dest=./wheels
 	# Required by IFCDiff
-	# Pinned <9.1: deepdiff 9.1.0 adds cachebox<6,>=5.2 which only ships macOS x86_64
-	# wheels for macosx_10_12+ and is incompatible with our macos py311 --platform
-	# macosx_10_10_x86_64 target. Revisit once the macos py311 platform tag is bumped
-	# to 10_13 (matching py312/py313).
-	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download "deepdiff<9.1" --dest=./wheels
+	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download deepdiff --dest=./wheels
 	# Required by IFCCSV and ifcopenshell.util.selector
 	cd build && . env/$(VENV_ACTIVATE) && $(PIP) download lark --dest=./wheels
 	# Required by IFC4D
@@ -360,10 +356,6 @@ else
 	pytest test/tool/test_$(MODULE).py --maxfail=1
 endif
 
-.PHONY: test-modal
-test-modal:
-	blender --enable-event-simulate --python test/modal/test_modal.py --window-maximized
-
 # Reregistering test is not added to the standard test suite because during unregister
 # Blender removes all Bonsai dependencies breaking dev-environment symlinks.
 .PHONY: test-reregister

src/bonsai/bonsai/bim/__init__.py

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import importlib
 import os
@@ -27,7 +25,7 @@ import bpy
 import bpy.utils.previews
 from bpy_extras.io_utils import ExportHelper, ImportHelper
 
-from . import handler, operator, parametric_lifecycle, prop, ui
+from . import handler, operator, prop, ui
 
 try:
     from bonsai.translations import translations_dict
@@ -90,7 +88,6 @@ modules = {
     "web": None,
     "light": None,
     "alignment": None,
-    "clip_box": None,
     # Uncomment this line to enable loading of the demo module. Happy hacking!
     # The name "demo" must correlate to a folder name in `bim/module/`.
     # "demo": None,
@@ -160,6 +157,9 @@ classes = [
     ui.BIM_UL_tab_visibilities,
     ui.BIM_UL_panel_visibilities,
     ui.DocPreferences,
+    ui.GizmoPreferencesDoor,  # Register before GizmoPreferences
+    ui.GizmoPreferencesWindow,  # Register before GizmoPreferences
+    ui.GizmoPreferencesStair,  # Register before GizmoPreferences
     ui.GizmoPreferences,
     # ui.DefaultParameters and ui.BIM_ADDON_preferences are registered separately after modules (see late_classes below)
     # Tabs panel
@@ -268,8 +268,6 @@ def register():
     bpy.app.handlers.depsgraph_update_post.append(on_register)
     bpy.app.handlers.undo_post.append(handler.undo_post)
     bpy.app.handlers.redo_post.append(handler.redo_post)
-    # Must follow the two appends above so regenerators see restored IFC state.
-    parametric_lifecycle.install_parametric_lifecycle_handlers()
     bpy.app.handlers.load_post.append(handler.load_post)
     bpy.app.handlers.load_post.append(handler.loadIfcStore)
     bpy.types.Scene.BIMProperties = bpy.props.PointerProperty(type=prop.BIMProperties)
@@ -327,7 +325,6 @@ def unregister():
 
     unregister_classes(classes)
 
-    parametric_lifecycle.uninstall_parametric_lifecycle_handlers()
     bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.app.handlers.load_post.remove(handler.loadIfcStore)
     del bpy.types.Scene.BIMProperties

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

@@ -1,96 +0,0 @@
-Copyright (c) 2011-2012, Nikita Volchenkov (<nikitavolchenkov@gmail.com>),
-with Reserved Font Name OpenGost Type B.
-
-Copyright (c) 2012, Valek Filippov (<frob@gnome.org>).
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.

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

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

src/bonsai/bonsai/bim/decorator_cache.py

@@ -1,119 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Shared structural-change cache token for POST_VIEW decorators.
-
-Decorators include the token in their cache key and rebuild on bump."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any, Generic, TypeVar
-
-import bpy
-
-T = TypeVar("T")
-
-_DECORATOR_CACHE_TOKEN = 0
-
-
-def get_decorator_cache_token() -> int:
-    return _DECORATOR_CACHE_TOKEN
-
-
-def reset_for_test() -> None:
-    """Test-only: reset the cache token to 0 so bump-count assertions are stable."""
-    global _DECORATOR_CACHE_TOKEN
-    _DECORATOR_CACHE_TOKEN = 0
-
-
-@bpy.app.handlers.persistent
-def _bump_decorator_cache_token(*args: Any) -> None:
-    """depsgraph_update_post fires every animation frame and every driver
-    evaluation, even when no IFC-relevant ID block changed. Unconditional
-    bumping defeats the cache: an animated scene rebuilds every decorator
-    every viewport tick. Gate the depsgraph path on Object geometry or
-    transform updates; undo / redo / load have no depsgraph and always
-    invalidate.
-
-    Coverage assumption: ``TokenCache`` consumers key on Object identity
-    (depsgraph updates whose ``id`` is a ``bpy.types.Object``). Mesh /
-    Material / NodeTree updates that don't surface as an Object change
-    do NOT invalidate the token — a decorator that caches material- or
-    mesh-data-derived state must gate on a separate signal."""
-    global _DECORATOR_CACHE_TOKEN
-    if len(args) >= 2:
-        depsgraph = args[1]
-        if depsgraph is not None and hasattr(depsgraph, "updates"):
-            if not any(
-                (getattr(u, "is_updated_geometry", False) or getattr(u, "is_updated_transform", False))
-                and hasattr(u, "id")
-                and isinstance(u.id, bpy.types.Object)
-                for u in depsgraph.updates
-            ):
-                return
-    _DECORATOR_CACHE_TOKEN += 1
-
-
-def _hooks() -> tuple[Any, ...]:
-    return (
-        bpy.app.handlers.depsgraph_update_post,
-        bpy.app.handlers.undo_post,
-        bpy.app.handlers.redo_post,
-        bpy.app.handlers.load_post,
-    )
-
-
-def install_decorator_cache_handlers() -> None:
-    """Append the bump handler to each hook; idempotent."""
-    for hook in _hooks():
-        if _bump_decorator_cache_token not in hook:
-            hook.append(_bump_decorator_cache_token)
-
-
-def uninstall_decorator_cache_handlers() -> None:
-    for hook in _hooks():
-        try:
-            hook.remove(_bump_decorator_cache_token)
-        except ValueError:
-            pass
-
-
-class TokenCache(Generic[T]):
-    """Memoise a single value keyed on ``(caller_key, get_decorator_cache_token())``.
-
-    The token component invalidates the cache on depsgraph / undo / redo / load,
-    so cached ``bpy.types.Object`` references can't outlive the underlying ID
-    blocks. Holds exactly one entry — last key wins."""
-
-    __slots__ = ("_key", "_value")
-
-    def __init__(self) -> None:
-        self._key: tuple[Any, int] | None = None
-        self._value: T | None = None
-
-    def get_or_compute(self, key: Any, compute: Callable[[], T]) -> T:
-        token_key = (key, _DECORATOR_CACHE_TOKEN)
-        if token_key == self._key:
-            return self._value  # type: ignore[return-value]
-        value = compute()
-        self._key = token_key
-        self._value = value
-        return value

src/bonsai/bonsai/bim/handler.py

@@ -15,12 +15,11 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import os
 import weakref
 from collections.abc import Callable
+from math import cos
 from typing import Union
 
 import bpy
@@ -32,32 +31,16 @@ from bpy.app.handlers import persistent
 from mathutils import Vector
 
 import bonsai.bim
-import bonsai.core.model as core_model
 import bonsai.tool as tool
-from bonsai.bim.decorator_cache import (
-    install_decorator_cache_handlers,
-    uninstall_decorator_cache_handlers,
-)
-from bonsai.bim.ifc import IfcStore, get_cache_or_detect_lock
+from bonsai.bim.ifc import IfcStore
 from bonsai.bim.module.aggregate.decorator import AggregateDecorator
 from bonsai.bim.module.georeference.decorator import GeoreferenceDecorator
-from bonsai.bim.module.model.array import (
-    ArrayPreviewDecorator,
-    ArraySelectionHighlightDecorator,
-)
 from bonsai.bim.module.model.data import AuthoringData
 from bonsai.bim.module.model.decorator import (
-    BendPreviewDecorator,
     BoundingBoxDecorator,
-    DoorSwingReadonlyDecorator,
-    MEPSegmentExtendPreviewDecorator,
-    MEPSystemPathDecorator,
     SlabDirectionDecorator,
     WallAxisDecorator,
-    WallFilletPreviewDecorator,
-    WallSystemPathDecorator,
 )
-from bonsai.bim.module.model.wall import WallGizmoPreviewDecorator
 from bonsai.bim.module.nest.decorator import NestDecorator
 
 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -125,13 +108,19 @@ def active_object_callback():
 
 
 def update_bim_tool_props():
-    """Selection-driven BIM Tool sync: re-target user-intent enums
-    (ifc_class, relating_type_id) AND refresh header values
-    (extrusion_depth, length, x_angle) for the new active object."""
-    ctx = _resolve_bim_tool_context()
-    if ctx is None:
+    """update BIM Tools props (such as extrusion_depth, length and x_angle) when active object changes"""
+    obj = bpy.context.active_object
+
+    # bunch of checks to see if we're in a valid state
+    if not obj:
+        return
+    mode = bpy.context.mode
+    current_tool = bpy.context.workspace.tools.from_space_view3d_mode(mode)
+    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
+        return
+    element = tool.Ifc.get_entity(obj)
+    if not element:
         return
-    obj, current_tool, element = ctx
 
     props = tool.Model.get_model_props()
     aprops = tool.Drawing.get_annotation_props()
@@ -144,85 +133,18 @@ def update_bim_tool_props():
 
             if is_annotation_tool and (object_type := tool.Drawing.get_annotation_type_object_type(element_type)):
                 aprops.object_type = object_type
-                try:
-                    aprops.relating_type_id = str(element_type.id())
-                except TypeError:
-                    # EnumProperty items are rebuilt asynchronously when ifc_class changes;
-                    # this assignment can race a stale item list. Skipping is harmless —
-                    # the UI will resync on the next active_object_callback.
-                    pass
+                aprops.relating_type_id = str(element_type.id())
                 return
 
             if is_bim_tool:
-                try:
-                    props.ifc_class = element_type.is_a()
-                except TypeError:
-                    # ifc_class only lists element/space types present in the model, so an
-                    # unsupported type (e.g. a raw IfcTypeProduct) or a stale item list mid-
-                    # rebuild raises `enum "<class>" not found`. Skip rather than crash the
-                    # handler — it re-fires on the next selection and the panel resyncs.
-                    pass
+                props.ifc_class = element_type.is_a()
 
-            # Only assign when the target enum is the one that lists this type — otherwise
-            # we hit `enum "<id>" not found in (...)` if the user selects an element of a
-            # different class than the workspace tool was built for (e.g. selecting a wall
-            # while the door tool is active).
-            tool_class_match = TOOLS_TO_CLASSES_MAP.get(current_tool.idname) == element_type.is_a()
-            bim_tool_class_match = is_bim_tool and props.ifc_class == element_type.is_a()
-            if bim_tool_class_match or tool_class_match:
-                try:
-                    props.relating_type_id = str(element_type.id())
-                except TypeError:
-                    # Defensive: the enum item list can lag behind ifc_class assignment
-                    # above. Skipping leaves the panel briefly out of sync rather than
-                    # crashing the handler (which Blender re-fires on every selection).
-                    pass
+            if is_bim_tool or TOOLS_TO_CLASSES_MAP.get(current_tool.idname) == element_type.is_a():
+                props.relating_type_id = str(element_type.id())
 
     if is_annotation_tool:
         return
 
-    _read_headers_into_props(obj, element)
-
-
-def refresh_bim_tool_headers():
-    """Push the active IFC entity's current header float values
-    (extrusion_depth, length, x_angle) into ``BIMModelProperties``.
-    Enum-safe: never writes user-intent enum slots, which are owned by
-    the selection callback."""
-    ctx = _resolve_bim_tool_context()
-    if ctx is None:
-        return
-    obj, current_tool, element = ctx
-    if current_tool.idname not in tool.Blender.get_property_header_tools():
-        return
-    _read_headers_into_props(obj, element)
-
-
-def _resolve_bim_tool_context():
-    """Return ``(obj, current_tool, element)`` when an active BIM workspace
-    tool sees a resolvable IFC element; ``None`` otherwise. Defensive
-    against stripped operator contexts — a missing ``active_object`` /
-    ``mode`` / ``workspace`` short-circuits to ``None`` instead of raising."""
-    obj = tool.Blender.get_active_object()
-    if not obj:
-        return None
-    mode = getattr(bpy.context, "mode", None)
-    workspace = getattr(bpy.context, "workspace", None)
-    if mode is None or workspace is None:
-        return None
-    current_tool = workspace.tools.from_space_view3d_mode(mode)
-    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
-        return None
-    element = tool.Ifc.get_entity(obj)
-    if not element:
-        return None
-    return obj, current_tool, element
-
-
-def _read_headers_into_props(obj, element):
-    """Populate ``BIMModelProperties`` header values from the active
-    object's IFC extrusion. Enum-safe: writes only header floats, never
-    user-intent enum slots, so it is safe to call on the post-commit hook."""
     representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
     if not representation:
         return
@@ -240,13 +162,10 @@ def _read_headers_into_props(obj, element):
     if not AuthoringData.is_loaded:
         AuthoringData.load()
 
-    props = tool.Model.get_model_props()
     if AuthoringData.data["active_material_usage"] == "LAYER2":
         x_angle = get_x_angle(extrusion)
         axis = tool.Model.get_wall_axis(obj)["reference"]
-        props.extrusion_depth = core_model.vertical_height_from_extrusion_depth(
-            extrusion.Depth * si_conversion, x_angle
-        )
+        props.extrusion_depth = abs(extrusion.Depth * si_conversion * cos(x_angle))
         props.length = (axis[1] - axis[0]).length
         props.x_angle = x_angle
 
@@ -320,11 +239,9 @@ def loadIfcStore(scene: bpy.types.Scene) -> None:
     IfcStore.purge()
     refresh_ui_data()
     if not tool.Ifc.get():
-        tool.Autosave.cancel_timer()
         return
     tool.Ifc.schema()
     IfcStore.relink_all_objects()
-    tool.Autosave.reset_timer()
 
 
 @persistent
@@ -439,10 +356,8 @@ def subscribe_to_viewport_shading_changes():
             )
 
 
-def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
-    """Invariants enforced on every load_post: msgbus subscription, IFC owner
-    settings, scene-bound caches, load-transient parametric state, and the
-    multi-instance lock probe."""
+@persistent
+def load_post(scene):
     global global_subscription_owner
     active_object_key = bpy.types.LayerObjects, "active"
     bpy.msgbus.subscribe_rna(
@@ -453,23 +368,6 @@ def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
     ifcopenshell.api.owner.settings.get_application = get_application
     AuthoringData.type_thumbnails = {}
 
-    tool.Parametric.on_load_post(scene)
-
-    if tool.Ifc.get() and bpy.data.is_saved:
-        props = tool.Blender.get_bim_props()
-        props.has_blend_warning = True
-
-    # Probe the H5 cooked-geometry cache so the multi-instance warning surfaces
-    # right after .blend load. Without this, the lock is only detected when a
-    # mutation triggers ``clear_cache`` — by which time the user has already
-    # made changes that may now conflict with the other Blender instance.
-    if tool.Ifc.get():
-        get_cache_or_detect_lock()
-
-
-def _apply_user_preferences() -> None:
-    """User-preference-driven UI setup: toolbar, BIM workspace, viewport shading
-    subscription, scene-panel hijack, tab layout, snap defaults."""
     preferences = tool.Blender.get_addon_preferences()
     if not preferences.should_setup_toolbar:
         tool.Blender.unregister_toolbar()
@@ -493,21 +391,11 @@ def _apply_user_preferences() -> None:
         tool.Blender.override_scene_panel(panel)
     tool.Blender.setup_tabs()
 
-    if preferences.should_use_snap and (scene := bpy.context.scene):
-        # Snapping is off by default in Blender, but in BIM, it's more useful to be on
-        scene.tool_settings.use_snap = True
-        # Match default Bonsai snaps
-        scene.tool_settings.snap_elements_base = {"EDGE", "EDGE_PERPENDICULAR", "VERTEX", "EDGE_MIDPOINT", "FACE"}
+    if tool.Ifc.get() and bpy.data.is_saved:
+        props = tool.Blender.get_bim_props()
+        props.has_blend_warning = True
 
-    tool.Blender.sync_old_preferences()
-
-
-def _install_viewport_overlays() -> None:
-    """Sync every Bonsai viewport decorator to its enabled state.
-
-    Wrapped in uninstall/install of the decorator-cache bump handlers so a
-    decorator's own install path doesn't double-bind to depsgraph_update_post
-    via ``TokenCache`` instances created during their own ``install()``."""
+    # Bonsai overlays
     georeference_props = tool.Georeference.get_georeference_props()
     aggregate_props = tool.Aggregate.get_aggregate_props()
     nest_props = tool.Nest.get_nest_props()
@@ -517,62 +405,23 @@ def _install_viewport_overlays() -> None:
     NestDecorator.uninstall()
     WallAxisDecorator.uninstall()
     SlabDirectionDecorator.uninstall()
-    MEPSystemPathDecorator.uninstall()
-    WallSystemPathDecorator.uninstall()
-    WallFilletPreviewDecorator.uninstall()
-    BendPreviewDecorator.uninstall()
-    MEPSegmentExtendPreviewDecorator.uninstall()
-    WallGizmoPreviewDecorator.uninstall()
-    DoorSwingReadonlyDecorator.uninstall()
-    ArrayPreviewDecorator.uninstall()
-    ArraySelectionHighlightDecorator.uninstall()
-    uninstall_decorator_cache_handlers()
-    try:
-        if georeference_props.should_visualise:
-            GeoreferenceDecorator.install(bpy.context)
-        if aggregate_props.aggregate_decorator:
-            AggregateDecorator.install(bpy.context)
-        if nest_props.nest_decorator:
-            NestDecorator.install(bpy.context)
-        if model_props.show_wall_axis:
-            WallAxisDecorator.install(bpy.context)
-        if model_props.show_slab_direction:
-            SlabDirectionDecorator.install(bpy.context)
-        if model_props.show_paths:
-            MEPSystemPathDecorator.install(bpy.context)
-            WallSystemPathDecorator.install(bpy.context)
-        if model_props.show_bounding_box:
-            BoundingBoxDecorator.install(bpy.context)
-        # Always-installed: draw() self-polls on Scene.BIMPreviewProperties.
-        # wall_fillet.is_active, so installation has no cost when no preview
-        # is open. No corresponding addon-preference toggle.
-        WallFilletPreviewDecorator.install(bpy.context)
-        # Always-installed siblings of WallFilletPreviewDecorator: each
-        # self-polls on its own scene.BIMPreviewProperties subgroup or on
-        # selection + hover gizmo state — zero cost when nothing is active.
-        BendPreviewDecorator.install(bpy.context)
-        MEPSegmentExtendPreviewDecorator.install(bpy.context)
-        # Always-installed: draw_lines() self-polls on selection + hover state
-        # for join / extend-to-wall / cursor-extend / cursor-split previews.
-        # Free when no preview-eligible state is active.
-        WallGizmoPreviewDecorator.install(bpy.context)
-        # Always-installed: draw() self-polls on active object + IfcDoor +
-        # parametric pset, so the cost is one bpy/IFC lookup per redraw when
-        # nothing eligible is selected.
-        DoorSwingReadonlyDecorator.install(bpy.context)
-        # Always-installed: draw() self-polls on the active object's array
-        # family membership, so installation has no cost when no array
-        # element is selected.
-        ArraySelectionHighlightDecorator.install(bpy.context)
-        # Always-installed: draw() self-polls on props.is_editing — only
-        # paints during an active array edit lifecycle.
-        ArrayPreviewDecorator.install(bpy.context)
-    finally:
-        install_decorator_cache_handlers()
+    if georeference_props.should_visualise:
+        GeoreferenceDecorator.install(bpy.context)
+    if aggregate_props.aggregate_decorator:
+        AggregateDecorator.install(bpy.context)
+    if nest_props.nest_decorator:
+        NestDecorator.install(bpy.context)
+    if model_props.show_wall_axis:
+        WallAxisDecorator.install(bpy.context)
+    if model_props.show_slab_direction:
+        SlabDirectionDecorator.install(bpy.context)
+    if model_props.show_bounding_box:
+        BoundingBoxDecorator.install(bpy.context)
 
+    if preferences.should_use_snap and (scene := bpy.context.scene):
+        # Snapping is off by default in Blender, but in BIM, it's more useful to be on
+        scene.tool_settings.use_snap = True
+        # Match default Bonsai snaps
+        scene.tool_settings.snap_elements_base = {"EDGE", "EDGE_PERPENDICULAR", "VERTEX", "EDGE_MIDPOINT", "FACE"}
 
-@persistent
-def load_post(scene):
-    _apply_save_file_invariants(scene)
-    _apply_user_preferences()
-    _install_viewport_overlays()
+    tool.Blender.sync_old_preferences()

src/bonsai/bonsai/bim/helper.py

@@ -187,7 +187,7 @@ def import_attributes(
         info = {a.name(): None for a in attributes}
         info["type"] = element
     else:
-        assert (entity := element.wrapped_data.declaration().as_entity())
+        assert (entity := element.declaration().as_entity())
         attributes = entity.all_attributes()
         info = element.get_info()
     for attribute in attributes:

src/bonsai/bonsai/bim/ifc.py

@@ -46,7 +46,7 @@ IFC_CONNECTED_TYPE = Union[bpy.types.Material, bpy.types.Object]
 class OperationData(TypedDict):
     id: int
     guid: NotRequired[str]
-    obj: NotRequired[str]
+    obj: str
 
 
 class EditObjectOperationData(TypedDict):
@@ -64,44 +64,6 @@ class TransactionStep(TypedDict):
     operations: list[Operation]
 
 
-# Set when ``IfcStore.get_cache`` observes an external lock on the HDF5 cache —
-# signal that another Blender process has the same IFC file open. Project panel
-# polls ``is_cache_locked_by_other_process`` to warn the user. The dismissed
-# flag is sticky per-session so the warning doesn't re-nag once the user has
-# acknowledged it.
-_cache_locked_by_other_process: bool = False
-_multi_instance_warning_dismissed: bool = False
-
-
-def is_cache_locked_by_other_process() -> bool:
-    return _cache_locked_by_other_process and not _multi_instance_warning_dismissed
-
-
-def dismiss_multi_instance_warning() -> None:
-    global _multi_instance_warning_dismissed
-    _multi_instance_warning_dismissed = True
-
-
-def get_cache_or_detect_lock() -> ifcopenshell.geom.serializers.hdf5 | None:
-    """Like ``IfcStore.get_cache`` but tracks the multi-instance lock flag — sets
-    it on ``PermissionError``, clears it (along with the dismiss flag) when a
-    subsequent call succeeds. Returns ``None`` on lock; other exceptions
-    propagate. Callers that don't need the warning side effect can use
-    ``IfcStore.get_cache`` directly."""
-    global _cache_locked_by_other_process, _multi_instance_warning_dismissed
-    try:
-        cache = IfcStore.get_cache()
-    except PermissionError:
-        _cache_locked_by_other_process = True
-        return None
-    if _cache_locked_by_other_process:
-        # Lock released — clear both flags so a future re-locking re-surfaces
-        # the warning rather than staying suppressed by the previous dismiss.
-        _cache_locked_by_other_process = False
-        _multi_instance_warning_dismissed = False
-    return cache
-
-
 class IfcStore:
     path: str = ""
     """Should be set only using ``tool.Ifc.set_path``."""
@@ -234,7 +196,7 @@ class IfcStore:
                 shutil.copy2(IfcStore.cache_path, new_cache_path)
             except PermissionError:
                 pass  # Well we tried. No cache for you!
-        get_cache_or_detect_lock()
+        IfcStore.get_cache()
 
     @staticmethod
     def load_file(path: str) -> None:
@@ -552,7 +514,6 @@ class IfcStore:
                     BrickStore.end_transaction()
                 IfcStore.end_transaction(operator)
                 bonsai.bim.handler.refresh_ui_data()
-                tool.Parametric.refresh_post_commit(operator)
 
                 if method == "MODAL":
                     cls.modal_in_progress = False
@@ -566,19 +527,6 @@ class IfcStore:
                 result = getattr(operator, "_modal")(context, event)
         except:
             bonsai.last_error = traceback.format_exc()
-            # An operator that mutated IFC then raised leaves the IFC graph captured
-            # by the transaction but the Blender side stale. Blender does not push an
-            # undo step for a raised operator (mirror of the CANCELLED-modal gap
-            # handled below), so we push one here so Ctrl+Z actually rewinds the
-            # partial mutation, then surface the recovery path to the user.
-            ifc_file = tool.Ifc.get()
-            if ifc_file and ifc_file.transaction and ifc_file.transaction.operations:
-                bpy.ops.ed.undo_push(message=f"Recover {operator.bl_idname}")
-                operator.report(
-                    {"WARNING"},
-                    "Operation partially completed (IFC changed, Blender state may be stale). "
-                    "Press Ctrl+Z to restore the previous state.",
-                )
             # Try to ensure undo will work since Blender undo does work in case of errors.
             # As error come unexpectedly, it's important that user might have a chance to save the file
             # before they got the error and not to lose the work they've done.

src/bonsai/bonsai/bim/import_ifc.py

@@ -223,7 +223,6 @@ class IfcImporter:
         self.elements: set[ifcopenshell.entity_instance] = set()
         self.annotations: set[ifcopenshell.entity_instance] = set()
         self.gross_elements: set[ifcopenshell.entity_instance] = set()
-        self.broken_arrays: set[ifcopenshell.entity_instance] = set()
         self.element_types: set[ifcopenshell.entity_instance] = set()
         self.spatial_elements: set[ifcopenshell.entity_instance] = set()
         self.meshes: dict[str, OBJECT_DATA_TYPE] = {}
@@ -980,13 +979,8 @@ class IfcImporter:
                     if unit.Name == "METRE":
                         if not unit.Prefix:
                             bpy.context.scene.unit_settings.length_unit = "METERS"
-                        elif f"{unit.Prefix}METERS" in ("KILOMETERS", "CENTIMETERS", "MILLIMETERS", "MICROMETERS"):
-                            bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
                         else:
-                            # Blender's length_unit enum has no entry for other
-                            # SI prefixes (e.g. DECIMETERS), so fall back to
-                            # adaptive display instead of failing to open.
-                            bpy.context.scene.unit_settings.length_unit = "ADAPTIVE"
+                            bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
                 else:
                     bpy.context.scene.unit_settings.system = "IMPERIAL"
                     name = unit.Name.lower()
@@ -1225,18 +1219,8 @@ class IfcImporter:
                         if element not in elements_to_import:
                             continue
                     for i in range(len(data)):
-                        tool.Array.set_children_lock_state(element, i, True)
-                    tool.Array.constrain_children_to_parent(element)
-                    for layer in data:
-                        for child_guid in layer.get("children", ()):
-                            try:
-                                self.file.by_guid(child_guid)
-                            except RuntimeError:
-                                print(
-                                    f"setup_arrays: array parent {element.GlobalId} references missing "
-                                    f"child GUID {child_guid!r}."
-                                )
-                                self.broken_arrays.add(element)
+                        tool.Blender.Modifier.Array.set_children_lock_state(element, i, True)
+                        tool.Blender.Modifier.Array.constrain_children_to_parent(element)
 
     def update_linked_aggregates(self):
         # TODO Remove this after a while. See commit 17d6b8a

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

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

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

@@ -139,7 +139,6 @@ class BIMAggregateProperties(PropertyGroup):
     previous_editing_aggregate: PointerProperty(name="Editing Aggregate", type=bpy.types.Object)
     editing_objects: CollectionProperty(type=Objects)
     not_editing_objects: CollectionProperty(type=Objects)
-    previously_selected_objects: CollectionProperty(type=Objects)
     aggregate_decorator: BoolProperty(
         name="Display Aggregate",
         default=False,
@@ -156,6 +155,5 @@ class BIMAggregateProperties(PropertyGroup):
         previous_editing_aggregate: Union[bpy.types.Object, None]
         editing_objects: bpy.types.bpy_prop_collection_idprop[Objects]
         not_editing_objects: bpy.types.bpy_prop_collection_idprop[Objects]
-        previously_selected_objects: bpy.types.bpy_prop_collection_idprop[Objects]
         aggregate_decorator: bool
         previous_state: bool

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

@@ -48,14 +48,12 @@ def draw_ui(context: bpy.types.Context, layout: bpy.types.UILayout, attributes)
         row = layout.row()
         op = row.operator("bim.enable_editing_attributes", icon="GREASEPENCIL", text="Edit")
 
-        element = tool.Ifc.get_entity(obj)
-        key_prefix = "type." if (element and element.is_a("IfcTypeObject")) else ""
         for attribute in attributes:
             row = layout.row(align=True)
             row.label(text=attribute["name"])
             value = bonsai.bim.helper.get_display_value(attribute["value"])
             op = row.operator("bim.select_similar", text=value, icon="NONE", emboss=False)
-            op.key = key_prefix + attribute["name"]
+            op.key = attribute["name"]
 
     # TODO: reimplement, see #1222
     # if "IfcSite/" in context.active_object.name or "IfcBuilding/" in context.active_object.name:

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

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

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

@@ -156,13 +156,16 @@ class BrickschemaReferencesData:
         for rel in getattr(tool.Ifc.get_entity(bpy.context.active_object), "HasAssociations", []):
             if rel.is_a("IfcRelAssociatesLibrary"):
                 reference = rel.RelatingLibrary
-                identification = tool.Document.get_external_reference_id(reference)
-                if not identification or "#" not in identification:
+                if tool.Ifc.get_schema() == "IFC2X3" and "#" not in reference.ItemReference:
+                    continue
+                if tool.Ifc.get_schema() != "IFC2X3" and "#" not in reference.Identification:
                     continue
                 results.append(
                     {
                         "id": reference.id(),
-                        "identification": identification,
+                        "identification": (
+                            reference.ItemReference if tool.Ifc.get_schema() == "IFC2X3" else reference.Identification
+                        ),
                         "name": reference.Name or "Unnamed",
                     }
                 )

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

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

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

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

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

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

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

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

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

@@ -1,130 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-import bpy
-from bpy.app.handlers import persistent
-
-import bonsai.tool as tool
-
-from . import face_quad, gizmos, operator, prop, ui
-
-classes = (
-    operator.BIM_OT_add_clip_box,
-    operator.BIM_OT_add_clip_box_for_source,
-    operator.BIM_OT_align_view_to_clip_face,
-    operator.BIM_OT_duplicate_clip_box,
-    operator.BIM_OT_remove_clip_box,
-    operator.BIM_OT_set_active_clip_box,
-    operator.BIM_OT_toggle_clip_box_enabled,
-    prop.BIMClipBoxProperties,
-    prop.BIMSceneClipBoxProperties,
-    face_quad.BIM_GT_box_face_quad,
-    face_quad.BIM_GT_box_face_outline,
-    gizmos.OBJECT_GGT_bim_clip_box,
-    ui.BIM_MT_clip_box_add_for_source,
-    ui.BIM_MT_clip_box_info,
-    ui.BIM_MT_clip_box_settings,
-    ui.BIM_UL_clip_box,
-    ui.BIM_PT_clip_box,
-)
-
-
-@persistent
-def _on_depsgraph_update(scene, depsgraph):
-    tool.ClipBox.on_depsgraph_update(scene, depsgraph)
-    tool.ClipBox.on_depsgraph_update_caps(scene, depsgraph)
-
-
-@persistent
-def _on_load_pre(filepath):
-    # Tear down any in-flight clip-box timers before Blender frees the
-    # WM / screens / areas / regions for the loading file. A refresh timer
-    # that survives the teardown fires against the new file's freshly-
-    # allocated regions before their GPU state is wired, CTD-ing inside
-    # GPU_matrix_ortho_set. The gate also blocks the depsgraph IFC-reload
-    # branch and is held closed until on_pre_view fires for the first time
-    # on the new file (first paint = GPU contexts wired).
-    tool.ClipBox._file_loading = True
-    tool.ClipBox._post_load_paint_pending = True
-    tool.ClipBox._cancel_pending_refresh()
-    tool.ClipBox._cancel_pending_cap_rebuild()
-
-
-@persistent
-def _on_load_post(filepath):
-    # The _file_loading gate is NOT cleared here: load_post fires before
-    # the new file's first paint, so GPU contexts may still be uninitialised.
-    # on_pre_view consumes _post_load_paint_pending to open the gate at the
-    # safe moment and kick the post-load re-arm.
-    # Restore the per-scene clip-box list from the project's BBIM_ClipBoxes
-    # pset. Runs after the standard load_post that creates Blender objects.
-    tool.ClipBox._last_seen_object_matrices.clear()
-    tool.ClipBox.load_from_project_pset()
-
-
-_draw_handler_pre = None
-_draw_handler_post = None
-
-
-def register():
-    global _draw_handler_pre, _draw_handler_post
-    bpy.types.Object.BIMClipBoxProperties = bpy.props.PointerProperty(type=prop.BIMClipBoxProperties)
-    bpy.types.Scene.BIMSceneClipBoxProperties = bpy.props.PointerProperty(type=prop.BIMSceneClipBoxProperties)
-    tool.ClipBox.reset_ownership()
-    if _on_depsgraph_update not in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.append(_on_depsgraph_update)
-    if _on_load_pre not in bpy.app.handlers.load_pre:
-        bpy.app.handlers.load_pre.append(_on_load_pre)
-    if _on_load_post not in bpy.app.handlers.load_post:
-        bpy.app.handlers.load_post.append(_on_load_post)
-    if _draw_handler_pre is None:
-        _draw_handler_pre = bpy.types.SpaceView3D.draw_handler_add(tool.ClipBox.on_pre_view, (), "WINDOW", "PRE_VIEW")
-    if _draw_handler_post is None:
-        _draw_handler_post = bpy.types.SpaceView3D.draw_handler_add(
-            tool.ClipBox.on_post_view_caps, (), "WINDOW", "POST_VIEW"
-        )
-
-
-def unregister():
-    global _draw_handler_pre, _draw_handler_post
-    if _draw_handler_post is not None:
-        try:
-            bpy.types.SpaceView3D.draw_handler_remove(_draw_handler_post, "WINDOW")
-        except ValueError:
-            pass
-        _draw_handler_post = None
-    if _draw_handler_pre is not None:
-        try:
-            bpy.types.SpaceView3D.draw_handler_remove(_draw_handler_pre, "WINDOW")
-        except ValueError:
-            pass
-        _draw_handler_pre = None
-    if _on_load_post in bpy.app.handlers.load_post:
-        bpy.app.handlers.load_post.remove(_on_load_post)
-    if _on_load_pre in bpy.app.handlers.load_pre:
-        bpy.app.handlers.load_pre.remove(_on_load_pre)
-    if _on_depsgraph_update in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.remove(_on_depsgraph_update)
-    tool.ClipBox._cancel_pending_refresh()
-    tool.ClipBox._cancel_pending_cap_rebuild()
-    tool.ClipBox._last_seen_object_matrices.clear()
-    tool.ClipBox.clear_clip_planes()
-    del bpy.types.Object.BIMClipBoxProperties
-    del bpy.types.Scene.BIMSceneClipBoxProperties

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

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

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

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

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

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

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

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

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

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

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

@@ -1,145 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-from __future__ import annotations
-
-from bpy.types import Menu, Panel, UIList
-
-import bonsai.tool as tool
-
-# Per-kind icon for the source-picker menu. Picked from Blender's built-in
-# icon set; semantically close to the kind so users can scan the menu visually.
-_SOURCE_MENU_ENTRIES: tuple[tuple[str, str, str], ...] = (
-    ("SPATIAL", "Clip Spatial Element", "OUTLINER_COLLECTION"),
-    ("CLASS", "Clip by Class", "BLANK1"),
-    ("TYPE", "Clip Type", "FILE_3D"),
-    ("MATERIAL", "Clip Material", "MATERIAL"),
-    ("PROFILE", "Clip Profile", "MESH_CIRCLE"),
-    ("DRAWING", "Clip Drawing Extents", "CAMERA_DATA"),
-    ("STATUS", "Clip by Status", "INFO"),
-    ("SYSTEM", "Clip by System", "MOD_FLUID"),
-    ("GROUP", "Clip by Group", "OUTLINER_OB_GROUP_INSTANCE"),
-    ("ZONE", "Clip by Zone", "MOD_LATTICE"),
-)
-
-
-class BIM_MT_clip_box_add_for_source(Menu):
-    bl_idname = "BIM_MT_clip_box_add_for_source"
-    bl_label = "Add Clip Box From Source"
-
-    def draw(self, context):
-        layout = self.layout
-        for kind, label, icon in _SOURCE_MENU_ENTRIES:
-            op = layout.operator("bim.add_clip_box_for_source", text=label, icon=icon)
-            op.source_kind = kind
-
-
-class BIM_MT_clip_box_settings(Menu):
-    bl_idname = "BIM_MT_clip_box_settings"
-    bl_label = "Clip Box Settings"
-
-    def draw(self, context):
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-        self.layout.prop(scene_props, "clip_only_ifc_products")
-        self.layout.prop(scene_props, "include_linked_ifc")
-        self.layout.prop(scene_props, "enable_gizmos")
-
-
-class BIM_MT_clip_box_info(Menu):
-    bl_idname = "BIM_MT_clip_box_info"
-    bl_label = "Clip Box Face Handles"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="Face Handles", icon="INFO")
-        layout.separator()
-        layout.label(text="Drag a face to resize the clip box on that axis.")
-        layout.label(text="The opposite face stays fixed (one-sided resize).")
-        layout.label(text="Ctrl+Click a face to align the viewport to it.")
-        layout.separator()
-        layout.label(text="Toggle handles from the Settings (gear) menu.")
-
-
-class BIM_UL_clip_box(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index, flt_flag):
-        obj = item.obj
-        row = layout.row(align=True)
-        if obj is None:
-            # Host empty was deleted from outliner; still expose the
-            # remove button so the orphan entry isn't permanent.
-            row.label(text="(missing)", icon="ERROR")
-            row.operator("bim.remove_clip_box", text="", icon="X", emboss=False).index = index
-            return
-        row.prop(obj, "name", text="", emboss=False, icon="MESH_CUBE")
-        row.operator("bim.duplicate_clip_box", text="", icon="DUPLICATE", emboss=False).index = index
-        row.operator("bim.remove_clip_box", text="", icon="X", emboss=False).index = index
-
-
-class BIM_PT_clip_box(Panel):
-    bl_idname = "BIM_PT_clip_box"
-    bl_label = "Clip Box"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_parent_id = "BIM_PT_tab_sandbox"
-
-    def draw(self, context):
-        layout = self.layout
-        scene_props = tool.ClipBox.get_scene_props(context.scene)
-
-        toggles = layout.row(align=True)
-        toggles.scale_y = 2.0
-        toggles.prop(
-            scene_props,
-            "enabled",
-            text="Enable Clipping",
-            icon="HIDE_OFF" if scene_props.enabled else "HIDE_ON",
-            toggle=True,
-        )
-        toggles.prop(scene_props, "show_caps", text="Show Caps", icon="MOD_SOLIDIFY", toggle=True)
-        toggles.menu("BIM_MT_clip_box_settings", icon="PREFERENCES", text="")
-        toggles.menu("BIM_MT_clip_box_info", icon="INFO", text="")
-
-        layout.separator()
-        row = layout.row(align=True)
-        row.operator("bim.add_clip_box", icon="ADD", text="Add Clip Box")
-        row.menu("BIM_MT_clip_box_add_for_source", icon="DOWNARROW_HLT", text="")
-
-        layout.template_list(
-            "BIM_UL_clip_box",
-            "",
-            scene_props,
-            "clip_boxes",
-            scene_props,
-            "active_clip_box_index",
-            rows=3,
-        )
-
-        obj = tool.ClipBox.get_active_clip_box(context.scene)
-        if obj is None:
-            layout.label(text="No active clip box", icon="INFO")
-            return
-
-        col = layout.column(align=True)
-        col.label(text="Edit the empty with G / R / S to move / rotate / resize")
-        col.prop(obj, "location")
-        col.prop(obj, "rotation_euler")
-        col.prop(obj, "scale")

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

@@ -206,7 +206,7 @@ class CostSchedulesData:
                 data["UnitSymbol"] = ifcopenshell.util.unit.get_unit_symbol(unit)
             if quantity.is_a("IfcPhysicalSimpleQuantity"):
                 measure_class = (
-                    quantity.wrapped_data.declaration()
+                    quantity.declaration()
                     .as_entity()
                     .attribute_by_index(3)
                     .type_of_attribute()

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

@@ -90,7 +90,7 @@ class PrintIfcFile(bpy.types.Operator):
         return tool.Ifc.get()
 
     def execute(self, context):
-        print(tool.Ifc.get().wrapped_data.to_string())
+        print(tool.Ifc.get().to_string())
         return {"FINISHED"}
 
 

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

@@ -127,25 +127,36 @@ class ObjectDocumentData:
                 identification = None
 
                 if is_information:
-                    identification = tool.Document.get_document_information_id(relating_document)
+                    if tool.Ifc.get_schema() == "IFC2X3":
+                        identification = relating_document.DocumentId
+                    else:
+                        identification = relating_document.Identification
 
                     location = getattr(relating_document, "Location", None)
                     description = getattr(relating_document, "Description", "No description")
                 else:
                     description = relating_document.Description
-                    referenced_document = tool.Document.get_reference_document(relating_document)
+                    if tool.Ifc.get_schema() == "IFC2X3":
+                        reference_to_document = relating_document.ReferenceToDocument
+                        if not name and reference_to_document:
+                            name = reference_to_document[0].Name
 
-                    if not name and referenced_document:
-                        name = referenced_document.Name
+                        identification = relating_document.ItemReference
+                        if not identification and reference_to_document:
+                            identification = reference_to_document[0].DocumentId
+                        location = relating_document.Location
+                    else:
+                        referenced_document = relating_document.ReferencedDocument
+                        if not name and referenced_document:
+                            name = referenced_document.Name
 
-                    identification = tool.Document.get_external_reference_id(relating_document)
-                    if not identification and referenced_document:
-                        identification = tool.Document.get_document_information_id(referenced_document)
+                        identification = relating_document.Identification
+                        if not identification and referenced_document:
+                            identification = referenced_document.Identification
 
-                    location = relating_document.Location
-                    # IFC2X3 IfcDocumentInformation has no Location to fall back to.
-                    if location is None and referenced_document and tool.Ifc.get_schema() != "IFC2X3":
-                        location = referenced_document.Location
+                        location = relating_document.Location
+                        if location is None and referenced_document:
+                            location = referenced_document.Location
 
                 location = cls.convert_to_file_uri(location) if location else None
 

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import bpy
 
@@ -138,34 +136,14 @@ classes = (
     gizmos.GizmoArrow2D,
     gizmos.GizmoCone,
     gizmos.GizmoDimension,
-    gizmos.GizmoLockOpen,
-    gizmos.GizmoLockClosed,
+    gizmos.GizmoLock,
     gizmos.GizmoArc,
-    gizmos.GizmoLinkToggle,
-    gizmos.GizmoFillet,
-    gizmos.GizmoWallCornerIcon,
-    gizmos.GizmoWallTeeIcon,
     gizmos.GizmoPen,
     gizmos.GizmoValidate,
     gizmos.GizmoCancel,
     gizmos.GizmoPlus,
     gizmos.GizmoMinus,
-    gizmos.GizmoTrash,
-    gizmos.GizmoArrayParent,
-    gizmos.GizmoArrayAll,
-    gizmos.GizmoArrayLayerIndicator,
-    gizmos.GizmoCountLabel,
-    gizmos.GizmoMerge,
-    gizmos.GizmoSplit,
-    gizmos.GizmoUnjoin,
-    gizmos.GizmoExtend,
-    gizmos.GizmoExtendVertical,
-    gizmos.GizmoOffsetExterior,
-    gizmos.GizmoOffsetCenter,
-    gizmos.GizmoOffsetInterior,
-    gizmos.GizmoAddOpening,
     gizmos.GizmoCycle,
-    gizmos.GizmoMenu,
     # Drawing-specific gizmos
     gizmos.UglyDotGizmo,
     gizmos.ExtrusionGuidesGizmo,

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

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

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

@@ -189,20 +189,14 @@ def format_distance(
             if hasattr(length_unit, "Prefix") and length_unit.Prefix:
                 unit_length = length_unit.Prefix + length_unit.Name
             unit_length_mapping = {
-                "MILE": "MILES",
                 "FOOT": "FEET",
                 "INCH": "INCHES",
-                "KILOMETRE": "KILOMETERS",
                 "METRE": "METERS",
                 "DECIMETRE": "DECIMETERS",
                 "CENTIMETRE": "CENTIMETERS",
                 "MILLIMETRE": "MILLIMETERS",
-                "MICROMETRE": "MICROMETERS",
             }
-            # Fall through for units without a dedicated formatter (e.g.
-            # HECTOMETRE) so they use the adaptive branch instead of a
-            # KeyError (#8255).
-            unit_length = unit_length_mapping.get(unit_length, unit_length)
+            unit_length = unit_length_mapping[unit_length]
         # For now we only format area in IFC Units
         if area_unit := ifcopenshell.util.unit.get_project_unit(tool.Ifc.get(), "AREAUNIT"):
             area_unit_symbol = " " + ifcopenshell.util.unit.get_unit_symbol(area_unit)
@@ -319,7 +313,7 @@ def format_distance(
             if not feet and not add_inches:
                 tx_dist += str(feet) + "'"
 
-            if not feet and add_inches and unit_length != "INCHES":
+            if not feet and add_inches:
                 if value < 0:
                     tx_dist += "-0' - "
                 else:

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

@@ -57,7 +57,7 @@ import shapely
 from bpy_extras.image_utils import load_image
 from bpy_extras.io_utils import ImportHelper
 from lxml import etree
-from mathutils import Color, Matrix, Vector
+from mathutils import Color, Vector
 
 import bonsai.bim.export_ifc
 import bonsai.bim.handler
@@ -602,7 +602,6 @@ class CreateDrawing(bpy.types.Operator):
         context_type: Literal["body", "annotation"],
         drawing_elements: set[ifcopenshell.entity_instance],
         target_view: str,
-        link_matrix: Optional[Matrix] = None,
     ) -> None:
         drawing_elements = drawing_elements.copy()
         contexts_: list[list[int]] = getattr(contexts, context_type)
@@ -614,19 +613,9 @@ class CreateDrawing(bpy.types.Operator):
                 geom_settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
                 geom_settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.NATIVE)
 
-                is_plan = ifc.by_id(context[0]).ContextType == "Plan" and "PLAN_VIEW" in target_view
-                z_offset = (0.002 if target_view == "PLAN_VIEW" else -0.002) if is_plan else 0.0
-
-                if link_matrix is not None:
-                    unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc)
-                    t = link_matrix.to_translation()
-                    offset = (t.x / unit_scale, t.y / unit_scale, t.z / unit_scale + z_offset)
-                    geom_settings.set("model-offset", offset)
-                    q = link_matrix.to_quaternion()
-                    geom_settings.set("model-rotation", (q.x, q.y, q.z, q.w))
-                elif z_offset:
+                if ifc.by_id(context[0]).ContextType == "Plan" and "PLAN_VIEW" in target_view:
                     # A 2mm Z offset to combat Z-fighting in plan or RCPs
-                    geom_settings.set("model-offset", (0.0, 0.0, z_offset))
+                    geom_settings.set("model-offset", (0.0, 0.0, 0.002 if target_view == "PLAN_VIEW" else -0.002))
 
                 geom_settings.set("context-ids", context)
                 it = ifcopenshell.geom.iterator(
@@ -934,16 +923,11 @@ class CreateDrawing(bpy.types.Operator):
 
         bim_props = tool.Blender.get_bim_props()
         prefs = tool.Blender.get_addon_preferences()
-        # Map ifc_path → (ifc_file, link_matrix); main file has no link_matrix (None)
-        files: dict[str, tuple[ifcopenshell.file, Optional[Matrix]]] = {bim_props.ifc_file: (tool.Ifc.get(), None)}
+        files = {bim_props.ifc_file: tool.Ifc.get()}
 
         props = tool.Project.get_project_props()
         for link in props.get_loaded_links_for_drawings():
-            try:
-                link_matrix = tool.Project.calculate_link_matrix(link)
-            except Exception:
-                link_matrix = None
-            files[link.filepath] = (self.get_linked_file(link), link_matrix)
+            files[link.filepath] = self.get_linked_file(link)
 
         target_view = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]["TargetView"]
         self.setup_serialiser(target_view)
@@ -951,13 +935,7 @@ class CreateDrawing(bpy.types.Operator):
         tree = ifcopenshell.geom.tree()
         tree.enable_face_styles(True)
 
-        # Accumulated across every file in the loop below (main model plus any
-        # linked models) so the SHAPELY fill pass after the loop covers all of
-        # them, not just whichever file happened to be processed last.
-        raycast_objs = set()
-        elements_with_faces = set()
-
-        for ifc_path, (ifc, link_matrix) in files.items():
+        for ifc_path, ifc in files.items():
             # Don't use draw.main() just whilst we're prototyping and experimenting
             # TODO: hash paths are never used
             ifc_hash = hashlib.md5(ifc_path.encode("utf-8")).hexdigest()
@@ -966,24 +944,13 @@ class CreateDrawing(bpy.types.Operator):
             self.serialiser.setFile(ifc)
             drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element, ifc_file=ifc)
 
-            if self.cprops.fill_mode == "SHAPELY":
-                for element in drawing_elements.copy():
-                    if element.is_a("IfcAnnotation"):
-                        continue
-                    obj = tool.Ifc.get_object(element)
-                    if obj and obj.type == "MESH" and len(obj.data.polygons):
-                        elements_with_faces.add(element.GlobalId)
-                        raycast_objs.add(obj)
-
             # Get all representation contexts to see what we're dealing with.
             # Drawings only draw bodies and annotations (and facetation, due to a Revit bug).
             # A drawing prioritises a target view context first, followed by a model view context as a fallback.
             # Specifically for PLAN_VIEW and REFLECTED_PLAN_VIEW, any Plan context is also prioritised.
             contexts = self.get_linework_contexts(ifc, target_view)
-            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view, link_matrix)
-            self.serialize_contexts_elements(
-                ifc, tree, contexts, "annotation", drawing_elements, target_view, link_matrix
-            )
+            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view)
+            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view)
 
             if tool.Ifc.get() == ifc and self.camera_element not in drawing_elements:
                 with profile("Camera element"):
@@ -1050,6 +1017,16 @@ class CreateDrawing(bpy.types.Operator):
             # shapely variant
             group = root.find("{http://www.w3.org/2000/svg}g")
 
+            raycast_objs = set()
+            elements_with_faces = set()
+            for element in drawing_elements.copy():
+                if element.is_a("IfcAnnotation"):
+                    continue
+                obj = tool.Ifc.get_object(element)
+                if obj and obj.type == "MESH" and len(obj.data.polygons):
+                    elements_with_faces.add(element.GlobalId)
+                    raycast_objs.add(obj)
+
             projections = root.xpath(
                 ".//svg:g[contains(@class, 'projection')]", namespaces={"svg": "http://www.w3.org/2000/svg"}
             )
@@ -1706,12 +1683,6 @@ class CreateDrawing(bpy.types.Operator):
             key=lambda a: (
                 tool.Drawing.get_annotation_z_index(a),
                 1 if ifcopenshell.util.element.get_predefined_type(a) == "TEXT" else 0,
-                # Deterministic tiebreaker so equal-priority annotations keep a
-                # stable order across sessions. Without it the order comes from
-                # the set union above, which depends on entity hashes (and thus
-                # the file pointer), shuffling annotations between Blender
-                # restarts. See #6608.
-                a.id(),
             ),
         )
 
@@ -2348,10 +2319,7 @@ class ActivateDrawingBase(tool.Ifc.Operator):
     bl_description = (
         "Activates the selected drawing view.\n\n"
         + "ALT+CLICK to keep the viewport position.\n\n"
-        + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views, "
-        + "then select their cameras (the first selected drawing's camera becomes active).\n\n"
-        + "SHIFT+CTRL+ALT+CLICK to do the same but also select the annotations, not just the cameras"
+        + "SHIFT+CLICK to load a quick preview of the drawing view"
     )
 
     drawing: bpy.props.IntProperty()
@@ -2367,32 +2335,13 @@ class ActivateDrawingBase(tool.Ifc.Operator):
         default=False,
         options={"SKIP_SAVE"},
     )
-    load_selected_annotations: bpy.props.BoolProperty(
-        name="Load Selected Annotations",
-        description="Load the annotations of all selected drawings without switching the active view.",
-        default=False,
-        options={"SKIP_SAVE"},
-    )
-    include_annotations_in_selection: bpy.props.BoolProperty(
-        name="Include Annotations In Selection",
-        description="Also select the loaded annotation objects, not just the drawing cameras.",
-        default=False,
-        options={"SKIP_SAVE"},
-    )
 
     if TYPE_CHECKING:
         drawing: int
         should_view_from_camera: bool
         use_quick_preview: bool
-        load_selected_annotations: bool
-        include_annotations_in_selection: bool
 
     def invoke(self, context, event) -> set["rna_enums.OperatorReturnItems"]:
-        if event.type == "LEFTMOUSE" and event.shift and event.ctrl:
-            self.load_selected_annotations = True
-            if event.alt:
-                self.include_annotations_in_selection = True
-            return self.execute(context)
         if event.type == "LEFTMOUSE" and event.alt:
             self.should_view_from_camera = False
         if event.type == "LEFTMOUSE" and event.shift:
@@ -2405,37 +2354,6 @@ class ActivateDrawingBase(tool.Ifc.Operator):
         if props.is_editing_drawings == False:
             bpy.ops.bim.load_drawings()
 
-        if self.load_selected_annotations:
-            objs_to_select = []
-            active_camera = None
-            for d in props.drawings:
-                if not (d.is_drawing and d.is_selected):
-                    continue
-                selected_drawing = tool.Ifc.get().by_id(d.ifc_definition_id)
-                # Importing the camera (if missing) ensures the drawing's
-                # collection exists so the annotations get collected into it.
-                if not (camera := tool.Ifc.get_object(selected_drawing)):
-                    camera = tool.Drawing.import_drawing(selected_drawing)
-                group = tool.Drawing.get_drawing_group(selected_drawing)
-                tool.Drawing.import_annotations_in_group(group)
-
-                if active_camera is None:
-                    active_camera = camera
-                objs_to_select.append(camera)
-                if self.include_annotations_in_selection:
-                    for element in tool.Drawing.get_group_elements(group) or []:
-                        if element.is_a("IfcAnnotation") and element.ObjectType != "DRAWING":
-                            if annotation_obj := tool.Ifc.get_object(element):
-                                objs_to_select.append(annotation_obj)
-
-            # Select the checked drawings' objects, with the first drawing's camera as active.
-            bpy.ops.object.select_all(action="DESELECT")
-            for obj in objs_to_select:
-                obj.select_set(True)
-            if active_camera is not None:
-                context.view_layer.objects.active = active_camera
-            return {"FINISHED"}
-
         drawing = tool.Ifc.get().by_id(self.drawing)
         dprops = tool.Drawing.get_document_props()
 
@@ -2521,10 +2439,7 @@ class ActivateDrawing(bpy.types.Operator, ActivateDrawingBase):
     bl_description = (
         "Activates the selected drawing view.\n\n"
         + "ALT+CLICK to keep the viewport position.\n\n"
-        + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views, "
-        + "then select their cameras (the first selected drawing's camera becomes active).\n\n"
-        + "SHIFT+CTRL+ALT+CLICK to do the same but also select the annotations, not just the cameras"
+        + "SHIFT+CLICK to load a quick preview of the drawing view"
     )
 
 
@@ -3586,7 +3501,7 @@ class EditSheet(bpy.types.Operator, tool.Ifc.Operator):
         if sheet.is_a("IfcDocumentInformation"):
             self.document_type = "SHEET"
             self.name = sheet.Name
-            self.identification = tool.Document.get_document_information_id(sheet)
+            self.identification = sheet.DocumentId if tool.Ifc.get_schema() == "IFC2X3" else sheet.Identification
         elif sheet.is_a("IfcDocumentReference") and tool.Drawing.get_reference_description(sheet) == "TITLEBLOCK":
             self.document_type = "TITLEBLOCK"
         else:

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

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

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

@@ -903,8 +903,12 @@ class SvgWriter:
                     continue
                 sheet = tool.Drawing.get_reference_document(sheet_reference)
                 if sheet:
-                    reference_id = tool.Document.get_external_reference_id(sheet_reference) or "-"
-                    sheet_id = tool.Document.get_document_information_id(sheet) or "-"
+                    if tool.Ifc.get_schema() == "IFC2X3":
+                        reference_id = sheet_reference.ItemReference or "-"
+                        sheet_id = sheet.DocumentId or "-"
+                    else:
+                        reference_id = sheet_reference.Identification or "-"
+                        sheet_id = sheet.Identification or "-"
                     return (reference_id, sheet_id)
                 break
         return ("-", "-")

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

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

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

@@ -44,12 +44,8 @@ class ViewportData:
 
     @classmethod
     def load(cls):
-        # Populate data BEFORE flipping is_loaded so a raising ``mode()``
-        # call doesn't leave the class half-loaded (flag set, dict empty).
-        # Subsequent items-callback invocations skip load() on a True flag
-        # and would hit ``cls.data["mode"]`` → KeyError.
-        cls.data = {"mode": cls.mode()}
         cls.is_loaded = True
+        cls.data = {"mode": cls.mode()}
 
     @classmethod
     def mode(cls) -> tool.Blender.BLENDER_ENUM_ITEMS:
@@ -80,9 +76,9 @@ class ViewportData:
                 modes.append(edit_mode)
             elif element.is_a("IfcGridAxis"):
                 modes.append(edit_mode)
-            elif tool.Parametric.is_roof(element):
+            elif tool.Blender.Modifier.is_roof(element):
                 modes.append(edit_mode)
-            elif tool.Parametric.is_railing(element):
+            elif tool.Blender.Modifier.is_railing(element):
                 modes.append(edit_mode)
             elif item_mode not in modes:
                 modes.append(item_mode)

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

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

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

@@ -60,7 +60,6 @@ import bonsai.core.root
 import bonsai.core.spatial
 import bonsai.tool as tool
 from bonsai.bim.ifc import IfcStore
-from bonsai.bim.module.model import preview_base
 from bonsai.bim.module.model.decorator import ProfileDecorator
 
 if TYPE_CHECKING:
@@ -546,13 +545,6 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
         objs = [bpy.data.objects[obj_name]] if obj_name else context.selected_objects
         self.file = tool.Ifc.get()
 
-        # Tessellated face sets (IfcTriangulatedFaceSet/IfcPolygonalFaceSet) were
-        # introduced in IFC4 and do not exist in IFC2X3. Catch this early so we
-        # don't silently fall back to a faceted brep after stripping materials.
-        if self.ifc_representation_class == "IfcTessellatedFaceSet" and self.file.schema == "IFC2X3":
-            self.report({"ERROR"}, "Tessellated face sets are not supported in IFC2X3.")
-            return {"CANCELLED"}
-
         for obj in objs:
             # TODO: write unit tests to see how this bulk operation handles
             # contradictory ifc_representation_class values and when
@@ -798,7 +790,7 @@ def lock_error_message(name: str) -> str:
 
 
 def calc_delete_is_batch(ifc_file: ifcopenshell.file, context: bpy.types.Context) -> bool:
-    total_elements = len(tool.Ifc.get().wrapped_data.entity_names())
+    total_elements = len(tool.Ifc.get().entity_names())
     total_polygons = sum([len(o.data.polygons) for o in context.selected_objects if o.type == "MESH"])
     # These numbers are a bit arbitrary, but basically batching is only
     # really necessary on large models and large geometry removals.
@@ -890,16 +882,6 @@ class OverrideDelete(bpy.types.Operator):
         # Track aggregates before deleting their parts
         aggregates_to_check = self.track_aggregates(objects_to_remove)
 
-        # Snapshot the set of IFC entity ids being deleted in this batch so the
-        # connection-rel cascade inside `delete_ifc_object` can suppress
-        # partner-side regenerate when the partner is also about to vanish.
-        batch_being_deleted_ids: set[int] = set()
-        for obj in objects_to_remove:
-            if not tool.Blender.is_valid_data_block(obj):
-                continue
-            if (entity := tool.Ifc.get_entity(obj)) is not None:
-                batch_being_deleted_ids.add(entity.id())
-
         clear_active_object = True
 
         for i, obj in enumerate(objects_to_remove, 1):
@@ -941,7 +923,7 @@ class OverrideDelete(bpy.types.Operator):
                 if tool.Drawing.is_auto_annotation(element):
                     self.report({"INFO"}, "References cannot be deleted. Exclude the referenced element instead.")
                     continue
-                tool.Geometry.delete_ifc_object(obj, batch_being_deleted_ids=batch_being_deleted_ids)
+                tool.Geometry.delete_ifc_object(obj)
             elif tool.Geometry.is_representation_item(obj):
                 tool.Geometry.delete_ifc_item(obj)
             else:
@@ -1040,17 +1022,14 @@ class OverrideDelete(bpy.types.Operator):
             pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
             if not pset:
                 continue
-            try:
-                array_parents.add(ifc_file.by_guid(pset["Parent"]))
-            except RuntimeError:
-                continue
+            array_parents.add(ifc_file.by_guid(pset["Parent"]))
 
         for array_parent in array_parents:
             array_parent_obj = tool.Ifc.get_object(array_parent)
-            data = [(i, data) for i, data in enumerate(tool.Array.get_modifiers_data(array_parent))]
+            data = [(i, data) for i, data in enumerate(tool.Blender.Modifier.Array.get_modifiers_data(array_parent))]
             # NOTE: there is a way to remove arrays more precisely but it's more complex
             for i, modifier_data in reversed(data):
-                children = set(tool.Array.get_children_objects(modifier_data))
+                children = set(tool.Blender.Modifier.Array.get_children_objects(modifier_data))
                 if children.issubset(selected_objects):
                     with context.temp_override(active_object=array_parent_obj):
                         bpy.ops.bim.remove_array(item=i)
@@ -1204,7 +1183,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
         operator: bpy.types.Operator, context: bpy.types.Context, linked: bool = False
     ) -> set["rna_enums.OperatorReturnItems"]:
         # Deep magick from the dawn of time
-        if tool.Ifc.get() and tool.Model.has_selected_ifc_objects(include_active=False):
+        if tool.Ifc.get():
             IfcStore.execute_ifc_operator(operator, context)
             return {"FINISHED"}
 
@@ -1308,9 +1287,6 @@ class OverrideDuplicateMove(bpy.types.Operator):
                             if part_obj:
                                 all_objects_to_select.add(part_obj)
 
-        # Non-IFC duplicates aren't tracked in old_to_new but are left selected by duplicate_ifc_objects
-        all_objects_to_select.update(obj for obj in context.selected_objects if not tool.Ifc.get_entity(obj))
-
         # Deselect everything first
         bpy.ops.object.select_all(action="DESELECT")
 
@@ -2247,8 +2223,6 @@ class OverrideEscape(bpy.types.Operator):
             bpy.ops.bim.hide_all_openings()
         elif tool.Aggregate.get_aggregate_props().in_aggregate_mode:
             bpy.ops.bim.disable_aggregate_mode()
-        elif preview_base.try_cancel_active_preview(context):
-            pass
         elif active_object := context.active_object:
             if tool.Blender.Modifier.try_canceling_editing_modifier_parameters_or_path(active_object):
                 pass
@@ -2290,8 +2264,6 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
                 gprops = tool.Geometry.get_geometry_props()
                 if gprops.representation_obj:
                     tool.Geometry.disable_item_mode()
-                    if active_obj := bpy.context.active_object:
-                        active_obj.select_set(False)
                 else:
                     bonsai.core.aggregate.exit_aggregate_mode(tool.Aggregate)
                 return {"FINISHED"}
@@ -2378,7 +2350,6 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
             and usage in ("LAYER1", "LAYER2")
         ):
             self.report({"INFO"}, f"Parametric {usage} elements cannot be edited directly")
-            obj.select_set(False)
         elif item.is_a("IfcSweptAreaSolid"):
             tool.Geometry.sync_item_positions()
             res = tool.Model.import_profile((profile := item.SweptArea), obj=obj)
@@ -2387,7 +2358,6 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
                     {"INFO"},
                     f"Couldn't import profile, editing it directly is not yet supported. Failing profile: {profile}.",
                 )
-                obj.select_set(False)
                 return
             tool.Ifc.link(item, obj.data)
             self.enable_edit_mode(context)
@@ -2515,9 +2485,9 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
                     profile = tool.Ifc.get().by_id(profile_id)
                     if tool.Ifc.get_object(profile):  # We are editing an arbitrary profile
                         bpy.ops.bim.edit_arbitrary_profile()
-                elif tool.Parametric.is_railing(element):
+                elif tool.Blender.Modifier.is_railing(element):
                     bpy.ops.bim.finish_editing_railing_path()
-                elif tool.Parametric.is_roof(element):
+                elif tool.Blender.Modifier.is_roof(element):
                     bpy.ops.bim.finish_editing_roof_path()
                 elif tool.Model.get_usage_type(element) == "PROFILE":
                     bpy.ops.bim.edit_extrusion_axis()
@@ -3186,7 +3156,7 @@ class EnableEditingRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
                 product_reps = element.RepresentationMaps
             item_aspect = {}
             for product_rep in product_reps:
-                for aspect in getattr(product_rep, "HasShapeAspects", ()):
+                for aspect in product_rep.HasShapeAspects:
                     for aspect_rep in aspect.ShapeRepresentations:
                         if aspect_rep.ContextOfItems != representation.ContextOfItems:
                             continue

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

@@ -17,7 +17,6 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-import ifcopenshell.util.unit
 from bpy.types import Menu, Panel, UIList
 
 import bonsai.bim
@@ -484,32 +483,10 @@ class BIM_PT_placement(Panel):
             row.label(text="No Object Placement Found")
             return
 
-        is_imperial = False
-        if tool.Ifc.get():
-            length_unit = ifcopenshell.util.unit.get_project_unit(tool.Ifc.get(), "LENGTHUNIT")
-            if length_unit and length_unit.Name != "METRE":
-                is_imperial = True
-
         row = self.layout.row()
-        row.label(text="Location:")
-
-        if is_imperial:
-            loc = context.active_object.location
-            for i, (axis, comp) in enumerate(zip("XYZ", (loc.x, loc.y, loc.z))):
-                split = self.layout.split(factor=0.6)
-                split.prop(context.active_object, "location", index=i, text=axis)
-                sub = split.row()
-                sub.enabled = False
-                sub.alignment = "LEFT"
-                sub.label(text=tool.Unit.format_distance(comp))
-        else:
-            for i, axis in enumerate("XYZ"):
-                self.layout.prop(context.active_object, "location", index=i, text=axis)
-
+        row.prop(context.active_object, "location", text="Location")
         row = self.layout.row()
-        row.label(text="Rotation:")
-        for i, axis in enumerate("XYZ"):
-            self.layout.prop(context.active_object, "rotation_euler", index=i, text=axis)
+        row.prop(context.active_object, "rotation_euler", text="Rotation")
 
         if props.blender_offset_type != "NONE":
             row = self.layout.row(align=True)

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

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

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

@@ -103,7 +103,9 @@ class LibraryReferencesData:
                 results.append(
                     {
                         "id": library.id(),
-                        "identification": tool.Document.get_external_reference_id(library),
+                        "identification": (
+                            library.ItemReference if tool.Ifc.get_schema() == "IFC2X3" else library.Identification
+                        ),
                         "name": library.Name or "Unnamed",
                     }
                 )

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

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

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

@@ -630,23 +630,13 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                     slab.DumbSlabPlaner().regenerate_from_layer_set(layer_set)
 
             if material_set_usage.is_a("IfcMaterialProfileSetUsage"):
-                if "CardinalPoint" in attributes and attributes["CardinalPoint"] is not None:
+                if "CardinalPoint" in attributes:
                     attributes["CardinalPoint"] = int(attributes["CardinalPoint"])
                 ifcopenshell.api.material.edit_profile_usage(
                     self.file,
                     usage=material_set_usage,
                     attributes=attributes,
                 )
-
-                for obj in objects:
-                    obj_element = tool.Ifc.get_entity(obj)
-                    if not obj_element:
-                        continue
-                    obj_material_usage = ifcopenshell.util.element.get_material(obj_element)
-                    if obj_material_usage and obj_material_usage.is_a("IfcMaterialProfileSetUsage"):
-                        obj_material_usage.CardinalPoint = material_set_usage.CardinalPoint
-                        obj_material_usage.ReferenceExtent = material_set_usage.ReferenceExtent
-
                 model_profile.DumbProfileRecalculator().recalculate(objects)
 
         bpy.ops.bim.disable_editing_assigned_material(obj=active_obj.name)

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

@@ -418,13 +418,6 @@ class ImportQuickFavorites(bpy.types.Operator):
     bl_description = "Import operators from Blender's Quick Favorites menu, including their configured properties"
     bl_options = {"REGISTER", "UNDO"}
 
-    @classmethod
-    def poll(cls, context):
-        if bpy.app.version[:2] not in tool.Misc.QuickFavorites.OFFSET_USER_MENUS:
-            cls.poll_message_set(f"Blender version {bpy.app.version_string} is not supported.")
-            return False
-        return True
-
     def execute(self, context) -> set["rna_enums.OperatorReturnItems"]:
         props = tool.Misc.get_misc_props()
         props.quick_favorites.clear()

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

@@ -15,26 +15,19 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from typing import NamedTuple
 
 import bpy
 
-import bonsai.tool as tool
-
 from . import (
     array,
     covering,
-    decorator,
     door,
     external,
     grid,
     handler,
-    host_add_opening_gizmo,
     mep,
-    mep_bend_preview,
     opening,
     product,
     profile,
@@ -53,28 +46,17 @@ from . import (
 
 classes = (
     array.AddArray,
-    array.CancelEditingArray,
+    array.DisableEditingArray,
+    array.EditArray,
     array.EnableEditingArray,
-    array.FinishEditingArray,
     array.ApplyArray,
     array.RegenerateArray,
     array.RemoveArray,
     array.SelectAllArrayObjects,
     array.SelectArrayParent,
-    array.ArrayParentGizmoClick,
-    array.EditArrayFromChild,
     array.Input3DCursorXArray,
     array.Input3DCursorYArray,
     array.Input3DCursorZArray,
-    array.EnableEditingParametric,
-    array.AddArrayFromFeatureEdit,
-    array.ArrayGizmoClick,
-    array.ToggleArrayMethod,
-    array.RemoveArrayLayerFromEdit,
-    array.InputArrayCount,
-    array.AdjustArrayCount,
-    array.GizmoArrayEdition,
-    array.GizmoArrayChild,
     product.AddDefaultType,
     product.AddEmptyType,
     product.AddOccurrence,
@@ -86,51 +68,21 @@ classes = (
     product.SetActiveType,
     workspace.Hotkey,
     workspace.BIM_MT_add_representation_item,
-    wall.AddPerpendicularWall,
     wall.AddWallsFromSlab,
     wall.AlignWall,
-    wall.CancelEditingWall,
     wall.ChangeExtrusionDepth,
     wall.ChangeExtrusionXAngle,
     wall.ChangeLayerLength,
-    wall.CycleWallOffset,
     wall.DrawPolylineWall,
-    wall.EnableEditingWall,
-    wall.ExtendWallHeightToCursor,
     wall.ExtendWallsToUnderside,
-    wall.RegenerateWallToUnderside,
     wall.ExtendWallsToWall,
     wall.ExtendWallsToPolylinePoint,
-    wall.ExtendWallToCursor,
-    wall.FinishEditingWall,
     wall.FlipWall,
-    host_add_opening_gizmo.GizmoHostAddOpening,
-    host_add_opening_gizmo.GizmoHostToggleOpenings,
-    wall.GizmoWallEdition,
-    wall.GizmoWallExtendVertically,
-    wall.GizmoWallFilletPreview,
-    wall.GizmoWallFilletReedit,
-    wall.GizmoWallFilletToggleOpenings,
-    wall.GizmoPairDisconnect,
-    wall.GizmoSlabEdition,
-    wall.GizmoSlabUnjoinWalls,
-    wall.GizmoWallJoinIntersection,
-    wall.GizmoWallLinkToggle,
-    wall.GizmoWallUnjoinSingle,
-    wall.JoinWallsIntersection,
     wall.MergeWall,
     wall.OffsetWalls,
     wall.RecalculateWall,
-    wall.RotateWall90,
     wall.SplitWall,
-    wall.SplitWallAtCursor,
-    wall.DisconnectElements,
     wall.UnjoinWalls,
-    wall.EnableWallFilletPreview,
-    wall.FinishWallFilletPreview,
-    wall.CancelWallFilletPreview,
-    wall.EnableWallFilletPreviewFromCorner,
-    wall.CreateWallFillet,
     opening.AddBoolean,
     opening.CloneOpening,
     opening.EditOpenings,
@@ -142,7 +94,6 @@ classes = (
     opening.RemoveBoolean,
     opening.SelectBoolean,
     opening.ShowOpenings,
-    opening.ToggleHostOpenings,
     opening.UpdateOpeningsFocus,
     profile.ChangeCardinalPoint,
     profile.ChangeProfileDepth,
@@ -158,14 +109,11 @@ classes = (
     slab.DisableEditingExtrusionProfile,
     slab.DisableEditingSketchExtrusionProfile,
     slab.AddSlabFromWall,
-    slab.CancelEditingSlab,
     slab.DrawPolylineSlab,
     slab.EditExtrusionProfile,
     slab.EditSketchExtrusionProfile,
     slab.EnableEditingExtrusionProfile,
     slab.EnableEditingSketchExtrusionProfile,
-    slab.EnableEditingSlab,
-    slab.FinishEditingSlab,
     slab.RecalculateSlab,
     slab.ResetVertex,
     slab.SetArcIndex,
@@ -192,19 +140,10 @@ classes = (
     prop.BIMDoorProperties,
     prop.BIMRailingProperties,
     prop.BIMRoofProperties,
-    prop.BIMSlabProperties,
-    prop.BIMWallProperties,
-    prop.BIMPipeSegmentProperties,
-    prop.BIMDuctSegmentProperties,
     prop.BIMPolylineProperties,
     prop.BIMExternalParametricGeometryProperties,
-    prop.BIMBendPreviewProperties,
-    prop.BIMWallFilletPreviewProperties,
-    prop.BIMPreviewProperties,
-    prop.BIMParametricEditDialogPrefs,
     ui.BIM_PT_array,
     ui.BIM_PT_stair,
-    ui.BIM_PT_wall,
     ui.BIM_PT_sverchok,
     ui.BIM_PT_window,
     ui.BIM_PT_door,
@@ -225,8 +164,7 @@ classes = (
     stair.ToggleStairProperty,
     stair.AdjustStairTreads,
     stair.SetStairTreads,
-    stair.InputStairTreads,
-    stair.PickStairType,
+    stair.CycleStairType,
     stair.GizmoStairEdition,
     sverchok_modifier.CreateNewSverchokGraph,
     sverchok_modifier.UpdateDataFromSverchok,
@@ -239,7 +177,7 @@ classes = (
     window.FinishEditingWindow,
     window.EnableEditingWindow,
     window.RemoveWindow,
-    window.PickWindowType,
+    window.CycleWindowType,
     window.GizmoWindowEdition,
     door.BIM_OT_add_door,
     door.AddDoor,
@@ -248,19 +186,15 @@ classes = (
     door.EnableEditingDoor,
     door.RemoveDoor,
     door.ToggleDoorSwing,
-    door.PickDoorType,
+    door.CycleDoorType,
     door.GizmoDoorEdition,
     railing.BIM_OT_add_railing,
     railing.CopyRailingParameters,
     railing.AddRailing,
     railing.CancelEditingRailing,
-    railing.CycleRailingType,
     railing.FinishEditingRailing,
-    railing.PickRailingTerminalType,
     railing.FlipRailingPathOrder,
     railing.EnableEditingRailing,
-    railing.GizmoRailingSchematic,
-    railing.ToggleRailingUseManualSupports,
     railing.CancelEditingRailingPath,
     railing.FinishEditingRailingPath,
     railing.EnableEditingRailingPath,
@@ -269,39 +203,16 @@ classes = (
     roof.AddRoof,
     roof.CancelEditingRoof,
     roof.CopyRoofParameters,
-    roof.CycleRoofGenerationMethod,
     roof.FinishEditingRoof,
     roof.EnableEditingRoof,
     roof.CancelEditingRoofPath,
     roof.FinishEditingRoofPath,
     roof.EnableEditingRoofPath,
-    roof.GizmoRoofEdition,
     roof.RemoveRoof,
     roof.SetGableRoofEdgeAngle,
     mep.MEPAddObstruction,
     mep.MEPAddTransition,
     mep.MEPAddBend,
-    mep.MEPRemoveTerminalFitting,
-    mep.SelectMEPPathMembers,
-    mep.MEPJoinSegments,
-    mep_bend_preview.EnableBendPreview,
-    mep_bend_preview.FinishBendPreview,
-    mep_bend_preview.CancelBendPreview,
-    mep_bend_preview.EnableBendPreviewFromBend,
-    mep_bend_preview.GizmoBendPreview,
-    mep.EnableEditingPipeSegment,
-    mep.FinishEditingPipeSegment,
-    mep.CancelEditingPipeSegment,
-    mep.EnableEditingDuctSegment,
-    mep.FinishEditingDuctSegment,
-    mep.CancelEditingDuctSegment,
-    mep.ExtendPipeSegmentToCursor,
-    mep.ExtendDuctSegmentToCursor,
-    mep.SplitPipeSegmentAtCursor,
-    mep.SplitDuctSegmentAtCursor,
-    mep.GizmoPipeSegmentEdition,
-    mep.GizmoDuctSegmentEdition,
-    mep.GizmoMEPActions,
     external.ApplyExternalParametricGeometry,
 )
 
@@ -353,17 +264,15 @@ def register():
     bpy.types.Scene.BIMModelProperties = bpy.props.PointerProperty(type=prop.BIMModelProperties)
     bpy.types.Scene.BIMPolylineProperties = bpy.props.PointerProperty(type=prop.BIMPolylineProperties)
     bpy.types.Object.BIMArrayProperties = bpy.props.PointerProperty(type=prop.BIMArrayProperties)
+    bpy.types.Object.BIMStairProperties = bpy.props.PointerProperty(type=prop.BIMStairProperties)
     bpy.types.Object.BIMSverchokProperties = bpy.props.PointerProperty(type=prop.BIMSverchokProperties)
-    # Per-parametric-type ``BIM<Name>Properties`` PointerProperties — driven by
-    # ``tool.Parametric.EDIT_TYPES``; adding a registry entry is the single touchpoint.
-    tool.Parametric.register_object_properties(prop)
+    bpy.types.Object.BIMWindowProperties = bpy.props.PointerProperty(type=prop.BIMWindowProperties)
+    bpy.types.Object.BIMDoorProperties = bpy.props.PointerProperty(type=prop.BIMDoorProperties)
+    bpy.types.Object.BIMRailingProperties = bpy.props.PointerProperty(type=prop.BIMRailingProperties)
+    bpy.types.Object.BIMRoofProperties = bpy.props.PointerProperty(type=prop.BIMRoofProperties)
     bpy.types.Object.BIMExternalParametricGeometryProperties = bpy.props.PointerProperty(
         type=prop.BIMExternalParametricGeometryProperties
     )
-    bpy.types.Scene.BIMPreviewProperties = bpy.props.PointerProperty(type=prop.BIMPreviewProperties)
-    bpy.types.WindowManager.BIMParametricEditDialogPrefs = bpy.props.PointerProperty(
-        type=prop.BIMParametricEditDialogPrefs
-    )
 
     bpy.types.VIEW3D_MT_add.prepend(ui.add_menu)
     bpy.app.handlers.load_post.append(handler.load_post)
@@ -372,17 +281,6 @@ def register():
 
 
 def unregister():
-    # DecorationsHandler is installed lazily by bim.show_openings; tear it down
-    # (along with its persistent depsgraph / undo / redo / load cache handlers)
-    # before the rest of unregister so those handlers can't fire against
-    # half-unloaded module state.
-    opening.DecorationsHandler.uninstall()
-
-    # Network path overlays attach SpaceView3D draw handlers on toggle;
-    # uninstall here so addon disable / Blender shutdown doesn't leak them.
-    decorator.MEPSystemPathDecorator.uninstall()
-    decorator.WallSystemPathDecorator.uninstall()
-
     if not bpy.app.background:
         for tool_data in reversed(tools):
             bpy.utils.unregister_tool(tool_data.tool)
@@ -390,11 +288,13 @@ def unregister():
     del bpy.types.Scene.BIMModelProperties
     del bpy.types.Scene.BIMPolylineProperties
     del bpy.types.Object.BIMArrayProperties
+    del bpy.types.Object.BIMStairProperties
     del bpy.types.Object.BIMSverchokProperties
-    tool.Parametric.unregister_object_properties()
+    del bpy.types.Object.BIMWindowProperties
+    del bpy.types.Object.BIMDoorProperties
+    del bpy.types.Object.BIMRailingProperties
+    del bpy.types.Object.BIMRoofProperties
     del bpy.types.Object.BIMExternalParametricGeometryProperties
-    del bpy.types.Scene.BIMPreviewProperties
-    del bpy.types.WindowManager.BIMParametricEditDialogPrefs
 
     bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.types.VIEW3D_MT_add.remove(ui.add_menu)

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

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

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

@@ -37,9 +37,7 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
-from bonsai.bim.module.model.wall_offset_gizmos import WALL_OFFSET_GIZMO_CONFIGS
 from bonsai.bim.module.model.window import create_bm_box, create_bm_window
-from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin, PickTypeMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMDoorProperties
@@ -568,58 +566,103 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class _DoorEditMixin(FeatureModifierEditMixin):
-    """Type-specific hooks for door parametric-edit operators. Multi-object —
-    iterates ``tool.Blender.get_selected_objects()`` so a finish/cancel applies
-    to every selected door at once."""
-
-    pset_name = "BBIM_Door"
-
-    @classmethod
-    def _iter_targets(cls, context: bpy.types.Context) -> list[bpy.types.Object]:
-        return tool.Blender.get_selected_objects()
-
-    @classmethod
-    def _is_element_type(cls, element):
-        return tool.Parametric.is_door(element)
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        return tool.Model.get_door_props(obj)
-
-    @classmethod
-    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_door_modifier_representation(obj)
-
-
-class CancelEditingDoor(_DoorEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class CancelEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.cancel_editing_door"
     bl_label = "Cancel Editing Door on Selected Objects"
     bl_description = "Cancel editing and revert door parameters to their previous values"
     bl_options = {"REGISTER", "UNDO"}
 
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cancel_targets(context)
+    def cancel_editing_door_on_object(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Door", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+
+        # restore previous settings since editing was canceled
+        props.set_props_kwargs_from_ifc_data(data)
+
+        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+        core.switch_representation(
+            tool.Ifc,
+            tool.Geometry,
+            obj=obj,
+            representation=body,
+        )
+
+        props.is_editing = False
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.cancel_editing_door_on_object(obj)
+        return {"FINISHED"}
 
 
-class FinishEditingDoor(_DoorEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.finish_editing_door"
     bl_label = "Finish Editing Door on Selected Objects"
     bl_description = "Apply changes and finish editing door parameters"
     bl_options = {"REGISTER", "UNDO"}
 
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._finish_targets(context)
+    def finish_editing_door_on_object(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+
+        door_data = props.get_general_kwargs(convert_to_project_units=True)
+        lining_props = props.get_lining_kwargs(convert_to_project_units=True)
+        panel_props = props.get_panel_kwargs(convert_to_project_units=True)
+
+        door_data["lining_properties"] = lining_props
+        door_data["panel_properties"] = panel_props
+
+        props.is_editing = False
+
+        update_door_modifier_representation(obj)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            tool.Model.mark_thumbnail_for_update(element_type)
+
+        pset = tool.Pset.get_element_pset(element, "BBIM_Door")
+        door_data = tool.Ifc.get().createIfcText(json.dumps(door_data, default=list))
+        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": door_data})
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.finish_editing_door_on_object(obj)
+        return {"FINISHED"}
 
 
-class EnableEditingDoor(_DoorEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_door"
     bl_label = "Enable Editing Door on Selected Objects"
     bl_description = "Enter edit mode to modify door parameters interactively"
     bl_options = {"REGISTER", "UNDO"}
 
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._enable_targets(context)
+    def edit_door_on_obj(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Door", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        data.update(tool.Model.get_constituents_props_data(element))
+
+        # required since we could load pset from .ifc and BIMDoorProperties won't be set
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.edit_door_on_obj(obj)
+        return {"FINISHED"}
 
 
 class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
@@ -630,7 +673,7 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
     def remove_door_on_object(self, obj: bpy.types.Object) -> None:
         element = tool.Ifc.get_entity(obj)
         assert element
-        if not tool.Parametric.is_door(element):
+        if not tool.Blender.Modifier.is_door(element):
             return
         props = tool.Model.get_door_props(obj)
         props.is_editing = False
@@ -645,8 +688,12 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
+    """Toggle door swing direction and optionally flip door geometry.
+
+    Shift+Click (when flip_geometry=True): Flip geometry only without changing door direction"""
+
     bl_idname = "bim.toggle_door_swing"
-    bl_label = "Change Door Swing"
+    bl_label = "Toggle Door Swing"
     bl_options = {"REGISTER", "UNDO"}
 
     flip_geometry: bpy.props.BoolProperty(name="Flip Geometry", default=False)
@@ -657,15 +704,6 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         name="Skip Direction Change", default=False, options={"HIDDEN", "SKIP_SAVE"}
     )
 
-    @classmethod
-    def description(cls, context: bpy.types.Context, properties: bpy.types.OperatorProperties) -> str:
-        if properties.flip_geometry:
-            return (
-                "Swing the door from the opposite side of the wall. "
-                "Shift+click: mirror the door without changing which side it opens to"
-            )
-        return "Move the door hinge to the opposite side"
-
     def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
         self.skip_direction_change = event.shift
         return self.execute(context)
@@ -692,7 +730,7 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         if not element:
             return {"CANCELLED"}
 
-        is_door = tool.Parametric.is_door(element)
+        is_door = tool.Blender.Modifier.is_door(element)
 
         if self.flip_geometry:
             tool.Geometry.flip_object(obj, self.flip_local_axes)
@@ -706,20 +744,20 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class PickDoorType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
-    """Pick a door type from a popup menu."""
+class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator, gizmo.CycleTypeMixin):
+    """Cycle through available door types. Shift+click to cycle in reverse."""
 
-    bl_idname = "bim.pick_door_type"
-    bl_label = "Pick Door Type"
+    bl_idname = "bim.cycle_door_type"
+    bl_label = "Cycle Door Type"
     bl_options = {"REGISTER", "UNDO"}
 
-    element_checker = tool.Parametric.is_door
-    props_getter = tool.Model.get_door_props
+    element_checker = "is_door"
+    props_getter = "get_door_props"
     type_literal = tool.Model.DoorType
     type_attr = "door_type"
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._pick_type(context)
+        return self._cycle_type(context)
 
 
 class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
@@ -732,7 +770,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
     enable_editing_operator = "bim.enable_editing_door"
     finish_editing_operator = "bim.finish_editing_door"
     cancel_editing_operator = "bim.cancel_editing_door"
-    pick_type_operator = "bim.pick_door_type"
+    cycle_type_operator = "bim.cycle_door_type"
 
     # Declarative dimension gizmo configuration with visibility and position
     # matrix_position lambdas replace the get_dimension_matrix_* methods
@@ -839,44 +877,14 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
                 p.get_transom_window_center_z(),
             ),
         ),
-        *WALL_OFFSET_GIZMO_CONFIGS,
     ]
 
-    # Big quarter-arc hit shapes cover much of the door face — without a
-    # negative select_bias they would steal clicks from the small dimension
-    # and edit gizmos drawn on top of them.
-    SWING_ARC_SELECT_BIAS = -1000.0
-    swing_arc_operator = "bim.toggle_door_swing"
-
-    swing_arc_props = [
-        gizmo.SwingArcConfig(
-            name="primary",
-            visibility_condition=lambda p: p.is_editing and "SLIDING" not in p.door_type,
-            hinge_x=lambda p: (
-                p.overall_width if p.door_type.endswith("RIGHT") and "DOUBLE_DOOR" not in p.door_type else 0.0
-            ),
-            hinge_y=lambda p: p.lining_offset,
-            panel_width=lambda p: p.overall_width / 2 if "DOUBLE_DOOR" in p.door_type else p.overall_width,
-            x_mirror=lambda p: p.door_type.endswith("RIGHT") and "DOUBLE_DOOR" not in p.door_type,
-        ),
-        gizmo.SwingArcConfig(
-            name="secondary",
-            visibility_condition=lambda p: p.is_editing
-            and "DOUBLE_DOOR" in p.door_type
-            and "SLIDING" not in p.door_type,
-            hinge_x=lambda p: p.overall_width,
-            hinge_y=lambda p: p.lining_offset,
-            panel_width=lambda p: p.overall_width / 2,
-            x_mirror=lambda _p: True,
-        ),
-    ]
-
-    props_getter = tool.Model.get_door_props
+    props_getter = "get_door_props"
     gizmo_pref_name = "door"
 
     @classmethod
     def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
-        return tool.Parametric.is_door(element)
+        return tool.Blender.Modifier.is_door(element)
 
     def get_icon_y_extent(self, props: "BIMDoorProperties") -> tuple[float, float]:
         """Get Y extents for door icon positioning.
@@ -894,20 +902,24 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         return (furthest_y, furthest_y)
 
     def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create one (main, flip) swing-arc pair per ``swing_arc_props`` entry.
-
-        Stored as ``self.gizmo_swing_arc_<name>`` and ``self.gizmo_swing_arc_<name>_flip``
-        and pinned to ``SWING_ARC_SELECT_BIAS`` so other door gizmos win selection."""
+        """Create door-specific swing arc gizmos."""
         prefs = tool.Blender.get_addon_preferences()
-        main_color = prefs.decorator_color_special[:3]
-        flip_color = prefs.decorator_color_background[:3]
-        for cfg in self.swing_arc_props:
-            main = self.create_arc_gizmo(main_color, self.swing_arc_operator, flip_geometry=False)
-            flip = self.create_arc_gizmo(flip_color, self.swing_arc_operator, flip_geometry=True)
-            for gz in (main, flip):
-                gz.select_bias = self.SWING_ARC_SELECT_BIAS
-            setattr(self, f"gizmo_swing_arc_{cfg.name}", main)
-            setattr(self, f"gizmo_swing_arc_{cfg.name}_flip", flip)
+        inactive_color = prefs.decorator_color_background[:3]
+        special_color = prefs.decorator_color_special[:3]
+
+        self.gizmo_door_type = self.create_arc_gizmo(
+            special_color,
+            "bim.toggle_door_swing",
+            prop_path="BIMDoorProperties.door_type",
+            flip_geometry=False,
+        )
+        self.gizmo_flip_arc = self.create_arc_gizmo(
+            inactive_color,
+            "bim.toggle_door_swing",
+            prop_path="BIMDoorProperties.door_type",
+            flip_geometry=True,
+            flip_local_axes="XY",
+        )
 
     def _refresh_element_specific(
         self, context: bpy.types.Context, mw: Matrix, props: "BIMDoorProperties"  # noqa: ARG002
@@ -926,23 +938,29 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         self._update_view_dependent_dimensions(context, mw, props)
 
     def update_swing_gizmos(self, mw: Matrix, props: "BIMDoorProperties") -> None:
-        """Position each declared swing-arc pair per its config + props state."""
-        mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
-        for cfg in self.swing_arc_props:
-            main = getattr(self, f"gizmo_swing_arc_{cfg.name}")
-            flip = getattr(self, f"gizmo_swing_arc_{cfg.name}_flip")
-            show = cfg.visibility_condition(props)
-            main_visible = self.update_gizmo_visibility(main, show)
-            flip_visible = self.update_gizmo_visibility(flip, show)
-            if not (main_visible or flip_visible):
-                continue
-            x_flip = Matrix.Scale(-1, 4, (1, 0, 0)) if cfg.x_mirror(props) else Matrix.Identity(4)
-            transform = (
-                Matrix.Translation(V_(cfg.hinge_x(props), cfg.hinge_y(props), 0))
-                @ Matrix.Scale(cfg.panel_width(props), 4)
-                @ x_flip
-            )
-            if main_visible:
-                main.matrix_basis = mw @ transform
-            if flip_visible:
-                flip.matrix_basis = mw @ transform @ mirror_y
+        """Update swing gizmo position and color based on editing state."""
+        prefs = tool.Blender.get_addon_preferences()
+        door_gizmo_prefs = prefs.gizmos.door
+
+        door_type_visible = self.update_gizmo_visibility(
+            self.gizmo_door_type, props.is_editing, door_gizmo_prefs.swing_arc
+        )
+        flip_arc_visible = self.update_gizmo_visibility(
+            self.gizmo_flip_arc, props.is_editing, door_gizmo_prefs.flip_arc
+        )
+
+        if not door_type_visible and not flip_arc_visible:
+            return
+
+        swing_x_offset = props.overall_width if "RIGHT" in props.door_type else 0.0
+        base_swing_transform = Matrix.Translation(V_(swing_x_offset, props.lining_offset, 0)) @ Matrix.Scale(
+            props.overall_width, 4
+        )
+
+        if door_type_visible:
+            self.gizmo_door_type.matrix_basis = mw @ base_swing_transform
+            self.gizmo_door_type.color = prefs.decorations_colour[:3]
+
+        if flip_arc_visible:
+            mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
+            self.gizmo_flip_arc.matrix_basis = mw @ base_swing_transform @ mirror_y

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

@@ -1,247 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Generic single-click "Add Opening" gizmo for hosts (walls, slabs, roofs).
-
-One GizmoGroup serves every IFC host type that exposes ``HasOpenings``:
-parametric LAYER2 walls, any ``IfcSlab``, and any ``IfcRoof``. The poll
-guards host-host pairings so this gizmo never overlaps with the existing
-wall-join / extend-vertically gizmos. The positioner dispatches on element
-type — walls use axis-projection + camera-facing-Y math (which requires the
-parametric layer-set); slabs and roofs use a world-Z face bias driven by
-the void object's elevation against the host's bounding box."""
-
-import bpy
-from mathutils import Vector
-
-import bonsai.tool as tool
-from bonsai.bim.module.drawing import gizmos as gizmo
-from bonsai.bim.module.model.opening import is_filling_supported
-from bonsai.bim.module.model.wall import (
-    _get_wall_geom_cached,
-    _wall_camera_facing_icon_y,
-    _wall_gizmo_poll_gate,
-    _WallGeomCachedBillboardingMixin,
-)
-
-
-def is_supported_host(element) -> bool:
-    """Total predicate (None → False). Walls accept either a parametric
-    LAYER2 wall OR a fillet-corner wall (both expose a usable axis +
-    layer-set for the anchor math); slabs and roofs only need the bound
-    box so any IfcSlab / IfcRoof qualifies regardless of parametric
-    modifier state."""
-    if element is None:
-        return False
-    return tool.Parametric.is_path_connectable_wall(element) or element.is_a("IfcSlab") or element.is_a("IfcRoof")
-
-
-def is_supported_filling_or_opening(element) -> bool:
-    """Total predicate for the add-opening gizmo poll. ``None`` (raw Blender
-    mesh) is accepted because the operator converts unclassified meshes
-    into ``IfcOpeningElement`` instances. ``IfcOpeningElement`` is accepted
-    because reassigning an existing opening to a new host is a legal path
-    through the operator. Otherwise defer to the generator's own
-    supported-filling predicate."""
-    if element is None:
-        return True
-    if element.is_a("IfcOpeningElement"):
-        return True
-    return is_filling_supported(element)
-
-
-def _resolve_active_host(context: bpy.types.Context, n_selected: int):
-    """Shared poll prologue: gizmo gate + selection cardinality + active-in-
-    selected + IFC entity lookup + supported-host predicate. Returns the
-    active element on success, ``None`` on any failure — callers chain their
-    feature-specific checks past the early-return."""
-    if not _wall_gizmo_poll_gate(context):
-        return None
-    selected = tool.Blender.get_selected_objects()
-    if len(selected) != n_selected:
-        return None
-    active = context.active_object
-    if active is None or active not in selected:
-        return None
-    element = tool.Ifc.get_entity(active)
-    if not element or not is_supported_host(element):
-        return None
-    return element
-
-
-class GizmoHostAddOpening(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
-    """Activates when exactly two objects are selected and one is a fillable
-    host (wall / slab / roof) while the other is a valid filling (door /
-    window / existing opening, or a plain Blender mesh).
-
-    Selection-order independent: the host role is identified by class, not
-    by active state. The "+" icon anchors on the host's surface regardless
-    of which object was clicked first. The dispatched ``bim.add_opening``
-    operator also handles either order.
-
-    Per-frame positioning keeps the icon facing the camera as the viewport
-    orbits."""
-
-    bl_idname = "OBJECT_GGT_bim_host_add_opening"
-    bl_label = "Host Add Opening Gizmo"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "WINDOW"
-    bl_options = {"3D", "PERSISTENT"}
-
-    @classmethod
-    def poll(cls, context: bpy.types.Context) -> bool:
-        if not _wall_gizmo_poll_gate(context):
-            return False
-        selected = list(tool.Blender.get_selected_objects())
-        if len(selected) != 2:
-            return False
-        active = context.active_object
-        if active is None or active not in selected:
-            return False
-        a_element = tool.Ifc.get_entity(selected[0])
-        b_element = tool.Ifc.get_entity(selected[1])
-        return cls._is_apply_opening_pair(a_element, b_element) or cls._is_apply_opening_pair(b_element, a_element)
-
-    @staticmethod
-    def _is_apply_opening_pair(host_element, filling_element) -> bool:
-        """``host_element`` qualifies as a fillable host AND ``filling_element``
-        qualifies as a filling. Used twice with the operands swapped so the
-        gizmo polls true regardless of which of the two selected objects is
-        active."""
-        if not is_supported_host(host_element):
-            return False
-        if not hasattr(host_element, "HasOpenings"):
-            return False
-        return is_supported_filling_or_opening(filling_element)
-
-    def setup(self, context: bpy.types.Context) -> None:
-        default_color, highlight_color = self.get_decoration_colors()
-        self.add_opening_icon = self.setup_icon_gizmo(
-            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.add_opening"
-        )
-
-    def position_gizmos(self, context: bpy.types.Context) -> None:
-        selected = list(tool.Blender.get_selected_objects())
-        if len(selected) != 2:
-            return
-        a, b = selected[0], selected[1]
-        a_element = tool.Ifc.get_entity(a)
-        b_element = tool.Ifc.get_entity(b)
-        if is_supported_host(a_element):
-            host_obj, host_element, other = a, a_element, b
-        elif is_supported_host(b_element):
-            host_obj, host_element, other = b, b_element, a
-        else:
-            return
-
-        if tool.Parametric.is_path_connectable_wall(host_element):
-            world_pos = wall_anchor(context, self, host_obj, other)
-        else:
-            world_pos = layer3_anchor(host_obj, other)
-        if world_pos is None:
-            return
-        self.add_opening_icon.matrix_basis = gizmo.billboarded_at(world_pos, gizmo.get_billboard_rotation(context))
-
-
-def wall_anchor(
-    context: bpy.types.Context, group: bpy.types.GizmoGroup, wall_obj: bpy.types.Object, other: bpy.types.Object
-) -> Vector | None:
-    """World-space anchor for the add-opening icon on a wall host: void origin
-    projected onto the wall reference-line X (clamped to wall extents), lifted to
-    the camera-facing wall-local Y."""
-    geom = _get_wall_geom_cached(group, wall_obj)
-    if not geom:
-        return None
-    mw = wall_obj.matrix_world
-    wall_local = mw.inverted() @ other.matrix_world.translation
-    local_x = max(geom["anchor_x"], min(wall_local.x, geom["anchor_x"] + geom["length"]))
-    icon_y = _wall_camera_facing_icon_y(context, mw, geom)
-    base_world = mw @ Vector((local_x, icon_y, 0.0))
-    top_world = mw @ Vector((local_x, icon_y, geom["height"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET))
-    return gizmo.BaseParametricGizmoGroup.pick_visible_anchor(context, base_world, top_world)
-
-
-def layer3_anchor(host_obj: bpy.types.Object, other: bpy.types.Object) -> Vector:
-    """World-space anchor for the add-opening icon on a LAYER3 host (slab / roof):
-    void's world XY, lifted just above the host's top face. Predictable height
-    regardless of where the void sits vertically — clicking the icon places the
-    opening at the void's XY, and the operator handles the actual cut depth."""
-    bbox = tool.Blender.get_object_world_bounding_box(host_obj)
-    anchor_xy = other.matrix_world.translation.xy
-    top_z = bbox["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
-    return Vector((anchor_xy.x, anchor_xy.y, top_z))
-
-
-def host_toggle_anchor(host_obj: bpy.types.Object) -> Vector:
-    """Object origin XY, lifted just above the topmost mesh vertex. Tracks
-    the parametric origin (useful reference even when the mesh extends
-    asymmetrically) and the visible top face (stays clear of sloped or
-    stepped bodies)."""
-    origin = host_obj.matrix_world.translation
-    top_z = tool.Blender.get_object_world_bounding_box(host_obj)["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
-    return Vector((origin.x, origin.y, top_z))
-
-
-class GizmoHostToggleOpenings(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
-    """Fallback toggle-openings icon for hosts that lack their own
-    parametric-edit toolbar — slabs today, plus any foreign-authored
-    IfcRoof that carries no BBIM_Roof pset (so ``GizmoRoofEdition`` doesn't
-    poll for it). Walls and parametric roofs already render an idle-row
-    toggle next to the pen and are excluded from this poll.
-
-    When slab parametric-edit lands the slab branch will pen-row-handle
-    its own toggle; updating the exclusion predicate here is the only
-    migration step needed."""
-
-    bl_idname = "OBJECT_GGT_bim_host_toggle_openings"
-    bl_label = "Host Toggle Openings Gizmo"
-    bl_space_type = "VIEW_3D"
-    bl_region_type = "WINDOW"
-    bl_options = {"3D", "PERSISTENT"}
-
-    @classmethod
-    def poll(cls, context: bpy.types.Context) -> bool:
-        element = _resolve_active_host(context, n_selected=1)
-        if element is None:
-            return False
-        if not tool.Geometry.has_openings(element):
-            return False
-        # Skip when a per-feature parametric-edit gizmo already surfaces
-        # an idle-row toggle for this element — walls and parametric roofs
-        # both render their own toggle in the pen row.
-        if tool.Parametric.is_path_connectable_wall(element):
-            return False
-        if tool.Parametric.is_roof(element):
-            return False
-        return True
-
-    def setup(self, context: bpy.types.Context) -> None:
-        default_color, highlight_color = self.get_decoration_colors()
-        self.toggle_openings_icon = self.setup_icon_gizmo(
-            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.toggle_host_openings"
-        )
-
-    def position_gizmos(self, context: bpy.types.Context) -> None:
-        host_obj = context.active_object
-        if not host_obj:
-            return
-        self.toggle_openings_icon.matrix_basis = gizmo.billboarded_at(
-            host_toggle_anchor(host_obj), gizmo.get_billboard_rotation(context)
-        )

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

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

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from collections.abc import Sequence
 from math import radians
@@ -43,211 +41,8 @@ from mathutils import Matrix, Vector
 
 import bonsai.core.geometry
 import bonsai.tool as tool
-from bonsai.bim import decorator_cache
 from bonsai.bim.module.drawing.decoration import DecoratorData
 
-# Multi-entry cache for the opening preview's dissolved-edges fallback.
-# Single-entry wouldn't fit: the draw handler iterates every active opening
-# per frame, each with its own mesh. Bumped wholesale on the shared
-# decorator-cache token (depsgraph / undo / redo / load), one slot per
-# (mesh.session_uid, angle_limit). Outlier vs. the per-object caches below —
-# consulted only on world-draw-data miss, so the global wipe rarely fires in
-# steady state and the simpler invalidation is enough.
-_dissolved_edges_cache: dict[
-    tuple[int, float],
-    tuple[list[Vector], list[tuple[int, int]]],
-] = {}
-_dissolved_edges_cache_token: int = -1
-
-
-def _get_cached_dissolved_edges(
-    mesh: bpy.types.Mesh,
-    angle_limit: float = radians(1.0),
-) -> tuple[list[Vector], list[tuple[int, int]]]:
-    global _dissolved_edges_cache_token
-    token = decorator_cache.get_decorator_cache_token()
-    if token != _dissolved_edges_cache_token:
-        _dissolved_edges_cache.clear()
-        _dissolved_edges_cache_token = token
-    key = (mesh.session_uid, angle_limit)
-    cached = _dissolved_edges_cache.get(key)
-    if cached is not None:
-        return cached
-    result = tool.Geometry.get_dissolved_edges(mesh, angle_limit=angle_limit)
-    _dissolved_edges_cache[key] = result
-    return result
-
-
-# Per-object epoch: bumped only when this specific object's transform or geometry
-# updates land in the depsgraph delta. Invalidation work scales with the number
-# of changed objects, not total scene size — moving one object leaves every
-# other entry valid. Bumped by the depsgraph handler below; cleared on
-# undo/redo/load alongside the cache dicts.
-_object_epochs: dict[int, int] = {}
-
-
-@bpy.app.handlers.persistent
-def _bump_object_epochs_for_decoration(*args) -> None:
-    # depsgraph_update_post is called as (scene, depsgraph) in 4.x but the
-    # *args signature follows decorator_cache's defensive idiom.
-    depsgraph = args[1] if len(args) >= 2 else None
-    if depsgraph is None or not hasattr(depsgraph, "updates"):
-        return
-    for u in depsgraph.updates:
-        if not isinstance(u.id, bpy.types.Object):
-            continue
-        if not (u.is_updated_geometry or u.is_updated_transform):
-            continue
-        # u.id is the evaluated COW copy; the cache keys are written from the
-        # original Object (read by the draw handler), and session_uid can
-        # differ across the COW boundary. Resolve to the original before keying.
-        original = getattr(u.id, "original", u.id)
-        if original is None:
-            continue
-        uid = original.session_uid
-        _object_epochs[uid] = _object_epochs.get(uid, 0) + 1
-
-
-@bpy.app.handlers.persistent
-def _clear_decoration_caches_globally(*args) -> None:
-    # Undo/redo/load: depsgraph deltas can't be trusted to describe the
-    # transition, so wipe every per-object cache state.
-    _object_epochs.clear()
-    _world_draw_data_cache.clear()
-    _batch_cache.clear()
-
-
-def _decoration_invalidation_hooks() -> tuple:
-    return (
-        bpy.app.handlers.undo_post,
-        bpy.app.handlers.redo_post,
-        bpy.app.handlers.load_post,
-    )
-
-
-def install_decoration_cache_handlers() -> None:
-    if _bump_object_epochs_for_decoration not in bpy.app.handlers.depsgraph_update_post:
-        bpy.app.handlers.depsgraph_update_post.append(_bump_object_epochs_for_decoration)
-    for hook in _decoration_invalidation_hooks():
-        if _clear_decoration_caches_globally not in hook:
-            hook.append(_clear_decoration_caches_globally)
-
-
-def uninstall_decoration_cache_handlers() -> None:
-    try:
-        bpy.app.handlers.depsgraph_update_post.remove(_bump_object_epochs_for_decoration)
-    except ValueError:
-        pass
-    for hook in _decoration_invalidation_hooks():
-        try:
-            hook.remove(_clear_decoration_caches_globally)
-        except ValueError:
-            pass
-
-
-# Per-object world-space draw payload: line_verts (dissolved or ios_edges-filtered),
-# verts (full mesh, indexed by loop_triangles), edges_indices, tris. Entries are
-# (epoch, payload) tuples; lookup compares epoch to _object_epochs[uid], so a
-# stale entry for an object that didn't change since the last build still hits.
-_world_draw_data_cache: dict[
-    int,
-    tuple[
-        int,
-        tuple[
-            list[tuple[float, float, float]],
-            list[tuple[float, float, float]],
-            list[tuple[int, int]],
-            list[tuple[int, ...]],
-        ],
-    ],
-] = {}
-
-
-def _get_cached_world_draw_data(
-    obj: bpy.types.Object,
-) -> tuple[
-    list[tuple[float, float, float]],
-    list[tuple[float, float, float]],
-    list[tuple[int, int]],
-    list[tuple[int, ...]],
-]:
-    uid = obj.session_uid
-    epoch = _object_epochs.get(uid, 0)
-    entry = _world_draw_data_cache.get(uid)
-    if entry is not None and entry[0] == epoch:
-        return entry[1]
-
-    mw = obj.matrix_world
-    verts = [tuple(mw @ v.co) for v in obj.data.vertices]
-    obj.data.calc_loop_triangles()
-    tris = [tuple(t.vertices) for t in obj.data.loop_triangles]
-
-    ios_edges_attribute = obj.data.attributes.get("ios_edges")
-    if ios_edges_attribute:
-        # Loader-curated edges: read the attribute aligned with bm.edges order.
-        bm = bmesh.new()
-        bm.from_mesh(obj.data)
-        edges_indices = [
-            tuple(v.index for v in e.verts) for i, e in enumerate(bm.edges) if ios_edges_attribute.data[i].value
-        ]
-        bm.free()
-        line_verts = verts
-    else:
-        dissolved, edges_indices = _get_cached_dissolved_edges(obj.data)
-        line_verts = [tuple(mw @ v) for v in dissolved]
-
-    result = (line_verts, verts, edges_indices, tris)
-    _world_draw_data_cache[uid] = (epoch, result)
-    return result
-
-
-# GPUBatch cache: skip per-frame batch_for_shader. Entries are (epoch, batch);
-# lookup compares epoch to _object_epochs[uid] so other objects' batches stay
-# alive when one object's depsgraph delta bumps only its own epoch. The cached
-# batches reference GPU-side buffers tied to Blender's built-in shaders, which
-# are themselves cached by name (gpu.shader.from_builtin returns the same
-# handle each call), so they stay drawable across frames.
-_batch_cache: dict[tuple[int, str], tuple[int, "gpu.types.GPUBatch"]] = {}
-
-# CAD hidden-line convention for the occluded back-pass: world-space dashes so
-# density stays coherent across zoom. Dash + gap = period; dash_width controls
-# the "on" portion.
-_DASH_PERIOD_METERS: float = 0.20
-_DASH_WIDTH_METERS: float = 0.10
-# Solid front pass is rendered wider than the dashed back pass so its halo
-# overpowers the dashed center on visible edges even when the WIRE-display
-# overlay biases the depth buffer at outline pixels.
-_DASH_LINE_WIDTH: float = 1.5
-_SOLID_LINE_WIDTH: float = 2.5
-# Per-iteration default line width used by every non-occlusion draw call in
-# this decorator's ``__call__``. Restored after each occlusion pair so the
-# next draw isn't silently inheriting the wider solid-pass override.
-_DEFAULT_LINE_WIDTH: float = 2.0
-
-
-def _get_cached_batch_or_none(cache_key: tuple[int, str]) -> "gpu.types.GPUBatch | None":
-    uid = cache_key[0]
-    epoch = _object_epochs.get(uid, 0)
-    entry = _batch_cache.get(cache_key)
-    if entry is not None and entry[0] == epoch:
-        return entry[1]
-    return None
-
-
-def _store_batch_in_cache(cache_key: tuple[int, str], batch: "gpu.types.GPUBatch") -> None:
-    uid = cache_key[0]
-    epoch = _object_epochs.get(uid, 0)
-    _batch_cache[cache_key] = (epoch, batch)
-
-
-def is_filling_supported(element) -> bool:
-    """True when Bonsai's opening generator can derive an opening from this
-    element. IFC's schema permits any IfcElement as a filling; Bonsai
-    currently supports only IfcDoor and IfcWindow because those are the
-    classes with OverallWidth/OverallHeight attributes (or their types'
-    ELEVATION_VIEW profiles) that the generator can consume."""
-    return element is not None and element.is_a() in ("IfcDoor", "IfcWindow")
-
 
 class FilledOpeningGenerator:
     def generate(
@@ -255,15 +50,9 @@ class FilledOpeningGenerator:
         filling_obj: bpy.types.Object,
         voided_obj: bpy.types.Object,
         target: Optional[Vector] = None,
-        preserve_placement: bool = False,
     ) -> Union[None, str]:
         """
         :param target: Target opening position. If ommited, cursor position is used.
-        :param preserve_placement: If True, keep ``filling_obj.matrix_world`` as-is
-            and skip the snap-to-wall-axis / rl1-rl2 Z-default logic. The opening
-            is still created at the filling's current world position. Useful
-            when the caller (e.g. the SHIFT-add-opening gizmo flow) has
-            already positioned the filling intentionally.
         :return: None if there was no errors, otherwise returns a string with error message.
         """
         props = tool.Model.get_model_props()
@@ -285,7 +74,7 @@ class FilledOpeningGenerator:
             should_set_z_level = False
 
         # Sometimes, the voided_obj may be an aggregate, which won't have any representation.
-        if not preserve_placement and voided_obj.data:
+        if voided_obj.data:
             raycast = voided_obj.closest_point_on_mesh(voided_obj.matrix_world.inverted() @ target, distance=0.01)
             if not raycast[0]:
                 target = filling_obj.matrix_world.translation.copy()
@@ -418,16 +207,18 @@ class FilledOpeningGenerator:
                 representation = tool.Geometry.get_representation_by_context(voided_element, context)
                 assert representation
 
-                tool.Geometry.recut_host(voided_obj, representation)
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc,
+                    tool.Geometry,
+                    obj=voided_obj,
+                    representation=representation,
+                )
 
     def regenerate_from_type(self, usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
         relating_type = settings["relating_type"]
 
-        # Filling type-switch on an array of fillings fans out N host recuts —
-        # one per related object — without batching. Coalesce them.
-        with tool.Geometry.batch_host_recut():
-            for related_object in settings["related_objects"]:
-                self._regenerate_from_type(related_object)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)
 
     def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
         filling = related_object
@@ -476,7 +267,12 @@ class FilledOpeningGenerator:
             representation = tool.Geometry.get_active_representation(voided_obj)
             if not representation:
                 continue
-            tool.Geometry.recut_host(voided_obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc,
+                tool.Geometry,
+                obj=voided_obj,
+                representation=representation,
+            )
 
     def generate_opening_from_filling(
         self,
@@ -611,31 +407,6 @@ class RecalculateFill(bpy.types.Operator, tool.Ifc.Operator):
         return context.selected_objects
 
     def _execute(self, context):
-        # N selected fillings × M voided host parts would fire N×M host recuts
-        # without batching. Coalesce per host.
-        with tool.Geometry.batch_host_recut():
-            return self._recalculate_fills(context)
-
-    def _recalculate_fills(self, context):
-        # Refresh each selected filling's mapped opening source before
-        # recutting the host. Dedup by source id covers the common shared-
-        # source case in one rewrite while leaving unrelated sibling sources
-        # untouched.
-        seen_source_ids: set[int] = set()
-        for obj in context.selected_objects:
-            element = tool.Ifc.get_entity(obj)
-            if not element or not element.FillsVoids:
-                continue
-            opening = element.FillsVoids[0].RelatingOpeningElement
-            body = tool.Geometry.get_body_representation(opening)
-            if body is None:
-                continue
-            source = tool.Geometry.resolve_mapped_representation(body)
-            if source.id() in seen_source_ids:
-                continue
-            seen_source_ids.add(source.id())
-            tool.Model.regenerate_filling_opening_body(element)
-
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
             if not element or not element.FillsVoids:
@@ -664,7 +435,12 @@ class RecalculateFill(bpy.types.Operator, tool.Ifc.Operator):
                 if building_obj and building_obj.data:
                     representation = tool.Geometry.get_active_representation(building_obj)
                     if representation:
-                        tool.Geometry.recut_host(building_obj, representation)
+                        bonsai.core.geometry.switch_representation(
+                            tool.Ifc,
+                            tool.Geometry,
+                            obj=building_obj,
+                            representation=representation,
+                        )
 
         # Refresh cut decorator
         DecoratorData.cut_cache.clear()
@@ -782,29 +558,6 @@ class AddBoolean(Operator, tool.Ifc.Operator):
         tool.Root.reload_item_decorator()
 
 
-class ToggleHostOpenings(Operator, tool.Ifc.Operator):
-    bl_idname = "bim.toggle_host_openings"
-    bl_label = "Toggle Openings"
-    bl_description = "Show or hide opening fills (doors and windows) in the viewport\n\nHotkey: Alt+O"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Model.has_selected_ifc_objects():
-            cls.poll_message_set("No IFC objects selected.")
-            return False
-        return True
-
-    def _execute(self, context: bpy.types.Context) -> set[str]:
-        # Opening visibility is independent of host geometry — don't commit any
-        # active parametric edit; the user can keep editing the host.
-        if tool.Model.get_model_props().openings:
-            bpy.ops.bim.edit_openings(apply_all=True)
-        else:
-            bpy.ops.bim.show_openings()
-        return {"FINISHED"}
-
-
 class ShowOpenings(Operator, tool.Ifc.Operator):
     bl_idname = "bim.show_openings"
     bl_label = "Show Openings"
@@ -986,29 +739,27 @@ class EditOpenings(Operator, tool.Ifc.Operator):
         for opening_element in opening_elements:
             opening_obj = tool.Ifc.get_object(opening_element)
 
+            similar_openings = bonsai.core.geometry.get_similar_openings(tool.Ifc, opening_element)
+            similar_openings_building_objs = bonsai.core.geometry.get_similar_openings_building_objs(
+                tool.Ifc, similar_openings
+            )
+            building_objs.update(similar_openings_building_objs)
+
             if opening_obj:
-                opening_edited = tool.Ifc.is_edited(opening_obj)
-                opening_moved = tool.Ifc.is_moved(opening_obj)
-                # Sibling walls only need a viewport-level refresh when the
-                # opening's shape or placement actually changed — a pure
-                # show/hide toggle leaves them in their existing state.
-                if opening_edited or opening_moved:
-                    similar_openings = bonsai.core.geometry.get_similar_openings(tool.Ifc, opening_element)
-                    similar_openings_building_objs = bonsai.core.geometry.get_similar_openings_building_objs(
-                        tool.Ifc, similar_openings
-                    )
-                    building_objs.update(similar_openings_building_objs)
-                    if opening_edited:
-                        tool.Geometry.run_geometry_update_representation(obj=opening_obj)
-                    else:
-                        bonsai.core.geometry.edit_object_placement(
-                            tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj
-                        )
+                if tool.Ifc.is_edited(opening_obj):
+                    tool.Geometry.run_geometry_update_representation(obj=opening_obj)
+                    bonsai.core.geometry.edit_similar_opening_placement(
+                        tool.Geometry, opening_element, similar_openings
+                    )
+                elif tool.Ifc.is_moved(opening_obj):
+                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj)
                     bonsai.core.geometry.edit_similar_opening_placement(
                         tool.Geometry, opening_element, similar_openings
                     )
-                    building_objs.update(self.get_all_building_objects_of_similar_openings(opening_element))
 
+                building_objs.update(
+                    self.get_all_building_objects_of_similar_openings(opening_element)
+                )  # NB this has nothing to do with clone similar_opening
                 tool.Ifc.unlink(element=opening_element)
                 if props.representation_obj == opening_obj:
                     props.representation_obj = None
@@ -1046,12 +797,6 @@ class CloneOpening(Operator, tool.Ifc.Operator):
         return True
 
     def _execute(self, context):
-        # The voided host may be an aggregate whose parts each get recut.
-        # Coalesce per host so a many-parts aggregate doesn't fan out.
-        with tool.Geometry.batch_host_recut():
-            return self._clone_opening(context)
-
-    def _clone_opening(self, context):
         # NOTE: Operator displayed in UI only with IfcOpeningElement being active.
         ifc_file = tool.Ifc.get()
         objects = bpy.context.selected_objects
@@ -1081,7 +826,12 @@ class CloneOpening(Operator, tool.Ifc.Operator):
                 continue
             representation = tool.Geometry.get_active_representation(obj)
             assert representation
-            tool.Geometry.recut_host(obj, representation)
+            bonsai.core.geometry.switch_representation(
+                tool.Ifc,
+                tool.Geometry,
+                obj=obj,
+                representation=representation,
+            )
 
         return {"FINISHED"}
 
@@ -1191,6 +941,7 @@ class SelectBoolean(Operator):
         return {"FINISHED"}
 
 
+# TODO: merge with ProfileDecorator?
 class DecorationsHandler:
     installed = None
 
@@ -1200,7 +951,6 @@ class DecorationsHandler:
             cls.uninstall()
         handler = cls()
         cls.installed = SpaceView3D.draw_handler_add(handler, (context,), "WINDOW", "POST_VIEW")
-        install_decoration_cache_handlers()
 
     @classmethod
     def uninstall(cls):
@@ -1209,79 +959,15 @@ class DecorationsHandler:
         except ValueError:
             pass
         cls.installed = None
-        uninstall_decoration_cache_handlers()
 
-    def _get_or_build_batch(self, shader, shader_type, content_pos, indices=None, cache_key=None):
-        if cache_key is not None:
-            cached = _get_cached_batch_or_none(cache_key)
-            if cached is not None:
-                return cached
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
         if not tool.Blender.validate_shader_batch_data(content_pos, indices):
-            return None
-        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
-        if cache_key is not None:
-            _store_batch_in_cache(cache_key, batch)
-        return batch
-
-    def draw_batch(self, shader_type, content_pos, color, indices=None, cache_key=None):
-        shader = self.line_shader if shader_type == "LINES" else self.shader
-        batch = self._get_or_build_batch(shader, shader_type, content_pos, indices, cache_key=cache_key)
-        if batch is None:
             return
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
         shader.uniform_float("color", color)
         batch.draw(shader)
 
-    def _draw_lines_with_occlusion(self, verts, color, edges_indices, cache_key=None):
-        # Two-pass CAD hidden-line convention. Both passes use POLYLINE_UNIFORM_COLOR.
-        #
-        # The solid front pass is rendered WIDER than the dashed back pass so it
-        # produces a halo around the line center, beyond the depth-bias zone that
-        # Blender's overlay engine writes when an opening is set to WIRE display.
-        # Without the width difference, the wire bias makes the center-pixel
-        # ``LESS_EQUAL`` comparison fail (line ends up slightly behind the biased
-        # wire depth) so the solid pass would lose to the dashed back pass even
-        # on visible edges. The halo gives the solid pass enough screen-space to
-        # overpower the dashed pattern visually.
-        #
-        # Dashed renders first at the standard width so the solid overlay's wider
-        # halo cleanly hides it on visible edges; on occluded edges the solid
-        # ``LESS_EQUAL`` pass fails against the wall depth and the dashed remains.
-        front_batch = self._get_or_build_batch(self.line_shader, "LINES", verts, edges_indices, cache_key=cache_key)
-        if front_batch is None:
-            return
-
-        dashed_cache_key = (cache_key[0], cache_key[1] + "_dashed") if cache_key is not None else None
-        dash_batch = None
-        if dashed_cache_key is not None:
-            dash_batch = _get_cached_batch_or_none(dashed_cache_key)
-        if dash_batch is None:
-            dash_verts, dash_edges = tool.Blender.build_dashed_line_segments(
-                verts, edges_indices, _DASH_PERIOD_METERS, _DASH_WIDTH_METERS
-            )
-            dash_batch = self._get_or_build_batch(self.line_shader, "LINES", dash_verts, dash_edges)
-            if dash_batch is not None and dashed_cache_key is not None:
-                _store_batch_in_cache(dashed_cache_key, dash_batch)
-
-        original_depth_test = gpu.state.depth_test_get()
-        front_color = list(color)
-        front_color[3] = 1.0
-        self.line_shader.uniform_float("color", front_color)
-
-        if dash_batch is not None:
-            self.line_shader.uniform_float("lineWidth", _DASH_LINE_WIDTH)
-            gpu.state.depth_test_set("ALWAYS")
-            dash_batch.draw(self.line_shader)
-
-        self.line_shader.uniform_float("lineWidth", _SOLID_LINE_WIDTH)
-        gpu.state.depth_test_set("LESS_EQUAL")
-        front_batch.draw(self.line_shader)
-
-        # Restore the per-iteration default set at the top of __call__ so
-        # subsequent draws (the HalfSpaceSolid arrow, future call-sites) are
-        # not silently affected by the front-pass width override.
-        self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
-        gpu.state.depth_test_set(original_depth_test)
-
     def __call__(self, context):
         props = tool.Model.get_model_props()
         if not props.openings:
@@ -1315,7 +1001,7 @@ class DecorationsHandler:
             self.line_shader.bind()  # required to be able to change uniforms of the shader
             # POLYLINE_UNIFORM_COLOR specific uniforms
             self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
-            self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
+            self.line_shader.uniform_float("lineWidth", 2.0)
 
             # general shader
             self.shader = gpu.shader.from_builtin("UNIFORM_COLOR")
@@ -1353,18 +1039,23 @@ class DecorationsHandler:
                 self.draw_batch("LINES", verts, selected_elements_color, selected_edges)
                 self.draw_batch("POINTS", unselected_vertices, unselected_elements_color)
                 self.draw_batch("POINTS", selected_vertices, selected_elements_color)
-                tool.Blender.draw_bmesh_face_tris(bm, verts, transparent_color(special_elements_color), self.draw_batch)
             else:
-                line_verts, verts, edges_indices, tris = _get_cached_world_draw_data(obj)
+                bm = bmesh.new()
+                bm.from_mesh(obj.data)
+
+                verts = [tuple(obj.matrix_world @ v.co) for v in bm.verts]
+                if ios_edges_attribute := obj.data.attributes.get("ios_edges"):
+                    edges = [e for i, e in enumerate(bm.edges) if ios_edges_attribute.data[i].value]
+                else:
+                    edges = bm.edges
+                edges_indices = [tuple([v.index for v in e.verts]) for e in edges]
+
                 color = selected_elements_color if obj in context.selected_objects else special_elements_color
-                self._draw_lines_with_occlusion(line_verts, color, edges_indices, cache_key=(obj.session_uid, "lines"))
-                self.draw_batch(
-                    "TRIS",
-                    verts,
-                    transparent_color(special_elements_color),
-                    tris,
-                    cache_key=(obj.session_uid, "tris"),
-                )
+                self.draw_batch("LINES", verts, color, edges_indices)
+
+            obj.data.calc_loop_triangles()
+            tris = [tuple(t.vertices) for t in obj.data.loop_triangles]
+            self.draw_batch("TRIS", verts, transparent_color(special_elements_color), tris)
 
             if "HalfSpaceSolid" in obj.name:
                 # Arrow shape
@@ -1378,4 +1069,7 @@ class DecorationsHandler:
                 ]
                 edges = [(0, 1), (1, 2), (1, 3), (1, 4), (1, 5)]
                 color = selected_elements_color if obj in context.selected_objects else special_elements_color
-                self._draw_lines_with_occlusion(verts, color, edges, cache_key=(obj.session_uid, "arrow"))
+                self.draw_batch("LINES", verts, color, edges)
+
+            if obj.mode != "EDIT":
+                bm.free()

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

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

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

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

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

@@ -24,7 +24,6 @@ import bpy
 import ifcopenshell
 import ifcopenshell.api.geometry
 import ifcopenshell.api.pset
-import ifcopenshell.api.style
 import ifcopenshell.api.type
 import ifcopenshell.util.element
 import ifcopenshell.util.placement
@@ -157,25 +156,13 @@ class DumbProfileGenerator:
                 tool.Ifc.get(), product=element, representation=representation
             )
 
-        material_profiles = list(self.profile_set.MaterialProfiles or [])
-        # A composite profile is an explicit, authored silhouette (e.g. for structural
-        # analysis) and always takes priority when present, matching prior behaviour.
-        # Only when there's no composite profile AND more than one material profile do
-        # we split the occurrence into one item per material profile, so each keeps its
-        # own material instead of collapsing to the first one.
-        is_multi_material = not self.profile_set.CompositeProfile and len(material_profiles) > 1
-
-        if is_multi_material:
-            representation, items = self.create_multi_material_profile_items(material_profiles)
-        else:
-            representation = ifcopenshell.api.geometry.add_profile_representation(
-                tool.Ifc.get(),
-                context=self.body_context,
-                profile=self.profile_set.CompositeProfile or self.profile_set.MaterialProfiles[0].Profile,
-                cardinal_point=self.cardinal_point,
-                depth=self.depth,
-            )
-
+        representation = ifcopenshell.api.geometry.add_profile_representation(
+            tool.Ifc.get(),
+            context=self.body_context,
+            profile=self.profile_set.CompositeProfile or self.profile_set.MaterialProfiles[0].Profile,
+            cardinal_point=self.cardinal_point,
+            depth=self.depth,
+        )
         ifcopenshell.api.geometry.assign_representation(tool.Ifc.get(), product=element, representation=representation)
         bonsai.core.geometry.switch_representation(
             tool.Ifc,
@@ -184,9 +171,6 @@ class DumbProfileGenerator:
             representation=representation,
         )
 
-        if is_multi_material:
-            self.tag_material_profile_items(element, representation, items, material_profiles)
-
         pset = ifcopenshell.api.pset.add_pset(self.file, product=element, name="EPset_Parametric")
         ifcopenshell.api.pset.edit_pset(self.file, pset=pset, properties={"Engine": "Bonsai.DumbProfile"})
 
@@ -194,73 +178,6 @@ class DumbProfileGenerator:
 
         return obj
 
-    def create_multi_material_profile_items(
-        self, material_profiles: list[ifcopenshell.entity_instance]
-    ) -> tuple[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]:
-        """Builds a single Body representation with one extruded item per `IfcMaterialProfile`.
-
-        All items share the same placement (derived from the first material profile's
-        cardinal point / bounding box), mirroring how door/window representations combine
-        multiple items in a single coordinate frame: each `IfcProfileDef` in a material
-        profile set is expected to already be positioned relative to that shared origin
-        (e.g. a cladding profile authored with its own offset `Position`), so reusing one
-        placement for every item preserves the intended nesting between profiles.
-        """
-        file = tool.Ifc.get()
-        reference_representation = ifcopenshell.api.geometry.add_profile_representation(
-            file,
-            context=self.body_context,
-            profile=material_profiles[0].Profile,
-            cardinal_point=self.cardinal_point,
-            depth=self.depth,
-        )
-        reference_item = reference_representation.Items[0]
-        items = [reference_item]
-        for material_profile in material_profiles[1:]:
-            items.append(
-                file.create_entity(
-                    "IfcExtrudedAreaSolid",
-                    material_profile.Profile,
-                    reference_item.Position,
-                    reference_item.ExtrudedDirection,
-                    reference_item.Depth,
-                )
-            )
-        reference_representation.Items = items
-        return reference_representation, items
-
-    def tag_material_profile_items(
-        self,
-        element: ifcopenshell.entity_instance,
-        representation: ifcopenshell.entity_instance,
-        items: list[ifcopenshell.entity_instance],
-        material_profiles: list[ifcopenshell.entity_instance],
-    ) -> None:
-        """Tags each item with an `IfcShapeAspect` named after its `IfcMaterialProfile`,
-        and applies that material's style (if any) directly to the item, following the
-        same item-level tagging pattern used by the door/window representation generators.
-
-        The element's own material assignment is left untouched (it keeps referencing the
-        type's `IfcMaterialProfileSetUsage`), since that's what carries the per-profile
-        material information; the shape aspect only correlates geometry items back to it.
-        """
-        file = tool.Ifc.get()
-        part_of_product = ifcopenshell.util.representation.get_part_of_product(element, self.body_context)
-        if not part_of_product:
-            return
-        for index, (item, material_profile) in enumerate(zip(items, material_profiles)):
-            material = material_profile.Material
-            aspect_name = material_profile.Name or (material and material.Name) or f"Profile {index + 1}"
-            ifcopenshell.api.geometry.add_shape_aspect(
-                file,
-                aspect_name,
-                items=[item],
-                representation=representation,
-                part_of_product=part_of_product,
-            )
-            if material and (style := ifcopenshell.util.representation.get_material_style(material, self.body_context)):
-                ifcopenshell.api.style.assign_item_style(file, item=item, style=style)
-
     def create_profile_from_2_points(
         self, coords: tuple[Vector, Vector], should_round: bool = False
     ) -> ProfileFrom2PointsReturn:
@@ -1085,14 +1002,6 @@ class EnableEditingExtrusionAxis(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         obj = context.active_object
-
-        # Commit any in-progress parametric (gizmo) draft on this object
-        # before switching to axis-edit. Otherwise the in-memory draft
-        # state is overwritten when the axis mesh is imported below,
-        # silently discarding the user's pending dimension edits.
-        if feature := tool.Parametric.is_object_editing(obj):
-            tool.Parametric.commit_object_draft(obj, feature.finish_op)
-
         element = tool.Ifc.get_entity(obj)
 
         axis = ifcopenshell.util.representation.get_representation(element, "Model", "Axis", "GRAPH_VIEW")
@@ -1248,8 +1157,7 @@ class DrawPolylineProfile(bpy.types.Operator, PolylineOperator, tool.Ifc.Operato
                         DumbProfileJoiner().join_V(profile2["obj"], profile1["obj"])
                         if connect_IfcFlowSegments:
                             bpy.ops.bim.mep_connect_elements(
-                                obj1_guid=tool.Ifc.get_entity(profile1["obj"]).GlobalId,
-                                obj2_guid=tool.Ifc.get_entity(profile2["obj"]).GlobalId,
+                                obj1_name=profile1["obj"].name, obj2_name=profile2["obj"].name
                             )
 
     def modal(self, context, event):

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import math
 from collections.abc import Callable
@@ -33,10 +31,8 @@ from bonsai.bim.module.drawing.decoration import CutDecorator
 from bonsai.bim.module.model.data import AuthoringData
 from bonsai.bim.module.model.decorator import (
     BoundingBoxDecorator,
-    MEPSystemPathDecorator,
     SlabDirectionDecorator,
     WallAxisDecorator,
-    WallSystemPathDecorator,
 )
 from bonsai.bim.module.model.door import update_door_modifier_bmesh
 from bonsai.bim.module.model.window import update_window_modifier_bmesh
@@ -105,12 +101,8 @@ def update_type_page(self: "BIMModelProperties", context: bpy.types.Context) ->
 
 
 def update_relating_array_from_object(self: "BIMArrayProperties", context: bpy.types.Context) -> None:
-    # 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)
+    bpy.ops.bim.enable_editing_array(item=self.is_editing)
+    return
 
 
 def is_object_array_applicable(self: "BIMArrayProperties", obj: bpy.types.Object) -> bool:
@@ -134,19 +126,6 @@ def update_slab_direction_decorator(self: "BIMModelProperties", context: bpy.typ
         SlabDirectionDecorator.uninstall()
 
 
-def update_paths_decorator(self: "BIMModelProperties", context: bpy.types.Context) -> None:
-    """Unified toggle for connected-element path overlays. Drives both the
-    MEP and wall path decorators — each decorator's ``draw`` short-circuits
-    when its kind of element isn't selected, so leaving both installed is
-    cheap and lets one toggle cover any connected-element family."""
-    if self.show_paths:
-        MEPSystemPathDecorator.install(bpy.context)
-        WallSystemPathDecorator.install(bpy.context)
-    else:
-        MEPSystemPathDecorator.uninstall()
-        WallSystemPathDecorator.uninstall()
-
-
 def update_measure_xyz(self: "BIMModelProperties", context: bpy.types.Context) -> None:
     if self.show_bounding_box:
         BoundingBoxDecorator.install(context)
@@ -214,36 +193,14 @@ 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:
-        _get_updater("railing", "update_railing_modifier_bmesh")(context)
+        # Only FRAMELESS_PANEL can update live via bmesh.
+        # WALL_MOUNTED_HANDRAIL geometry is generated from IFC representation,
+        # so it only updates on "Finish Editing" to avoid modifying IFC during preview.
+        if self.railing_type == "FRAMELESS_PANEL":
+            _get_updater("railing", "update_railing_modifier_bmesh")(context)
 
 
 def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
@@ -253,20 +210,6 @@ def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
         _get_updater("roof", "update_roof_modifier_bmesh")(obj)
 
 
-def update_pipe_segment(self: "BIMPipeSegmentProperties", context: bpy.types.Context) -> None:
-    """Regenerate pipe-segment preview mesh from props during edit. Does NOT touch IFC."""
-    obj = context.active_object
-    if obj and self.is_editing:
-        _get_updater("mep", "regenerate_pipe_segment_mesh_from_props")(obj)
-
-
-def update_duct_segment(self: "BIMDuctSegmentProperties", context: bpy.types.Context) -> None:
-    """Regenerate duct-segment preview mesh from props during edit. Does NOT touch IFC."""
-    obj = context.active_object
-    if obj and self.is_editing:
-        _get_updater("mep", "regenerate_duct_segment_mesh_from_props")(obj)
-
-
 class BIMModelProperties(PropertyGroup):
     ifc_class: bpy.props.EnumProperty(items=get_ifc_class, name="Construction Class", update=update_ifc_class)
     relating_type_id: bpy.props.EnumProperty(
@@ -369,19 +312,6 @@ class BIMModelProperties(PropertyGroup):
         default=False,
         update=update_slab_direction_decorator,
     )
-    show_paths: bpy.props.BoolProperty(
-        name="Show Paths",
-        default=False,
-        update=update_paths_decorator,
-        description=(
-            "Trace the connected element path from the selected element. For "
-            "walls, follows IfcRelConnectsPathElements and draws each "
-            "connected wall's reference axis with endpoint dots. For MEP "
-            "elements, follows IfcRelConnectsPorts and draws each segment's "
-            "axis plus a port-to-port spider for each fitting. Toggle off to "
-            "skip the BFS traversal entirely."
-        ),
-    )
 
     prev_transform_orientation_slot_type: bpy.props.StringProperty(name="Previous Gizmo Orientation Type")
     prev_show_gizmo_object_translate: bpy.props.BoolProperty(name="Previous Gizmo Translate")
@@ -429,7 +359,6 @@ class BIMModelProperties(PropertyGroup):
         offset: float
         show_wall_axis: bool
         show_slab_direction: bool
-        show_paths: bool
 
         prev_transform_orientation_slot_type: str
         prev_show_gizmo_object_translate: bool
@@ -440,13 +369,8 @@ class BIMModelProperties(PropertyGroup):
 
 
 class BIMArrayProperties(PropertyGroup):
-    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.",
+    is_editing: bpy.props.IntProperty(
+        default=-1, description="Currently edited array index. -1 if not in array editing mode."
     )
     count: bpy.props.IntProperty(name="Count", default=0, min=0)
     x: bpy.props.FloatProperty(name="X", default=0, subtype="DISTANCE")
@@ -462,15 +386,6 @@ 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",
@@ -479,15 +394,13 @@ class BIMArrayProperties(PropertyGroup):
     )
 
     if TYPE_CHECKING:
-        is_editing: bool
-        editing_item_index: int
+        is_editing: 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]
 
@@ -1718,133 +1631,6 @@ class BIMRoofProperties(PropertyGroup):
             setattr(target_props, prop_name, prop_value)
 
 
-class BIMSlabProperties(PropertyGroup):
-    """Transient state for the slab disconnect-access gizmo.
-
-    ``is_editing`` flips True when the user clicks the pen icon on a slab
-    that has wall connections — gating the per-wall disconnect icons in
-    ``GizmoSlabUnjoinWalls`` so they're hidden until the user opts in. No
-    IFC draft state lives here: the disconnect operator commits directly,
-    so this PropertyGroup carries only the UI gate."""
-
-    is_editing: bpy.props.BoolProperty(name="Slab Edit Active", default=False, options={"SKIP_SAVE"})
-
-    if TYPE_CHECKING:
-        is_editing: bool
-
-
-class BIMWallProperties(PropertyGroup):
-    """Transient draft state for parametric wall gizmo editing.
-
-    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")
@@ -1976,236 +1762,3 @@ class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
         geometry_source: Literal["GEONODES", "IFCSVERCHOK"]
         geo_nodes: Union[bpy.types.GeometryNodeTree, None]
         sverchok_nodes: Union[sverchok.node_tree.SverchCustomTree, None]
-
-
-class 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