Fix stale object reference crash in measure tool snapping

Drop deleted Blender objects from the snap cache before comparing names. Accessing an attribute on a removed object raised ReferenceError ("StructRNA of type Object has been removed"), crashing detect_snapping_points after an object was deleted. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Fix: commit pending parametric draft before extrusion-edit
2026-08-06 16:01:36 +00:00 · 2026-06-25 11:45:38 -05:00 · 2026-06-24 17:08:50 +02:00 · 2026-06-24 17:08:50 +02:00 · 2026-06-24 17:08:50 +02:00 · 2026-06-24 17:08:50 +02:00
571 changed files with 59393 additions and 5764 deletions
@@ -0,0 +1,95 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = [
+#     "PyGithub",
+#     "requests",
+# ]
+# ///
+
+import os
+from pathlib import Path
+
+import requests
+from github import Github
+from github.GitReleaseAsset import GitReleaseAsset
+
+EXTENSION_ID = "bonsai"
+CURRENT_PYTHON_VERSION = "py313"
+CURRENT_PLATFORMS = ["linux-x64", "macos-arm64", "windows-x64"]
+
+
+def publish_asset(asset: GitReleaseAsset, token: str, repo_root: Path) -> None:
+    """
+    Publish an asset to Blender Extensions.
+    Reference: https://extensions.blender.org/api/v1/swagger
+    """
+    temp_path = repo_root / asset.name
+
+    response = requests.get(asset.browser_download_url)
+    response.raise_for_status()
+    temp_path.write_bytes(response.content)
+
+    url = f"https://extensions.blender.org/api/v1/extensions/{EXTENSION_ID}/versions/upload/"
+    headers = {"Authorization": f"Bearer {token}"}
+
+    files = {"version_file": temp_path.read_bytes()}
+    response = requests.post(url, headers=headers, files=files)
+    response.raise_for_status()
+
+    temp_path.unlink()
+
+    print(f"✓ Published {asset.name}")
+
+
+def main() -> None:
+    token = os.getenv("BLENDER_EXTENSIONS_TOKEN")
+    if not token:
+        raise Exception("BLENDER_EXTENSIONS_TOKEN environment variable not set")
+
+    # Get the repository root
+    repo_root = Path(__file__).parent.parent.parent
+
+    # Read VERSION file
+    version_file = repo_root / "VERSION"
+    version = version_file.read_text().strip()
+
+    print(f"Current VERSION: {version}")
+
+    tag_name = f"bonsai-{version}"
+
+    # Get release from GitHub
+    gh = Github()
+    gh_repo = gh.get_repo("IfcOpenShell/IfcOpenShell")
+    release = gh_repo.get_release(tag_name)
+
+    assets = release.get_assets()
+
+    asset_platform_map: dict[str, tuple[GitReleaseAsset, str]] = {}
+    for asset in assets:
+        if CURRENT_PYTHON_VERSION not in asset.name:
+            continue
+        for platform in CURRENT_PLATFORMS:
+            if platform in asset.name:
+                asset_platform_map[asset.name] = (asset, platform)
+                break
+
+    if len(asset_platform_map) != len(CURRENT_PLATFORMS):
+        found_platforms = {platform for _, (_, platform) in asset_platform_map.items()}
+        missing_platforms = set(CURRENT_PLATFORMS) - found_platforms
+        raise Exception(
+            f"Expected {len(CURRENT_PLATFORMS)} assets but found {len(asset_platform_map)}. "
+            f"Missing: {', '.join(sorted(missing_platforms))}"
+        )
+
+    print("\nRelease assets:")
+    for asset_name in sorted(asset_platform_map.keys()):
+        print(f"- {asset_name}")
+
+    # https://extensions.blender.org/api/v1/swagger
+    print("\nPublishing assets to Blender Extensions:")
+    for asset_name, (asset, platform) in asset_platform_map.items():
+        publish_asset(asset, token, repo_root)
+
+
+if __name__ == "__main__":
+    main()
@@ -53,7 +53,7 @@ jobs:
          python ../nix/cache_dependencies.py unpack

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

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

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

@@ -9,6 +9,13 @@ jobs:
    container: rockylinux:9

    steps:
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+
+      - name: Install Python
+        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
+        run: uv python install
+
      - name: Install Dependencies
        run: |
          dnf update -y
@@ -17,7 +24,6 @@ jobs:
                         sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                         readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                         findutils xz byacc
-          python3 -m pip install typing_extensions
          git config --global --add safe.directory '*'

      - name: Install aws cli
@@ -45,10 +51,10 @@ jobs:
      - name: Unpack Dependencies
        run: |
          cd build
-          python3 ../nix/cache_dependencies.py unpack
+          uv run ../nix/cache_dependencies.py unpack

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

@@ -56,7 +62,7 @@ jobs:
        shell: bash
        run: |
          set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log

      - name: Upload Build Logs
        if: always()
@@ -71,7 +77,7 @@ jobs:
      - name: Pack Dependencies
        run: |
          cd build
-          python3 ../nix/cache_dependencies.py pack
+          uv run ../nix/cache_dependencies.py pack

      - name: Commit and Push Changes to Build Repository
        run: |
@@ -9,6 +9,13 @@ jobs:
    container: arm64v8/rockylinux:9

    steps:
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+
+      - name: Install Python
+        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
+        run: uv python install
+
      - name: Install Dependencies
        run: |
          dnf update -y
@@ -17,7 +24,6 @@ jobs:
                         sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                         readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                         findutils xz byacc
-          python3 -m pip install typing_extensions
          git config --global --add safe.directory '*'

      - name: Install aws cli
@@ -45,10 +51,10 @@ jobs:
      - name: Unpack Dependencies
        run: |
          cd build
-          python3 ../nix/cache_dependencies.py unpack
+          uv run ../nix/cache_dependencies.py unpack

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

@@ -56,7 +62,7 @@ jobs:
        shell: bash
        run: |
          set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log

      - name: Upload Build Logs
        if: always()
@@ -71,7 +77,7 @@ jobs:
      - name: Pack Dependencies
        run: |
          cd build
-          python3 ../nix/cache_dependencies.py pack
+          uv run ../nix/cache_dependencies.py pack

      - name: Commit and Push Changes to Build Repository
        run: |
@@ -52,7 +52,7 @@ jobs:
          }

      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.23
        with:
          key: win-${{ matrix.arch }}
          # Windows ccache needs ~1GB
@@ -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.0/blender-5.0.1-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.
@@ -122,7 +122,7 @@ jobs:
          pip install -r requirements.txt
          python setup_extensions_repo.py --last-tag
          cd ..
-          bonsai_zip="$(pwd)/$(ls bonsai_unstable_repo/bonsai_py311*-linux-x64.zip)"
+          bonsai_zip="$(pwd)/$(ls bonsai_unstable_repo/bonsai_py313*-linux-x64.zip)"

          # Install Bonsai.
          blender --command extension install-file -r user_default -e $bonsai_zip
@@ -24,7 +24,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        pyver: [py311, py312]
+        pyver: [py311, py312, py313]
        config:
          - {
            name: "Windows Build",
@@ -42,6 +42,11 @@ jobs:
            name: "MacOS ARM Build",
            short_name: macosm1,
          }
+        exclude:
+          # Python 3.13 is needed for Blender 5.1+ and Blender dropped Intel Mac support in 5.0.
+          - pyver: py313
+            config:
+              short_name: macos
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-python@v6 # https://github.com/actions/setup-python
@@ -0,0 +1,35 @@
+name: ci-ifcedit-pypi
+
+on:
+  workflow_dispatch:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: Compile
+        run: |
+          pip install build
+          cd src/ifcedit &&
+          make dist IS_STABLE=TRUE
+      - name: Publish a Python distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: src/ifcedit/dist
@@ -0,0 +1,36 @@
+name: ci-ifcmcp-pypi
+
+on:
+  workflow_dispatch:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: Compile
+        run: |
+          pip install build
+          cd src/ifcmcp &&
+          make dist IS_STABLE=TRUE
+      - name: Publish a Python distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: src/ifcmcp/dist
+          verbose: true
@@ -35,7 +35,7 @@ jobs:

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

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

 on:
  push:
@@ -30,6 +30,7 @@ jobs:
          uv tool install ruff
          uv tool install black
          uv tool install poethepoet
+          uv tool install ty==0.0.34

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

+      - name: ty check
+        id: ty
+        run: |
+          poe ty-venv
+          poe ty
+        continue-on-error: true
+
      - name: Ruff check
        id: ruff
        run: |
@@ -87,8 +95,7 @@ jobs:
            echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
          }

-          run_check poe ruff-main
-          run_check poe ruff-old
+          run_check poe ruff

          exit $ERROR
        continue-on-error: true
@@ -105,4 +112,7 @@ jobs:
          if [ "${{ steps.ruff.outcome }}" != "success" ]; then
            echo "::error::Ruff check failed, see Summary or 'ruff' step for the details." && ERROR=1
          fi
+          if [ "${{ steps.ty.outcome }}" != "success" ]; then
+            echo "::error::ty check failed, see 'ty check' step for the details." && ERROR=1
+          fi
          exit $ERROR
@@ -0,0 +1,46 @@
+name: Release Pyodide WASM Wheel
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout IfcOpenShell
+        uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Build wheel
+        working-directory: pyodide
+        run: uv run pack_wheel.py --build
+
+      - name: Find wheel
+        id: wheel
+        run: |
+          WHEEL=$(ls pyodide/dist/ifcopenshell-*.whl)
+          echo "path=$WHEEL" >> $GITHUB_OUTPUT
+          echo "name=$(basename $WHEEL)" >> $GITHUB_OUTPUT
+
+      - name: Checkout wasm-wheels
+        uses: actions/checkout@v6
+        with:
+          repository: IfcOpenShell/wasm-wheels
+          path: wasm-wheels
+          token: ${{ secrets.BUILD_REPO_TOKEN }}
+
+      - name: Commit and push wheel to wasm-wheels
+        run: |
+          WHEEL_NAME="${{ steps.wheel.outputs.name }}"
+          cp "${{ steps.wheel.outputs.path }}" "wasm-wheels/$WHEEL_NAME"
+          cd wasm-wheels
+          git config user.name "IfcOpenBot"
+          git config user.email "ifcopenbot@ifcopenshell.org"
+          git add "$WHEEL_NAME"
+          git commit -m "Add $WHEEL_NAME"
+          VERSION=$(cat ../VERSION)
+          git tag "v${VERSION}"
+          git push origin main
+          git push origin "v${VERSION}"
@@ -51,7 +51,7 @@ jobs:
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
-          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing
          pip install src/bcf --no-deps
          pip install pytest-xdist==3.8.0

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

@@ -1,36 +0,0 @@
-name: Build and Deploy Stable Documentation
-
-on:
-  workflow_dispatch:  # Manual trigger
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.x'
-
-      - name: Install dependencies
-        run: |
-          cd src/bonsai/docs
-          pip install -r requirements.txt  # Run pip install from the docs directory
-
-      - name: Build documentation
-        run: |
-          cd src/bonsai/docs
-          make html
-
-      - name: Deploy to GitHub Pages (Stable)
-        uses: peaceiris/actions-gh-pages@v4
-        with:
-          deploy_key: ${{ secrets.ACTIONS_DEPLOY_KEY }}
-          external_repository: IfcOpenShell/bonsaibim_org_docs
-          publish_branch: main
-          cname: docs.bonsaibim.org
-          publish_dir: src/bonsai/docs/_build/html
@@ -0,0 +1,65 @@
+name: Deploy AI chat App to static page repo
+
+permissions:
+  id-token: write
+  pages: write
+
+on:
+  push:
+    paths:
+      - 'src/ifcchat/**'
+      - '.github/workflows/publish-aichat-app.yaml'
+    branches:
+      - v0.8.0
+  workflow_dispatch:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+      
+  build:
+    needs: activate
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout (recursive)
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+          fetch-depth: 0
+      - name: Checkout intermediate Pages repo
+        uses: actions/checkout@v6
+        with:
+          repository: IfcOpenShell/aichat_ifcopenshell_org_static_html
+          ref: gh-pages
+          path: output
+          token: ${{ secrets.WEBSITE_PUBLISH }}
+      - name: Sync demo app into target subfolder
+        run: |
+          rsync -av --delete --exclude='.git/' src/ifcchat/ output/
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.x"
+      - name: Download wheels
+        working-directory: output/
+        run: |
+          pip download ifcquery==0.8.5 ifcopenshell-mcp==0.8.5 ifcedit==0.8.5 lark==1.3.1 isodate==0.7.2 --no-deps -d ./dist
+      - name: Commit and push if changed
+        working-directory: output
+        run: |
+          git config --global user.name 'IfcOpenBot'
+          git config --global user.email 'IfcOpenBot@users.noreply.github.com'
+
+          git add .
+          if git diff --cached --quiet; then
+            echo "No changes to commit"
+            exit 0
+          fi
+
+          git commit  -m "$(git log --oneline -1)"
+          git push origin gh-pages
@@ -0,0 +1,16 @@
+name: Publish Bonsai Releases
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: astral-sh/setup-uv@v7
+
+      - run: uv run .github/scripts/publish-bonsai-releases.py
+        env:
+          BLENDER_EXTENSIONS_TOKEN: ${{ secrets.BLENDER_EXTENSIONS_TOKEN }}
@@ -1,4 +1,4 @@
-name: Deploy Pyodide Demo App to GitHub Pages
+name: Deploy Pyodide Demo App to static page repo

 permissions:
  id-token: write
@@ -11,6 +11,7 @@ on:
      - '.github/workflows/publish-pyodide-demo-app.yml'
    branches:
      - v0.8.0
+  workflow_dispatch:

 jobs:
  activate:
@@ -30,21 +31,27 @@ jobs:
        with:
          submodules: recursive
          fetch-depth: 0
-      - name: Setup Pages
-        uses: actions/configure-pages@v6
-      - name: Upload static files as artifact
-        id: deployment
-        uses: actions/upload-pages-artifact@v4
+      - name: Checkout intermediate Pages repo
+        uses: actions/checkout@v6
        with:
-          path: src/pyodide/demo-app/
+          repository: IfcOpenShell/wasm_ifcopenshell_org_static_html
+          ref: gh-pages
+          path: output
+          token: ${{ secrets.WEBSITE_PUBLISH }}
+      - name: Sync demo app into target subfolder
+        run: |
+          rsync -av --delete --exclude='.git/' src/pyodide/demo-app/ output/
+      - name: Commit and push if changed
+        working-directory: output
+        run: |
+          git config --global user.name 'IfcOpenBot'
+          git config --global user.email 'IfcOpenBot@users.noreply.github.com'

-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v5
+          git add .
+          if git diff --cached --quiet; then
+            echo "No changes to commit"
+            exit 0
+          fi
+
+          git commit -m "$(git log --oneline -1)"
+          git push origin gh-pages
@@ -50,11 +50,14 @@ Contents
 | [ifcconvert](https://docs.ifcopenshell.org/ifcconvert.html)                | CLI app to convert IFC to many other formats                          | LGPL-3.0-or-later\* | [![Official](https://img.shields.io/badge/IfcOpenShell.org-Download-70ba35)](https://docs.ifcopenshell.org/ifcconvert/installation.html) [![GitHub](https://img.shields.io/github/v/release/ifcopenshell/ifcopenshell?filter=ifcconvert-*&label=GitHub&color=f6f8fa)](https://github.com/IfcOpenShell/IfcOpenShell/releases?q=ifcconvert&expanded=true)
 | [ifccsv](https://docs.ifcopenshell.org/ifccsv.html)                    | Library and CLI app to export and import schedules from IFC           | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifccsv?label=PyPI&color=006dad)](https://pypi.org/project/ifccsv/) |
 | [ifcdiff](https://docs.ifcopenshell.org/ifcdiff.html)                   | Compare changes between IFC models                                    | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifcdiff?label=PyPI&color=006dad)](https://pypi.org/project/ifcdiff/) |
+| [ifcedit](https://docs.ifcopenshell.org/ifcedit.html)                   | CLI wrapper for ifcopenshell.api IFC model mutation functions         | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifcedit?label=PyPI&color=006dad)](https://pypi.org/project/ifcedit/) |
 | [ifcfm](https://docs.ifcopenshell.org/ifcfm.html)                     | Extract IFC data for FM handover requirements                         | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifcfm?label=PyPI&color=006dad)](https://pypi.org/project/ifcfm/) |
 | [ifcmax](https://docs.ifcopenshell.org/ifcmax.html)                    | Historic extension for IFC support in 3DS Max                         | LGPL-3.0-or-later\* | [![Official](https://img.shields.io/badge/IfcOpenShell.org-Download-70ba35)](https://docs.ifcopenshell.org/ifcmax.html)
-| [ifcopenshell-python](https://docs.ifcopenshell.org/ifcopenshell-python.html)       | Python library for IFC manipulation                                   | LGPL-3.0-or-later\* | [![Official](https://img.shields.io/badge/IfcOpenShell.org-Download-70ba35)](https://docs.ifcopenshell.org/ifcopenshell-python/installation.html) [![GitHub](https://img.shields.io/github/v/release/ifcopenshell/ifcopenshell?filter=ifcopenshell-python-*&label=GitHub&color=f6f8fa)](https://github.com/IfcOpenShell/IfcOpenShell/releases?q=ifcopenshell-python&expanded=true) [![PyPI](https://img.shields.io/pypi/v/ifcopenshell?label=PyPI&color=006dad)](https://pypi.org/project/ifcopenshell/) [![Anaconda](https://img.shields.io/conda/vn/conda-forge/ifcopenshell?label=Anaconda&color=43b02a)](https://anaconda.org/conda-forge/ifcopenshell) [![Anaconda](https://img.shields.io/conda/vn/ifcopenshell/ifcopenshell?label=Anaconda-Unstable&color=43b02a)](https://anaconda.org/ifcopenshell/ifcopenshell) [![Docker](https://img.shields.io/docker/pulls/aecgeeks/ifcopenshell?label=Docker&color=1D63ED)](https://hub.docker.com/r/aecgeeks/ifcopenshell) [![AUR](https://img.shields.io/aur/version/ifcopenshell?label=AUR&color=1793d1)](https://aur.archlinux.org/packages/ifcopenshell) [![AUR Unstable](https://img.shields.io/aur/version/ifcopenshell-git?label=AUR-Unstable&color=1793d1)](https://aur.archlinux.org/packages/ifcopenshell-git) [Pyodide WASM Wheels](https://github.com/IfcOpenShell/wasm-wheels#pyodide-test-wheels) |
+| [ifcmcp](https://docs.ifcopenshell.org/ifcmcp.html)                    | MCP server for querying and editing IFC building models               | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifcopenshell-mcp?label=PyPI&color=006dad)](https://pypi.org/project/ifcopenshell-mcp/) |
+| [ifcopenshell-python](https://docs.ifcopenshell.org/ifcopenshell-python.html)       | Python library for IFC manipulation                                   | LGPL-3.0-or-later\* | [![Official](https://img.shields.io/badge/IfcOpenShell.org-Download-70ba35)](https://docs.ifcopenshell.org/ifcopenshell-python/installation.html) [![GitHub](https://img.shields.io/github/v/release/ifcopenshell/ifcopenshell?filter=ifcopenshell-python-*&label=GitHub&color=f6f8fa)](https://github.com/IfcOpenShell/IfcOpenShell/releases?q=ifcopenshell-python&expanded=true) [![PyPI](https://img.shields.io/pypi/v/ifcopenshell?label=PyPI&color=006dad)](https://pypi.org/project/ifcopenshell/) [![Anaconda](https://img.shields.io/conda/vn/conda-forge/ifcopenshell?label=Anaconda&color=43b02a)](https://anaconda.org/conda-forge/ifcopenshell) [![Anaconda](https://img.shields.io/conda/vn/ifcopenshell/ifcopenshell?label=Anaconda-Unstable&color=43b02a)](https://anaconda.org/ifcopenshell/ifcopenshell) [![Docker](https://img.shields.io/docker/pulls/aecgeeks/ifcopenshell?label=Docker&color=1D63ED)](https://hub.docker.com/r/aecgeeks/ifcopenshell) [![AUR](https://img.shields.io/aur/version/ifcopenshell?label=AUR&color=1793d1)](https://aur.archlinux.org/packages/ifcopenshell) [![AUR Unstable](https://img.shields.io/aur/version/ifcopenshell-git?label=AUR-Unstable&color=1793d1)](https://aur.archlinux.org/packages/ifcopenshell-git) [![Pyodide WASM Wheels tag](https://img.shields.io/github/v/tag/ifcopenshell/wasm-wheels?sort=semver&label=pyodide-wasm-wheels)](https://github.com/IfcOpenShell/wasm-wheels) |
 | [ifcpatch](https://docs.ifcopenshell.org/ifcpatch.html)                  | Utility to run pre-packaged scripts to manipulate IFCs                | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifcpatch?label=PyPI&color=006dad)](https://pypi.org/project/ifcpatch/) |
-| [ifcsverchok](https://docs.ifcopenshell.org/ifcsverchok.html)               | Blender Add-on for visual node programming with IFC                   | GPL-3.0-or-later    | [![GitHub Unstable](https://img.shields.io/github/v/release/ifcopenshell/ifcopenshell?filter=ifcsverchok-*.*.*.*&label=GitHub-Unstable&color=f6f8fa)](https://github.com/IfcOpenShell/IfcOpenShell/releases?q=ifcsverchok&expanded=true)
+| [ifcquery](https://docs.ifcopenshell.org/ifcquery.html)                  | CLI tool for querying and inspecting IFC building models              | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifcquery?label=PyPI&color=006dad)](https://pypi.org/project/ifcquery/) |
+| [ifcsverchok](https://docs.ifcopenshell.org/ifcsverchok.html)               | Blender Add-on for visual node programming with IFC                   | GPL-3.0-or-later    | [![GitHub](https://img.shields.io/github/v/release/ifcopenshell/ifcopenshell?filter=ifcsverchok-*.*.*&label=GitHub&color=f6f8fa)](https://github.com/IfcOpenShell/IfcOpenShell/releases?q=ifcsverchok&expanded=true)
 | [ifctester](https://docs.ifcopenshell.org/ifctester.html)                 | Library, CLI and webapp for IDS model auditing                        | LGPL-3.0-or-later   | [![PyPI](https://img.shields.io/pypi/v/ifctester?label=PyPI&color=006dad)](https://pypi.org/project/ifctester/) |

 The IfcOpenShell C++ codebase is split into multiple interal libraries:
@@ -1 +1 @@
-0.8.5
+0.8.6
@@ -258,10 +258,14 @@ if(WITH_ROCKSDB)
    set(ROCKSDB_LIBRARIES "IFCOPENSHELL_RocksDB")
    target_compile_definitions(IFCOPENSHELL_RocksDB INTERFACE IFOPSH_WITH_ROCKSDB)
    set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_ROCKSDB)
-    # Shared binaries for `rocksdb` only support limited API (only `c.h`), but we use `db.h` API.
-    # So rocksdb supported only as a static library.
    # See https://github.com/facebook/rocksdb/issues/981.
-    target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
+    if(TARGET RocksDB::rocksdb)
+        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
+    elseif(TARGET RocksDB::rocksdb-shared)
+        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb-shared)
+    else()
+        message(FATAL_ERROR "RocksDB found but neither RocksDB::rocksdb nor RocksDB::rocksdb-shared target exists")
+    endif()

    if(WITH_ZSTD)
        # @todo do we actually need the zstd include dir or rather just pass
@@ -88,7 +88,15 @@ if(NOT HDF5_INCLUDE_DIR OR NOT HDF5_LIBRARY_DIR)
    mark_as_advanced(HDF5_DIR)
    if(HDF5_DIR)
        message(STATUS "HDF5: found config at '${HDF5_DIR}'.")
-        set(HDF5_LIBRARIES hdf5_cpp-static)
+        if(TARGET hdf5_cpp-static)
+            set(HDF5_LIBRARIES hdf5_cpp-static)
+        elseif(TARGET hdf5_cpp-shared)
+            set(HDF5_LIBRARIES hdf5_cpp-shared)
+        elseif(TARGET hdf5::hdf5_cpp-shared)
+            set(HDF5_LIBRARIES hdf5::hdf5_cpp-shared)
+        else()
+            find_package(HDF5 REQUIRED COMPONENTS CXX)
+        endif()
    else()
        # If it failed, still try to find as a module.
        # E.g. on Ubuntu `libhdf5-dev` doesn't provie hdf5-config.cmake.
@@ -0,0 +1,131 @@
+# This file was generated with the assistance of an AI coding tool.
+################################################################################
+#                                                                              #
+# This file is part of IfcOpenShell.                                           #
+#                                                                              #
+# IfcOpenShell is free software: you can redistribute it and/or modify         #
+# it under the terms of the Lesser GNU General Public License as published by  #
+# the Free Software Foundation, either version 3.0 of the License, or          #
+# (at your option) any later version.                                          #
+#                                                                              #
+# IfcOpenShell is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 #
+# Lesser GNU General Public License for more details.                          #
+#                                                                              #
+# You should have received a copy of the Lesser GNU General Public License     #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.         #
+#                                                                              #
+################################################################################
+
+include("${CMAKE_CURRENT_LIST_DIR}/utilities.cmake" OPTIONAL)
+
+set(_IfcOpenShell_find_args)
+if(IfcOpenShell_FIND_VERSION)
+    list(APPEND _IfcOpenShell_find_args "${IfcOpenShell_FIND_VERSION}")
+    if(IfcOpenShell_FIND_VERSION_EXACT)
+        list(APPEND _IfcOpenShell_find_args EXACT)
+    endif()
+endif()
+list(APPEND _IfcOpenShell_find_args CONFIG QUIET)
+if(IfcOpenShell_FIND_COMPONENTS)
+    list(APPEND _IfcOpenShell_find_args COMPONENTS ${IfcOpenShell_FIND_COMPONENTS})
+endif()
+
+set(_IfcOpenShell_saved_module_path "${CMAKE_MODULE_PATH}")
+list(REMOVE_ITEM CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+find_package(IfcOpenShell ${_IfcOpenShell_find_args})
+set(CMAKE_MODULE_PATH "${_IfcOpenShell_saved_module_path}")
+
+if(NOT IfcOpenShell_FOUND)
+    set(_IfcOpenShell_error "Could not find an IfcOpenShell CMake config package. Set IfcOpenShell_DIR or CMAKE_PREFIX_PATH.")
+    if(IfcOpenShell_FIND_REQUIRED)
+        message(FATAL_ERROR "${_IfcOpenShell_error}")
+    elseif(NOT IfcOpenShell_FIND_QUIETLY)
+        message(STATUS "${_IfcOpenShell_error}")
+    endif()
+    return()
+endif()
+
+set(_IfcOpenShell_required_targets IfcOpenShell::IfcParse IfcOpenShell::IfcGeom)
+set(_IfcOpenShell_missing_targets "")
+foreach(_IfcOpenShell_target IN LISTS _IfcOpenShell_required_targets)
+    if(NOT TARGET ${_IfcOpenShell_target})
+        list(APPEND _IfcOpenShell_missing_targets ${_IfcOpenShell_target})
+    endif()
+endforeach()
+
+if(_IfcOpenShell_missing_targets)
+    set(IfcOpenShell_FOUND FALSE)
+    string(REPLACE ";" ", " _IfcOpenShell_missing_targets_text "${_IfcOpenShell_missing_targets}")
+    set(_IfcOpenShell_error "IfcOpenShell config was found, but required targets are missing: ${_IfcOpenShell_missing_targets_text}.")
+    if(IfcOpenShell_FIND_REQUIRED)
+        message(FATAL_ERROR "${_IfcOpenShell_error}")
+    elseif(NOT IfcOpenShell_FIND_QUIETLY)
+        message(STATUS "${_IfcOpenShell_error}")
+    endif()
+    return()
+endif()
+
+if(NOT DEFINED IFCOPENSHELL_WITH_OPENCASCADE)
+    set(IFCOPENSHELL_WITH_OPENCASCADE OFF)
+    if(TARGET IfcOpenShell::geometry_kernel_opencascade)
+        set(IFCOPENSHELL_WITH_OPENCASCADE ON)
+    endif()
+endif()
+
+if(NOT DEFINED IFCOPENSHELL_WITH_CGAL)
+    set(IFCOPENSHELL_WITH_CGAL OFF)
+    if(TARGET IfcOpenShell::IFCOPENSHELL_CGAL)
+        set(IFCOPENSHELL_WITH_CGAL ON)
+    endif()
+endif()
+
+if(NOT DEFINED IFCOPENSHELL_IFCXML)
+    set(IFCOPENSHELL_IFCXML OFF)
+endif()
+
+if(NOT DEFINED IFCOPENSHELL_WITH_ROCKSDB)
+    set(IFCOPENSHELL_WITH_ROCKSDB OFF)
+endif()
+
+set(IFCOPENSHELL_LIBRARIES IfcOpenShell::IfcParse)
+foreach(_IfcOpenShell_target IN ITEMS IfcOpenShell::geometry_serializer IfcOpenShell::Serializers)
+    if(TARGET ${_IfcOpenShell_target})
+        list(APPEND IFCOPENSHELL_LIBRARIES ${_IfcOpenShell_target})
+    endif()
+endforeach()
+
+set(IFCOPENSHELL_KERNEL_LIBRARIES "")
+foreach(_IfcOpenShell_target IN ITEMS
+    IfcOpenShell::geometry_kernel_opencascade
+    IfcOpenShell::geometry_kernel_cgal
+    IfcOpenShell::geometry_kernel_cgal_simple
+)
+    if(TARGET ${_IfcOpenShell_target})
+        list(APPEND IFCOPENSHELL_KERNEL_LIBRARIES ${_IfcOpenShell_target})
+    endif()
+endforeach()
+
+set(IFCOPENSHELL_GEOMETRY_LIBRARIES IfcOpenShell::IfcGeom ${IFCOPENSHELL_KERNEL_LIBRARIES})
+
+if(TARGET IfcOpenShell::OpenCASCADE_INTERFACE)
+    set(OpenCASCADE_LIBRARIES IfcOpenShell::OpenCASCADE_INTERFACE)
+endif()
+
+if(TARGET IfcOpenShell::IFCOPENSHELL_CGAL)
+    set(CGAL_LIBRARIES IfcOpenShell::IFCOPENSHELL_CGAL)
+endif()
+
+if(TARGET IfcOpenShell::svgfill)
+    set(IFCOPENSHELL_SVGFILL_LIBRARY IfcOpenShell::svgfill)
+endif()
+
+mark_as_advanced(IfcOpenShell_DIR)
+
+unset(_IfcOpenShell_error)
+unset(_IfcOpenShell_find_args)
+unset(_IfcOpenShell_missing_targets)
+unset(_IfcOpenShell_missing_targets_text)
+unset(_IfcOpenShell_required_targets)
+unset(_IfcOpenShell_target)
@@ -7,12 +7,26 @@ set(IFCOPENSHELL_WITH_OPENCASCADE @WITH_OPENCASCADE@)
 set(IFCOPENSHELL_WITH_CGAL @WITH_CGAL@)
 set(IFCOPENSHELL_IFCXML @IFCXML_SUPPORT@)
 set(IFCOPENSHELL_WITH_ROCKSDB @WITH_ROCKSDB@)
+set(IFCOPENSHELL_COLLADA_SUPPORT @COLLADA_SUPPORT@)
+set(IFCOPENSHELL_GLTF_SUPPORT @GLTF_SUPPORT@)
+set(IFCOPENSHELL_HDF5_SUPPORT @HDF5_SUPPORT@)
+set(IFCOPENSHELL_WITH_PROJ @WITH_PROJ@)
+set(IFCOPENSHELL_USD_SUPPORT @USD_SUPPORT@)

 include(CMakeFindDependencyMacro)

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

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

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

+if(IFCOPENSHELL_COLLADA_SUPPORT)
+    find_dependency(OpenCOLLADA)
+endif()
+
+if(IFCOPENSHELL_GLTF_SUPPORT)
+    find_dependency(nlohmann_json CONFIG)
+endif()
+
+if(IFCOPENSHELL_HDF5_SUPPORT)
+    find_dependency(HDF5 COMPONENTS C CXX)
+endif()
+
+if(IFCOPENSHELL_WITH_PROJ)
+    find_dependency(PROJ)
+endif()
+
+if(IFCOPENSHELL_USD_SUPPORT)
+    find_dependency(USD)
+endif()
+
 if(IFCOPENSHELL_WITH_OPENCASCADE)
    find_dependency(OpenCASCADE CONFIG)
    if(OpenCASCADE_VERSION VERSION_LESS "7.7.0")
@@ -1,4 +1,6 @@
 #!/usr/bin/python
+# /// script
+# ///
 ###############################################################################
 #                                                                             #
 # This file is part of IfcOpenShell.                                          #
@@ -124,16 +126,9 @@ ssl._create_default_https_context = ssl._create_unverified_context
 import time
 from collections.abc import Generator, Sequence
 from pathlib import Path
+from typing import Literal, Union
 from urllib.request import urlretrieve

-try:
-    from typing import Literal, Union
-except:
-    # python 3.6 compatibility for rocky 8
-    from typing import Union
-
-    from typing_extensions import Literal
-
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 ch = logging.StreamHandler()
@@ -1094,10 +1089,19 @@ if "python" in targets and not USE_CURRENT_PYTHON_VERSION and "wasm" not in flag
            f"http://www.python.org/ftp/python/{PYTHON_VERSION}/",
            f"Python-{PYTHON_VERSION}.tgz",
        )
-        python_bin = INSTALL_DIR / f"python-{PYTHON_VERSION}" / "bin" / "python3"
+        python_install = INSTALL_DIR / f"python-{PYTHON_VERSION}"
+        python_bin = python_install / "bin" / "python3"
        # `_ssl` module is present -> we will be able to install `numpy` later
        # to verify IfcOpenShell installation
-        run([str(python_bin), "-c", "import _ssl"])
+        try:
+            run([str(python_bin), "-c", "import _ssl"])
+        except RuntimeError:
+            print(
+                "ERROR: Python was built without SSL support (_ssl module is missing). "
+                f"To fix this: remove the installed Python at {python_install}; "
+                "install OpenSSL development libraries and re-run."
+            )
+            raise

    if MAC_CROSS_COMPILE_INTEL:
        assert original_path
@@ -1515,7 +1519,7 @@ if "IfcOpenShell-Python" in targets:
        )
        # Copy setup.py where pyodide build system expects it.
        shutil.copy(REPO_PATH / "pyodide" / "setup.py", REPO_PATH)
-        # Empty pyproject so it's contents won't affect the resulting wheelthe the
+        # Empty pyproject so it's contents won't affect the resulting wheel
        # otherwise the wheel will use version and dependencies from toml, not setup.py.
        (REPO_PATH / "pyproject.toml").write_text("")

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

@@ -1,6 +1,11 @@
 #!/usr/bin/bash
 set -ex

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

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

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

-# Emscripten doesn't come with xbuildenv.
-if [ ! -d emsdk ]; then
-  git clone https://github.com/emscripten-core/emsdk
-fi
-pushd emsdk
-PYODIDE_EMSCRIPTEN_VERSION=$(pyodide config get emscripten_version)
-./emsdk install ${PYODIDE_EMSCRIPTEN_VERSION}
-./emsdk activate ${PYODIDE_EMSCRIPTEN_VERSION}
-source emsdk_env.sh
+EMSDK_ROOT="${PYODIDE_XBUILDENV}/emsdk"
+source "${EMSDK_ROOT}/emsdk_env.sh"
 which emcc
-popd
+emcc --version

 mkdir -p packages/ifcopenshell
 VERSION=`cat IfcOpenShell/VERSION`
@@ -0,0 +1,232 @@
+#
+# /// script
+# # Latest Pyodide build env versions are listed here:
+# # https://pyodide.github.io/pyodide/api/pyodide-cross-build-environments.json
+# # https://github.com/pyodide/pyodide-build/blob/main/pyodide_build/xbuildenv_releases.py
+# requires-python = "==3.13.2"
+# dependencies = [
+#   "requests",
+#   "setuptools",
+# ]
+# ///
+"""
+Pack an IfcOpenShell WASM wheel using Pyodide build system.
+
+Usage:
+    uv run make_wheel.py           # Show this help
+    uv run make_wheel.py --build   # Build wheel
+    uv run make_wheel.py --clean   # Clean build artifacts and exit
+"""
+
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import time
+import zipfile
+from pathlib import Path
+from urllib.parse import quote
+
+import requests
+
+# Get repo root (parent of this script's parent directory)
+REPO_ROOT = Path(__file__).parent.parent
+PYODIDE_DIR = REPO_ROOT / "pyodide"
+BUILD_DIR = PYODIDE_DIR / "build"
+
+# Hardcoded path (Windows packing workaround with --dev flag)
+PYODIDE_BUILD = Path(r"L:\Projects\Github\pyodide-build")
+
+# Wheel platform tag (from PYODIDE_EMSCRIPTEN_VERSION in pyodide-build/Makefile.envs)
+WHEEL_PLATFORM_TAG = "emscripten_4_0_9_wasm32"
+
+# Location where ifcopenshell will be extracted
+IFCOPENSHELL_DIR = PYODIDE_DIR / "ifcopenshell"
+
+
+class WheelBuilder:
+    @staticmethod
+    def extract_ifcopenshell_from_git(dst: Path) -> None:
+        """Extract ifcopenshell directory from git repo into destination."""
+        Tools.rmrf(dst)
+
+        print(f"Extracting ifcopenshell from git to {dst}...")
+        # Use git ls-files piped to git checkout-index to avoid copying
+        # untracked or ignored files from the actual repo.
+        ls_proc = subprocess.Popen(
+            ["git", "ls-files", "-z", "src/ifcopenshell-python/ifcopenshell"],
+            cwd=REPO_ROOT,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        checkout_proc = subprocess.Popen(
+            ["git", "checkout-index", "-z", "--prefix", "pyodide/", "--stdin"],
+            cwd=REPO_ROOT,
+            stdin=ls_proc.stdout,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        assert ls_proc.stdout is not None
+        ls_proc.stdout.close()
+        checkout_proc.communicate()
+
+        if checkout_proc.returncode != 0:
+            assert checkout_proc.stderr is not None
+            raise RuntimeError(f"Failed to extract: {checkout_proc.stderr.decode()}")
+
+        # Move src/ifcopenshell-python/ifcopenshell to ifcopenshell.
+        temp_src = PYODIDE_DIR / "src" / "ifcopenshell-python" / "ifcopenshell"
+        shutil.move(temp_src, dst)
+
+        # Clean up temporary src directory.
+        Tools.rmrf(PYODIDE_DIR / "src")
+
+        print("✓ Extracted ifcopenshell from git")
+
+    @staticmethod
+    def get_wheel_url(makefile_path: Path) -> str:
+        """Get S3 wheel URL based on BINARY_VERSION and BUILD_COMMIT from Makefile."""
+
+        def parse_makefile_vars() -> dict[str, str]:
+            content = makefile_path.read_text()
+            vars: dict[str, str] = {}
+            for match in re.finditer(r"^(BINARY_VERSION|BUILD_COMMIT):=(.+)$", content, re.MULTILINE):
+                vars[match.group(1)] = match.group(2).strip()
+            return vars
+
+        vars: dict[str, str] = parse_makefile_vars()
+        binary_version = vars["BINARY_VERSION"]
+        build_commit = vars["BUILD_COMMIT"]
+        filename = f"ifcopenshell-{binary_version}+{build_commit}-cp313-cp313-pyodide_2025_0_wasm32.whl"
+        encoded_filename = quote(filename, safe="")
+        return f"https://s3.amazonaws.com/ifcopenshell-builds/{encoded_filename}"
+
+    @staticmethod
+    def download_and_extract_so(url: str, build_dir: Path) -> tuple[Path, Path]:
+        """Download wheel from URL and extract .so and .py files."""
+        py_wrapper_filename = "ifcopenshell_wrapper.py"
+        build_dir.mkdir(parents=True, exist_ok=True)
+
+        wheel_path = build_dir / url.rsplit("/", 1)[-1]
+
+        if wheel_path.exists():
+            print(f"Using cached wheel: {wheel_path}")
+        else:
+            print(f"Downloading {url}...")
+            response = requests.get(url)
+            response.raise_for_status()
+            wheel_path.write_bytes(response.content)
+
+        print("Extracting _ifcopenshell_wrapper files...")
+        with zipfile.ZipFile(wheel_path) as zf:
+            so_files = [f for f in zf.namelist() if f.endswith(".so")]
+            py_files = [f for f in zf.namelist() if f.endswith(py_wrapper_filename)]
+
+            assert so_files, "No .so file found in wheel"
+            assert py_files, f"No {py_wrapper_filename} file found in wheel"
+
+            so_file = so_files[0]
+            so_dst = build_dir / Path(so_file).name
+            so_dst.write_bytes(zf.read(so_file))
+
+            py_file = py_files[0]
+            py_dst = build_dir / Path(py_file).name
+            py_dst.write_bytes(zf.read(py_file))
+
+        return so_dst, py_dst
+
+
+class Tools:
+    @staticmethod
+    def run(
+        cmd: list[str],
+        cwd: Path | None = None,
+    ) -> None:
+        print(f"$ {' '.join(cmd)}")
+        subprocess.check_call(cmd, cwd=cwd)
+
+    @staticmethod
+    def create_symlink(dst: Path, src: Path) -> None:
+        Tools.rmrf(dst)
+        dst.symlink_to(src)
+
+    @staticmethod
+    def rmrf(path: Path) -> None:
+        if path.exists() or path.is_symlink():
+            if path.is_dir() and not path.is_symlink():
+                shutil.rmtree(path)
+            else:
+                path.unlink()
+
+
+def clean() -> None:
+    """Remove build artifacts."""
+    paths_to_remove = (
+        BUILD_DIR,
+        PYODIDE_DIR / ".pyodide_build",
+        PYODIDE_DIR / "dist",
+        PYODIDE_DIR / "ifcopenshell.egg-info",
+        PYODIDE_DIR / "src",
+        IFCOPENSHELL_DIR,
+    )
+    for path in paths_to_remove:
+        if path.exists() or path.is_symlink():
+            print(f"Removing {path}...")
+            Tools.rmrf(path)
+    print("✓ Clean complete")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, add_help=False)
+    parser.add_argument("--build", action="store_true", help="Build the wheel")
+    parser.add_argument("--clean", action="store_true", help="Clean build folder")
+    parser.add_argument(
+        "--dev",
+        action="store_true",
+        help="Use editable pyodide-build from hardcoded path (Windows packing workaround)",
+    )
+    args = parser.parse_args()
+
+    if not args.build and not args.clean:
+        print(__doc__)
+        return
+
+    if args.clean:
+        clean()
+        return
+
+    start_time = time.time()
+
+    WheelBuilder.extract_ifcopenshell_from_git(IFCOPENSHELL_DIR)
+
+    print("Downloading and extracting _ifcopenshell_wrapper files...")
+    makefile = REPO_ROOT / "src" / "ifcopenshell-python" / "Makefile"
+    wheel_url = WheelBuilder.get_wheel_url(makefile)
+    so_file, py_file = WheelBuilder.download_and_extract_so(wheel_url, BUILD_DIR)
+
+    Tools.create_symlink(IFCOPENSHELL_DIR / Path(so_file).name, so_file)
+    Tools.create_symlink(IFCOPENSHELL_DIR / Path(py_file).name, py_file)
+
+    print("Installing pyodide-build...")
+    if args.dev:
+        Tools.run(["uv", "pip", "install", "-e", str(PYODIDE_BUILD)])
+    else:
+        Tools.run(["uv", "pip", "install", "pyodide-build"])
+
+    print("Building with pyodide...")
+    # Use --no-isolation due to pyodide-build Windows support issues:
+    # symlink_unisolated_packages fails with missing `_sysconfigdata_$(CPYTHON_ABI_FLAGS)_emscripten_wasm32-emscripten.py`.
+    # Hardcode platform name since pyodide doesn't yet support overriding wheel tags on Windows.
+    #
+    # Use `LEGACY_PLATFORM` since pyodide 0.34.1 introduced new tag for wheels `pyemscripten`,
+    # which doesn't work with pyodide itself yet - https://github.com/pyodide/pyodide/issues/6177.
+    os.environ["USE_LEGACY_PLATFORM"] = "1"
+    Tools.run(["pyodide", "build", f"-C--build-option=--plat-name={WHEEL_PLATFORM_TAG}"])
+
+    elapsed = time.time() - start_time
+    print(f"\n✓ Done! ({elapsed:.1f}s)")
+
+
+if __name__ == "__main__":
+    main()
@@ -2,12 +2,16 @@
 # because `tool.setuptools.ext-modules` is still experimental in pyproject.toml
 # and we need it to get the wheel suffix right.
 import os
+import sys
 from pathlib import Path

 import tomllib
 from setuptools import Extension, find_packages, setup
+from setuptools.command.build_ext import build_ext

-REPO_FOLDER = Path(__file__).parent
+# Detect repo folder: if setup.py is in pyodide folder, go to parent
+SETUP_DIR = Path(__file__).parent
+REPO_FOLDER = SETUP_DIR.parent if SETUP_DIR.name == "pyodide" else SETUP_DIR


 def get_version() -> str:
@@ -25,6 +29,39 @@ def get_dependencies() -> list[str]:
    return dependencies


+class UnixBuildExt(build_ext):
+    """Customize ``build_ext`` to support packing on Windows."""
+
+    def finalize_options(self):
+        from distutils import sysconfig
+
+        super().finalize_options()
+        if sys.platform == "win32":
+            self.compiler = "unix"
+
+            # Configure sysconfig for Windows builds
+            # CCSHARED is the only variable that's not customizable with env vars.
+            # Basically avoiding this:
+            # File ".venv\Lib\site-packages\setuptools\_distutils\sysconfig.py", line 366, in customize_compiler
+            #     compiler_so=cc_cmd + ' ' + ccshared,
+            #                 ~~~~~~~~~~~~~^~~~~~~~~~
+            # TypeError: can only concatenate str (not "NoneType") to str
+            sysconfig.get_config_vars()  # Initialize config cache
+            if sysconfig._config_vars.get("CCSHARED") is None:
+                sysconfig._config_vars["CCSHARED"] = "-fPIC"
+            # Override compiler type before it's instantiated
+
+        # Set Emscripten compiler environment variables
+        os.environ["CC"] = "emcc"
+        os.environ["CXX"] = "em++"
+        os.environ["CFLAGS"] = ""
+        os.environ["CXXFLAGS"] = ""
+        os.environ["LDSHARED"] = "emcc -shared"
+        os.environ["AR"] = "emar"
+        os.environ["ARFLAGS"] = "rcs"
+        os.environ["SETUPTOOLS_EXT_SUFFIX"] = ".cpython-313-wasm32-emscripten.so"
+
+
 setup(
    name="ifcopenshell",
    version=get_version(),
@@ -44,4 +81,5 @@ setup(
    },
    # Has to provide extension to get the correct wheel suffix.
    ext_modules=[Extension("ifcopenshell._ifcopenshell_wrapper", sources=[])],
+    cmdclass={"build_ext": UnixBuildExt},
 )
@@ -3,8 +3,9 @@ name = "IfcOpenShell"
 version = "0.0.0"
 dependencies = [
    "black==26.3.1",
-    "ruff==0.15.8",
+    "ruff==0.15.12",
    "poethepoet",
+    "ty==0.0.32",
    "gersemi==0.26.1",
 ]

@@ -28,6 +29,9 @@ extend-exclude = '''
 reportInvalidTypeForm = false
 disableBytesTypePromotions = true
 reportUnnecessaryTypeIgnoreComment = true
+reportRedeclaration = false
+# Ignore warnings from bpy stubs missing actual source files.
+reportMissingModuleSource = false
 # Pylance doesn't respect gitignore, so we have to exclude files manually here
 # to avoid VS Code slowing down.
 # https://github.com/microsoft/pylance-release/issues/5169
@@ -84,7 +88,6 @@ all = "ignore"
 # Structural rules (no deep type inference needed, easier to adapt).
 abstract-method-in-final-class = "error"
 ambiguous-protocol-member = "error"
-byte-string-type-annotation = "error"
 conflicting-declarations = "error"
 conflicting-metaclass = "error"
 cyclic-class-definition = "error"
@@ -96,7 +99,6 @@ empty-body = "error"
 escape-character-in-forward-annotation = "error"
 final-on-non-method = "error"
 final-without-value = "error"
-fstring-type-annotation = "error"
 ignore-comment-unknown-rule = "error"
 implicit-concatenated-string-type-annotation = "error"
 inconsistent-mro = "error"
@@ -213,10 +215,7 @@ exclude = [

 [tool.poe.tasks]

-ruff-main = "ruff check --extend-exclude nix/build-all.py"
-# It's actually Python 3.6, but ruff only supports 3.7+, but it should do.
-ruff-old = "ruff check nix/build-all.py --target-version py37"
-ruff.sequence = ["ruff-main", "ruff-old"]
+ruff = "ruff check"

 black = "black ."

@@ -224,7 +223,7 @@ ty.sequence = ["ty-bonsai", "ty-ios"]
 ty.help = "Run ty type checker. Requires ty-venv to be set up first."
 ty-bonsai = "ty check src/bonsai --python=src/bonsai/.venv"

-ty-venv.sequence = ["ty-venv-bonsai", "ty-venv-ios"]
+ty-venv.sequence = ["bonsai-deps", "ty-venv-bonsai", "ty-venv-ios"]

 ty-venv-bonsai.sequence = [
    {cmd = "uv venv src/bonsai/.venv --python=3.11 --allow-existing"},
@@ -236,7 +235,7 @@ ty-venv-ios.sequence = [
    {cmd = "uv pip install -r src/ifcopenshell-python/type-check-requirements.txt --python=src/ifcopenshell-python/.venv"},
 ]

-format.sequence = ["black", "ruff-main", "ruff-old"]
+format.sequence = ["black", "ruff"]

 cmake-format = "gersemi . --in-place"

@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.

 SHELL := sh
-PYTHON:=python3.11
-PIP:=pip3.11
+PYTHON:=python3
+PIP:=pip3
 PATCH:=patch
 SED:=sed -i
 VENV_ACTIVATE:=bin/activate
@@ -48,6 +48,7 @@ VERSION_PATCH:=$(shell cat '../../VERSION' | cut -d '.' -f 3)
 VERSION_DATE:=$(shell date '+%y%m%d')
 LAST_COMMIT_HASH:=$(shell git rev-parse HEAD)
 LAST_COMMIT_DATE:=$(shell git show -s --format=%cI)
+LAST_GIT_BRANCH:=$(shell git rev-parse --abbrev-ref HEAD)
 PYPI_IMP:=cp

 ifdef PYVERSION
@@ -63,6 +64,7 @@ PYNUMBER:=3$(PYMINOR)
 PYPI_VERSION:=3.$(PYMINOR)
 endif # def PYVERSION

+IFCMERGE_VERSION:=2026-04-07

 ifdef PLATFORM
 SUPPORTED_PLATFORMS := linux macos macosm1 win
@@ -104,7 +106,7 @@ endif
 endif # def PLATFORM

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

 	# required for three-way git merging
 ifeq ($(PLATFORM), win)
-	cd build/bonsai/libs/bin && wget https://github.com/brunopostle/ifcmerge/releases/download/2025-01-26/ifcmerge.zip
-	cd build/bonsai/libs/bin && unzip ifcmerge.zip && rm ifcmerge.zip
+	cd build/bonsai/libs/bin && wget https://github.com/brunopostle/ifcmerge/releases/download/$(IFCMERGE_VERSION)/ifcmerge.exe
 else
-	cd build/bonsai/libs/bin && wget https://raw.githubusercontent.com/brunopostle/ifcmerge/main/ifcmerge && chmod +x ifcmerge
+	cd build/bonsai/libs/bin && wget https://raw.githubusercontent.com/brunopostle/ifcmerge/$(IFCMERGE_VERSION)/ifcmerge && chmod +x ifcmerge
 endif

 	# Generate translations module for Bonsai build
@@ -261,6 +266,7 @@ else
 	$(SED) "s/0.0.0/$(VERSION)-alpha$(VERSION_DATE)/" build/bonsai/blender_manifest.toml
 	$(SED) "s/8888888/$(LAST_COMMIT_HASH)/" build/bonsai/__init__.py
 	$(SED) "s/9999999/$(LAST_COMMIT_DATE)/" build/bonsai/__init__.py
+	$(SED) "s/7777777/$(LAST_GIT_BRANCH)/" build/bonsai/__init__.py
 	$(SED) 's/version = "0.0.0"/version = "$(VERSION)-alpha$(VERSION_DATE)"/' build/pyproject.toml
 endif

@@ -354,6 +360,10 @@ else
 	pytest test/tool/test_$(MODULE).py --maxfail=1
 endif

+.PHONY: test-modal
+test-modal:
+	blender --enable-event-simulate --python test/modal/test_modal.py --window-maximized
+
 # Reregistering test is not added to the standard test suite because during unregister
 # Blender removes all Bonsai dependencies breaking dev-environment symlinks.
 .PHONY: test-reregister
@@ -43,6 +43,7 @@ from typing import TYPE_CHECKING, Any, Union

 last_commit_hash = "8888888"
 last_commit_date = "9999999"
+last_git_branch = "7777777"


 def get_last_commit_hash() -> Union[str, None]:
@@ -60,6 +61,15 @@ def get_last_commit_date() -> Union[str, None]:
    return last_commit_date


+def get_git_branch() -> Union[str, None]:
+    # Using this weird way to write 7777777,
+    # so makefile won't accidentally replace it here
+    # we'll be able to distinguish branch from placeholder value.
+    if last_git_branch == str(7_777777):
+        return None
+    return last_git_branch
+
+
 # Accessed from bonsai extension:
 bbim_semver: dict[str, Any] = {}

@@ -125,6 +135,7 @@ def get_debug_info(*, bonsai_failed_to_load: bool = False) -> dict[str, Any]:
        "bonsai_version": bbim_version,
        "bonsai_commit_hash": get_last_commit_hash(),
        "bonsai_commit_date": get_last_commit_date(),
+        "bonsai_git_branch": get_git_branch(),
        "last_actions": last_actions,
        "last_error": last_error,
    }
@@ -251,10 +262,12 @@ if IN_BLENDER:

            global last_commit_hash
            global last_commit_date
+            global last_git_branch
            path = Path(__file__).resolve().parent
            repo = git.Repo(str(path), search_parent_directories=True)
            last_commit_hash = repo.head.object.hexsha
            last_commit_date = repo.head.object.committed_datetime.isoformat()
+            last_git_branch = repo.active_branch.name
        except:
            pass

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

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

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

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

    unregister_classes(classes)

+    parametric_lifecycle.uninstall_parametric_lifecycle_handlers()
    bpy.app.handlers.load_post.remove(handler.load_post)
    bpy.app.handlers.load_post.remove(handler.loadIfcStore)
    del bpy.types.Scene.BIMProperties
@@ -0,0 +1,96 @@
+Copyright (c) 2011-2012, Nikita Volchenkov (<nikitavolchenkov@gmail.com>),
+with Reserved Font Name OpenGost Type B.
+
+Copyright (c) 2012, Valek Filippov (<frob@gnome.org>).
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -0,0 +1,119 @@
+# Bonsai - OpenBIM Blender Add-on
+# Copyright (C) 2026
+#
+# This file is part of Bonsai.
+#
+# Bonsai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Bonsai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was generated with the assistance of an AI coding tool.
+
+"""Shared structural-change cache token for POST_VIEW decorators.
+
+Decorators include the token in their cache key and rebuild on bump."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+import bpy
+
+T = TypeVar("T")
+
+_DECORATOR_CACHE_TOKEN = 0
+
+
+def get_decorator_cache_token() -> int:
+    return _DECORATOR_CACHE_TOKEN
+
+
+def reset_for_test() -> None:
+    """Test-only: reset the cache token to 0 so bump-count assertions are stable."""
+    global _DECORATOR_CACHE_TOKEN
+    _DECORATOR_CACHE_TOKEN = 0
+
+
+@bpy.app.handlers.persistent
+def _bump_decorator_cache_token(*args: Any) -> None:
+    """depsgraph_update_post fires every animation frame and every driver
+    evaluation, even when no IFC-relevant ID block changed. Unconditional
+    bumping defeats the cache: an animated scene rebuilds every decorator
+    every viewport tick. Gate the depsgraph path on Object geometry or
+    transform updates; undo / redo / load have no depsgraph and always
+    invalidate.
+
+    Coverage assumption: ``TokenCache`` consumers key on Object identity
+    (depsgraph updates whose ``id`` is a ``bpy.types.Object``). Mesh /
+    Material / NodeTree updates that don't surface as an Object change
+    do NOT invalidate the token — a decorator that caches material- or
+    mesh-data-derived state must gate on a separate signal."""
+    global _DECORATOR_CACHE_TOKEN
+    if len(args) >= 2:
+        depsgraph = args[1]
+        if depsgraph is not None and hasattr(depsgraph, "updates"):
+            if not any(
+                (getattr(u, "is_updated_geometry", False) or getattr(u, "is_updated_transform", False))
+                and hasattr(u, "id")
+                and isinstance(u.id, bpy.types.Object)
+                for u in depsgraph.updates
+            ):
+                return
+    _DECORATOR_CACHE_TOKEN += 1
+
+
+def _hooks() -> tuple[Any, ...]:
+    return (
+        bpy.app.handlers.depsgraph_update_post,
+        bpy.app.handlers.undo_post,
+        bpy.app.handlers.redo_post,
+        bpy.app.handlers.load_post,
+    )
+
+
+def install_decorator_cache_handlers() -> None:
+    """Append the bump handler to each hook; idempotent."""
+    for hook in _hooks():
+        if _bump_decorator_cache_token not in hook:
+            hook.append(_bump_decorator_cache_token)
+
+
+def uninstall_decorator_cache_handlers() -> None:
+    for hook in _hooks():
+        try:
+            hook.remove(_bump_decorator_cache_token)
+        except ValueError:
+            pass
+
+
+class TokenCache(Generic[T]):
+    """Memoise a single value keyed on ``(caller_key, get_decorator_cache_token())``.
+
+    The token component invalidates the cache on depsgraph / undo / redo / load,
+    so cached ``bpy.types.Object`` references can't outlive the underlying ID
+    blocks. Holds exactly one entry — last key wins."""
+
+    __slots__ = ("_key", "_value")
+
+    def __init__(self) -> None:
+        self._key: tuple[Any, int] | None = None
+        self._value: T | None = None
+
+    def get_or_compute(self, key: Any, compute: Callable[[], T]) -> T:
+        token_key = (key, _DECORATOR_CACHE_TOKEN)
+        if token_key == self._key:
+            return self._value  # type: ignore[return-value]
+        value = compute()
+        self._key = token_key
+        self._value = value
+        return value
@@ -15,11 +15,12 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.

 import os
 import weakref
 from collections.abc import Callable
-from math import cos
 from typing import Union

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

 import bonsai.bim
+import bonsai.core.model as core_model
 import bonsai.tool as tool
-from bonsai.bim.ifc import IfcStore
+from bonsai.bim.decorator_cache import (
+    install_decorator_cache_handlers,
+    uninstall_decorator_cache_handlers,
+)
+from bonsai.bim.ifc import IfcStore, get_cache_or_detect_lock
 from bonsai.bim.module.aggregate.decorator import AggregateDecorator
 from bonsai.bim.module.georeference.decorator import GeoreferenceDecorator
+from bonsai.bim.module.model.array import (
+    ArrayPreviewDecorator,
+    ArraySelectionHighlightDecorator,
+)
 from bonsai.bim.module.model.data import AuthoringData
 from bonsai.bim.module.model.decorator import (
+    BendPreviewDecorator,
    BoundingBoxDecorator,
+    DoorSwingReadonlyDecorator,
+    MEPSegmentExtendPreviewDecorator,
+    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__))
@@ -108,19 +125,13 @@ def active_object_callback():


 def update_bim_tool_props():
-    """update BIM Tools props (such as extrusion_depth, length and x_angle) when active object changes"""
-    obj = bpy.context.active_object
-
-    # bunch of checks to see if we're in a valid state
-    if not obj:
-        return
-    mode = bpy.context.mode
-    current_tool = bpy.context.workspace.tools.from_space_view3d_mode(mode)
-    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
-        return
-    element = tool.Ifc.get_entity(obj)
-    if not element:
+    """Selection-driven BIM Tool sync: re-target user-intent enums
+    (ifc_class, relating_type_id) AND refresh header values
+    (extrusion_depth, length, x_angle) for the new active object."""
+    ctx = _resolve_bim_tool_context()
+    if ctx is None:
        return
+    obj, current_tool, element = ctx

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

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

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

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

    if is_annotation_tool:
        return

+    _read_headers_into_props(obj, element)
+
+
+def refresh_bim_tool_headers():
+    """Push the active IFC entity's current header float values
+    (extrusion_depth, length, x_angle) into ``BIMModelProperties``.
+    Enum-safe: never writes user-intent enum slots, which are owned by
+    the selection callback."""
+    ctx = _resolve_bim_tool_context()
+    if ctx is None:
+        return
+    obj, current_tool, element = ctx
+    if current_tool.idname not in tool.Blender.get_property_header_tools():
+        return
+    _read_headers_into_props(obj, element)
+
+
+def _resolve_bim_tool_context():
+    """Return ``(obj, current_tool, element)`` when an active BIM workspace
+    tool sees a resolvable IFC element; ``None`` otherwise. Defensive
+    against stripped operator contexts — a missing ``active_object`` /
+    ``mode`` / ``workspace`` short-circuits to ``None`` instead of raising."""
+    obj = tool.Blender.get_active_object()
+    if not obj:
+        return None
+    mode = getattr(bpy.context, "mode", None)
+    workspace = getattr(bpy.context, "workspace", None)
+    if mode is None or workspace is None:
+        return None
+    current_tool = workspace.tools.from_space_view3d_mode(mode)
+    if not current_tool or current_tool.idname not in tool.Blender.get_list_of_tools():
+        return None
+    element = tool.Ifc.get_entity(obj)
+    if not element:
+        return None
+    return obj, current_tool, element
+
+
+def _read_headers_into_props(obj, element):
+    """Populate ``BIMModelProperties`` header values from the active
+    object's IFC extrusion. Enum-safe: writes only header floats, never
+    user-intent enum slots, so it is safe to call on the post-commit hook."""
    representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
    if not representation:
        return
@@ -162,10 +240,13 @@ def update_bim_tool_props():
    if not AuthoringData.is_loaded:
        AuthoringData.load()

+    props = tool.Model.get_model_props()
    if AuthoringData.data["active_material_usage"] == "LAYER2":
        x_angle = get_x_angle(extrusion)
        axis = tool.Model.get_wall_axis(obj)["reference"]
-        props.extrusion_depth = abs(extrusion.Depth * si_conversion * cos(x_angle))
+        props.extrusion_depth = core_model.vertical_height_from_extrusion_depth(
+            extrusion.Depth * si_conversion, x_angle
+        )
        props.length = (axis[1] - axis[0]).length
        props.x_angle = x_angle

@@ -356,8 +437,10 @@ def subscribe_to_viewport_shading_changes():
            )


-@persistent
-def load_post(scene):
+def _apply_save_file_invariants(scene: bpy.types.Scene) -> None:
+    """Invariants enforced on every load_post: msgbus subscription, IFC owner
+    settings, scene-bound caches, load-transient parametric state, and the
+    multi-instance lock probe."""
    global global_subscription_owner
    active_object_key = bpy.types.LayerObjects, "active"
    bpy.msgbus.subscribe_rna(
@@ -368,6 +451,23 @@ def load_post(scene):
    ifcopenshell.api.owner.settings.get_application = get_application
    AuthoringData.type_thumbnails = {}

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

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

-    # Bonsai overlays
+    tool.Blender.sync_old_preferences()
+
+
+def _install_viewport_overlays() -> None:
+    """Sync every Bonsai viewport decorator to its enabled state.
+
+    Wrapped in uninstall/install of the decorator-cache bump handlers so a
+    decorator's own install path doesn't double-bind to depsgraph_update_post
+    via ``TokenCache`` instances created during their own ``install()``."""
    georeference_props = tool.Georeference.get_georeference_props()
    aggregate_props = tool.Aggregate.get_aggregate_props()
    nest_props = tool.Nest.get_nest_props()
@@ -405,23 +515,62 @@ def load_post(scene):
    NestDecorator.uninstall()
    WallAxisDecorator.uninstall()
    SlabDirectionDecorator.uninstall()
-    if georeference_props.should_visualise:
-        GeoreferenceDecorator.install(bpy.context)
-    if aggregate_props.aggregate_decorator:
-        AggregateDecorator.install(bpy.context)
-    if nest_props.nest_decorator:
-        NestDecorator.install(bpy.context)
-    if model_props.show_wall_axis:
-        WallAxisDecorator.install(bpy.context)
-    if model_props.show_slab_direction:
-        SlabDirectionDecorator.install(bpy.context)
-    if model_props.show_bounding_box:
-        BoundingBoxDecorator.install(bpy.context)
+    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 preferences.should_use_snap and (scene := bpy.context.scene):
-        # Snapping is off by default in Blender, but in BIM, it's more useful to be on
-        scene.tool_settings.use_snap = True
-        # Match default Bonsai snaps
-        scene.tool_settings.snap_elements_base = {"EDGE", "EDGE_PERPENDICULAR", "VERTEX", "EDGE_MIDPOINT", "FACE"}

-    tool.Blender.sync_old_preferences()
+@persistent
+def load_post(scene):
+    _apply_save_file_invariants(scene)
+    _apply_user_preferences()
+    _install_viewport_overlays()
@@ -64,6 +64,44 @@ class TransactionStep(TypedDict):
    operations: list[Operation]


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

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

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

@@ -223,6 +223,7 @@ class IfcImporter:
        self.elements: set[ifcopenshell.entity_instance] = set()
        self.annotations: set[ifcopenshell.entity_instance] = set()
        self.gross_elements: set[ifcopenshell.entity_instance] = set()
+        self.broken_arrays: set[ifcopenshell.entity_instance] = set()
        self.element_types: set[ifcopenshell.entity_instance] = set()
        self.spatial_elements: set[ifcopenshell.entity_instance] = set()
        self.meshes: dict[str, OBJECT_DATA_TYPE] = {}
@@ -1219,8 +1220,18 @@ class IfcImporter:
                        if element not in elements_to_import:
                            continue
                    for i in range(len(data)):
-                        tool.Blender.Modifier.Array.set_children_lock_state(element, i, True)
-                        tool.Blender.Modifier.Array.constrain_children_to_parent(element)
+                        tool.Array.set_children_lock_state(element, i, True)
+                    tool.Array.constrain_children_to_parent(element)
+                    for layer in data:
+                        for child_guid in layer.get("children", ()):
+                            try:
+                                self.file.by_guid(child_guid)
+                            except RuntimeError:
+                                print(
+                                    f"setup_arrays: array parent {element.GlobalId} references missing "
+                                    f"child GUID {child_guid!r}."
+                                )
+                                self.broken_arrays.add(element)

    def update_linked_aggregates(self):
        # TODO Remove this after a while. See commit 17d6b8a
@@ -101,7 +101,7 @@ class AggregateDecorator:
        cls.is_installed = False

    def dotted_line_shader(self):
-        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")  # ty:ignore[too-many-positional-arguments]
+        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
        vert_out.smooth("FLOAT", "v_ArcLength")

        shader_info = gpu.types.GPUShaderCreateInfo()
@@ -73,6 +73,22 @@ def poll_related_object(self: "BIMObjectAggregateProperties", related_obj: bpy.t
    return True


+def update_relating_object(self, context):
+    if self.relating_object:
+        ifc_id = tool.Blender.get_object_bim_props(self.relating_object).ifc_definition_id
+        if ifc_id:
+            bpy.ops.bim.aggregate_assign_object(relating_object=ifc_id)
+            bpy.ops.bim.disable_editing_aggregate()
+
+
+def update_related_object(self, context):
+    if self.related_object:
+        ifc_id = tool.Blender.get_object_bim_props(self.related_object).ifc_definition_id
+        if ifc_id:
+            bpy.ops.bim.aggregate_assign_object(related_object=ifc_id)
+            bpy.ops.bim.disable_editing_aggregate()
+
+
 def update_aggregate_decorator(self, context):
    if self.aggregate_decorator:
        AggregateDecorator.install(bpy.context)
@@ -89,12 +105,15 @@ def update_aggregate_mode_decorator(self, context):

 class BIMObjectAggregateProperties(PropertyGroup):
    is_editing: BoolProperty(name="Is Editing")
-    relating_object: PointerProperty(name="Relating Whole", type=bpy.types.Object, poll=poll_relating_object)
+    relating_object: PointerProperty(
+        name="Relating Whole", type=bpy.types.Object, poll=poll_relating_object, update=update_relating_object
+    )
    related_object: PointerProperty(
        name="Related Part",
        description="Related Part, will be used to derive the Relating Object",
        type=bpy.types.Object,
        poll=poll_related_object,
+        update=update_related_object,
    )

    if TYPE_CHECKING:
@@ -120,6 +139,7 @@ class BIMAggregateProperties(PropertyGroup):
    previous_editing_aggregate: PointerProperty(name="Editing Aggregate", type=bpy.types.Object)
    editing_objects: CollectionProperty(type=Objects)
    not_editing_objects: CollectionProperty(type=Objects)
+    previously_selected_objects: CollectionProperty(type=Objects)
    aggregate_decorator: BoolProperty(
        name="Display Aggregate",
        default=False,
@@ -136,5 +156,6 @@ class BIMAggregateProperties(PropertyGroup):
        previous_editing_aggregate: Union[bpy.types.Object, None]
        editing_objects: bpy.types.bpy_prop_collection_idprop[Objects]
        not_editing_objects: bpy.types.bpy_prop_collection_idprop[Objects]
+        previously_selected_objects: bpy.types.bpy_prop_collection_idprop[Objects]
        aggregate_decorator: bool
        previous_state: bool
@@ -295,13 +295,13 @@ class ExplorerShowUIPopup(bpy.types.Operator):
    bl_description = "Show Explorer UI to select element as attribute value or edit it."
    bl_options = {"REGISTER", "UNDO"}

-    ifc_class: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    ifc_class: bpy.props.StringProperty()
    """Element IFC class."""
-    attribute_name: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    attribute_name: bpy.props.StringProperty()
    """IFC class attribute name."""
-    data_path: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    data_path: bpy.props.StringProperty()
    """Full data path"""
-    preselect_ifc_id: bpy.props.IntProperty(options={"SKIP_SAVE"})  # pyright: ignore[reportRedeclaration]
+    preselect_ifc_id: bpy.props.IntProperty(options={"SKIP_SAVE"})
    """IFC id to preselect in the popup."""

    if TYPE_CHECKING:
@@ -41,7 +41,7 @@ class BIMAttributeProperties(PropertyGroup):


 class ExplorerEntity(PropertyGroup):
-    ifc_definition_id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    ifc_definition_id: bpy.props.IntProperty()

    if TYPE_CHECKING:
        ifc_definition_id: int
@@ -60,7 +60,7 @@ class BIMExplorerProperties(PropertyGroup):
            self.property_unset("editing_entity_id")
            self.entity_attributes.clear()

-    is_loaded: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    is_loaded: BoolProperty(
        name="Toggle Explorer UI",
        update=update_is_loaded,
    )
@@ -76,15 +76,15 @@ class BIMExplorerProperties(PropertyGroup):
    def update_ifc_class(self, context: object) -> None:
        tool.Attribute.refresh_uilist_entities()

-    ifc_class: EnumProperty(  # pyright: ignore[reportRedeclaration]
+    ifc_class: EnumProperty(
        name="IFC Class To Search",
        items=get_ifc_class,
        update=update_ifc_class,
    )
-    entities: CollectionProperty(type=ExplorerEntity)  # pyright: ignore[reportRedeclaration]
-    active_entity_index: IntProperty()  # pyright: ignore[reportRedeclaration]
-    editing_entity_id: IntProperty()  # pyright: ignore[reportRedeclaration]
-    entity_attributes: CollectionProperty(type=Attribute)  # pyright: ignore[reportRedeclaration]
+    entities: CollectionProperty(type=ExplorerEntity)
+    active_entity_index: IntProperty()
+    editing_entity_id: IntProperty()
+    entity_attributes: CollectionProperty(type=Attribute)

    if TYPE_CHECKING:
        is_loaded: bool
@@ -48,12 +48,14 @@ def draw_ui(context: bpy.types.Context, layout: bpy.types.UILayout, attributes)
        row = layout.row()
        op = row.operator("bim.enable_editing_attributes", icon="GREASEPENCIL", text="Edit")

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

    # TODO: reimplement, see #1222
    # if "IfcSite/" in context.active_object.name or "IfcBuilding/" in context.active_object.name:
@@ -377,6 +377,8 @@ class EnableEditingBoundary(bpy.types.Operator):
            obj = tool.Ifc.get_object(entity)
            if entity and obj:
                setattr(bprops, blender_property, obj)
+        bprops.physical_or_virtual = boundary.PhysicalOrVirtualBoundary or "NOTDEFINED"
+        bprops.internal_or_external = boundary.InternalOrExternalBoundary or "NOTDEFINED"
        return {"FINISHED"}


@@ -392,6 +394,8 @@ class DisableEditingBoundary(bpy.types.Operator):
        bprops.is_editing = False
        for ifc_attribute, blender_property in EDITABLE_ATTRIBUTES.items():
            setattr(bprops, blender_property, None)
+        bprops.physical_or_virtual = "NOTDEFINED"
+        bprops.internal_or_external = "NOTDEFINED"
        return {"FINISHED"}


@@ -411,6 +415,8 @@ class EditBoundaryAttributes(bpy.types.Operator, tool.Ifc.Operator):
            obj = getattr(bprops, blender_property, None)
            entity = tool.Ifc.get_entity(obj)
            attributes[blender_property] = entity
+        attributes["physical_or_virtual"] = bprops.physical_or_virtual
+        attributes["internal_or_external"] = bprops.internal_or_external
        ifcopenshell.api.boundary.edit_attributes(tool.Ifc.get(), entity=boundary, **attributes)
        bpy.ops.bim.disable_editing_boundary()
        return {"FINISHED"}
@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING, Union
 import bpy
 from bpy.props import (
    BoolProperty,
+    EnumProperty,
    PointerProperty,
 )
 from bpy.types import PropertyGroup
@@ -50,12 +51,43 @@ def element_filter(self: "BIMObjectBoundaryProperties", object: bpy.types.Object
    return False


+def get_internal_or_external_items(
+    self: "BIMObjectBoundaryProperties", context: bpy.types.Context | None
+) -> list[tuple[str, str, str]]:
+    items = [
+        ("INTERNAL", "Internal", ""),
+        ("EXTERNAL", "External", ""),
+    ]
+    ifc = tool.Ifc.get()
+    if not ifc or ifc.schema != "IFC2X3":
+        items += [
+            ("EXTERNAL_EARTH", "External Earth", ""),
+            ("EXTERNAL_WATER", "External Water", ""),
+            ("EXTERNAL_FIRE", "External Fire", ""),
+        ]
+    items.append(("NOTDEFINED", "Not Defined", ""))
+    return items
+
+
 class BIMObjectBoundaryProperties(PropertyGroup):
    is_editing: BoolProperty(name="Is Editing")
    relating_space: PointerProperty(name="RelatingSpace", type=bpy.types.Object, poll=space_filter)
    related_building_element: PointerProperty(name="RelatedBuildingElement", type=bpy.types.Object, poll=element_filter)
    parent_boundary: PointerProperty(name="ParentBoundary", type=bpy.types.Object, poll=boundary_filter)
    corresponding_boundary: PointerProperty(name="CorrespondingBoundary", type=bpy.types.Object, poll=boundary_filter)
+    physical_or_virtual: EnumProperty(
+        name="PhysicalOrVirtualBoundary",
+        items=[
+            ("PHYSICAL", "Physical", ""),
+            ("VIRTUAL", "Virtual", ""),
+            ("NOTDEFINED", "Not Defined", ""),
+        ],
+        default="NOTDEFINED",
+    )
+    internal_or_external: EnumProperty(
+        name="InternalOrExternalBoundary",
+        items=get_internal_or_external_items,
+    )

    if TYPE_CHECKING:
        is_editing: bool
@@ -63,6 +95,8 @@ class BIMObjectBoundaryProperties(PropertyGroup):
        related_building_element: Union[bpy.types.Object, None]
        parent_boundary: Union[bpy.types.Object, None]
        corresponding_boundary: Union[bpy.types.Object, None]
+        physical_or_virtual: str
+        internal_or_external: str  # values depend on schema: IFC2X3 omits EXTERNAL_EARTH/WATER/FIRE


 class BIMBoundaryProperties(PropertyGroup):
@@ -77,6 +77,10 @@ class BIM_PT_Boundary(Panel):
            self.draw_relation_editor(boundary, "RelatedBuildingElement", "related_building_element")
            self.draw_relation_editor(boundary, "ParentBoundary", "parent_boundary")
            self.draw_relation_editor(boundary, "CorrespondingBoundary", "corresponding_boundary")
+            row = self.layout.row()
+            row.prop(self.bprops, "physical_or_virtual")
+            row = self.layout.row()
+            row.prop(self.bprops, "internal_or_external")
        else:
            row = self.layout.row()
            row.operator("bim.enable_editing_boundary", icon="GREASEPENCIL", text="Edit")
@@ -84,6 +88,8 @@ class BIM_PT_Boundary(Panel):
            self.draw_relation_data(boundary, "RelatedBuildingElement")
            self.draw_relation_data(boundary, "ParentBoundary")
            self.draw_relation_data(boundary, "CorrespondingBoundary")
+            self.draw_enum_data(boundary, "PhysicalOrVirtualBoundary")
+            self.draw_enum_data(boundary, "InternalOrExternalBoundary")
            if hasattr(boundary, "InnerBoundaries"):
                for i, inner_boundary in enumerate(getattr(boundary, "InnerBoundaries", ())):
                    row = self.layout.row(align=True)
@@ -110,6 +116,11 @@ class BIM_PT_Boundary(Panel):
            else:
                row.label(text="")

+    def draw_enum_data(self, boundary, ifc_attribute: str):
+        row = self.layout.row(align=True)
+        row.label(text=ifc_attribute)
+        row.label(text=getattr(boundary, ifc_attribute, "") or "")
+
    def draw_relation_editor(self, boundary, ifc_attribute: str, blender_property: str):
        if hasattr(boundary, ifc_attribute):
            row = self.layout.row(align=True)
@@ -345,9 +345,17 @@ class CadArcFrom3Points(bpy.types.Operator):
 class CadOffset(bpy.types.Operator):
    bl_idname = "bim.cad_offset"
    bl_label = "CAD Offset"
-    bl_description = "Copy selected mesh geometry at provided offset. Mesh copied based on the current viewport angle."
+    bl_description = (
+        "Offset selected mesh geometry at provided distance, based on the current viewport angle. "
+        "Creates a copy by default, or moves the existing edges if Copy is disabled."
+    )
    bl_options = {"REGISTER", "UNDO"}
    distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
+    copy: bpy.props.BoolProperty(
+        name="Copy",
+        description="Create a new offset copy of the geometry. If disabled, move the existing edges to the offset location",
+        default=True,
+    )

    @classmethod
    def poll(cls, context):
@@ -405,6 +413,11 @@ class CadOffset(bpy.types.Operator):
        rotation = Matrix.Rotation(pi / 2, 2, "Z")
        rotation_i = Matrix.Rotation(-pi / 2, 2, "Z")

+        # When not copying, the offset positions are gathered here and applied to
+        # the existing verts only after all loops are processed, so that the
+        # original coordinates are still available while computing offsets.
+        moved_verts = []
+
        # Create loops from edges
        loop_edges = set(edges)
        loops = []
@@ -517,12 +530,15 @@ class CadOffset(bpy.types.Operator):
                    offset_length = self.distance / sqrt((1 + normals[0].dot(normals[1])) / 2)
                    offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ (new_normal * offset_length).to_3d())
                    new_vert = v1.co + offset
-                    new_verts.append(bm.verts.new(new_vert))
                else:
                    normal = (normals[0] * self.distance).to_3d()
                    offset = mw.inverted().to_quaternion() @ (wp.to_quaternion() @ normal)
                    new_vert = v1.co + offset
+
+                if self.copy:
                    new_verts.append(bm.verts.new(new_vert))
+                else:
+                    moved_verts.append((v1, new_vert))

                processed_verts.add(v1.index)

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

                v1 = v2

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

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

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

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

    def hotkey_S_Q(self):
        obj = bpy.context.active_object
@@ -201,16 +201,10 @@ class ExecuteIfcClash(bpy.types.Operator, ExportHelper):
        "ALT+click to run a quick clash without selecting a file to save."
    )

-    filter_glob: bpy.props.StringProperty(  # pyright: ignore[reportRedeclaration]
-        default="*.bcf;*.json", options={"HIDDEN"}
-    )
-    format: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
-        name="Format", items=[(i, i, "") for i in ("bcf", "json")]
-    )
-    filepath: bpy.props.StringProperty(  # pyright: ignore[reportRedeclaration]
-        subtype="FILE_PATH", options={"SKIP_SAVE"}
-    )
-    quick_clash: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    filter_glob: bpy.props.StringProperty(default="*.bcf;*.json", options={"HIDDEN"})
+    format: bpy.props.EnumProperty(name="Format", items=[(i, i, "") for i in ("bcf", "json")])
+    filepath: bpy.props.StringProperty(subtype="FILE_PATH", options={"SKIP_SAVE"})
+    quick_clash: bpy.props.BoolProperty(
        options={"SKIP_SAVE"},
    )

@@ -37,12 +37,12 @@ from bonsai.bim.prop import BIMFilterGroup, StrProperty


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

    if TYPE_CHECKING:
        cost_schedule: int
@@ -260,14 +260,14 @@ class CreateAllShapes(bpy.types.Operator):
    )
    bl_options = {"REGISTER"}

-    geometry_library: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    geometry_library: bpy.props.EnumProperty(
        name="Geometry Library",
        description="Geometry library to use for testing shape creation.",
        items=[(i, i, "") for i in get_args(ifcopenshell.geom.GEOMETRY_LIBRARY)],
        # By default use the same library as used for importing ifc project.
        default="hybrid-cgal-simple-opencascade",
    )
-    custom_geometry_library: bpy.props.StringProperty(  # pyright: ignore[reportRedeclaration]
+    custom_geometry_library: bpy.props.StringProperty(
        name="Custom Geometry Library",
        description="Provide a custom geometry library name, will override the 'geometry library' property.",
    )
@@ -781,7 +781,7 @@ class PurgeUnusedObjects(bpy.types.Operator, tool.Ifc.Operator):
    bl_label = "Purge Unused Objects"
    bl_options = {"REGISTER", "UNDO"}

-    object_type: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    object_type: bpy.props.EnumProperty(
        name="Object Type",
        items=((s, s.capitalize(), "") for s in get_args(tool.Debug.PurgeMergeObjectType)),
    )
@@ -827,7 +827,7 @@ class MergeIdenticalObjects(bpy.types.Operator, tool.Ifc.Operator):
    )
    bl_options = {"REGISTER", "UNDO"}

-    object_type: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    object_type: bpy.props.EnumProperty(
        name="Object Type",
        items=((s, s.capitalize(), "") for s in get_args(tool.Debug.PurgeMergeObjectType)),
    )
@@ -1073,7 +1073,7 @@ class ChangeLogLevel(bpy.types.Operator):
    bl_options = {"REGISTER"}
    bl_description = "Change general log level across all Python code in Blender"

-    log_level: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    log_level: bpy.props.EnumProperty(
        name="Log Level",
        items=[(i, i, "") for i in get_args(LogLevelType)],
        default="WARNING",
@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.

 import bpy

@@ -136,14 +138,34 @@ classes = (
    gizmos.GizmoArrow2D,
    gizmos.GizmoCone,
    gizmos.GizmoDimension,
-    gizmos.GizmoLock,
+    gizmos.GizmoLockOpen,
+    gizmos.GizmoLockClosed,
    gizmos.GizmoArc,
+    gizmos.GizmoLinkToggle,
+    gizmos.GizmoFillet,
+    gizmos.GizmoWallCornerIcon,
+    gizmos.GizmoWallTeeIcon,
    gizmos.GizmoPen,
    gizmos.GizmoValidate,
    gizmos.GizmoCancel,
    gizmos.GizmoPlus,
    gizmos.GizmoMinus,
+    gizmos.GizmoTrash,
+    gizmos.GizmoArrayParent,
+    gizmos.GizmoArrayAll,
+    gizmos.GizmoArrayLayerIndicator,
+    gizmos.GizmoCountLabel,
+    gizmos.GizmoMerge,
+    gizmos.GizmoSplit,
+    gizmos.GizmoUnjoin,
+    gizmos.GizmoExtend,
+    gizmos.GizmoExtendVertical,
+    gizmos.GizmoOffsetExterior,
+    gizmos.GizmoOffsetCenter,
+    gizmos.GizmoOffsetInterior,
+    gizmos.GizmoAddOpening,
    gizmos.GizmoCycle,
+    gizmos.GizmoMenu,
    # Drawing-specific gizmos
    gizmos.UglyDotGizmo,
    gizmos.ExtrusionGuidesGizmo,
@@ -313,7 +313,7 @@ def format_distance(
            if not feet and not add_inches:
                tx_dist += str(feet) + "'"

-            if not feet and add_inches:
+            if not feet and add_inches and unit_length != "INCHES":
                if value < 0:
                    tx_dist += "-0' - "
                else:
@@ -246,17 +246,17 @@ class CreateDrawing(bpy.types.Operator):
        + "Add the CTRL modifier to optionally open drawings to view them as\n"
        + "they are created"
    )
-    print_all: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    print_all: bpy.props.BoolProperty(
        name="Print All",
        default=False,
        options={"SKIP_SAVE"},
    )
-    open_viewer: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    open_viewer: bpy.props.BoolProperty(
        name="Open in Viewer",
        default=False,
        options={"SKIP_SAVE"},
    )
-    sync: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    sync: bpy.props.BoolProperty(
        name="Sync Before Creating Drawing",
        description="Could save some time if you're sure IFC and current Blender session are already in sync",
        default=True,
@@ -2322,14 +2322,14 @@ class ActivateDrawingBase(tool.Ifc.Operator):
        + "SHIFT+CLICK to load a quick preview of the drawing view"
    )

-    drawing: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    should_view_from_camera: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    drawing: bpy.props.IntProperty()
+    should_view_from_camera: bpy.props.BoolProperty(
        name="Should View From Camera",
        description="Move view to the activated drawing's camera position.",
        default=True,
        options={"SKIP_SAVE"},
    )
-    use_quick_preview: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    use_quick_preview: bpy.props.BoolProperty(
        name="Use Quick Preview",
        description="Just move the camera to the drawing view, without loading anything else.",
        default=False,
@@ -3635,14 +3635,12 @@ class ToggleTargetView(bpy.types.Operator):
    bl_label = "Toggle Target View"
    bl_options = {"REGISTER", "UNDO"}

-    target_view: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
-    toggle_all: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    target_view: bpy.props.StringProperty()
+    toggle_all: bpy.props.BoolProperty(
        default=False,
        options={"SKIP_SAVE"},
    )
-    option: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
-        items=[(i, i, "") for i in get_args(ToggleOption)]
-    )
+    option: bpy.props.EnumProperty(items=[(i, i, "") for i in get_args(ToggleOption)])

    if TYPE_CHECKING:
        target_view: str
@@ -860,13 +860,13 @@ class BIMTextProperties(PropertyGroup):
    is_editing: BoolProperty(name="Is Editing", default=False)
    literals: CollectionProperty(name="Literals", type=LiteralProps)
    newline_at: IntProperty(name="Newline At")
-    symbol: EnumProperty(  # pyright: ignore[reportRedeclaration]
+    symbol: EnumProperty(
        name="Symbol",
        description="Symbol from symbols.svg to use for this text.",
        items=[(s, s, "") for s in ["NO SYMBOL", "CUSTOM SYMBOL"] + tool.Drawing.DEFAULT_SYMBOLS],
        default="NO SYMBOL",
    )
-    custom_symbol: StringProperty(  # pyright: ignore[reportRedeclaration]
+    custom_symbol: StringProperty(
        name="Custom Symbol",
        description="Non-default symbol to use for this text.",
    )
@@ -44,8 +44,12 @@ class ViewportData:

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

    @classmethod
    def mode(cls) -> tool.Blender.BLENDER_ENUM_ITEMS:
@@ -76,9 +80,9 @@ class ViewportData:
                modes.append(edit_mode)
            elif element.is_a("IfcGridAxis"):
                modes.append(edit_mode)
-            elif tool.Blender.Modifier.is_roof(element):
+            elif tool.Parametric.is_roof(element):
                modes.append(edit_mode)
-            elif tool.Blender.Modifier.is_railing(element):
+            elif tool.Parametric.is_railing(element):
                modes.append(edit_mode)
            elif item_mode not in modes:
                modes.append(item_mode)
@@ -60,6 +60,7 @@ import bonsai.core.root
 import bonsai.core.spatial
 import bonsai.tool as tool
 from bonsai.bim.ifc import IfcStore
+from bonsai.bim.module.model import preview_base
 from bonsai.bim.module.model.decorator import ProfileDecorator

 if TYPE_CHECKING:
@@ -85,7 +86,7 @@ class EditObjectPlacement(bpy.types.Operator, tool.Ifc.Operator):
 class OverrideMeshSeparate(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.override_mesh_separate"
    bl_label = "IFC Mesh Separate"
-    blender_op = bpy.ops.mesh.separate.get_rna_type()
+    blender_op = bpy.ops.mesh.separate.get_rna_type()  # ty: ignore[missing-argument]
    bl_description = blender_op.description + ".\nAlso makes sure changes are in sync with IFC."
    bl_options = {"REGISTER", "UNDO"}
    blender_type_prop = blender_op.properties["type"]
@@ -246,7 +247,7 @@ class OverrideMeshSeparate(bpy.types.Operator, tool.Ifc.Operator):

 class OverrideOriginSet(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.override_origin_set"
-    blender_op = bpy.ops.object.origin_set.get_rna_type()
+    blender_op = bpy.ops.object.origin_set.get_rna_type()  # ty: ignore[missing-argument]
    bl_label = "IFC Origin Set"
    bl_description = (
        blender_op.description + ".\nAlso makes sure changes are in sync with IFC (operator works only on IFC objects)"
@@ -545,6 +546,13 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
        objs = [bpy.data.objects[obj_name]] if obj_name else context.selected_objects
        self.file = tool.Ifc.get()

+        # Tessellated face sets (IfcTriangulatedFaceSet/IfcPolygonalFaceSet) were
+        # introduced in IFC4 and do not exist in IFC2X3. Catch this early so we
+        # don't silently fall back to a faceted brep after stripping materials.
+        if self.ifc_representation_class == "IfcTessellatedFaceSet" and self.file.schema == "IFC2X3":
+            self.report({"ERROR"}, "Tessellated face sets are not supported in IFC2X3.")
+            return {"CANCELLED"}
+
        for obj in objs:
            # TODO: write unit tests to see how this bulk operation handles
            # contradictory ifc_representation_class values and when
@@ -801,7 +809,7 @@ def calc_delete_is_batch(ifc_file: ifcopenshell.file, context: bpy.types.Context
 class OverrideDelete(bpy.types.Operator):
    bl_idname = "bim.override_object_delete"
    bl_label = "IFC Delete"
-    blender_op = bpy.ops.object.delete.get_rna_type()
+    blender_op = bpy.ops.object.delete.get_rna_type()  # ty: ignore[missing-argument]
    bl_description = (
        blender_op.description
        + ".\nAlso makes sure changes in sync with IFC."
@@ -821,7 +829,7 @@ class OverrideDelete(bpy.types.Operator):
    def poll(cls, context):
        # Match `object.delete` poll for consistency.
        # `object.delete` poll just checks for OBJECT mode.
-        poll = bpy.ops.object.delete.poll()
+        poll = bpy.ops.object.delete.poll()  # ty: ignore[missing-argument]
        if poll:
            return True
        cls.poll_message_set("Only available in OBJECT mode")
@@ -882,6 +890,16 @@ class OverrideDelete(bpy.types.Operator):
        # Track aggregates before deleting their parts
        aggregates_to_check = self.track_aggregates(objects_to_remove)

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

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

        for array_parent in array_parents:
            array_parent_obj = tool.Ifc.get_object(array_parent)
-            data = [(i, data) for i, data in enumerate(tool.Blender.Modifier.Array.get_modifiers_data(array_parent))]
+            data = [(i, data) for i, data in enumerate(tool.Array.get_modifiers_data(array_parent))]
            # NOTE: there is a way to remove arrays more precisely but it's more complex
            for i, modifier_data in reversed(data):
-                children = set(tool.Blender.Modifier.Array.get_children_objects(modifier_data))
+                children = set(tool.Array.get_children_objects(modifier_data))
                if children.issubset(selected_objects):
                    with context.temp_override(active_object=array_parent_obj):
                        bpy.ops.bim.remove_array(item=i)
@@ -1045,7 +1066,7 @@ class SelectedIdsData(NamedTuple):
 class OverrideOutlinerDelete(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.override_outliner_delete"
    bl_label = "IFC Delete"
-    blender_op = bpy.ops.outliner.delete.get_rna_type()
+    blender_op = bpy.ops.outliner.delete.get_rna_type()  # ty: ignore[missing-argument]
    bl_description = (
        blender_op.description
        + ".\nAlso makes sure changes in sync with IFC."
@@ -1060,7 +1081,7 @@ class OverrideOutlinerDelete(bpy.types.Operator, tool.Ifc.Operator):
    def poll(cls, context) -> bool:
        # Match `outliner.delete` poll for consistency.
        # `outliner.delete` just checks `area.type` == `OUTLINER`.
-        poll = bpy.ops.outliner.delete.poll()
+        poll = bpy.ops.outliner.delete.poll()  # ty: ignore[missing-argument]
        if poll:
            return True
        cls.poll_message_set("Only available from Outliner.")
@@ -1164,7 +1185,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
    def poll(cls, context) -> bool:
        # Match `object.duplicate_move` poll for consistency.
        # `object.duplicate_move` poll checks for OBJECT mode.
-        poll = bpy.ops.object.duplicate_move.poll()
+        poll = bpy.ops.object.duplicate_move.poll()  # ty: ignore[missing-argument]
        if poll:
            return True
        cls.poll_message_set("Only available in OBJECT mode")
@@ -1183,7 +1204,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
        operator: bpy.types.Operator, context: bpy.types.Context, linked: bool = False
    ) -> set["rna_enums.OperatorReturnItems"]:
        # Deep magick from the dawn of time
-        if tool.Ifc.get():
+        if tool.Ifc.get() and tool.Model.has_selected_ifc_objects(include_active=False):
            IfcStore.execute_ifc_operator(operator, context)
            return {"FINISHED"}

@@ -1287,6 +1308,9 @@ class OverrideDuplicateMove(bpy.types.Operator):
                            if part_obj:
                                all_objects_to_select.add(part_obj)

+        # Non-IFC duplicates aren't tracked in old_to_new but are left selected by duplicate_ifc_objects
+        all_objects_to_select.update(obj for obj in context.selected_objects if not tool.Ifc.get_entity(obj))
+
        # Deselect everything first
        bpy.ops.object.select_all(action="DESELECT")

@@ -1908,7 +1932,7 @@ class RefreshLinkedAggregate(bpy.types.Operator, tool.Ifc.Operator):
 class OverrideJoin(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.override_object_join"
    bl_label = "IFC Join"
-    blender_op = bpy.ops.mesh.separate.get_rna_type()
+    blender_op = bpy.ops.mesh.separate.get_rna_type()  # ty: ignore[missing-argument]
    bl_description = (
        blender_op.description
        + ".\nAlso makes sure changes are in sync with IFC."
@@ -1926,7 +1950,7 @@ class OverrideJoin(bpy.types.Operator, tool.Ifc.Operator):

    @classmethod
    def poll(cls, context):
-        if not bpy.ops.object.join.poll():
+        if not bpy.ops.object.join.poll():  # ty: ignore[missing-argument]
            cls.poll_message_set("Active object is not EDITable.")
            return False
        if not context.selected_editable_objects:
@@ -2223,6 +2247,8 @@ class OverrideEscape(bpy.types.Operator):
            bpy.ops.bim.hide_all_openings()
        elif tool.Aggregate.get_aggregate_props().in_aggregate_mode:
            bpy.ops.bim.disable_aggregate_mode()
+        elif preview_base.try_cancel_active_preview(context):
+            pass
        elif active_object := context.active_object:
            if tool.Blender.Modifier.try_canceling_editing_modifier_parameters_or_path(active_object):
                pass
@@ -2264,6 +2290,8 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
                gprops = tool.Geometry.get_geometry_props()
                if gprops.representation_obj:
                    tool.Geometry.disable_item_mode()
+                    if active_obj := bpy.context.active_object:
+                        active_obj.select_set(False)
                else:
                    bonsai.core.aggregate.exit_aggregate_mode(tool.Aggregate)
                return {"FINISHED"}
@@ -2350,6 +2378,7 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
            and usage in ("LAYER1", "LAYER2")
        ):
            self.report({"INFO"}, f"Parametric {usage} elements cannot be edited directly")
+            obj.select_set(False)
        elif item.is_a("IfcSweptAreaSolid"):
            tool.Geometry.sync_item_positions()
            res = tool.Model.import_profile((profile := item.SweptArea), obj=obj)
@@ -2358,6 +2387,7 @@ class OverrideModeSetEdit(bpy.types.Operator, tool.Ifc.Operator):
                    {"INFO"},
                    f"Couldn't import profile, editing it directly is not yet supported. Failing profile: {profile}.",
                )
+                obj.select_set(False)
                return
            tool.Ifc.link(item, obj.data)
            self.enable_edit_mode(context)
@@ -2485,9 +2515,9 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
                    profile = tool.Ifc.get().by_id(profile_id)
                    if tool.Ifc.get_object(profile):  # We are editing an arbitrary profile
                        bpy.ops.bim.edit_arbitrary_profile()
-                elif tool.Blender.Modifier.is_railing(element):
+                elif tool.Parametric.is_railing(element):
                    bpy.ops.bim.finish_editing_railing_path()
-                elif tool.Blender.Modifier.is_roof(element):
+                elif tool.Parametric.is_roof(element):
                    bpy.ops.bim.finish_editing_roof_path()
                elif tool.Model.get_usage_type(element) == "PROFILE":
                    bpy.ops.bim.edit_extrusion_axis()
@@ -3156,7 +3186,7 @@ class EnableEditingRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
                product_reps = element.RepresentationMaps
            item_aspect = {}
            for product_rep in product_reps:
-                for aspect in product_rep.HasShapeAspects:
+                for aspect in getattr(product_rep, "HasShapeAspects", ()):
                    for aspect_rep in aspect.ShapeRepresentations:
                        if aspect_rep.ContextOfItems != representation.ContextOfItems:
                            continue
@@ -19,6 +19,7 @@
 import bpy
 from bpy.types import Menu, Panel, UIList

+import ifcopenshell.util.unit
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import prop_with_search
@@ -483,10 +484,32 @@ class BIM_PT_placement(Panel):
            row.label(text="No Object Placement Found")
            return

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

        if props.blender_offset_type != "NONE":
            row = self.layout.row(align=True)
@@ -43,11 +43,11 @@ class ToggleGroup(bpy.types.Operator, tool.Ifc.Operator):
    bl_label = "Toggle Group"
    bl_options = {"REGISTER", "UNDO"}

-    ifc_definition_id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    group_type: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    ifc_definition_id: bpy.props.IntProperty()
+    group_type: bpy.props.EnumProperty(
        items=[(i, i, "") for i in get_args(tool.Group.GroupType)],
    )
-    option: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    option: bpy.props.EnumProperty(
        items=[(i, i, "") for i in get_args(tool.Group.ToggleOption)],
    )

@@ -34,8 +34,10 @@ classes = (
    operator.Fetch,
    operator.Merge,
    operator.ObjectLog,
+    operator.SelectConflictEntity,
    operator.Push,
    operator.RefreshGit,
+    operator.RenameBranch,
    operator.SwitchRevision,
    operator.InstallGit,
    operator.RunGitDiff,
@@ -21,65 +21,71 @@ class IfcGitData:

    @classmethod
    def load(cls):
+        repo = None
+        if bool(tool.Ifc.get()):
+            path_ifc = tool.Ifc.get_path()
+            if os.path.isfile(path_ifc):
+                repo = tool.IfcGit.repo_from_path(path_ifc)
+
        cls.data = {
-            "repo": cls.repo(),
-            "remotes": cls.remotes(),
-            "branch_names": cls.branch_names(),
-            "remote_names": cls.remote_names(),
-            "remote_urls": cls.remote_urls(),
+            "repo": repo,
+            "remotes": repo.remotes if repo else None,
+            "branch_names": cls.branch_names(repo),
+            "tag_names": cls.tag_names(repo),
+            "remote_names": cls.remote_names(repo),
+            "remote_urls": {r.name: r.url for r in repo.remotes} if repo else {},
            "path_ifc": cls.path_ifc(),
            "branches_by_hexsha": cls.branches_by_hexsha(),
            "tags_by_hexsha": cls.tags_by_hexsha(),
-            "name_ifc": cls.name_ifc(),
+            "name_ifc": cls.name_ifc(repo),
            "dir_name": cls.dir_name(),
            "base_name": cls.base_name(),
-            "working_dir": cls.working_dir(),
-            "untracked_files": cls.untracked_files(),
-            "is_detached": cls.is_detached(),
-            "active_branch_name": cls.active_branch_name(),
-            "is_dirty": cls.is_dirty(),
-            "commit": cls.commit(),
-            "current_revision": cls.current_revision(),
+            "working_dir": repo.working_dir if repo else None,
+            "ifc_is_untracked": cls.ifc_is_untracked(repo),
+            "is_detached": repo.head.is_detached if repo else None,
+            "active_branch_name": repo.active_branch.name if repo and not repo.head.is_detached else None,
+            "is_dirty": cls.is_dirty(repo),
+            "current_revision": cls.current_revision(repo),
            "git_exe": cls.git_exe(),
            "ifcmerge_exe": cls.ifcmerge_exe(),
        }
        cls.is_loaded = True

    @classmethod
-    def repo(cls):
-        if bool(tool.Ifc.get()):
-            path_ifc = tool.Ifc.get_path()
-            if os.path.isfile(path_ifc):
-                return tool.IfcGit.repo_from_path(path_ifc)
-        return None
+    def branch_names(cls, repo):
+        if not repo or not repo.heads:
+            return []
+        names = sorted([b.name for b in repo.branches])
+        if "main" in names:
+            names.remove("main")
+            names = ["main"] + names
+        if repo.remotes:
+            for remote in repo.remotes:
+                for ref in remote.refs:
+                    names.append(ref.name)
+        return names

    @classmethod
-    def remotes(cls):
-        if cls.repo():
-            return cls.repo().remotes
-        return None
+    def tag_names(cls, repo):
+        if not repo:
+            return []
+        return [t.name for t in repo.tags]

    @classmethod
-    def branch_names(cls):
-        return []
-
-    @classmethod
-    def remote_names(cls):
-        return []
-
-    @classmethod
-    def remote_urls(cls):
-        result = {}
-        if cls.repo():
-            for remote in cls.repo().remotes:
-                result[remote.name] = remote.url
-        return result
+    def remote_names(cls, repo):
+        if not repo:
+            return []
+        names = sorted([r.name for r in repo.remotes])
+        if "origin" in names:
+            names.remove("origin")
+            names = ["origin"] + names
+        return names

    @classmethod
    def path_ifc(cls):
        path_ifc = tool.Ifc.get_path()
        if os.path.isfile(path_ifc):
-            return tool.Ifc.get_path()
+            return path_ifc
        return None

    @classmethod
@@ -88,7 +94,8 @@ class IfcGitData:
            if tool.IfcGitRepo.repo.branches:
                return tool.IfcGit.branches_by_hexsha(tool.IfcGitRepo.repo)
        except AttributeError:
-            return {}
+            pass
+        return {}

    @classmethod
    def tags_by_hexsha(cls):
@@ -97,12 +104,11 @@ class IfcGitData:
        return {}

    @classmethod
-    def name_ifc(cls):
-        if bool(tool.Ifc.get()):
+    def name_ifc(cls, repo):
+        if bool(tool.Ifc.get()) and repo:
            path_ifc = tool.Ifc.get_path()
-            if tool.IfcGitRepo.repo and os.path.isfile(path_ifc):
-                working_dir = tool.IfcGitRepo.repo.working_dir
-                return os.path.relpath(path_ifc, working_dir)
+            if os.path.isfile(path_ifc):
+                return os.path.relpath(path_ifc, repo.working_dir)
        return None

    @classmethod
@@ -122,49 +128,28 @@ class IfcGitData:
        return None

    @classmethod
-    def working_dir(cls):
-        if cls.repo():
-            return cls.repo().working_dir
+    def ifc_is_untracked(cls, repo):
+        """Return True if the IFC file exists in the repo but has not been added to git."""
+        if not repo:
+            return False
+        path_ifc = tool.Ifc.get_path()
+        if not os.path.isfile(path_ifc):
+            return False
+        return not bool(repo.git.ls_files(path_ifc))

    @classmethod
-    def untracked_files(cls):
-        if cls.repo():
-            return cls.repo().untracked_files
-        return []
-
-    @classmethod
-    def is_detached(cls):
-        if cls.repo():
-            return cls.repo().head.is_detached
-
-    @classmethod
-    def active_branch_name(cls):
-        if cls.repo() and not cls.is_detached():
-            return cls.repo().active_branch.name
-
-    @classmethod
-    def is_dirty(cls):
-        if cls.repo() and cls.git_exe():
+    def is_dirty(cls, repo):
+        if repo and cls.git_exe():
            path_ifc = tool.Ifc.get_path()
            if os.path.isfile(path_ifc):
-                return cls.repo().is_dirty(path=path_ifc)
+                return repo.is_dirty(path=path_ifc)
        return False

    @classmethod
-    def commit(cls):
+    def current_revision(cls, repo):
        props = tool.IfcGit.get_ifcgit_props()
-        if cls.repo() and len(props.ifcgit_commits) > 0:
-            item = props.ifcgit_commits[props.commit_index]
-            try:
-                return cls.repo().commit(rev=item.hexsha)
-            except ValueError:
-                return
-
-    @classmethod
-    def current_revision(cls):
-        props = tool.IfcGit.get_ifcgit_props()
-        if cls.repo() and cls.repo().head.is_valid() and len(props.ifcgit_commits) > 0:
-            return tool.IfcGitRepo.repo.commit()
+        if repo and repo.head.is_valid() and len(props.ifcgit_commits) > 0:
+            return repo.commit()

    @classmethod
    def git_exe(cls):
@@ -120,11 +120,11 @@ class CommitChanges(bpy.types.Operator):
        if props.commit_message == "":
            return False
        if repo:
-            if props.new_branch_name in [branch.name for branch in repo.branches]:
+            if props.new_branch_name in IfcGitData.data["branch_names"]:
                cls.poll_message_set("Branch already exists!")
                return False
            elif not tool.IfcGit.is_valid_ref_format(props.new_branch_name):
-                if repo.head.is_detached:
+                if IfcGitData.data["is_detached"]:
                    cls.poll_message_set("Branch name is invalid or empty!")
                    return False
                elif props.new_branch_name != "":
@@ -134,10 +134,17 @@ class CommitChanges(bpy.types.Operator):

    def execute(self, context):

-        repo = IfcGitData.data["repo"]
-        core.commit_changes(tool.IfcGit, tool.Ifc, repo)
-        core.refresh_revision_list(tool.IfcGit, repo, tool.Ifc)
+        props = tool.IfcGit.get_ifcgit_props()
+        commit_message = props.commit_message
+        new_branch_name = props.new_branch_name
+        core.commit_changes(tool.IfcGit, tool.Ifc, commit_message, new_branch_name)
+        props.new_branch_name = ""
+        props.commit_message = ""
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
        refresh()
+        IfcGitData.load()
+        if new_branch_name:
+            props.display_branch = new_branch_name
        return {"FINISHED"}


@@ -157,7 +164,7 @@ class AddTag(bpy.types.Operator):
        repo = IfcGitData.data["repo"]
        if repo and (
            not tool.IfcGit.is_valid_ref_format(props.new_tag_name)
-            or props.new_tag_name in [tag.name for tag in repo.tags]
+            or props.new_tag_name in IfcGitData.data["tag_names"]
        ):
            return False
        return True
@@ -165,8 +172,12 @@ class AddTag(bpy.types.Operator):
    def execute(self, context):

        repo = IfcGitData.data["repo"]
-        core.add_tag(tool.IfcGit, repo)
-        core.refresh_revision_list(tool.IfcGit, repo, tool.Ifc)
+        props = tool.IfcGit.get_ifcgit_props()
+        item = props.ifcgit_commits[props.commit_index]
+        core.add_tag(tool.IfcGit, repo, item.hexsha, props.new_tag_name, props.new_tag_message)
+        props.new_tag_name = ""
+        props.new_tag_message = ""
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
        refresh()
        return {"FINISHED"}

@@ -183,7 +194,7 @@ class DeleteTag(bpy.types.Operator):

        repo = IfcGitData.data["repo"]
        core.delete_tag(tool.IfcGit, repo, self.tag_name)
-        core.refresh_revision_list(tool.IfcGit, repo, tool.Ifc)
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
        refresh()
        return {"FINISHED"}

@@ -191,7 +202,7 @@ class DeleteTag(bpy.types.Operator):
 class RefreshGit(bpy.types.Operator):
    """Refresh revision list"""

-    bl_label = ""
+    bl_label = "Refresh"
    bl_idname = "ifcgit.refresh"
    bl_options = {"REGISTER"}

@@ -205,8 +216,7 @@ class RefreshGit(bpy.types.Operator):

    def execute(self, context):

-        repo = IfcGitData.data["repo"]
-        core.refresh_revision_list(tool.IfcGit, repo, tool.Ifc)
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
        refresh()
        tool.IfcGit.decolourise()
        return {"FINISHED"}
@@ -215,7 +225,7 @@ class RefreshGit(bpy.types.Operator):
 class DisplayRevision(bpy.types.Operator):
    """Colourise objects by selected revision"""

-    bl_label = ""
+    bl_label = "Colourise Revision"
    bl_idname = "ifcgit.display_revision"
    bl_options = {"REGISTER"}

@@ -250,7 +260,7 @@ class DisplayUncommitted(bpy.types.Operator):
 class SwitchRevision(bpy.types.Operator):
    """Switches the repository to the selected revision and reloads the IFC file"""

-    bl_label = ""
+    bl_label = "Switch Revision"
    bl_idname = "ifcgit.switch_revision"
    bl_options = {"REGISTER"}

@@ -268,7 +278,7 @@ class SwitchRevision(bpy.types.Operator):


 class Merge(bpy.types.Operator):
-    """Merges the selected branch into working branch"""
+    """Merges the selected branch into working branch.\nCtrl+click to preview without merging"""

    bl_label = "Merge this branch"
    bl_idname = "ifcgit.merge"
@@ -282,15 +292,84 @@ class Merge(bpy.types.Operator):
            return True
        return False

-    def execute(self, context):
+    def invoke(self, context, event):
+        if event.ctrl:
+            core.dry_run_merge(tool.IfcGit, tool.Ifc, self)
+            refresh()
+            return {"FINISHED"}
+        return self.execute(context)

-        if core.merge_branch(tool.IfcGit, tool.Ifc, self):
+    def execute(self, context):
+        if core.merge_branch(tool.IfcGit, tool.Ifc, self) is not False:
            refresh()
            return {"FINISHED"}
        else:
            return {"CANCELLED"}


+class SelectConflictEntity(bpy.types.Operator):
+    """Select the conflicting entity in the viewport"""
+
+    bl_label = "Select Conflict Entity"
+    bl_idname = "ifcgit.select_conflict_entity"
+    bl_options = {"REGISTER"}
+
+    step_id: bpy.props.IntProperty()
+
+    if TYPE_CHECKING:
+        step_id: int
+
+    def execute(self, context):
+        model = tool.Ifc.get()
+        if not model:
+            return {"CANCELLED"}
+
+        try:
+            entity = model.by_id(self.step_id)
+        except Exception:
+            self.report({"WARNING"}, f"Entity #{self.step_id} not found (may have been deleted locally)")
+            return {"CANCELLED"}
+
+        obj = tool.Ifc.get_object(entity)
+        if obj is None:
+            # Walk inverse references up to 5 hops to find nearest entity with a Blender object
+            visited = {entity.id()}
+            queue = [entity]
+            for _ in range(5):
+                next_queue = []
+                for ent in queue:
+                    for inv in model.get_inverse(ent):
+                        if inv.id() in visited:
+                            continue
+                        visited.add(inv.id())
+                        obj = tool.Ifc.get_object(inv)
+                        if obj is not None:
+                            break
+                        next_queue.append(inv)
+                    if obj is not None:
+                        break
+                if obj is not None:
+                    break
+                queue = next_queue
+
+        if obj is None:
+            self.report({"INFO"}, f"No viewport representation found for #{self.step_id} ({entity.is_a()})")
+            return {"CANCELLED"}
+
+        bpy.ops.object.select_all(action="DESELECT")
+        obj.select_set(True)
+        context.view_layer.objects.active = obj
+        for area in context.screen.areas:
+            if area.type == "VIEW_3D":
+                region = next((r for r in area.regions if r.type == "WINDOW"), None)
+                if region:
+                    with context.temp_override(area=area, region=region):
+                        bpy.ops.view3d.view_selected()
+                break
+
+        return {"FINISHED"}
+
+
 class Push(bpy.types.Operator):
    """Pushes the working branch to selected remote"""

@@ -314,9 +393,9 @@ class Fetch(bpy.types.Operator):

    def execute(self, context):
        props = tool.IfcGit.get_ifcgit_props()
-        repo = IfcGitData.data["repo"]
-        remote = repo.remotes[props.select_remote]
-        remote.fetch()
+        core.fetch(tool.IfcGit, props.select_remote)
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
+        refresh()
        return {"FINISHED"}


@@ -336,7 +415,7 @@ class AddRemote(bpy.types.Operator):
            not repo
            or not tool.IfcGit.is_valid_ref_format(props.remote_name)
            or not props.remote_url
-            or props.remote_name in [remote.name for remote in repo.remotes]
+            or props.remote_name in IfcGitData.data["remote_names"]
        ):
            return False
        return True
@@ -344,8 +423,11 @@ class AddRemote(bpy.types.Operator):
    def execute(self, context):

        repo = IfcGitData.data["repo"]
-        core.add_remote(tool.IfcGit, repo)
-        core.refresh_revision_list(tool.IfcGit, repo, tool.Ifc)
+        props = tool.IfcGit.get_ifcgit_props()
+        core.add_remote(tool.IfcGit, repo, props.remote_name, props.remote_url)
+        props.remote_name = ""
+        props.remote_url = ""
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
        refresh()
        return {"FINISHED"}

@@ -360,8 +442,19 @@ class DeleteRemote(bpy.types.Operator):
    def execute(self, context):

        repo = IfcGitData.data["repo"]
-        core.delete_remote(tool.IfcGit, repo)
-        core.refresh_revision_list(tool.IfcGit, repo, tool.Ifc)
+        props = tool.IfcGit.get_ifcgit_props()
+        remote_name = props.select_remote
+        if props.display_branch.startswith(remote_name + "/"):
+            active = IfcGitData.data["active_branch_name"]
+            if active:
+                props.display_branch = active
+            else:
+                local_branches = [b for b in IfcGitData.data["branch_names"] if "/" not in b]
+                if local_branches:
+                    props.display_branch = local_branches[0]
+        core.delete_remote(tool.IfcGit, repo, remote_name)
+        tool.IfcGit.select_first_remote()
+        core.refresh_revision_list(tool.IfcGit, tool.Ifc)
        refresh()
        return {"FINISHED"}

@@ -375,8 +468,8 @@ class ObjectLog(bpy.types.Operator):

    @classmethod
    def poll(cls, context):
-        if not (obj := context.active_object):
-            cls.poll_message_set("No Active Object")
+        if not (obj := context.active_object) or not obj.select_get():
+            cls.poll_message_set("No selected object")
        elif not tool.Blender.get_ifc_definition_id(obj):
            cls.poll_message_set("Active Object doesn't have an IFC definition")
        else:
@@ -422,7 +515,7 @@ class RunGitDiff(bpy.types.Operator):
    )
    bl_options = set()

-    save_to_temp: bpy.props.BoolProperty(options={"SKIP_SAVE"})  # pyright: ignore[reportRedeclaration]
+    save_to_temp: bpy.props.BoolProperty(options={"SKIP_SAVE"})

    if TYPE_CHECKING:
        save_to_temp: bool
@@ -445,3 +538,37 @@ class RunGitDiff(bpy.types.Operator):
    def execute(self, context):
        core.run_git_diff(tool.IfcGit, self, self.save_to_temp)
        return {"FINISHED"}
+
+
+class RenameBranch(bpy.types.Operator):
+    """Rename the current branch"""
+
+    bl_label = "Rename Branch"
+    bl_idname = "ifcgit.rename_branch"
+    bl_options = {"REGISTER"}
+
+    new_name: bpy.props.StringProperty(name="New name")
+
+    if TYPE_CHECKING:
+        new_name: str
+
+    @classmethod
+    def poll(cls, context):
+        IfcGitData.make_sure_is_loaded()
+        if not IfcGitData.data["repo"]:
+            return False
+        if IfcGitData.data["is_detached"]:
+            return False
+        if IfcGitData.data["is_dirty"]:
+            return False
+        return True
+
+    def invoke(self, context, event):
+        self.new_name = IfcGitData.data["active_branch_name"]
+        return context.window_manager.invoke_props_dialog(self)
+
+    def execute(self, context):
+        repo = IfcGitData.data["repo"]
+        core.rename_branch(tool.IfcGit, repo, self.new_name)
+        refresh()
+        return {"FINISHED"}
@@ -17,28 +17,14 @@ from bonsai.bim.module.ifcgit.data import IfcGitData
 def git_branches(self: "IfcGitProperties", context: bpy.types.Context) -> tool.Blender.BLENDER_ENUM_ITEMS:
    # NOTE "Python must keep a reference to the strings returned by
    # the callback or Blender will misbehave or even crash"
-    IfcGitData.data["branch_names"] = sorted([branch.name for branch in IfcGitData.data["repo"].heads])
-
-    if "main" in IfcGitData.data["branch_names"]:
-        IfcGitData.data["branch_names"].remove("main")
-        IfcGitData.data["branch_names"] = ["main"] + IfcGitData.data["branch_names"]
-
-    if IfcGitData.data["remotes"]:
-        for remote in IfcGitData.data["remotes"]:
-            for remote_branch in remote.refs:
-                IfcGitData.data["branch_names"].append(remote_branch.name)
-
-    return [(myname, myname, myname) for myname in IfcGitData.data["branch_names"]]
+    # Branch list (local + remote, main first) is computed once in IfcGitData.load()
+    IfcGitData.make_sure_is_loaded()
+    return [(name, name, name) for name in IfcGitData.data["branch_names"]]


 def git_remotes(self: "IfcGitProperties", context: bpy.types.Context) -> tool.Blender.BLENDER_ENUM_ITEMS:
-    IfcGitData.data["remote_names"] = sorted([remote.name for remote in IfcGitData.data["remotes"]])
-
-    if "origin" in IfcGitData.data["remote_names"]:
-        IfcGitData.data["remote_names"].remove("origin")
-        IfcGitData.data["remote_names"] = ["origin"] + IfcGitData.data["remote_names"]
-
-    return [(myname, myname, myname) for myname in IfcGitData.data["remote_names"]]
+    IfcGitData.make_sure_is_loaded()
+    return [(name, name, name) for name in IfcGitData.data["remote_names"]]


 def update_revlist(self: "IfcGitProperties", context: bpy.types.Context) -> None:
@@ -90,6 +76,7 @@ class IfcGitListItem(PropertyGroup):
        name="Commit Message",
        default="",
    )
+    committed_date: IntProperty(name="Committed Date", default=0)
    tags: CollectionProperty(type=IfcGitTag, name="List of revision tags")

    if TYPE_CHECKING:
@@ -98,6 +85,7 @@ class IfcGitListItem(PropertyGroup):
        author_name: str
        author_email: str
        message: str
+        committed_date: int
        tags: bpy.types.bpy_prop_collection_idprop[IfcGitTag]


@@ -151,6 +139,11 @@ class IfcGitProperties(PropertyGroup):
        ],
        update=update_revlist,
    )
+    merge_conflicts: StringProperty(
+        name="Merge Conflicts",
+        description="JSON report from last failed merge attempt",
+        default="",
+    )

    if TYPE_CHECKING:
        ifcgit_commits: bpy.types.bpy_prop_collection_idprop[IfcGitListItem]
@@ -165,3 +158,4 @@ class IfcGitProperties(PropertyGroup):
        display_branch: str
        select_remote: str
        ifcgit_filter: Literal["all", "tagged", "relevant"]
+        merge_conflicts: str
@@ -52,7 +52,7 @@ class IFCGIT_PT_panel(bpy.types.Panel):
            if IfcGitData.data["repo"] and os.path.exists(IfcGitData.data["repo"].git_dir):
                name_ifc = IfcGitData.data["name_ifc"]
                row.label(text=IfcGitData.data["working_dir"], icon="SYSTEM")
-                if name_ifc in IfcGitData.data["untracked_files"]:
+                if IfcGitData.data["ifc_is_untracked"]:
                    row.operator(
                        "ifcgit.addfile",
                        text="Add '" + name_ifc + "' to repository",
@@ -112,15 +112,13 @@ class IFCGIT_PT_panel(bpy.types.Panel):
            row.label(text="Working branch: Detached HEAD")
        else:
            row.label(text="Working branch: " + IfcGitData.data["active_branch_name"])
+            row.operator("ifcgit.rename_branch", icon="GREASEPENCIL", text="")

-        grouped = layout.row()
-        column = grouped.column()
-        row = column.row()
+        row = layout.row()
        row.prop(props, "display_branch", text="Browse branch")
        row.prop(props, "ifcgit_filter", text="Filter revisions")

-        row = column.row()
-        row.template_list(
+        layout.template_list(
            "COMMIT_UL_List",
            "The_List",
            props,
@@ -128,20 +126,64 @@ class IFCGIT_PT_panel(bpy.types.Panel):
            props,
            "commit_index",
        )
-        column = grouped.column()
-        row = column.row()
+
+        row = layout.row(align=True)
        row.operator("ifcgit.refresh", icon="FILE_REFRESH")
-
        if not is_dirty:
-
-            row = column.row()
            row.operator("ifcgit.display_revision", icon="SELECT_DIFFERENCE")
-
-            row = column.row()
            row.operator("ifcgit.switch_revision", icon="CURRENT_FILE")
+            row.operator("ifcgit.merge", icon="SYSTEM")

-            row = column.row()
-            row.operator("ifcgit.merge", icon="EXPERIMENTAL", text="")
+        conflicts = tool.IfcGit.get_merge_conflicts()
+        if conflicts is not None:
+            box = layout.box()
+            box.alert = True
+            row = box.row()
+            row.label(
+                text=f"Merge failed \u2014 {len(conflicts)} conflict(s)",
+                icon="ERROR",
+            )
+            for conflict in conflicts:
+                col = box.column(align=True)
+                conflict_type = conflict.get("type", "")
+                entity_id = conflict.get("entity_id", "?")
+                local_id = conflict.get("original_local_id")
+
+                if conflict_type == "attribute_conflict":
+                    entity_class = conflict.get("entity_class", "Entity")
+                    attr_idx = conflict.get("attribute_index", "?")
+                    desc = f"#{entity_id} {entity_class}: attribute {attr_idx} conflict"
+                elif conflict_type == "entity_deleted_and_modified":
+                    entity_class = conflict.get("entity_class", "Entity")
+                    desc = f"#{entity_id} {entity_class}: " + conflict.get("message", "deleted/modified conflict")
+                elif conflict_type == "class_changed":
+                    desc = (
+                        f"#{entity_id}: class changed "
+                        + conflict.get("base_class", "?")
+                        + " \u2192 "
+                        + conflict.get("modified_class", "?")
+                    )
+                elif conflict_type == "required_entity_deleted":
+                    desc = f"#{entity_id}: " + conflict.get("message", "required entity deleted")
+                else:
+                    desc = f"#{entity_id}: {conflict_type}"
+
+                row = col.row(align=True)
+                row.label(text=desc)
+                if local_id:
+                    op = row.operator(
+                        "ifcgit.select_conflict_entity",
+                        text="",
+                        icon="RESTRICT_SELECT_OFF",
+                    )
+                    op.step_id = local_id
+
+                if conflict_type == "attribute_conflict":
+                    sub = col.column(align=True)
+                    sub.scale_y = 0.75
+                    sub.label(text=f"  Base:   {conflict.get('base_value', '')}")
+                    sub.label(text=f"  Local:  {conflict.get('local_value', '')}")
+                    sub.label(text=f"  Remote: {conflict.get('remote_value', '')}")

        if not props.ifcgit_commits:
            return
@@ -216,13 +258,7 @@ class COMMIT_UL_List(bpy.types.UIList):
    ):

        current_revision = IfcGitData.data["current_revision"]
-
-        # TODO Figure how this "item" can be acesse in "data.py"
-        # so it's possible to move the ".commit"
-        try:
-            commit = IfcGitData.data["repo"].commit(rev=item.hexsha)
-        except ValueError:
-            return
+        current_hexsha = current_revision.hexsha if current_revision else None

        lookup = IfcGitData.data["branches_by_hexsha"]
        refs = ""
@@ -236,11 +272,11 @@ class COMMIT_UL_List(bpy.types.UIList):
            for tag in lookup[item.hexsha]:
                refs += "{" + tag.name + "} "

-        if commit == current_revision:
-            layout.label(text="[HEAD] " + refs + commit.message.split("\n")[0], icon="DECORATE_KEYFRAME")
+        if item.hexsha == current_hexsha:
+            layout.label(text="[HEAD] " + refs + item.message.split("\n")[0], icon="DECORATE_KEYFRAME")
        else:
-            layout.label(text=refs + commit.message.split("\n")[0], icon="DECORATE_ANIMATE")
-        layout.label(text=time.strftime("%c", time.localtime(commit.committed_date)))
+            layout.label(text=refs + item.message.split("\n")[0], icon="DECORATE_ANIMATE")
+        layout.label(text=time.strftime("%c", time.localtime(item.committed_date)))

    def draw_filter(self, context, layout):

@@ -272,21 +272,21 @@ class RadianceRender(bpy.types.Operator):
                    + '''" map_u map_v
 0
 1 0.5
- 
+
 # This is a multiplier to colour balance the env map
 # In this case, it provides a rough ground luminance from 3k-5k
 env_map colorfunc env_colour
 4 100 100 100 .
 0
 0
- 
+
 # .37 .57 1.5 is measured from a HDRI image
 # It is multiplied by a factor such that grey(r,g,b) = 1
 skyfunc colorfunc sky_colour
 4 .64 .99 2.6 .
 0
 0
- 
+
 void mixpict composite
 7 env_colour sky_colour grey "'''
                    + hdr_mask_path
@@ -295,22 +295,22 @@ void mixpict composite
                    + """" map_u map_v
 0
 2 0.5 1
- 
+
 composite glow env_map_glow
 0
 0
 4 1 1 1 0
- 
+
 env_map_glow source sky
 0
 0
 4 0 0 1 180
- 
+
 env_colour glow ground_glow
 0
 0
 4 1 1 1 0
- 
+
 ground_glow source ground
 0
 0
@@ -566,7 +566,7 @@ class LightPickCoordinates(bpy.types.Operator):
    )
    bl_options = {"REGISTER", "UNDO"}

-    use_current_location: bpy.props.BoolProperty(options={"SKIP_SAVE"})  # pyright: ignore[reportRedeclaration]
+    use_current_location: bpy.props.BoolProperty(options={"SKIP_SAVE"})

    if TYPE_CHECKING:
        use_current_location: bool
@@ -630,13 +630,23 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                    slab.DumbSlabPlaner().regenerate_from_layer_set(layer_set)

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

        bpy.ops.bim.disable_editing_assigned_material(obj=active_obj.name)
@@ -136,7 +136,7 @@ class SplitAlongEdge(bpy.types.Operator, tool.Ifc.Operator):
        "Will unassign element from a type if type has a representation."
    )
    bl_options = {"REGISTER", "UNDO"}
-    mode: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    mode: bpy.props.EnumProperty(
        default="BOOLEAN",
        items=tuple((i, i, "") for i in get_args(SplitAlongEdgeMode)),
    )
@@ -359,7 +359,7 @@ class ConfirmQuickFavoriteOperator(bpy.types.Operator):
    bl_idname = "bim.confirm_quick_favorite_operator"
    bl_label = "Confirm Operator"
    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    index: bpy.props.IntProperty()

    if TYPE_CHECKING:
        index: int
@@ -452,10 +452,8 @@ class MoveQuickFavoritesItem(bpy.types.Operator):
    bl_idname = "bim.move_quick_favorites_item"
    bl_label = "Move Quick Favorites Item"
    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    direction: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
-        items=[("UP", "Up", ""), ("DOWN", "Down", "")]
-    )
+    index: bpy.props.IntProperty()
+    direction: bpy.props.EnumProperty(items=[("UP", "Up", ""), ("DOWN", "Down", "")])

    if TYPE_CHECKING:
        index: int
@@ -474,7 +472,7 @@ class RemoveQuickFavoritesItem(bpy.types.Operator):
    bl_idname = "bim.remove_quick_favorites_item"
    bl_label = "Remove Quick Favorites Item"
    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    index: bpy.props.IntProperty()

    if TYPE_CHECKING:
        index: int
@@ -36,9 +36,9 @@ QuickFavoriteValueType = Literal["float_value", "bool_value", "int_value", "stri


 class QuickFavoriteEnumItem(PropertyGroup):
-    name: StringProperty(name="Name", default="")  # pyright: ignore[reportRedeclaration]
-    display_name: StringProperty(name="Display Name", default="")  # pyright: ignore[reportRedeclaration]
-    description: StringProperty(name="Description", default="")  # pyright: ignore[reportRedeclaration]
+    name: StringProperty(name="Name", default="")
+    display_name: StringProperty(name="Display Name", default="")
+    description: StringProperty(name="Description", default="")

    if TYPE_CHECKING:
        name: str
@@ -51,19 +51,19 @@ def get_enum_items(self: "QuickFavoriteProperty", context: bpy.types.Context | N


 class QuickFavoriteProperty(PropertyGroup):
-    name: StringProperty(name="Name", default="")  # pyright: ignore[reportRedeclaration]
-    display_name: StringProperty(name="Display Name", default="")  # pyright: ignore[reportRedeclaration]
-    value_prop: EnumProperty(  # pyright: ignore[reportRedeclaration]
+    name: StringProperty(name="Name", default="")
+    display_name: StringProperty(name="Display Name", default="")
+    value_prop: EnumProperty(
        name="Value Prop",
        items=tuple((v, v, "") for v in get_args(QuickFavoriteValueType)),
    )
-    string_value: StringProperty(name="String Value", default="")  # pyright: ignore[reportRedeclaration]
-    float_value: FloatProperty(name="Float Value", default=0.0)  # pyright: ignore[reportRedeclaration]
-    int_value: IntProperty(name="Int Value", default=0)  # pyright: ignore[reportRedeclaration]
-    bool_value: BoolProperty(name="Bool Value", default=False)  # pyright: ignore[reportRedeclaration]
-    enum_value: EnumProperty(name="Enum Value", items=get_enum_items)  # pyright: ignore[reportRedeclaration]
-    enum_items: CollectionProperty(type=QuickFavoriteEnumItem)  # pyright: ignore[reportRedeclaration]
-    is_active: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    string_value: StringProperty(name="String Value", default="")
+    float_value: FloatProperty(name="Float Value", default=0.0)
+    int_value: IntProperty(name="Int Value", default=0)
+    bool_value: BoolProperty(name="Bool Value", default=False)
+    enum_value: EnumProperty(name="Enum Value", items=get_enum_items)
+    enum_items: CollectionProperty(type=QuickFavoriteEnumItem)
+    is_active: BoolProperty(
        name="Is Active",
        description="Only active properties will be added to the operator when invoked from Quick Favorites",
        default=False,
@@ -100,20 +100,20 @@ def get_operator_suggestions(self: "QuickFavoritesItem", context: bpy.types.Cont


 class QuickFavoritesItem(PropertyGroup):
-    is_expanded: BoolProperty(name="Is Expanded", default=False)  # pyright: ignore[reportRedeclaration]
-    search: StringProperty(  # pyright: ignore[reportRedeclaration]
+    is_expanded: BoolProperty(name="Is Expanded", default=False)
+    search: StringProperty(
        name="Search",
        default="",
        search=get_operator_suggestions,
        # Resetting `search_options`, allowing users only to use suggestions.
        search_options=set(),
    )
-    properties: CollectionProperty(type=QuickFavoriteProperty)  # pyright: ignore[reportRedeclaration]
-    operator_id: StringProperty(  # pyright: ignore[reportRedeclaration]
+    properties: CollectionProperty(type=QuickFavoriteProperty)
+    operator_id: StringProperty(
        name="Operator ID",
        default="",
    )
-    label: StringProperty(  # pyright: ignore[reportRedeclaration]
+    label: StringProperty(
        name="Label",
        description="Label that will be used in Quick Favorites for this operator",
        default="",
@@ -139,15 +139,15 @@ class QuickFavoritesItem(PropertyGroup):


 class BIMMiscProperties(PropertyGroup):
-    total_storeys: IntProperty(  # pyright: ignore[reportRedeclaration]
+    total_storeys: IntProperty(
        name="Total Storeys",
        description="Number of storeys above object's storey to take into account for resizing",
        default=1,
    )
-    override_colour: FloatVectorProperty(  # pyright: ignore[reportRedeclaration]
+    override_colour: FloatVectorProperty(
        name="Override Colour", subtype="COLOR", default=(1, 0, 0, 1), min=0.0, max=1.0, size=4
    )
-    quick_favorites: CollectionProperty(type=QuickFavoritesItem)  # pyright: ignore[reportRedeclaration]
+    quick_favorites: CollectionProperty(type=QuickFavoritesItem)

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

 from typing import NamedTuple

 import bpy

+import bonsai.tool as tool
+
 from . import (
    array,
    covering,
@@ -27,7 +31,9 @@ from . import (
    external,
    grid,
    handler,
+    host_add_opening_gizmo,
    mep,
+    mep_bend_preview,
    opening,
    product,
    profile,
@@ -46,17 +52,28 @@ from . import (

 classes = (
    array.AddArray,
-    array.DisableEditingArray,
-    array.EditArray,
+    array.CancelEditingArray,
    array.EnableEditingArray,
+    array.FinishEditingArray,
    array.ApplyArray,
    array.RegenerateArray,
    array.RemoveArray,
    array.SelectAllArrayObjects,
    array.SelectArrayParent,
+    array.ArrayParentGizmoClick,
+    array.EditArrayFromChild,
    array.Input3DCursorXArray,
    array.Input3DCursorYArray,
    array.Input3DCursorZArray,
+    array.EnableEditingParametric,
+    array.AddArrayFromFeatureEdit,
+    array.ArrayGizmoClick,
+    array.ToggleArrayMethod,
+    array.RemoveArrayLayerFromEdit,
+    array.InputArrayCount,
+    array.AdjustArrayCount,
+    array.GizmoArrayEdition,
+    array.GizmoArrayChild,
    product.AddDefaultType,
    product.AddEmptyType,
    product.AddOccurrence,
@@ -68,21 +85,51 @@ 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,
@@ -94,6 +141,7 @@ classes = (
    opening.RemoveBoolean,
    opening.SelectBoolean,
    opening.ShowOpenings,
+    opening.ToggleHostOpenings,
    opening.UpdateOpeningsFocus,
    profile.ChangeCardinalPoint,
    profile.ChangeProfileDepth,
@@ -104,17 +152,19 @@ classes = (
    profile.ExtendProfile,
    profile.RecalculateProfile,
    profile.Rotate90,
-    profile.SplitProfile,
    profile.PatchNonParametricMepSegment,
    roof.GenerateHippedRoof,
    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,
@@ -141,10 +191,19 @@ 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,
@@ -165,7 +224,8 @@ classes = (
    stair.ToggleStairProperty,
    stair.AdjustStairTreads,
    stair.SetStairTreads,
-    stair.CycleStairType,
+    stair.InputStairTreads,
+    stair.PickStairType,
    stair.GizmoStairEdition,
    sverchok_modifier.CreateNewSverchokGraph,
    sverchok_modifier.UpdateDataFromSverchok,
@@ -178,7 +238,7 @@ classes = (
    window.FinishEditingWindow,
    window.EnableEditingWindow,
    window.RemoveWindow,
-    window.CycleWindowType,
+    window.PickWindowType,
    window.GizmoWindowEdition,
    door.BIM_OT_add_door,
    door.AddDoor,
@@ -187,15 +247,19 @@ classes = (
    door.EnableEditingDoor,
    door.RemoveDoor,
    door.ToggleDoorSwing,
-    door.CycleDoorType,
+    door.PickDoorType,
    door.GizmoDoorEdition,
    railing.BIM_OT_add_railing,
    railing.CopyRailingParameters,
    railing.AddRailing,
    railing.CancelEditingRailing,
+    railing.CycleRailingType,
    railing.FinishEditingRailing,
+    railing.PickRailingTerminalType,
    railing.FlipRailingPathOrder,
    railing.EnableEditingRailing,
+    railing.GizmoRailingSchematic,
+    railing.ToggleRailingUseManualSupports,
    railing.CancelEditingRailingPath,
    railing.FinishEditingRailingPath,
    railing.EnableEditingRailingPath,
@@ -204,16 +268,39 @@ classes = (
    roof.AddRoof,
    roof.CancelEditingRoof,
    roof.CopyRoofParameters,
+    roof.CycleRoofGenerationMethod,
    roof.FinishEditingRoof,
    roof.EnableEditingRoof,
    roof.CancelEditingRoofPath,
    roof.FinishEditingRoofPath,
    roof.EnableEditingRoofPath,
+    roof.GizmoRoofEdition,
    roof.RemoveRoof,
    roof.SetGableRoofEdgeAngle,
    mep.MEPAddObstruction,
    mep.MEPAddTransition,
    mep.MEPAddBend,
+    mep.MEPRemoveTerminalFitting,
+    mep.SelectMEPPathMembers,
+    mep.MEPJoinSegments,
+    mep_bend_preview.EnableBendPreview,
+    mep_bend_preview.FinishBendPreview,
+    mep_bend_preview.CancelBendPreview,
+    mep_bend_preview.EnableBendPreviewFromBend,
+    mep_bend_preview.GizmoBendPreview,
+    mep.EnableEditingPipeSegment,
+    mep.FinishEditingPipeSegment,
+    mep.CancelEditingPipeSegment,
+    mep.EnableEditingDuctSegment,
+    mep.FinishEditingDuctSegment,
+    mep.CancelEditingDuctSegment,
+    mep.ExtendPipeSegmentToCursor,
+    mep.ExtendDuctSegmentToCursor,
+    mep.SplitPipeSegmentAtCursor,
+    mep.SplitDuctSegmentAtCursor,
+    mep.GizmoPipeSegmentEdition,
+    mep.GizmoDuctSegmentEdition,
+    mep.GizmoMEPActions,
    external.ApplyExternalParametricGeometry,
 )

@@ -265,15 +352,17 @@ def register():
    bpy.types.Scene.BIMModelProperties = bpy.props.PointerProperty(type=prop.BIMModelProperties)
    bpy.types.Scene.BIMPolylineProperties = bpy.props.PointerProperty(type=prop.BIMPolylineProperties)
    bpy.types.Object.BIMArrayProperties = bpy.props.PointerProperty(type=prop.BIMArrayProperties)
-    bpy.types.Object.BIMStairProperties = bpy.props.PointerProperty(type=prop.BIMStairProperties)
    bpy.types.Object.BIMSverchokProperties = bpy.props.PointerProperty(type=prop.BIMSverchokProperties)
-    bpy.types.Object.BIMWindowProperties = bpy.props.PointerProperty(type=prop.BIMWindowProperties)
-    bpy.types.Object.BIMDoorProperties = bpy.props.PointerProperty(type=prop.BIMDoorProperties)
-    bpy.types.Object.BIMRailingProperties = bpy.props.PointerProperty(type=prop.BIMRailingProperties)
-    bpy.types.Object.BIMRoofProperties = bpy.props.PointerProperty(type=prop.BIMRoofProperties)
+    # Per-parametric-type ``BIM<Name>Properties`` PointerProperties — driven by
+    # ``tool.Parametric.EDIT_TYPES``; adding a registry entry is the single touchpoint.
+    tool.Parametric.register_object_properties(prop)
    bpy.types.Object.BIMExternalParametricGeometryProperties = bpy.props.PointerProperty(
        type=prop.BIMExternalParametricGeometryProperties
    )
+    bpy.types.Scene.BIMPreviewProperties = bpy.props.PointerProperty(type=prop.BIMPreviewProperties)
+    bpy.types.WindowManager.BIMParametricEditDialogPrefs = bpy.props.PointerProperty(
+        type=prop.BIMParametricEditDialogPrefs
+    )

    bpy.types.VIEW3D_MT_add.prepend(ui.add_menu)
    bpy.app.handlers.load_post.append(handler.load_post)
@@ -282,6 +371,17 @@ 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)
@@ -289,13 +389,11 @@ def unregister():
    del bpy.types.Scene.BIMModelProperties
    del bpy.types.Scene.BIMPolylineProperties
    del bpy.types.Object.BIMArrayProperties
-    del bpy.types.Object.BIMStairProperties
    del bpy.types.Object.BIMSverchokProperties
-    del bpy.types.Object.BIMWindowProperties
-    del bpy.types.Object.BIMDoorProperties
-    del bpy.types.Object.BIMRailingProperties
-    del bpy.types.Object.BIMRoofProperties
+    tool.Parametric.unregister_object_properties()
    del bpy.types.Object.BIMExternalParametricGeometryProperties
+    del bpy.types.Scene.BIMPreviewProperties
+    del bpy.types.WindowManager.BIMParametricEditDialogPrefs

    bpy.app.handlers.load_post.remove(handler.load_post)
    bpy.types.VIEW3D_MT_add.remove(ui.add_menu)
@@ -51,6 +51,10 @@ class AuthoringData:

    @classmethod
    def load(cls, ifc_element_type: Optional[str] = None):
+        # ``is_loaded`` is set first as a recursion guard: one of the data
+        # computations evaluates a PropertyGroup enum's ``items`` callback,
+        # which re-enters this method. Without the guard, load recurses to
+        # RecursionError.
        cls.is_loaded = True
        cls.props = tool.Model.get_model_props()
        cls.data["default_container"] = cls.default_container()
@@ -37,7 +37,9 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+from bonsai.bim.module.model.wall_offset_gizmos import WALL_OFFSET_GIZMO_CONFIGS
 from bonsai.bim.module.model.window import create_bm_box, create_bm_window
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin, PickTypeMixin

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


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

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


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

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


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

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


 class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
@@ -673,7 +630,7 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
    def remove_door_on_object(self, obj: bpy.types.Object) -> None:
        element = tool.Ifc.get_entity(obj)
        assert element
-        if not tool.Blender.Modifier.is_door(element):
+        if not tool.Parametric.is_door(element):
            return
        props = tool.Model.get_door_props(obj)
        props.is_editing = False
@@ -688,12 +645,8 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):


 class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
-    """Toggle door swing direction and optionally flip door geometry.
-
-    Shift+Click (when flip_geometry=True): Flip geometry only without changing door direction"""
-
    bl_idname = "bim.toggle_door_swing"
-    bl_label = "Toggle Door Swing"
+    bl_label = "Change Door Swing"
    bl_options = {"REGISTER", "UNDO"}

    flip_geometry: bpy.props.BoolProperty(name="Flip Geometry", default=False)
@@ -704,6 +657,15 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
        name="Skip Direction Change", default=False, options={"HIDDEN", "SKIP_SAVE"}
    )

+    @classmethod
+    def description(cls, context: bpy.types.Context, properties: bpy.types.OperatorProperties) -> str:
+        if properties.flip_geometry:
+            return (
+                "Swing the door from the opposite side of the wall. "
+                "Shift+click: mirror the door without changing which side it opens to"
+            )
+        return "Move the door hinge to the opposite side"
+
    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]:
        self.skip_direction_change = event.shift
        return self.execute(context)
@@ -730,7 +692,7 @@ class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
        if not element:
            return {"CANCELLED"}

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

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


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

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

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

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


 class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
@@ -770,7 +732,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
    enable_editing_operator = "bim.enable_editing_door"
    finish_editing_operator = "bim.finish_editing_door"
    cancel_editing_operator = "bim.cancel_editing_door"
-    cycle_type_operator = "bim.cycle_door_type"
+    pick_type_operator = "bim.pick_door_type"

    # Declarative dimension gizmo configuration with visibility and position
    # matrix_position lambdas replace the get_dimension_matrix_* methods
@@ -877,14 +839,44 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
                p.get_transom_window_center_z(),
            ),
        ),
+        *WALL_OFFSET_GIZMO_CONFIGS,
    ]

-    props_getter = "get_door_props"
+    # Big quarter-arc hit shapes cover much of the door face — without a
+    # negative select_bias they would steal clicks from the small dimension
+    # and edit gizmos drawn on top of them.
+    SWING_ARC_SELECT_BIAS = -1000.0
+    swing_arc_operator = "bim.toggle_door_swing"
+
+    swing_arc_props = [
+        gizmo.SwingArcConfig(
+            name="primary",
+            visibility_condition=lambda p: p.is_editing and "SLIDING" not in p.door_type,
+            hinge_x=lambda p: (
+                p.overall_width if p.door_type.endswith("RIGHT") and "DOUBLE_DOOR" not in p.door_type else 0.0
+            ),
+            hinge_y=lambda p: p.lining_offset,
+            panel_width=lambda p: p.overall_width / 2 if "DOUBLE_DOOR" in p.door_type else p.overall_width,
+            x_mirror=lambda p: p.door_type.endswith("RIGHT") and "DOUBLE_DOOR" not in p.door_type,
+        ),
+        gizmo.SwingArcConfig(
+            name="secondary",
+            visibility_condition=lambda p: p.is_editing
+            and "DOUBLE_DOOR" in p.door_type
+            and "SLIDING" not in p.door_type,
+            hinge_x=lambda p: p.overall_width,
+            hinge_y=lambda p: p.lining_offset,
+            panel_width=lambda p: p.overall_width / 2,
+            x_mirror=lambda _p: True,
+        ),
+    ]
+
+    props_getter = tool.Model.get_door_props
    gizmo_pref_name = "door"

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

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

    def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create door-specific swing arc gizmos."""
-        prefs = tool.Blender.get_addon_preferences()
-        inactive_color = prefs.decorator_color_background[:3]
-        special_color = prefs.decorator_color_special[:3]
+        """Create one (main, flip) swing-arc pair per ``swing_arc_props`` entry.

-        self.gizmo_door_type = self.create_arc_gizmo(
-            special_color,
-            "bim.toggle_door_swing",
-            prop_path="BIMDoorProperties.door_type",
-            flip_geometry=False,
-        )
-        self.gizmo_flip_arc = self.create_arc_gizmo(
-            inactive_color,
-            "bim.toggle_door_swing",
-            prop_path="BIMDoorProperties.door_type",
-            flip_geometry=True,
-            flip_local_axes="XY",
-        )
+        Stored as ``self.gizmo_swing_arc_<name>`` and ``self.gizmo_swing_arc_<name>_flip``
+        and pinned to ``SWING_ARC_SELECT_BIAS`` so other door gizmos win selection."""
+        prefs = tool.Blender.get_addon_preferences()
+        main_color = prefs.decorator_color_special[:3]
+        flip_color = prefs.decorator_color_background[:3]
+        for cfg in self.swing_arc_props:
+            main = self.create_arc_gizmo(main_color, self.swing_arc_operator, flip_geometry=False)
+            flip = self.create_arc_gizmo(flip_color, self.swing_arc_operator, flip_geometry=True)
+            for gz in (main, flip):
+                gz.select_bias = self.SWING_ARC_SELECT_BIAS
+            setattr(self, f"gizmo_swing_arc_{cfg.name}", main)
+            setattr(self, f"gizmo_swing_arc_{cfg.name}_flip", flip)

    def _refresh_element_specific(
        self, context: bpy.types.Context, mw: Matrix, props: "BIMDoorProperties"  # noqa: ARG002
@@ -938,29 +926,23 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
        self._update_view_dependent_dimensions(context, mw, props)

    def update_swing_gizmos(self, mw: Matrix, props: "BIMDoorProperties") -> None:
-        """Update swing gizmo position and color based on editing state."""
-        prefs = tool.Blender.get_addon_preferences()
-        door_gizmo_prefs = prefs.gizmos.door
-
-        door_type_visible = self.update_gizmo_visibility(
-            self.gizmo_door_type, props.is_editing, door_gizmo_prefs.swing_arc
-        )
-        flip_arc_visible = self.update_gizmo_visibility(
-            self.gizmo_flip_arc, props.is_editing, door_gizmo_prefs.flip_arc
-        )
-
-        if not door_type_visible and not flip_arc_visible:
-            return
-
-        swing_x_offset = props.overall_width if "RIGHT" in props.door_type else 0.0
-        base_swing_transform = Matrix.Translation(V_(swing_x_offset, props.lining_offset, 0)) @ Matrix.Scale(
-            props.overall_width, 4
-        )
-
-        if door_type_visible:
-            self.gizmo_door_type.matrix_basis = mw @ base_swing_transform
-            self.gizmo_door_type.color = prefs.decorations_colour[:3]
-
-        if flip_arc_visible:
-            mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
-            self.gizmo_flip_arc.matrix_basis = mw @ base_swing_transform @ mirror_y
+        """Position each declared swing-arc pair per its config + props state."""
+        mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
+        for cfg in self.swing_arc_props:
+            main = getattr(self, f"gizmo_swing_arc_{cfg.name}")
+            flip = getattr(self, f"gizmo_swing_arc_{cfg.name}_flip")
+            show = cfg.visibility_condition(props)
+            main_visible = self.update_gizmo_visibility(main, show)
+            flip_visible = self.update_gizmo_visibility(flip, show)
+            if not (main_visible or flip_visible):
+                continue
+            x_flip = Matrix.Scale(-1, 4, (1, 0, 0)) if cfg.x_mirror(props) else Matrix.Identity(4)
+            transform = (
+                Matrix.Translation(V_(cfg.hinge_x(props), cfg.hinge_y(props), 0))
+                @ Matrix.Scale(cfg.panel_width(props), 4)
+                @ x_flip
+            )
+            if main_visible:
+                main.matrix_basis = mw @ transform
+            if flip_visible:
+                flip.matrix_basis = mw @ transform @ mirror_y
@@ -0,0 +1,221 @@
+# Bonsai - OpenBIM Blender Add-on
+# Copyright (C) 2026
+#
+# This file is part of Bonsai.
+#
+# Bonsai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Bonsai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was generated with the assistance of an AI coding tool.
+
+"""Generic single-click "Add Opening" gizmo for hosts (walls, slabs, roofs).
+
+One GizmoGroup serves every IFC host type that exposes ``HasOpenings``:
+parametric LAYER2 walls, any ``IfcSlab``, and any ``IfcRoof``. The poll
+guards host-host pairings so this gizmo never overlaps with the existing
+wall-join / extend-vertically gizmos. The positioner dispatches on element
+type — walls use axis-projection + camera-facing-Y math (which requires the
+parametric layer-set); slabs and roofs use a world-Z face bias driven by
+the void object's elevation against the host's bounding box."""
+
+import bpy
+from mathutils import Vector
+
+import bonsai.tool as tool
+from bonsai.bim.module.drawing import gizmos as gizmo
+from bonsai.bim.module.model.wall import (
+    _get_wall_geom_cached,
+    _wall_camera_facing_icon_y,
+    _wall_gizmo_poll_gate,
+    _WallGeomCachedBillboardingMixin,
+)
+
+
+def is_supported_host(element) -> bool:
+    """Total predicate (None → False). Walls accept either a parametric
+    LAYER2 wall OR a fillet-corner wall (both expose a usable axis +
+    layer-set for the anchor math); slabs and roofs only need the bound
+    box so any IfcSlab / IfcRoof qualifies regardless of parametric
+    modifier state."""
+    if element is None:
+        return False
+    return tool.Parametric.is_path_connectable_wall(element) or element.is_a("IfcSlab") or element.is_a("IfcRoof")
+
+
+def _resolve_active_host(context: bpy.types.Context, n_selected: int):
+    """Shared poll prologue: gizmo gate + selection cardinality + active-in-
+    selected + IFC entity lookup + supported-host predicate. Returns the
+    active element on success, ``None`` on any failure — callers chain their
+    feature-specific checks past the early-return."""
+    if not _wall_gizmo_poll_gate(context):
+        return None
+    selected = tool.Blender.get_selected_objects()
+    if len(selected) != n_selected:
+        return None
+    active = context.active_object
+    if active is None or active not in selected:
+        return None
+    element = tool.Ifc.get_entity(active)
+    if not element or not is_supported_host(element):
+        return None
+    return element
+
+
+class GizmoHostAddOpening(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
+    """Activates when a host element (wall / slab / roof) is the active object
+    and exactly one other selected object is *not* itself a host.
+
+    Renders a single ``VIEW3D_GT_add_opening`` icon at the void object's
+    projected location on the host. A click dispatches ``bim.add_opening``,
+    which handles any element exposing the ``HasOpenings`` inverse.
+
+    Per-frame positioning keeps the icon facing the camera as the viewport
+    orbits."""
+
+    bl_idname = "OBJECT_GGT_bim_host_add_opening"
+    bl_label = "Host Add Opening Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        element = _resolve_active_host(context, n_selected=2)
+        if element is None:
+            return False
+        # The operator itself filters on HasOpenings, but checking here keeps
+        # the icon from appearing on host classes that can't accept openings
+        # in the active IFC schema.
+        if not hasattr(element, "HasOpenings"):
+            return False
+        active = context.active_object
+        other = next(o for o in tool.Blender.get_selected_objects() if o is not active)
+        # Host + host pairings are claimed by host-specific gizmos (wall-join,
+        # extend-vertical, …) — suppress here so the add-opening icon never
+        # stacks on top of them.
+        if is_supported_host(tool.Ifc.get_entity(other)):
+            return False
+        return True
+
+    def setup(self, context: bpy.types.Context) -> None:
+        default_color, highlight_color = self.get_decoration_colors()
+        self.add_opening_icon = self.setup_icon_gizmo(
+            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.add_opening"
+        )
+
+    def position_gizmos(self, context: bpy.types.Context) -> None:
+        host_obj = context.active_object
+        if not host_obj:
+            return
+        selected = tool.Blender.get_selected_objects()
+        other = next((o for o in selected if o is not host_obj), None)
+        if not other:
+            return
+        element = tool.Ifc.get_entity(host_obj)
+        if not element:
+            return
+
+        if tool.Parametric.is_path_connectable_wall(element):
+            world_pos = wall_anchor(context, self, host_obj, other)
+        else:
+            world_pos = layer3_anchor(host_obj, other)
+        if world_pos is None:
+            return
+        self.add_opening_icon.matrix_basis = gizmo.billboarded_at(world_pos, gizmo.get_billboard_rotation(context))
+
+
+def wall_anchor(
+    context: bpy.types.Context, group: bpy.types.GizmoGroup, wall_obj: bpy.types.Object, other: bpy.types.Object
+) -> Vector | None:
+    """World-space anchor for the add-opening icon on a wall host: void origin
+    projected onto the wall reference-line X (clamped to wall extents), lifted to
+    the camera-facing wall-local Y."""
+    geom = _get_wall_geom_cached(group, wall_obj)
+    if not geom:
+        return None
+    mw = wall_obj.matrix_world
+    wall_local = mw.inverted() @ other.matrix_world.translation
+    local_x = max(geom["anchor_x"], min(wall_local.x, geom["anchor_x"] + geom["length"]))
+    icon_y = _wall_camera_facing_icon_y(context, mw, geom)
+    base_world = mw @ Vector((local_x, icon_y, 0.0))
+    top_world = mw @ Vector((local_x, icon_y, geom["height"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET))
+    return gizmo.BaseParametricGizmoGroup.pick_visible_anchor(context, base_world, top_world)
+
+
+def layer3_anchor(host_obj: bpy.types.Object, other: bpy.types.Object) -> Vector:
+    """World-space anchor for the add-opening icon on a LAYER3 host (slab / roof):
+    void's world XY, lifted just above the host's top face. Predictable height
+    regardless of where the void sits vertically — clicking the icon places the
+    opening at the void's XY, and the operator handles the actual cut depth."""
+    bbox = tool.Blender.get_object_world_bounding_box(host_obj)
+    anchor_xy = other.matrix_world.translation.xy
+    top_z = bbox["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
+    return Vector((anchor_xy.x, anchor_xy.y, top_z))
+
+
+def host_toggle_anchor(host_obj: bpy.types.Object) -> Vector:
+    """Object origin XY, lifted just above the topmost mesh vertex. Tracks
+    the parametric origin (useful reference even when the mesh extends
+    asymmetrically) and the visible top face (stays clear of sloped or
+    stepped bodies)."""
+    origin = host_obj.matrix_world.translation
+    top_z = tool.Blender.get_object_world_bounding_box(host_obj)["max_z"] + gizmo.BaseParametricGizmoGroup.ICON_Z_OFFSET
+    return Vector((origin.x, origin.y, top_z))
+
+
+class GizmoHostToggleOpenings(bpy.types.GizmoGroup, _WallGeomCachedBillboardingMixin):
+    """Fallback toggle-openings icon for hosts that lack their own
+    parametric-edit toolbar — slabs today, plus any foreign-authored
+    IfcRoof that carries no BBIM_Roof pset (so ``GizmoRoofEdition`` doesn't
+    poll for it). Walls and parametric roofs already render an idle-row
+    toggle next to the pen and are excluded from this poll.
+
+    When slab parametric-edit lands the slab branch will pen-row-handle
+    its own toggle; updating the exclusion predicate here is the only
+    migration step needed."""
+
+    bl_idname = "OBJECT_GGT_bim_host_toggle_openings"
+    bl_label = "Host Toggle Openings Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    @classmethod
+    def poll(cls, context: bpy.types.Context) -> bool:
+        element = _resolve_active_host(context, n_selected=1)
+        if element is None:
+            return False
+        if not tool.Geometry.has_openings(element):
+            return False
+        # Skip when a per-feature parametric-edit gizmo already surfaces
+        # an idle-row toggle for this element — walls and parametric roofs
+        # both render their own toggle in the pen row.
+        if tool.Parametric.is_path_connectable_wall(element):
+            return False
+        if tool.Parametric.is_roof(element):
+            return False
+        return True
+
+    def setup(self, context: bpy.types.Context) -> None:
+        default_color, highlight_color = self.get_decoration_colors()
+        self.toggle_openings_icon = self.setup_icon_gizmo(
+            "VIEW3D_GT_add_opening", default_color, highlight_color, "bim.toggle_host_openings"
+        )
+
+    def position_gizmos(self, context: bpy.types.Context) -> None:
+        host_obj = context.active_object
+        if not host_obj:
+            return
+        self.toggle_openings_icon.matrix_basis = gizmo.billboarded_at(
+            host_toggle_anchor(host_obj), gizmo.get_billboard_rotation(context)
+        )
@@ -0,0 +1,444 @@
+# Bonsai - OpenBIM Blender Add-on
+# Copyright (C) 2026
+#
+# This file is part of Bonsai.
+#
+# Bonsai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Bonsai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was generated with the assistance of an AI coding tool.
+
+"""Bend-preview lifecycle for MEP segment joins.
+
+Holds the four lifecycle operators (Enable / Finish / Cancel /
+EnableFromBend) and the ``GizmoBendPreview`` group that surfaces the
+tunable dimensions and validate/cancel icons during preview. Draft state
+lives at ``Scene.BIMPreviewProperties.bend`` per CLAUDE.md §2.9 (Scene
+for cross-element previews).
+
+The geometry math (``compute_bend_preview_polylines``,
+``_bend_profile_cross_section``, ``_sweep_profile_along_polyline``)
+stays in ``mep.py`` because the commit operator ``MEPAddBend`` reuses
+it; this module imports the polyline helper for per-frame gizmo
+positioning. The GPU lines themselves are drawn by
+``decorator.BendPreviewDecorator``, kept in ``decorator.py`` with its
+sibling decorators."""
+
+from typing import ClassVar
+
+import bpy
+import ifcopenshell.util.element
+import ifcopenshell.util.unit
+from mathutils import Matrix, Vector
+
+import bonsai.tool as tool
+from bonsai.bim.module.drawing import gizmos as gizmo
+from bonsai.bim.module.model import preview_base
+from bonsai.bim.module.model.mep import (
+    _is_bend_fitting,
+    _n_mep_selected,
+    cached_compute_bend_preview_polylines,
+    segments_are_parallel,
+    validate_bend_preconditions,
+)
+
+
+class EnableBendPreview(bpy.types.Operator):
+    """Enter bend-preview mode for two selected MEP segments. Populates
+    scene.BIMPreviewProperties.bend with segment IFC ids and default
+    start_length / end_length / radius; no IFC mutation until finish."""
+
+    bl_idname = "bim.enable_bend_preview"
+    bl_label = "Enter Bend Preview"
+    bl_description = "Begin tuning bend parameters before committing the bend"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not _n_mep_selected(2):
+            cls.poll_message_set("Select exactly 2 MEP segments to bend.")
+            return False
+        return True
+
+    def execute(self, context):
+        selected = tool.Blender.get_selected_objects()
+        active = context.active_object
+        if active is None or active not in selected:
+            self.report({"ERROR"}, "Active object must be one of the selected MEP segments.")
+            return {"CANCELLED"}
+        other = next((o for o in selected if o is not active), None)
+        if other is None:
+            self.report({"ERROR"}, "Two MEP segments must be selected.")
+            return {"CANCELLED"}
+        active_element = tool.Ifc.get_entity(active)
+        other_element = tool.Ifc.get_entity(other)
+        if active_element is None or other_element is None:
+            self.report({"ERROR"}, "Both selected objects must be IFC elements.")
+            return {"CANCELLED"}
+        if segments_are_parallel(active, other):
+            self.report({"ERROR"}, "Bend preview is for non-parallel segments only.")
+            return {"CANCELLED"}
+
+        # Pre-check the same preconditions MEPAddBend enforces so the user
+        # sees the rejection here rather than after tuning a doomed preview.
+        precondition_error = validate_bend_preconditions(active_element, other_element)
+        if precondition_error is not None:
+            self.report({"ERROR"}, precondition_error)
+            return {"CANCELLED"}
+
+        preview_base.sync_uncommitted_moves([active, other])
+
+        props = preview_base.get_preview_props(context, "bend")
+        # Auto-cancel any prior preview so re-clicking join on a different
+        # pair doesn't silently commit the previous tuning.
+        if props is not None and props.is_active:
+            bpy.ops.bim.cancel_bend_preview()
+
+        props.start_segment_id = active_element.id()
+        props.end_segment_id = other_element.id()
+        props.start_length = 0.1
+        props.end_length = 0.1
+        props.radius = 0.2
+        props.is_active = True
+        return {"FINISHED"}
+
+
+class FinishBendPreview(bpy.types.Operator):
+    """Commit the previewed bend with the tuned parameters and exit preview.
+
+    Preview state survives a failed commit so the user can re-tune without
+    re-selecting."""
+
+    bl_idname = "bim.finish_bend_preview"
+    bl_label = "Apply Bend"
+    bl_description = "Commit the bend with the previewed parameters"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        return preview_base.commit_preview(
+            self,
+            context,
+            "bend",
+            "mep_add_bend",
+            ("start_segment_id", "end_segment_id", "start_length", "end_length", "radius", "editing_bend_id"),
+        )
+
+
+class CancelBendPreview(bpy.types.Operator):
+    """Exit bend preview without committing."""
+
+    bl_idname = "bim.cancel_bend_preview"
+    bl_label = "Cancel Bend"
+    bl_description = "Discard the previewed bend"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        if context.screen is None:
+            return {"CANCELLED"}
+        props = preview_base.get_preview_props(context, "bend")
+        if props is None or not props.is_active:
+            return {"CANCELLED"}
+        preview_base.clear_preview_state(props)
+        return {"FINISHED"}
+
+
+class EnableBendPreviewFromBend(bpy.types.Operator):
+    """Re-open the bend preview on an existing bend fitting.
+
+    Resolves the two connected segments via the bend's ports +
+    ``IfcRelConnectsPorts``, reads parametric values back from the bend's
+    ``BBIM_Fitting`` pset, and flags the preview so committing replaces
+    the existing bend in place."""
+
+    bl_idname = "bim.enable_bend_preview_from_bend"
+    bl_label = "Edit Bend"
+    bl_description = "Re-open the bend preview to retune an existing bend"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        active = context.active_object
+        if active is None:
+            cls.poll_message_set("No active object.")
+            return False
+        element = tool.Ifc.get_entity(active)
+        if element is None or not _is_bend_fitting(element):
+            cls.poll_message_set("Active object must be a bend fitting.")
+            return False
+        return True
+
+    def execute(self, context):
+        active = context.active_object
+        bend_element = tool.Ifc.get_entity(active)
+        if bend_element is None or not _is_bend_fitting(bend_element):
+            self.report({"ERROR"}, "Active object is not a bend fitting.")
+            return {"CANCELLED"}
+
+        connected_segments: list = []
+        for port in tool.System.get_ports(bend_element):
+            connected_port = tool.System.get_connected_port(port)
+            if connected_port is None:
+                continue
+            related = tool.System.get_port_relating_element(connected_port)
+            if related is not None and related.is_a("IfcFlowSegment") and related not in connected_segments:
+                connected_segments.append(related)
+
+        if len(connected_segments) != 2:
+            self.report(
+                {"ERROR"},
+                f"Bend has {len(connected_segments)} connected segments; need exactly 2 to re-edit.",
+            )
+            return {"CANCELLED"}
+
+        # Read parametric values from the bend type's BBIM_Fitting pset. The
+        # type carries the canonical parameters; querying the occurrence
+        # would force a get_type round-trip and miss user-edited types.
+        bend_type = ifcopenshell.util.element.get_type(bend_element)
+        if bend_type is None:
+            self.report({"ERROR"}, "Bend fitting has no type to read parameters from.")
+            return {"CANCELLED"}
+        bend_type_obj = tool.Ifc.get_object(bend_type)
+        if bend_type_obj is None:
+            self.report({"ERROR"}, "Bend type has no Blender object — cannot read pset.")
+            return {"CANCELLED"}
+        bbim = tool.Model.get_modeling_bbim_pset_data(bend_type_obj, "BBIM_Fitting")
+        if bbim is None:
+            self.report({"ERROR"}, "Bend fitting has no BBIM_Fitting pset — not a parametric bend.")
+            return {"CANCELLED"}
+        data = bbim.get("data_dict", {})
+
+        props = preview_base.get_preview_props(context, "bend")
+        if props is not None and props.is_active:
+            bpy.ops.bim.cancel_bend_preview()
+
+        # Segment order is load-bearing: the bend's lateral sign and z-axis
+        # flip are derived from which segment is "start" vs "end". Re-edit
+        # must reuse the same pairing as the original create so the recreate
+        # lands at the same orientation.
+        start_segment, end_segment = connected_segments
+        props.start_segment_id = start_segment.id()
+        props.end_segment_id = end_segment.id()
+        # Pset values are in IFC native units; scene units come from si_conversion.
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        props.start_length = float(data.get("start_length", 0.1)) * si_conversion
+        props.end_length = float(data.get("end_length", 0.1)) * si_conversion
+        props.radius = float(data.get("radius", 0.2)) * si_conversion
+        props.editing_bend_id = bend_element.id()
+        props.is_active = True
+        return {"FINISHED"}
+
+
+def _bend_preview_segments(context):
+    """Resolve the two segment objects from the scene-level preview props.
+
+    Re-resolves by IFC id each frame so undo / file reload during preview
+    never dangles a stale bpy reference."""
+    props = context.scene.BIMPreviewProperties.bend
+    ifc_file = tool.Ifc.get()
+    if ifc_file is None or not props.is_active:
+        return None, None
+    try:
+        start_element = ifc_file.by_id(props.start_segment_id)
+        end_element = ifc_file.by_id(props.end_segment_id)
+    except Exception:
+        return None, None
+    start_obj = tool.Ifc.get_object(start_element) if start_element else None
+    end_obj = tool.Ifc.get_object(end_element) if end_element else None
+    return start_obj, end_obj
+
+
+def _gizmo_x_matrix(location: Vector, x_direction: Vector) -> Matrix:
+    """Build a 4x4 matrix placing a gizmo at ``location`` with its local +X
+    axis aligned to ``x_direction`` in world space. ``BIM_GT_gizmo_dimension``
+    draws + drags along local +X by convention."""
+    x = x_direction.normalized()
+    seed = Vector((0, 0, 1)) if abs(x.z) < 0.9 else Vector((1, 0, 0))
+    y = (seed - x * seed.dot(x)).normalized()
+    z = x.cross(y)
+    mat = Matrix.Identity(4)
+    mat[0][:3] = (x.x, y.x, z.x)
+    mat[1][:3] = (x.y, y.y, z.y)
+    mat[2][:3] = (x.z, y.z, z.z)
+    mat.translation = location
+    return mat
+
+
+class GizmoBendPreview(bpy.types.GizmoGroup):
+    """Interactive gizmo group for the bend preview flow.
+
+    Three dimension widgets drag start_length / end_length / radius; two
+    icon gizmos commit or cancel. When the geometry is degenerate the
+    dimensions and validate hide but cancel stays visible so the user
+    always has an exit."""
+
+    bl_idname = "OBJECT_GGT_bim_bend_preview"
+    bl_label = "Bend Preview Gizmos"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    ICON_SCALE: ClassVar[float] = 0.375
+    ICON_SPACING_X: ClassVar[float] = 0.4
+    ICON_Z_OFFSET: ClassVar[float] = 1.5
+
+    @classmethod
+    def poll(cls, context):
+        preview = getattr(context.scene, "BIMPreviewProperties", None)
+        props = preview.bend if preview is not None else None
+        if props is None or not props.is_active:
+            return False
+        if not tool.Blender.are_viewport_gizmos_enabled():
+            return False
+        ifc_file = tool.Ifc.get()
+        if ifc_file is None:
+            return False
+        try:
+            ifc_file.by_id(props.start_segment_id)
+            ifc_file.by_id(props.end_segment_id)
+        except (RuntimeError, KeyError):
+            return False
+        return True
+
+    def setup(self, context):
+        prefs = tool.Blender.get_addon_preferences()
+        default_color = tuple(prefs.decorations_colour[:3])
+        highlight_color = tuple(prefs.decorator_color_selected[:3])
+
+        _props = preview_base.make_props_callback("bend")
+
+        def setup_dimension(attr: str, prop_name: str, invert_delta: bool = False) -> bpy.types.Gizmo:
+            gz = self.gizmos.new("BIM_GT_gizmo_dimension")
+            gz.move_get_cb = preview_base.make_dim_getter(_props, attr)
+            gz.move_set_cb = preview_base.make_dim_setter(_props, attr)
+            gz.axis = Vector((1, 0, 0))
+            gz.invert_delta = invert_delta
+            gz.delta_scale = 1.0
+            gz.prop_name = prop_name
+            gz.gizmo_group = self
+            gz.color = default_color
+            gz.color_highlight = highlight_color
+            gz.alpha = 1.0
+            gz.use_draw_modal = True
+            gz.use_draw_scale = False
+            gz.text_offset_sign = 1
+            gz.text_alignment = gizmo.TextAlignment.CENTER
+            gz.show_start_arrow = False
+            gz.show_end_arrow = True
+            gz.show_extension_lines = False
+            gz.text_formatter = None
+            return gz
+
+        self.start_dim = setup_dimension("start_length", "Start Length")
+        self.end_dim = setup_dimension("end_length", "End Length")
+        self.radius_dim = setup_dimension("radius", "Radius")
+
+        from bonsai.bim.module.drawing.gizmos import BaseParametricGizmoGroup
+
+        self.validate_icon = self.gizmos.new("VIEW3D_GT_validate")
+        self.validate_icon.use_draw_scale = False
+        self.validate_icon.color = BaseParametricGizmoGroup.COLOR_GREEN
+        self.validate_icon.color_highlight = highlight_color
+        self.validate_icon.target_set_operator("bim.finish_bend_preview")
+
+        self.cancel_icon = self.gizmos.new("VIEW3D_GT_cancel")
+        self.cancel_icon.use_draw_scale = False
+        self.cancel_icon.color = BaseParametricGizmoGroup.COLOR_RED
+        self.cancel_icon.color_highlight = highlight_color
+        self.cancel_icon.target_set_operator("bim.cancel_bend_preview")
+
+    def refresh(self, context):
+        self._position_gizmos(context)
+
+    def draw_prepare(self, context):
+        self._position_gizmos(context)
+
+    def _position_gizmos(self, context):
+        """Place gizmos at the bend intersection using the current scene
+        props. Cancel stays visible on degenerate geometry so the user
+        always has an exit; the other widgets hide when there's no defined
+        tangent / arc to anchor them on."""
+        start_obj, end_obj = _bend_preview_segments(context)
+        if start_obj is None or end_obj is None:
+            for gz in (self.start_dim, self.end_dim, self.radius_dim, self.validate_icon, self.cancel_icon):
+                gz.hide = True
+            return
+
+        props = context.scene.BIMPreviewProperties.bend
+        preview = cached_compute_bend_preview_polylines(
+            start_obj, end_obj, props.start_length, props.end_length, props.radius
+        )
+        if not preview["valid"]:
+            for gz in (self.start_dim, self.end_dim, self.radius_dim, self.validate_icon):
+                gz.hide = True
+            self.cancel_icon.hide = False
+            axes = preview.get("invalid_axes") or []
+            if axes:
+                intersection_point = axes[0][1]
+                billboard_rot = gizmo.get_billboard_rotation(context)
+                anchor = intersection_point + Vector((0, 0, self.ICON_Z_OFFSET))
+                self.cancel_icon.matrix_basis = gizmo.billboarded_at(anchor, billboard_rot, scale=self.ICON_SCALE)
+            return
+
+        for gz in (self.start_dim, self.end_dim, self.radius_dim, self.validate_icon, self.cancel_icon):
+            gz.hide = False
+
+        leg_a_far, leg_a_end = preview["leg_a"]
+        leg_b_far, leg_b_end = preview["leg_b"]
+        toward_bend_a = (
+            (leg_a_end - leg_a_far).normalized() if (leg_a_end - leg_a_far).length > 1e-6 else Vector((0, 0, 1))
+        )
+        toward_bend_b = (
+            (leg_b_end - leg_b_far).normalized() if (leg_b_end - leg_b_far).length > 1e-6 else Vector((0, 0, 1))
+        )
+        leg_a_tangent = leg_a_end + toward_bend_a * props.start_length
+        leg_b_tangent = leg_b_end + toward_bend_b * props.end_length
+
+        # axis is set in world space every frame so the drag projection
+        # matches the visual regardless of either segment's matrix_world.
+        self.start_dim.matrix_basis = _gizmo_x_matrix(leg_a_tangent, -toward_bend_a)
+        self.start_dim.axis = -toward_bend_a
+        self.start_dim.set_dimension_length(props.start_length)
+        self.end_dim.matrix_basis = _gizmo_x_matrix(leg_b_tangent, -toward_bend_b)
+        self.end_dim.axis = -toward_bend_b
+        self.end_dim.set_dimension_length(props.end_length)
+
+        arc = preview["arc"]
+        if len(arc) >= 3:
+            mid = len(arc) // 2
+            chord_mid = (arc[0] + arc[-1]) * 0.5
+            toward_mid = arc[mid] - chord_mid
+            if toward_mid.length > 1e-6:
+                toward_mid = toward_mid.normalized()
+                half_chord = (arc[-1] - arc[0]).length * 0.5
+                center_dist = max(0.0, props.radius * props.radius - half_chord * half_chord) ** 0.5
+                arc_center = chord_mid - toward_mid * center_dist
+                radial_out = arc[mid] - arc_center
+                if radial_out.length > 1e-6:
+                    radial_out.normalize()
+                    inward = -radial_out
+                    self.radius_dim.matrix_basis = _gizmo_x_matrix(arc[mid], inward)
+                    self.radius_dim.axis = inward
+                    self.radius_dim.set_dimension_length(props.radius)
+                else:
+                    self.radius_dim.hide = True
+            else:
+                self.radius_dim.hide = True
+        else:
+            self.radius_dim.hide = True
+
+        billboard_rot = gizmo.get_billboard_rotation(context)
+        anchor_base = arc[len(arc) // 2] if arc else (leg_a_end + leg_b_end) * 0.5
+        anchor = anchor_base + Vector((0, 0, self.ICON_Z_OFFSET))
+        offset_x = billboard_rot @ Vector((self.ICON_SPACING_X, 0.0, 0.0))
+        self.validate_icon.matrix_basis = gizmo.billboarded_at(anchor, billboard_rot, scale=self.ICON_SCALE)
+        self.cancel_icon.matrix_basis = gizmo.billboarded_at(anchor + offset_x, billboard_rot, scale=self.ICON_SCALE)
@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.

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

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

+# Multi-entry cache for the opening preview's dissolved-edges fallback.
+# Single-entry wouldn't fit: the draw handler iterates every active opening
+# per frame, each with its own mesh. Bumped wholesale on the shared
+# decorator-cache token (depsgraph / undo / redo / load), one slot per
+# (mesh.session_uid, angle_limit). Outlier vs. the per-object caches below —
+# consulted only on world-draw-data miss, so the global wipe rarely fires in
+# steady state and the simpler invalidation is enough.
+_dissolved_edges_cache: dict[
+    tuple[int, float],
+    tuple[list[Vector], list[tuple[int, int]]],
+] = {}
+_dissolved_edges_cache_token: int = -1
+
+
+def _get_cached_dissolved_edges(
+    mesh: bpy.types.Mesh,
+    angle_limit: float = radians(1.0),
+) -> tuple[list[Vector], list[tuple[int, int]]]:
+    global _dissolved_edges_cache_token
+    token = decorator_cache.get_decorator_cache_token()
+    if token != _dissolved_edges_cache_token:
+        _dissolved_edges_cache.clear()
+        _dissolved_edges_cache_token = token
+    key = (mesh.session_uid, angle_limit)
+    cached = _dissolved_edges_cache.get(key)
+    if cached is not None:
+        return cached
+    result = tool.Geometry.get_dissolved_edges(mesh, angle_limit=angle_limit)
+    _dissolved_edges_cache[key] = result
+    return result
+
+
+# Per-object epoch: bumped only when this specific object's transform or geometry
+# updates land in the depsgraph delta. Invalidation work scales with the number
+# of changed objects, not total scene size — moving one object leaves every
+# other entry valid. Bumped by the depsgraph handler below; cleared on
+# undo/redo/load alongside the cache dicts.
+_object_epochs: dict[int, int] = {}
+
+
+@bpy.app.handlers.persistent
+def _bump_object_epochs_for_decoration(*args) -> None:
+    # depsgraph_update_post is called as (scene, depsgraph) in 4.x but the
+    # *args signature follows decorator_cache's defensive idiom.
+    depsgraph = args[1] if len(args) >= 2 else None
+    if depsgraph is None or not hasattr(depsgraph, "updates"):
+        return
+    for u in depsgraph.updates:
+        if not isinstance(u.id, bpy.types.Object):
+            continue
+        if not (u.is_updated_geometry or u.is_updated_transform):
+            continue
+        # u.id is the evaluated COW copy; the cache keys are written from the
+        # original Object (read by the draw handler), and session_uid can
+        # differ across the COW boundary. Resolve to the original before keying.
+        original = getattr(u.id, "original", u.id)
+        if original is None:
+            continue
+        uid = original.session_uid
+        _object_epochs[uid] = _object_epochs.get(uid, 0) + 1
+
+
+@bpy.app.handlers.persistent
+def _clear_decoration_caches_globally(*args) -> None:
+    # Undo/redo/load: depsgraph deltas can't be trusted to describe the
+    # transition, so wipe every per-object cache state.
+    _object_epochs.clear()
+    _world_draw_data_cache.clear()
+    _batch_cache.clear()
+
+
+def _decoration_invalidation_hooks() -> tuple:
+    return (
+        bpy.app.handlers.undo_post,
+        bpy.app.handlers.redo_post,
+        bpy.app.handlers.load_post,
+    )
+
+
+def install_decoration_cache_handlers() -> None:
+    if _bump_object_epochs_for_decoration not in bpy.app.handlers.depsgraph_update_post:
+        bpy.app.handlers.depsgraph_update_post.append(_bump_object_epochs_for_decoration)
+    for hook in _decoration_invalidation_hooks():
+        if _clear_decoration_caches_globally not in hook:
+            hook.append(_clear_decoration_caches_globally)
+
+
+def uninstall_decoration_cache_handlers() -> None:
+    try:
+        bpy.app.handlers.depsgraph_update_post.remove(_bump_object_epochs_for_decoration)
+    except ValueError:
+        pass
+    for hook in _decoration_invalidation_hooks():
+        try:
+            hook.remove(_clear_decoration_caches_globally)
+        except ValueError:
+            pass
+
+
+# Per-object world-space draw payload: line_verts (dissolved or ios_edges-filtered),
+# verts (full mesh, indexed by loop_triangles), edges_indices, tris. Entries are
+# (epoch, payload) tuples; lookup compares epoch to _object_epochs[uid], so a
+# stale entry for an object that didn't change since the last build still hits.
+_world_draw_data_cache: dict[
+    int,
+    tuple[
+        int,
+        tuple[
+            list[tuple[float, float, float]],
+            list[tuple[float, float, float]],
+            list[tuple[int, int]],
+            list[tuple[int, ...]],
+        ],
+    ],
+] = {}
+
+
+def _get_cached_world_draw_data(
+    obj: bpy.types.Object,
+) -> tuple[
+    list[tuple[float, float, float]],
+    list[tuple[float, float, float]],
+    list[tuple[int, int]],
+    list[tuple[int, ...]],
+]:
+    uid = obj.session_uid
+    epoch = _object_epochs.get(uid, 0)
+    entry = _world_draw_data_cache.get(uid)
+    if entry is not None and entry[0] == epoch:
+        return entry[1]
+
+    mw = obj.matrix_world
+    verts = [tuple(mw @ v.co) for v in obj.data.vertices]
+    obj.data.calc_loop_triangles()
+    tris = [tuple(t.vertices) for t in obj.data.loop_triangles]
+
+    ios_edges_attribute = obj.data.attributes.get("ios_edges")
+    if ios_edges_attribute:
+        # Loader-curated edges: read the attribute aligned with bm.edges order.
+        bm = bmesh.new()
+        bm.from_mesh(obj.data)
+        edges_indices = [
+            tuple(v.index for v in e.verts) for i, e in enumerate(bm.edges) if ios_edges_attribute.data[i].value
+        ]
+        bm.free()
+        line_verts = verts
+    else:
+        dissolved, edges_indices = _get_cached_dissolved_edges(obj.data)
+        line_verts = [tuple(mw @ v) for v in dissolved]
+
+    result = (line_verts, verts, edges_indices, tris)
+    _world_draw_data_cache[uid] = (epoch, result)
+    return result
+
+
+# GPUBatch cache: skip per-frame batch_for_shader. Entries are (epoch, batch);
+# lookup compares epoch to _object_epochs[uid] so other objects' batches stay
+# alive when one object's depsgraph delta bumps only its own epoch. The cached
+# batches reference GPU-side buffers tied to Blender's built-in shaders, which
+# are themselves cached by name (gpu.shader.from_builtin returns the same
+# handle each call), so they stay drawable across frames.
+_batch_cache: dict[tuple[int, str], tuple[int, "gpu.types.GPUBatch"]] = {}
+
+# CAD hidden-line convention for the occluded back-pass: world-space dashes so
+# density stays coherent across zoom. Dash + gap = period; dash_width controls
+# the "on" portion.
+_DASH_PERIOD_METERS: float = 0.20
+_DASH_WIDTH_METERS: float = 0.10
+# Solid front pass is rendered wider than the dashed back pass so its halo
+# overpowers the dashed center on visible edges even when the WIRE-display
+# overlay biases the depth buffer at outline pixels.
+_DASH_LINE_WIDTH: float = 1.5
+_SOLID_LINE_WIDTH: float = 2.5
+# Per-iteration default line width used by every non-occlusion draw call in
+# this decorator's ``__call__``. Restored after each occlusion pair so the
+# next draw isn't silently inheriting the wider solid-pass override.
+_DEFAULT_LINE_WIDTH: float = 2.0
+
+
+def _get_cached_batch_or_none(cache_key: tuple[int, str]) -> "gpu.types.GPUBatch | None":
+    uid = cache_key[0]
+    epoch = _object_epochs.get(uid, 0)
+    entry = _batch_cache.get(cache_key)
+    if entry is not None and entry[0] == epoch:
+        return entry[1]
+    return None
+
+
+def _store_batch_in_cache(cache_key: tuple[int, str], batch: "gpu.types.GPUBatch") -> None:
+    uid = cache_key[0]
+    epoch = _object_epochs.get(uid, 0)
+    _batch_cache[cache_key] = (epoch, batch)
+

 class FilledOpeningGenerator:
    def generate(
@@ -50,9 +246,15 @@ class FilledOpeningGenerator:
        filling_obj: bpy.types.Object,
        voided_obj: bpy.types.Object,
        target: Optional[Vector] = None,
+        preserve_placement: bool = False,
    ) -> Union[None, str]:
        """
        :param target: Target opening position. If ommited, cursor position is used.
+        :param preserve_placement: If True, keep ``filling_obj.matrix_world`` as-is
+            and skip the snap-to-wall-axis / rl1-rl2 Z-default logic. The opening
+            is still created at the filling's current world position. Useful
+            when the caller (e.g. the SHIFT-add-opening gizmo flow) has
+            already positioned the filling intentionally.
        :return: None if there was no errors, otherwise returns a string with error message.
        """
        props = tool.Model.get_model_props()
@@ -74,7 +276,7 @@ class FilledOpeningGenerator:
            should_set_z_level = False

        # Sometimes, the voided_obj may be an aggregate, which won't have any representation.
-        if voided_obj.data:
+        if not preserve_placement and voided_obj.data:
            raycast = voided_obj.closest_point_on_mesh(voided_obj.matrix_world.inverted() @ target, distance=0.01)
            if not raycast[0]:
                target = filling_obj.matrix_world.translation.copy()
@@ -558,6 +760,29 @@ class AddBoolean(Operator, tool.Ifc.Operator):
        tool.Root.reload_item_decorator()


+class ToggleHostOpenings(Operator, tool.Ifc.Operator):
+    bl_idname = "bim.toggle_host_openings"
+    bl_label = "Toggle Openings"
+    bl_description = "Show or hide opening fills (doors and windows) in the viewport\n\nHotkey: Alt+O"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Model.has_selected_ifc_objects():
+            cls.poll_message_set("No IFC objects selected.")
+            return False
+        return True
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        # Opening visibility is independent of host geometry — don't commit any
+        # active parametric edit; the user can keep editing the host.
+        if tool.Model.get_model_props().openings:
+            bpy.ops.bim.edit_openings(apply_all=True)
+        else:
+            bpy.ops.bim.show_openings()
+        return {"FINISHED"}
+
+
 class ShowOpenings(Operator, tool.Ifc.Operator):
    bl_idname = "bim.show_openings"
    bl_label = "Show Openings"
@@ -941,7 +1166,6 @@ class SelectBoolean(Operator):
        return {"FINISHED"}


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

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

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

-    def draw_batch(self, shader_type, content_pos, color, indices=None):
+    def _get_or_build_batch(self, shader, shader_type, content_pos, indices=None, cache_key=None):
+        if cache_key is not None:
+            cached = _get_cached_batch_or_none(cache_key)
+            if cached is not None:
+                return cached
        if not tool.Blender.validate_shader_batch_data(content_pos, indices):
-            return
-        shader = self.line_shader if shader_type == "LINES" else self.shader
+            return None
        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        if cache_key is not None:
+            _store_batch_in_cache(cache_key, batch)
+        return batch
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None, cache_key=None):
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = self._get_or_build_batch(shader, shader_type, content_pos, indices, cache_key=cache_key)
+        if batch is None:
+            return
        shader.uniform_float("color", color)
        batch.draw(shader)

+    def _draw_lines_with_occlusion(self, verts, color, edges_indices, cache_key=None):
+        # Two-pass CAD hidden-line convention. Both passes use POLYLINE_UNIFORM_COLOR.
+        #
+        # The solid front pass is rendered WIDER than the dashed back pass so it
+        # produces a halo around the line center, beyond the depth-bias zone that
+        # Blender's overlay engine writes when an opening is set to WIRE display.
+        # Without the width difference, the wire bias makes the center-pixel
+        # ``LESS_EQUAL`` comparison fail (line ends up slightly behind the biased
+        # wire depth) so the solid pass would lose to the dashed back pass even
+        # on visible edges. The halo gives the solid pass enough screen-space to
+        # overpower the dashed pattern visually.
+        #
+        # Dashed renders first at the standard width so the solid overlay's wider
+        # halo cleanly hides it on visible edges; on occluded edges the solid
+        # ``LESS_EQUAL`` pass fails against the wall depth and the dashed remains.
+        front_batch = self._get_or_build_batch(self.line_shader, "LINES", verts, edges_indices, cache_key=cache_key)
+        if front_batch is None:
+            return
+
+        dashed_cache_key = (cache_key[0], cache_key[1] + "_dashed") if cache_key is not None else None
+        dash_batch = None
+        if dashed_cache_key is not None:
+            dash_batch = _get_cached_batch_or_none(dashed_cache_key)
+        if dash_batch is None:
+            dash_verts, dash_edges = tool.Blender.build_dashed_line_segments(
+                verts, edges_indices, _DASH_PERIOD_METERS, _DASH_WIDTH_METERS
+            )
+            dash_batch = self._get_or_build_batch(self.line_shader, "LINES", dash_verts, dash_edges)
+            if dash_batch is not None and dashed_cache_key is not None:
+                _store_batch_in_cache(dashed_cache_key, dash_batch)
+
+        original_depth_test = gpu.state.depth_test_get()
+        front_color = list(color)
+        front_color[3] = 1.0
+        self.line_shader.uniform_float("color", front_color)
+
+        if dash_batch is not None:
+            self.line_shader.uniform_float("lineWidth", _DASH_LINE_WIDTH)
+            gpu.state.depth_test_set("ALWAYS")
+            dash_batch.draw(self.line_shader)
+
+        self.line_shader.uniform_float("lineWidth", _SOLID_LINE_WIDTH)
+        gpu.state.depth_test_set("LESS_EQUAL")
+        front_batch.draw(self.line_shader)
+
+        # Restore the per-iteration default set at the top of __call__ so
+        # subsequent draws (the HalfSpaceSolid arrow, future call-sites) are
+        # not silently affected by the front-pass width override.
+        self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)
+        gpu.state.depth_test_set(original_depth_test)
+
    def __call__(self, context):
        props = tool.Model.get_model_props()
        if not props.openings:
@@ -1001,7 +1290,7 @@ class DecorationsHandler:
            self.line_shader.bind()  # required to be able to change uniforms of the shader
            # POLYLINE_UNIFORM_COLOR specific uniforms
            self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
-            self.line_shader.uniform_float("lineWidth", 2.0)
+            self.line_shader.uniform_float("lineWidth", _DEFAULT_LINE_WIDTH)

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

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

    if TYPE_CHECKING:
        page: int
@@ -271,7 +271,7 @@ class ExtendProfile(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.extend_profile"
    bl_label = "Extend Profile"
    bl_options = {"REGISTER", "UNDO"}
-    join_type: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    join_type: bpy.props.EnumProperty(
        items=[("-", "Unjoin", ""), ("L", "L", ""), ("V", "V", ""), ("T", "T", "")],
        default="-",
    )
@@ -849,57 +849,6 @@ class DumbProfileJoiner:
    def create_matrix(self, p: Vector, x: Vector, y: Vector, z: Vector) -> Matrix:
        return Matrix([x, y, z, p]).to_4x4().transposed()

-    def split(self, profile1: bpy.types.Object, target: Vector) -> None:
-        element1 = tool.Ifc.get_entity(profile1)
-        if not element1:
-            return
-
-        if tool.Ifc.is_moved(profile1):
-            bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=profile1)
-
-        axis1 = self.get_profile_axis(profile1)
-        intersect, cut_percentage = mathutils.geometry.intersect_point_line(target, *axis1)
-        if cut_percentage < 0 or cut_percentage > 1 or tool.Cad.is_x(cut_percentage, (0, 1)):
-            return
-
-        # Duplicate the profile element
-        profile2 = profile1.copy()
-        profile2.data = profile2.data.copy()
-        for collection in profile1.users_collection:
-            collection.objects.link(profile2)
-        bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=profile2)
-        element2 = tool.Ifc.get_entity(profile2)
-
-        # Transfer ATEND connection from element1 to element2
-        relating_element = None
-        relating_connection = None
-        description = None
-        for conn in list(element1.ConnectedTo):
-            if conn.is_a("IfcRelConnectsPathElements") and conn.RelatingConnectionType == "ATEND":
-                relating_element = conn.RelatedElement
-                relating_connection = conn.RelatedConnectionType
-                description = conn.Description
-                bonsai.core.geometry.remove_connection(tool.Geometry, connection=conn)
-        for conn in list(element1.ConnectedFrom):
-            if conn.is_a("IfcRelConnectsPathElements") and conn.RelatedConnectionType == "ATEND":
-                relating_element = conn.RelatingElement
-                relating_connection = conn.RelatingConnectionType
-                description = conn.Description
-                bonsai.core.geometry.remove_connection(tool.Geometry, connection=conn)
-        if relating_element:
-            ifcopenshell.api.geometry.connect_path(
-                tool.Ifc.get(),
-                relating_element=relating_element,
-                related_element=element2,
-                relating_connection=relating_connection,
-                related_connection="ATEND",
-                description=description,
-            )
-
-        # Recreate both profiles with split axes
-        self.recreate_profile(element1, profile1, [axis1[0], intersect], [axis1[0], intersect])
-        self.recreate_profile(element2, profile2, [intersect, axis1[1]], [intersect, axis1[1]])
-
    def get_profile_axis(self, obj: bpy.types.Object) -> list[Vector]:
        z_values = [v[2] for v in obj.bound_box]
        return [
@@ -908,29 +857,6 @@ class DumbProfileJoiner:
        ]


-class SplitProfile(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.split_profile"
-    bl_label = "Split Profile"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = (
-        "Split selected profile element into two elements at the Blender cursor location. "
-        "The cursor must be positioned on the element's axis."
-    )
-
-    @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):
-        selected_objs = tool.Model.get_selected_mesh_objects()
-        for obj in selected_objs:
-            DumbProfileJoiner().split(obj, context.scene.cursor.location)
-        return {"FINISHED"}
-
-
 class RecalculateProfile(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.recalculate_profile"
    bl_label = "Recalculate Profile"
@@ -1076,6 +1002,14 @@ class EnableEditingExtrusionAxis(bpy.types.Operator, tool.Ifc.Operator):
    def _execute(self, context):
        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
        obj = context.active_object
+
+        # Commit any in-progress parametric (gizmo) draft on this object
+        # before switching to axis-edit. Otherwise the in-memory draft
+        # state is overwritten when the axis mesh is imported below,
+        # silently discarding the user's pending dimension edits.
+        if feature := tool.Parametric.is_object_editing(obj):
+            tool.Parametric.commit_object_draft(obj, feature.finish_op)
+
        element = tool.Ifc.get_entity(obj)

        axis = ifcopenshell.util.representation.get_representation(element, "Model", "Axis", "GRAPH_VIEW")
@@ -1231,7 +1165,8 @@ class DrawPolylineProfile(bpy.types.Operator, PolylineOperator, tool.Ifc.Operato
                        DumbProfileJoiner().join_V(profile2["obj"], profile1["obj"])
                        if connect_IfcFlowSegments:
                            bpy.ops.bim.mep_connect_elements(
-                                obj1_name=profile1["obj"].name, obj2_name=profile2["obj"].name
+                                obj1_guid=tool.Ifc.get_entity(profile1["obj"]).GlobalId,
+                                obj2_guid=tool.Ifc.get_entity(profile2["obj"]).GlobalId,
                            )

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

 import math
 from collections.abc import Callable
@@ -31,8 +33,10 @@ from bonsai.bim.module.drawing.decoration import CutDecorator
 from bonsai.bim.module.model.data import AuthoringData
 from bonsai.bim.module.model.decorator import (
    BoundingBoxDecorator,
+    MEPSystemPathDecorator,
    SlabDirectionDecorator,
    WallAxisDecorator,
+    WallSystemPathDecorator,
 )
 from bonsai.bim.module.model.door import update_door_modifier_bmesh
 from bonsai.bim.module.model.window import update_window_modifier_bmesh
@@ -101,8 +105,12 @@ def update_type_page(self: "BIMModelProperties", context: bpy.types.Context) ->


 def update_relating_array_from_object(self: "BIMArrayProperties", context: bpy.types.Context) -> None:
-    bpy.ops.bim.enable_editing_array(item=self.is_editing)
-    return
+    # Skip the cleanup-time clear: Finish/Cancel sets relating_array_object back to None,
+    # which has no source to hydrate from. Only the user-driven pick (None → some array)
+    # should auto-enter edit on the picked source's layer 0.
+    if self.relating_array_object is None:
+        return
+    bpy.ops.bim.enable_editing_array(item=0)


 def is_object_array_applicable(self: "BIMArrayProperties", obj: bpy.types.Object) -> bool:
@@ -126,6 +134,19 @@ def update_slab_direction_decorator(self: "BIMModelProperties", context: bpy.typ
        SlabDirectionDecorator.uninstall()


+def update_paths_decorator(self: "BIMModelProperties", context: bpy.types.Context) -> None:
+    """Unified toggle for connected-element path overlays. Drives both the
+    MEP and wall path decorators — each decorator's ``draw`` short-circuits
+    when its kind of element isn't selected, so leaving both installed is
+    cheap and lets one toggle cover any connected-element family."""
+    if self.show_paths:
+        MEPSystemPathDecorator.install(bpy.context)
+        WallSystemPathDecorator.install(bpy.context)
+    else:
+        MEPSystemPathDecorator.uninstall()
+        WallSystemPathDecorator.uninstall()
+
+
 def update_measure_xyz(self: "BIMModelProperties", context: bpy.types.Context) -> None:
    if self.show_bounding_box:
        BoundingBoxDecorator.install(context)
@@ -193,14 +214,36 @@ 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:
-        # Only FRAMELESS_PANEL can update live via bmesh.
-        # WALL_MOUNTED_HANDRAIL geometry is generated from IFC representation,
-        # so it only updates on "Finish Editing" to avoid modifying IFC during preview.
-        if self.railing_type == "FRAMELESS_PANEL":
-            _get_updater("railing", "update_railing_modifier_bmesh")(context)
+        _get_updater("railing", "update_railing_modifier_bmesh")(context)


 def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
@@ -210,6 +253,20 @@ def update_roof(self: "BIMRoofProperties", context: bpy.types.Context) -> None:
        _get_updater("roof", "update_roof_modifier_bmesh")(obj)


+def update_pipe_segment(self: "BIMPipeSegmentProperties", context: bpy.types.Context) -> None:
+    """Regenerate pipe-segment preview mesh from props during edit. Does NOT touch IFC."""
+    obj = context.active_object
+    if obj and self.is_editing:
+        _get_updater("mep", "regenerate_pipe_segment_mesh_from_props")(obj)
+
+
+def update_duct_segment(self: "BIMDuctSegmentProperties", context: bpy.types.Context) -> None:
+    """Regenerate duct-segment preview mesh from props during edit. Does NOT touch IFC."""
+    obj = context.active_object
+    if obj and self.is_editing:
+        _get_updater("mep", "regenerate_duct_segment_mesh_from_props")(obj)
+
+
 class BIMModelProperties(PropertyGroup):
    ifc_class: bpy.props.EnumProperty(items=get_ifc_class, name="Construction Class", update=update_ifc_class)
    relating_type_id: bpy.props.EnumProperty(
@@ -312,6 +369,19 @@ class BIMModelProperties(PropertyGroup):
        default=False,
        update=update_slab_direction_decorator,
    )
+    show_paths: bpy.props.BoolProperty(
+        name="Show Paths",
+        default=False,
+        update=update_paths_decorator,
+        description=(
+            "Trace the connected element path from the selected element. For "
+            "walls, follows IfcRelConnectsPathElements and draws each "
+            "connected wall's reference axis with endpoint dots. For MEP "
+            "elements, follows IfcRelConnectsPorts and draws each segment's "
+            "axis plus a port-to-port spider for each fitting. Toggle off to "
+            "skip the BFS traversal entirely."
+        ),
+    )

    prev_transform_orientation_slot_type: bpy.props.StringProperty(name="Previous Gizmo Orientation Type")
    prev_show_gizmo_object_translate: bpy.props.BoolProperty(name="Previous Gizmo Translate")
@@ -359,6 +429,7 @@ class BIMModelProperties(PropertyGroup):
        offset: float
        show_wall_axis: bool
        show_slab_direction: bool
+        show_paths: bool

        prev_transform_orientation_slot_type: str
        prev_show_gizmo_object_translate: bool
@@ -369,8 +440,13 @@ class BIMModelProperties(PropertyGroup):


 class BIMArrayProperties(PropertyGroup):
-    is_editing: bpy.props.IntProperty(
-        default=-1, description="Currently edited array index. -1 if not in array editing mode."
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while an array layer is in parametric edit mode. The specific layer is in editing_item_index.",
+    )
+    editing_item_index: bpy.props.IntProperty(
+        default=-1,
+        description="Index of the array layer currently being edited; -1 when not in edit mode.",
    )
    count: bpy.props.IntProperty(name="Count", default=0, min=0)
    x: bpy.props.FloatProperty(name="X", default=0, subtype="DISTANCE")
@@ -386,6 +462,15 @@ class BIMArrayProperties(PropertyGroup):
        name="Method",
        default="OFFSET",
    )
+    per_child_opening: bpy.props.BoolProperty(
+        name="Per-Child Opening",
+        description=(
+            "When the array parent fills a wall (or any voidable host), give each array child its own opening + "
+            "filling pair so the host is cut once per child. Disable to leave the host uncut by the children — "
+            "only the parent's original opening remains"
+        ),
+        default=True,
+    )
    relating_array_object: bpy.props.PointerProperty(
        type=bpy.types.Object,
        name="Copy Array Properties",
@@ -394,13 +479,15 @@ class BIMArrayProperties(PropertyGroup):
    )

    if TYPE_CHECKING:
-        is_editing: int
+        is_editing: bool
+        editing_item_index: int
        count: int
        x: float
        y: float
        z: float
        use_local_space: bool
        method: Literal["OFFSET", "DISTRIBUTE"]
+        per_child_opening: bool
        sync_children: bool
        relating_array_object: Union[bpy.types.Object, None]

@@ -1631,6 +1718,133 @@ 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")
@@ -1729,20 +1943,20 @@ def poll_sverchok_nodes(self: "BIMExternalParametricGeometryProperties", node_tr


 class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
-    is_editing: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    is_editing: bpy.props.BoolProperty(
        name="Is Editing Paramteric Geometry",
        description="Toggle editing parametric geometry.",
        default=False,
        update=update_is_editing,
    )
-    geometry_source: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    geometry_source: bpy.props.EnumProperty(
        name="Geometry Source",
        items=[
            ("GEONODES", "Geometry Nodes", ""),
            ("IFCSVERCHOK", "IFC Sverchok", ""),
        ],
    )
-    geo_nodes: bpy.props.PointerProperty(  # pyright: ignore[reportRedeclaration]
+    geo_nodes: bpy.props.PointerProperty(
        name="Geometry Nodes",
        description="Geometry nodes tree to use as a source for representation.",
        type=bpy.types.GeometryNodeTree,
@@ -1750,7 +1964,7 @@ class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
        poll=lambda self, node_tree: not node_tree.name.startswith("BBIM_EPG"),
    )

-    sverchok_nodes: bpy.props.PointerProperty(  # pyright: ignore[reportRedeclaration]
+    sverchok_nodes: bpy.props.PointerProperty(
        name="Sverchok Nodes",
        description="Sverchok node tree to use as a source for representation.",
        type=bpy.types.NodeTree,
@@ -1762,3 +1976,236 @@ class BIMExternalParametricGeometryProperties(bpy.types.PropertyGroup):
        geometry_source: Literal["GEONODES", "IFCSVERCHOK"]
        geo_nodes: Union[bpy.types.GeometryNodeTree, None]
        sverchok_nodes: Union[sverchok.node_tree.SverchCustomTree, None]
+
+
+class BIMPipeSegmentProperties(PropertyGroup):
+    """Transient draft state for parametric pipe-segment gizmo editing."""
+
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while pipe-segment parametric edit mode is active.",
+    )
+    mesh_dirty: bpy.props.BoolProperty(
+        default=False,
+        options={"HIDDEN", "SKIP_SAVE"},
+        description=(
+            "True while the visible mesh is the preview shape; cleared once the "
+            "real IFC-derived geometry is restored (on commit or cancel)."
+        ),
+    )
+    length: bpy.props.FloatProperty(
+        name="Length",
+        default=1.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_pipe_segment,
+        description="Pipe-segment extrusion length (preview value; committed on finish).",
+    )
+    snap_length: bpy.props.FloatProperty(
+        description="Snapshot of length at edit-enable; commit skips no-op writes.",
+    )
+    snap_object_scale_z: bpy.props.FloatProperty(
+        default=1.0,
+        description=(
+            "Snapshot of obj.scale.z at edit-enable. Cancel / no-op-finish restore "
+            "this exact value so a user's non-identity pre-edit scale isn't silently "
+            "zeroed by the scale-based preview."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_editing: bool
+        mesh_dirty: bool
+        length: float
+        snap_length: float
+        snap_object_scale_z: float
+
+
+class BIMDuctSegmentProperties(PropertyGroup):
+    """Transient draft state for parametric duct-segment gizmo editing."""
+
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while duct-segment parametric edit mode is active.",
+    )
+    mesh_dirty: bpy.props.BoolProperty(
+        default=False,
+        options={"HIDDEN", "SKIP_SAVE"},
+        description=(
+            "True while the visible mesh is the preview shape; cleared once the "
+            "real IFC-derived geometry is restored (on commit or cancel)."
+        ),
+    )
+    length: bpy.props.FloatProperty(
+        name="Length",
+        default=1.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_duct_segment,
+        description="Duct-segment extrusion length (preview value; committed on finish).",
+    )
+    snap_length: bpy.props.FloatProperty(
+        description="Snapshot of length at edit-enable; commit skips no-op writes.",
+    )
+    snap_object_scale_z: bpy.props.FloatProperty(
+        default=1.0,
+        description=(
+            "Snapshot of obj.scale.z at edit-enable. Cancel / no-op-finish restore "
+            "this exact value so a user's non-identity pre-edit scale isn't silently "
+            "zeroed by the scale-based preview."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_editing: bool
+        mesh_dirty: bool
+        length: float
+        snap_length: float
+        snap_object_scale_z: float
+
+
+class BIMBendPreviewProperties(PropertyGroup):
+    """Scene-level pending state for the bend-creation preview flow.
+
+    Scene-level (not per-object) because the bend involves two segments by
+    IFC id — neither alone owns the draft."""
+
+    is_active: bpy.props.BoolProperty(
+        default=False,
+        options={"SKIP_SAVE"},
+        description="True while the bend-creation preview flow is active.",
+    )
+    start_segment_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description="IFC element id of the start (active) segment.",
+    )
+    end_segment_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description="IFC element id of the end (other selected) segment.",
+    )
+    start_length: bpy.props.FloatProperty(
+        name="Start Length",
+        default=0.1,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Length of the bend fitting's tangent leg on the start (active) segment side",
+    )
+    end_length: bpy.props.FloatProperty(
+        name="End Length",
+        default=0.1,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Length of the bend fitting's tangent leg on the end (other) segment side",
+    )
+    radius: bpy.props.FloatProperty(
+        name="Radius",
+        default=0.2,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Inner radius of the bend curve",
+    )
+    editing_bend_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description=(
+            "IFC element id of an existing bend fitting being re-edited "
+            "(non-zero only on the pen-icon re-edit flow). The create "
+            "operator deletes this bend + its port connections before "
+            "recreating with the new parameters."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_active: bool
+        start_segment_id: int
+        end_segment_id: int
+        start_length: float
+        end_length: float
+        radius: float
+        editing_bend_id: int
+
+
+class BIMWallFilletPreviewProperties(PropertyGroup):
+    """Scene-level pending state for the wall-fillet preview flow.
+
+    Scene-level because the fillet spans two walls and commits a third
+    (corner) wall between them. ``SKIP_SAVE`` fields throughout."""
+
+    is_active: bpy.props.BoolProperty(
+        default=False,
+        options={"SKIP_SAVE"},
+        description="True while the wall-fillet preview flow is active.",
+    )
+    wall_a_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description=(
+            "IFC element id of the active wall — the corner wall inherits its "
+            "material layer set, height, x_angle, and type."
+        ),
+    )
+    wall_b_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description="IFC element id of the other selected wall.",
+    )
+    radius: bpy.props.FloatProperty(
+        name="Radius",
+        default=0.5,
+        soft_min=-10.0,
+        soft_max=10.0,
+        subtype="DISTANCE",
+        unit="LENGTH",
+        options={"SKIP_SAVE"},
+        description="Radius of the circular arc connecting the two walls.",
+    )
+    editing_corner_id: bpy.props.IntProperty(
+        default=0,
+        options={"SKIP_SAVE"},
+        description=(
+            "IFC element id of an existing fillet corner being re-edited "
+            "(non-zero only on the pen-icon re-edit flow). The create "
+            "operator deletes this corner + its connections before recreating "
+            "with the new radius."
+        ),
+    )
+
+    if TYPE_CHECKING:
+        is_active: bool
+        wall_a_id: int
+        wall_b_id: int
+        radius: float
+        editing_corner_id: int
+
+
+class BIMPreviewProperties(PropertyGroup):
+    """Umbrella for parametric-edit preview drafts attached to ``Scene``."""
+
+    bend: bpy.props.PointerProperty(type=BIMBendPreviewProperties)
+    wall_fillet: bpy.props.PointerProperty(type=BIMWallFilletPreviewProperties)
+
+    if TYPE_CHECKING:
+        bend: BIMBendPreviewProperties
+        wall_fillet: BIMWallFilletPreviewProperties
+
+
+class BIMParametricEditDialogPrefs(PropertyGroup):
+    """Session-scoped flag for the parametric-edit pen-icon dispatcher.
+
+    Attached to ``WindowManager`` so the state lives for one Blender session
+    and resets on restart — the right scope for "don't show this again for
+    this session" toggles."""
+
+    suppress_shared_rep_warning: bpy.props.BoolProperty(
+        name="Suppress shared-representation warning",
+        description=(
+            "When true, the pen-icon dispatcher skips the shared-geometry "
+            "confirmation dialog. Resets on Blender restart."
+        ),
+        default=False,
+    )
+
+    if TYPE_CHECKING:
+        suppress_shared_rep_warning: bool
@@ -18,6 +18,7 @@


 import json
+import math
 from typing import Any

 import bmesh
@@ -27,13 +28,24 @@ import ifcopenshell.api.geometry
 import ifcopenshell.api.pset
 import ifcopenshell.util.representation
 import ifcopenshell.util.unit
-from mathutils import Vector
+from mathutils import Matrix, Vector

 import bonsai.core.geometry
 import bonsai.core.root
 import bonsai.tool as tool
+from bonsai.bim.module.drawing import gizmos as gizmo
+from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+from bonsai.bim.module.model import prop
 from bonsai.bim.module.model.data import RailingData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
+from bonsai.bim.parametric_lifecycle import (
+    CycleTypeMixin,
+    PathPreservingEditMixin,
+    PickTypeMixin,
+)
+from bonsai.tool.cad import WELD_TOLERANCE
+
+V_ = tool.Blender.V_

 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRailing.htm
@@ -92,7 +104,6 @@ def update_railing_modifier_ifc_data(context: bpy.types.Context) -> None:
        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())

        representation_data = {
-            "railing_type": props.railing_type,
            "context": body,
            "railing_path": railing_path,
            "use_manual_supports": props.use_manual_supports,
@@ -125,6 +136,56 @@ def update_bbim_railing_pset(element: ifcopenshell.entity_instance, railing_data
    ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": railing_data})


+def generate_wall_mounted_handrail_preview(
+    obj: bpy.types.Object,
+    props: "BIMRailingProperties",
+    path_data: dict[str, Any],
+    si_conversion: float,
+) -> None:
+    """Viewport-only WALL_MOUNTED_HANDRAIL preview: rebuild ``obj.data`` from the same
+    geometry helper the IFC representation builder uses, without writing any IFC."""
+    railing_path = [Vector(v) * si_conversion for v in path_data["verts"]]
+    looped_path = path_data["edges"][-1][-1] == path_data["edges"][0][0]
+
+    geom = ifcopenshell.api.geometry.compute_wall_mounted_handrail_geometry(
+        railing_path=railing_path,
+        support_spacing=props.support_spacing,
+        railing_diameter=props.railing_diameter,
+        clear_width=props.clear_width,
+        height=props.height,
+        use_manual_supports=props.use_manual_supports,
+        terminal_type=props.terminal_type,
+        looped_path=looped_path,
+        unit_scale=1.0,  # props are already SI; bypass the IFC project-units conversion
+    )
+
+    bm = tool.Blender.get_bmesh_for_mesh(obj.data, clean=True)
+
+    tool.Cad.sweep_disk_along_polyline(
+        bm,
+        [Vector(p) for p in geom.handrail_polyline],
+        geom.handrail_radius,
+        arc_indices=geom.handrail_arc_point_indices,
+    )
+
+    for support in geom.supports:
+        tool.Cad.sweep_disk_along_polyline(
+            bm,
+            [Vector(p) for p in support.arc_polyline],
+            support.arc_radius,
+        )
+        tool.Cad.add_disk_extrusion(
+            bm,
+            Vector(support.disk_position),
+            support.disk_radius,
+            support.disk_depth,
+            support.disk_z_rotation,
+        )
+
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
+    tool.Blender.apply_bmesh(obj.data, bm)
+
+
 def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
    """before using should make sure that Data contains up-to-date information.
    If BBIM Pset just changed should call refresh() before updating bmesh
@@ -140,6 +201,13 @@ def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
    path_data = RailingData.data["path_data"]

    si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+
+    # WALL_MOUNTED_HANDRAIL renders the preview from the compute helper; IFC stays
+    # untouched until Finish Editing rebuilds the representation.
+    if not props.is_editing_path and props.railing_type == "WALL_MOUNTED_HANDRAIL":
+        generate_wall_mounted_handrail_preview(obj, props, path_data, si_conversion)
+        return
+
    # need to make sure we support edit mode
    # since users will probably be in edit mode when they'll be changing railing path
    bm = tool.Blender.get_bmesh_for_mesh(obj.data, clean=True)
@@ -165,8 +233,6 @@ def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
        thickness = props.thickness
        spacing = props.spacing

-        # spacing
-        # split each edge in 3 segments by 0.5 * spacing by x-y plane
        main_edges = bm.edges[:]
        for main_edge in main_edges:
            bm_split_edge_at_offset(main_edge, spacing)
@@ -211,7 +277,7 @@ def update_railing_modifier_bmesh(context: bpy.types.Context) -> None:
        bmesh.ops.dissolve_edges(bm, edges=edges_to_dissolve)
        bmesh.ops.dissolve_verts(bm, verts=verts_to_dissolve)
        # to remove unnecessary verts in 0 spacing case
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=WELD_TOLERANCE)

        bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])

@@ -271,8 +337,8 @@ def get_path_data(obj: bpy.types.Object) -> dict[str, Any]:
            segments.append((i - 1, 0))
            break

-        # skip path verts if they just go vertical to avoid errors
-        if (v.co.xy - prev_v.co.xy).length <= 0.0001:
+        # Vertical-only segments project to a degenerate XY edge; skip to avoid divide-by-zero downstream.
+        if (v.co.xy - prev_v.co.xy).length <= WELD_TOLERANCE:
            continue

        points.append(v.co)
@@ -406,68 +472,628 @@ class CopyRailingParameters(bpy.types.Operator, tool.Ifc.Operator):
        return {"FINISHED"}


-class EnableEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.enable_editing_railing"
-    bl_label = "Enable Editing Railing"
-    bl_options = {"REGISTER"}
+class _RailingEditMixin(PathPreservingEditMixin):
+    """Single-object (active_object) railing-edit hooks; path_data is preserved
+    through the edit (path editing is a separate operator family)."""

-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        props = tool.Model.get_railing_props(obj)
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
+    pset_name = "BBIM_Railing"
+
+    @classmethod
+    def _is_element_type(cls, element):
+        return tool.Parametric.is_railing(element)
+
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        return tool.Model.get_railing_props(obj)
+
+    @classmethod
+    def _post_load_data(cls, data: dict) -> dict:
+        # BIMRailingProperties.path_data is a StringProperty holding JSON.
        data["path_data"] = json.dumps(data["path_data"])
+        return data

-        # required since we could load pset from .ifc and BIMRailingProperties won't be set
-        props.set_props_kwargs_from_ifc_data(data)
+    @classmethod
+    def _update_pset(cls, element, data: dict) -> None:
+        update_bbim_railing_pset(element, data)

-        props.is_editing = True
-        return {"FINISHED"}
+    @classmethod
+    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        update_railing_modifier_ifc_data(context)

-
-class CancelEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.cancel_editing_railing"
-    bl_label = "Cancel Editing Railing"
-    bl_options = {"REGISTER"}
-
-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
+    @classmethod
+    def _restore_viewport_after_cancel(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """WALL_MOUNTED_HANDRAIL reloads the committed Body; others rebuild the preview bmesh."""
        props = tool.Model.get_railing_props(obj)
-
-        # restore previous settings since editing was canceled
-        props.set_props_kwargs_from_ifc_data(data)
+        if props.railing_type == "WALL_MOUNTED_HANDRAIL":
+            element = tool.Ifc.get_entity(obj)
+            assert element
+            body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+            if body:
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc,
+                    tool.Geometry,
+                    obj=obj,
+                    representation=body,
+                )
+            return
        update_railing_modifier_bmesh(context)

-        props.is_editing = False
-        return {"FINISHED"}

-
-class FinishEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.finish_editing_railing"
-    bl_label = "Finish Editing Railing"
-    bl_options = {"REGISTER"}
+class EnableEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_railing"
+    bl_label = "Enable Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        props = tool.Model.get_railing_props(obj)
+        return self._enable_targets(context)

-        pset_data = tool.Model.get_modeling_bbim_pset_data(bpy.context.active_object, "BBIM_Railing")
-        path_data = pset_data["data_dict"]["path_data"]

-        railing_data = props.get_general_kwargs(convert_to_project_units=True)
-        railing_data["path_data"] = path_data
-        props.is_editing = False
+class CancelEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.cancel_editing_railing"
+    bl_label = "Cancel Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}

-        update_bbim_railing_pset(element, railing_data)
-        update_railing_modifier_ifc_data(context)
+    def _execute(self, context):
+        return self._cancel_targets(context)
+
+
+class FinishEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.finish_editing_railing"
+    bl_label = "Finish Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        return self._finish_targets(context)
+
+
+class CycleRailingType(bpy.types.Operator, tool.Ifc.Operator, CycleTypeMixin):
+    """Cycle railing_type (FRAMELESS_PANEL ↔ WALL_MOUNTED_HANDRAIL). Shift+click reverses."""
+
+    bl_idname = "bim.cycle_railing_type"
+    bl_label = "Cycle Railing Type"
+    bl_options = {"REGISTER", "UNDO"}
+
+    element_checker = tool.Parametric.is_railing
+    props_getter = tool.Model.get_railing_props
+    type_literal = tool.Model.RailingType
+    type_attr = "railing_type"
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        return self._cycle_type(context)
+
+
+class ToggleRailingUseManualSupports(bpy.types.Operator):
+    """Flip use_manual_supports on the active WALL_MOUNTED_HANDRAIL railing.
+
+    No-op unless a parametric edit is active and the railing is wall-mounted.
+    """
+
+    bl_idname = "bim.toggle_railing_use_manual_supports"
+    bl_label = "Toggle Railing Manual Supports"
+    bl_description = "Switch between automatic support spacing and manual per-vertex placement"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        resolved = tool.Model.resolve_active_props_for_edit(
+            context,
+            tool.Model.get_railing_props,
+            subtype=("railing_type", "WALL_MOUNTED_HANDRAIL"),
+        )
+        if resolved is None:
+            return {"CANCELLED"}
+        _obj, props = resolved
+        props.use_manual_supports = not props.use_manual_supports
        return {"FINISHED"}


+class PickRailingTerminalType(bpy.types.Operator, tool.Ifc.Operator, PickTypeMixin):
+    """Pick ``terminal_type`` for the active WALL_MOUNTED_HANDRAIL railing."""
+
+    bl_idname = "bim.pick_railing_terminal_type"
+    bl_label = "Pick Railing Terminal Type"
+    bl_description = "Pick the cap geometry applied at the rail ends"
+    bl_options = {"REGISTER", "UNDO"}
+
+    skip_element_check = True
+    props_getter = tool.Model.get_railing_props
+    type_literal = prop.CapType
+    type_attr = "terminal_type"
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        if (
+            tool.Model.resolve_active_props_for_edit(
+                context,
+                tool.Model.get_railing_props,
+                subtype=("railing_type", "WALL_MOUNTED_HANDRAIL"),
+            )
+            is None
+        ):
+            return {"CANCELLED"}
+        return self._pick_type(context)
+
+
+def _format_attr_distance(attr_name: str):
+    """text_formatter that renders the named property as a distance, ignoring the
+    dimension's visible-length argument (which is fixed for schematic gizmos)."""
+    return lambda p, _v: tool.Unit.format_distance(getattr(p, attr_name))
+
+
+class GizmoRailingSchematic(bpy.types.GizmoGroup, gizmo.BaseSchematicGizmoGroup):
+    """Schematic-frame parametric editor for railings. Mutually exclusive with path-edit mode."""
+
+    bl_idname = "OBJECT_GGT_bim_railing_edition"
+    bl_label = "Railing Editing Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    enable_editing_operator = "bim.enable_editing_railing"
+    finish_editing_operator = "bim.finish_editing_railing"
+    cancel_editing_operator = "bim.cancel_editing_railing"
+    cycle_type_operator = "bim.cycle_railing_type"
+
+    props_getter = tool.Model.get_railing_props
+    gizmo_pref_name = "railing"
+
+    # Schematic-local layout. +X → screen RIGHT, +Y → screen UP, +Z → toward viewer
+    # (post billboard rotation). Each dimension is anchored alongside the feature it
+    # measures so the label, not the bar length, carries the value.
+    SCHEMATIC_MESH_HEIGHT_FRAC = 0.9  # Mesh top edge in schematic-local +Y
+    SCHEMATIC_MESH_WIDTH_FRAC = 0.7  # Mesh side edges in schematic-local ±X
+    SCHEMATIC_MESH_RAIL_Y_FRAC = SCHEMATIC_MESH_HEIGHT_FRAC / 2  # WALL_MOUNTED_HANDRAIL rail centreline
+    SCHEMATIC_MESH_DEPTH_FRAC = 0.06  # Panel depth — small so the schematic reads as slabs not boxes
+    # WALL_MOUNTED_HANDRAIL dimensions — fractions of schematic_box_size so they
+    # scale with the host group's box size.
+    SCHEMATIC_RAIL_RADIUS_FRAC = 0.05
+    SCHEMATIC_RAIL_CLEAR_FRAC = 0.5  # Stylised — wider than real-world for visible bracket arm
+    SCHEMATIC_RAIL_INSET_FRAC = 0.08  # Wall extends past the outermost support on both sides
+
+    @classmethod
+    def schematic_rail_radius(cls) -> float:
+        return cls.schematic_box_size * cls.SCHEMATIC_RAIL_RADIUS_FRAC
+
+    @classmethod
+    def schematic_rail_clear(cls) -> float:
+        return cls.schematic_box_size * cls.SCHEMATIC_RAIL_CLEAR_FRAC
+
+    # Axonometric 3/4 view: +Z projects down-and-left so the depth axis
+    # is visibly separated from the back face. Without the X tilt, panel
+    # thickness (schematic-local Z) collapses to a near-horizontal bar.
+    schematic_view_rotation = Matrix.Rotation(math.radians(20), 4, "X") @ Matrix.Rotation(math.radians(-25), 4, "Y")
+
+    # Hover a dimension → highlight the schematic edges tagged with the matching feature.
+    # Tags are written by the mesh builders. "spacing" is empty space (no edges) so it's
+    # absent from this map and gracefully no-ops on hover.
+    schematic_attr_to_feature = {
+        "height": "panel_height",
+        "thickness": "panel_thickness",
+        "railing_diameter": "rail_tube",
+        "clear_width": "bracket",
+        "support_spacing": "bracket",
+    }
+
+    schematic_dimension_props = [
+        # ── FRAMELESS_PANEL ─────────────────────────────────────────────
+        DimensionGizmoConfig(
+            attr_name="height",
+            axis=(0, 1, 0),
+            min_value=0.01,
+            # Gated to FRAMELESS_PANEL: in WALL_MOUNTED_HANDRAIL, height only
+            # feeds TO_FLOOR / TO_END_POST_AND_FLOOR terminals so dragging it
+            # is a no-op under the default "180" terminal.
+            visibility_condition=lambda p: p.railing_type == "FRAMELESS_PANEL",
+            matrix_position=lambda p: Vector((-GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2 - 0.08, 0.0, 0.0)),
+            schematic_visible_length=SCHEMATIC_MESH_HEIGHT_FRAC,
+            text_formatter=_format_attr_distance("height"),
+        ),
+        DimensionGizmoConfig(
+            attr_name="thickness",
+            axis=(0, 0, 1),  # panel depth — projects to a true depth direction under the 3/4 tilt
+            min_value=0.005,
+            visibility_condition=lambda p: p.railing_type == "FRAMELESS_PANEL",
+            matrix_position=lambda p: Vector(
+                (
+                    (
+                        -GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2
+                        - GizmoRailingSchematic.SCHEMATIC_MESH_GAP_HALF_WIDTH
+                    )
+                    / 2,
+                    GizmoRailingSchematic.SCHEMATIC_MESH_HEIGHT_FRAC + 0.05,
+                    -GizmoRailingSchematic.SCHEMATIC_MESH_DEPTH_FRAC / 2,
+                )
+            ),
+            schematic_visible_length=0.4,  # longer than default to survive depth foreshortening
+            text_formatter=_format_attr_distance("thickness"),
+        ),
+        DimensionGizmoConfig(
+            attr_name="spacing",
+            axis=(1, 0, 0),
+            min_value=0.0,  # zero-spacing collapses the picket gap into a single continuous panel
+            visibility_condition=lambda p: p.railing_type == "FRAMELESS_PANEL",
+            matrix_position=lambda p: Vector((0.0, -0.1, 0.0)),
+            text_formatter=_format_attr_distance("spacing"),
+        ),
+        # ── WALL_MOUNTED_HANDRAIL ──────────────────────────────────────
+        DimensionGizmoConfig(
+            attr_name="railing_diameter",
+            axis=(0, 1, 0),
+            min_value=0.001,
+            visibility_condition=lambda p: p.railing_type == "WALL_MOUNTED_HANDRAIL",
+            matrix_position=lambda p: Vector(
+                (
+                    -GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2 - 0.05,
+                    GizmoRailingSchematic.SCHEMATIC_MESH_RAIL_Y_FRAC - 0.09,
+                    GizmoRailingSchematic.schematic_rail_clear(),
+                )
+            ),
+            text_formatter=_format_attr_distance("railing_diameter"),
+        ),
+        DimensionGizmoConfig(
+            attr_name="clear_width",
+            axis=(0, 0, 1),  # +Z is the wall-to-rail perpendicular axis under the 3/4 tilt
+            min_value=0.001,
+            visibility_condition=lambda p: p.railing_type == "WALL_MOUNTED_HANDRAIL",
+            matrix_position=lambda p: Vector(
+                (
+                    0.0,
+                    GizmoRailingSchematic.SCHEMATIC_MESH_RAIL_Y_FRAC,
+                    0.0,
+                )
+            ),
+            schematic_visible_length=0.36,  # 2× default so the call-out survives depth projection
+            text_formatter=_format_attr_distance("clear_width"),
+        ),
+        DimensionGizmoConfig(
+            attr_name="support_spacing",
+            axis=(1, 0, 0),
+            min_value=0.05,
+            visibility_condition=lambda p: (p.railing_type == "WALL_MOUNTED_HANDRAIL" and not p.use_manual_supports),
+            matrix_position=lambda p: Vector(
+                (
+                    -GizmoRailingSchematic.SCHEMATIC_MESH_WIDTH_FRAC / 2
+                    + GizmoRailingSchematic.SCHEMATIC_RAIL_INSET_FRAC,
+                    -0.18,
+                    0.0,
+                )
+            ),
+            # Bare names (not Gizmo…SCHEMATIC_…) because the class is still under construction here.
+            schematic_visible_length=SCHEMATIC_MESH_WIDTH_FRAC - 2 * SCHEMATIC_RAIL_INSET_FRAC,
+            text_formatter=_format_attr_distance("support_spacing"),
+        ),
+    ]
+
+    @classmethod
+    def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
+        return tool.Parametric.is_railing(element)
+
+    @classmethod
+    def schematic_cache_key(cls, props) -> tuple:
+        """Cache the schematic mesh by ``railing_type`` — proportions are fixed
+        per type, so the bmesh build runs at most twice across a session
+        (once for ``FRAMELESS_PANEL``, once for ``WALL_MOUNTED_HANDRAIL``)
+        rather than once per draw call."""
+        return (props.railing_type,)
+
+    def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
+        """Create the WALL_MOUNTED_HANDRAIL-only affordances on the schematic.
+
+        Two static lock glyphs (open/closed) for toggling
+        ``use_manual_supports``: instantiate both and let the per-frame state
+        query pick which one to show. State-aware icons use a static pair
+        rather than a single dynamic gizmo to avoid ``prop_path`` resolution
+        in the render path.
+
+        Plus a cycle-glyph at the rail end that opens the ``terminal_type``
+        popup when clicked.
+        """
+        default_color, highlight_color = self.get_decoration_colors()
+
+        self.lock_open_gizmo, self.lock_closed_gizmo = self.create_icon_gizmo_lock_pair(
+            "bim.toggle_railing_use_manual_supports",
+            open_color=default_color,
+        )
+
+        self.terminal_gizmo = self.gizmos.new("VIEW3D_GT_menu")
+        self.terminal_gizmo.color = default_color
+        self.terminal_gizmo.color_highlight = highlight_color
+        self.terminal_gizmo.use_draw_scale = False
+        self.terminal_gizmo.alpha = 0.8
+        self.terminal_gizmo.target_set_operator("bim.pick_railing_terminal_type")
+
+    def _refresh_element_specific(self, context: bpy.types.Context, mw: "Matrix", props) -> None:
+        """Position and gate the WALL_MOUNTED_HANDRAIL-only gizmos.
+
+        - Lock glyphs: only WALL_MOUNTED_HANDRAIL while editing. Show
+          ``lock_open`` when ``use_manual_supports`` is True, the closed
+          padlock when False ("auto-spacing is locked to support_spacing").
+        - Terminal gizmo: same gating, positioned just past the right rail
+          end so it reads as "configure the rail's end cap".
+        """
+        super()._refresh_element_specific(context, mw, props)
+
+        # ``draw_prepare`` can fire on a freshly recreated GizmoGroup instance
+        # before ``setup_element_specific_gizmos`` has populated the lock /
+        # terminal attributes (Blender 5.x recreates per-region groups on
+        # reload). Bail out cheaply; the next refresh after setup completes
+        # will reposition them correctly.
+        if not hasattr(self, "lock_open_gizmo"):
+            return
+
+        # Single gate for all WALL_MOUNTED_HANDRAIL extras.
+        active = props.is_editing and not props.is_editing_path and props.railing_type == "WALL_MOUNTED_HANDRAIL"
+
+        if not active:
+            self.lock_open_gizmo.hide = True
+            self.lock_closed_gizmo.hide = True
+            self.terminal_gizmo.hide = True
+            return
+
+        billboard_rot = self._frame_billboard_rot
+        view_rotation = self.schematic_view_rotation
+        anchor = self._compute_schematic_anchor(props, mw, billboard_rot)
+
+        # ── Lock glyphs for use_manual_supports ──────────────────────────
+        # Sit just above the wall's bottom line, near the centre of the
+        # schematic — visually grouped with the dimension it controls
+        # (support_spacing) without overlapping the arrow tail below.
+        is_manual = bool(props.use_manual_supports)
+        self.lock_open_gizmo.hide = not is_manual
+        self.lock_closed_gizmo.hide = is_manual
+        lock_local = Vector((0.0, 0.05, 0.0))
+        lock_world = anchor + billboard_rot @ view_rotation @ lock_local
+        lock_matrix = gizmo.billboarded_at(lock_world, billboard_rot, 0.09)
+        self.lock_open_gizmo.matrix_basis = lock_matrix
+        self.lock_closed_gizmo.matrix_basis = lock_matrix
+
+        # ── Terminal-type popup gizmo at the right rail end ──────────────
+        # Pushed well past the right wall edge so the icon doesn't crowd
+        # the wall outline or the bracket attach point. At rail height and
+        # rail depth so it reads as "attached to the rail terminal".
+        self.terminal_gizmo.hide = False
+        terminal_local = Vector(
+            (
+                self.SCHEMATIC_MESH_WIDTH_FRAC / 2 + 0.25,
+                self.SCHEMATIC_MESH_RAIL_Y_FRAC,
+                self.schematic_rail_clear(),
+            )
+        )
+        terminal_world = anchor + billboard_rot @ view_rotation @ terminal_local
+        self.terminal_gizmo.matrix_basis = gizmo.billboarded_at(terminal_world, billboard_rot, 0.18)
+
+    def update_editing_gizmos(self, context: bpy.types.Context, mw: "Matrix", props: "BIMRailingProperties") -> None:
+        """Hide the pen gizmo while polyline path-edit is active; reposition the cycle icon.
+
+        The base class shows the pen gizmo whenever ``is_editing`` is False,
+        which is the case during path-edit too. Allowing the user to click
+        through into parametric edit while the polyline mesh is open in EDIT
+        mode mixes two distinct editing states and leaves a stale draft if
+        they cancel out — block the entry point instead. The operator itself
+        is intentionally not guarded (callers via scripting can still invoke
+        it); this is the UX-level enforcement.
+
+        The cycle icon defaults to the editing icon row (next to validate /
+        cancel) via the parent's positioning. We move it to just above the
+        schematic mesh so it reads as "cycle the railing type *shown here*"
+        — associated with the preview the user is interacting with, not a
+        generic editing button at the bottom of the schematic.
+        """
+        super().update_editing_gizmos(context, mw, props)
+        if props.is_editing_path:
+            self.pen_gizmo.hide = True
+
+        if props.is_editing and not props.is_editing_path:
+            billboard_rot = self._frame_billboard_rot
+            view_rotation = self.schematic_view_rotation
+            anchor = self._compute_schematic_anchor(props, mw, billboard_rot)
+            # Comfortably above the mesh top edge so the icon doesn't crowd
+            # the ``thickness`` / ``clear_width`` dimension callouts that
+            # already sit just above the panel/wall.
+            cycle_local = Vector((0.0, self.SCHEMATIC_MESH_HEIGHT_FRAC + 0.25, 0.0))
+            world_pos = anchor + billboard_rot @ view_rotation @ cycle_local
+            # 30% smaller than the editing-icon-row default (0.30 → 0.21):
+            # the cycle is a tertiary affordance compared to pen/validate/cancel.
+            self.cycle_gizmo.matrix_basis = gizmo.billboarded_at(world_pos, billboard_rot, 0.21)
+
+    @classmethod
+    def build_schematic_mesh(cls, props) -> "bmesh.types.BMesh":
+        """Build a wireframe preview of the railing in schematic-local coordinates.
+
+        FRAMELESS_PANEL renders as a box whose proportions track the bound
+        properties (height / thickness / spacing); WALL_MOUNTED_HANDRAIL
+        renders as a horizontal tube with two L-shaped supports whose
+        proportions track railing_diameter / clear_width / support_spacing.
+        Both are scaled to fit inside ``[-schematic_box_size, +schematic_box_size]``
+        on each axis so the schematic reads the same regardless of absolute
+        property values.
+
+        The mesh is decorative — clicks land on the labeled sliders, not on
+        the preview geometry. See ``BaseSchematicGizmoGroup`` for the
+        draw-handler lifecycle.
+        """
+        bm = bmesh.new()
+        if props.railing_type == "FRAMELESS_PANEL":
+            cls._build_frameless_panel_schematic(bm, props)
+        else:
+            cls._build_wall_mounted_handrail_schematic(bm, props)
+        return bm
+
+    # Schematic-local half-width of the visible gap between the two panel boxes.
+    # Conveys the "spacing" semantic at a glance — the user sees two pickets
+    # separated by air, with the spacing dimension emerging from that gap.
+    SCHEMATIC_MESH_GAP_HALF_WIDTH = 0.05
+
+    @classmethod
+    def _build_frameless_panel_schematic(cls, bm: "bmesh.types.BMesh", props) -> None:
+        """Stylised panel: two wireframe boxes with a visible gap between them.
+
+        The box edges sit at the ``SCHEMATIC_MESH_*_FRAC`` positions
+        (matching where the dimension gizmos anchor), so each dimension line
+        visually starts at the geometry feature it measures. Internal
+        proportions are stable across drags — the actual values are shown
+        through the dimension labels, while the schematic communicates
+        which feature each label refers to. The gap between the two boxes
+        (set by ``SCHEMATIC_MESH_GAP_HALF_WIDTH``) gives the "spacing"
+        dimension a real visual referent.
+
+        Edges are tagged on a string layer so hover-highlight can colour
+        the geometric feature being measured: vertical edges → height,
+        depth edges → thickness. The X-aligned edges along the panel
+        width are untagged (they don't correspond to a single dimension).
+        """
+        hw = cls.SCHEMATIC_MESH_WIDTH_FRAC / 2
+        hd = cls.SCHEMATIC_MESH_DEPTH_FRAC / 2
+        h_top = cls.SCHEMATIC_MESH_HEIGHT_FRAC
+        gap = cls.SCHEMATIC_MESH_GAP_HALF_WIDTH
+
+        layer_name = cls.SCHEMATIC_FEATURE_LAYER_NAME
+        feat_layer = bm.edges.layers.string.get(layer_name) or bm.edges.layers.string.new(layer_name)
+
+        # Edge index → feature tag for one box. Order matches the (a, b)
+        # tuple order below: bottom ring (4) + top ring (4) + verticals (4).
+        edge_tags_per_box = (
+            b"",  # (0,1) bottom-back, X-aligned
+            b"panel_thickness",  # (1,2) bottom-right, Z-aligned
+            b"",  # (2,3) bottom-front, X-aligned
+            b"panel_thickness",  # (3,0) bottom-left, Z-aligned
+            b"",  # (4,5) top-back, X-aligned
+            b"panel_thickness",  # (5,6) top-right, Z-aligned
+            b"",  # (6,7) top-front, X-aligned
+            b"panel_thickness",  # (7,4) top-left, Z-aligned
+            b"panel_height",  # (0,4) vertical back-left
+            b"panel_height",  # (1,5) vertical back-right
+            b"panel_height",  # (2,6) vertical front-right
+            b"panel_height",  # (3,7) vertical front-left
+        )
+
+        # Build two separate wireframe boxes — one on each side of the central
+        # gap. The boxes share the same Y range (0..h_top) and Z range (±hd)
+        # but split the X range so the gap from -gap to +gap stays empty.
+        for x_left, x_right in ((-hw, -gap), (gap, hw)):
+            corners = [
+                bm.verts.new((x_left, 0.0, -hd)),
+                bm.verts.new((x_right, 0.0, -hd)),
+                bm.verts.new((x_right, 0.0, hd)),
+                bm.verts.new((x_left, 0.0, hd)),
+                bm.verts.new((x_left, h_top, -hd)),
+                bm.verts.new((x_right, h_top, -hd)),
+                bm.verts.new((x_right, h_top, hd)),
+                bm.verts.new((x_left, h_top, hd)),
+            ]
+            for tag, (a, b) in zip(
+                edge_tags_per_box,
+                (
+                    (0, 1),
+                    (1, 2),
+                    (2, 3),
+                    (3, 0),  # bottom ring
+                    (4, 5),
+                    (5, 6),
+                    (6, 7),
+                    (7, 4),  # top ring
+                    (0, 4),
+                    (1, 5),
+                    (2, 6),
+                    (3, 7),  # vertical edges
+                ),
+            ):
+                edge = bm.edges.new((corners[a], corners[b]))
+                if tag:
+                    edge[feat_layer] = tag
+
+    @classmethod
+    def _build_wall_mounted_handrail_schematic(cls, bm: "bmesh.types.BMesh", props) -> None:
+        """Stylised wall-mounted handrail: wall outline, hex tube, two L-brackets.
+
+        Three visual elements convey "rail mounted on a wall":
+
+        - **Wall outline** — a wireframe rectangle in the YZ plane at ``z=0``,
+          extending slightly past the rail ends so the wall reads as a
+          surface the rail is *attached to* rather than a coincident frame.
+        - **Handrail tube** — a hexagonal cross-section extruded along ±X
+          at ``z=+clear_s`` (in front of the wall), at ``y=rail_y``.
+        - **L-shaped brackets** at each rail end — from the rail centreline
+          drop a short distance, then run perpendicular back to the wall
+          plane. Mirrors the standard wall-mount bracket geometry: a
+          horizontal arm holding the rail off the wall, a vertical drop
+          attaching to the rail.
+
+        Like ``_build_frameless_panel_schematic``, the schematic uses fixed
+        proportions so the dimension gizmos' anchor points stay aligned
+        with the geometry features regardless of property values.
+        """
+        half_len = cls.SCHEMATIC_MESH_WIDTH_FRAC / 2
+        wall_top = cls.SCHEMATIC_MESH_HEIGHT_FRAC
+        rail_y = cls.SCHEMATIC_MESH_RAIL_Y_FRAC  # rail sits at half wall height
+        radius_s = cls.schematic_rail_radius()
+        clear_s = cls.schematic_rail_clear()
+
+        layer_name = cls.SCHEMATIC_FEATURE_LAYER_NAME
+        feat_layer = bm.edges.layers.string.get(layer_name) or bm.edges.layers.string.new(layer_name)
+
+        # ── Wall outline (rectangle at z=0, slightly wider than the rail) ──
+        # Spans the full schematic height; the rail attaches in the middle,
+        # so the wall reads as "continuing past the rail above and below".
+        # Wall edges stay untagged — they're background context, not a
+        # feature any dimension measures.
+        wall_extra = 0.08
+        wall_x_left = -half_len - wall_extra
+        wall_x_right = half_len + wall_extra
+        wall_corners = [
+            bm.verts.new((wall_x_left, 0.0, 0.0)),
+            bm.verts.new((wall_x_right, 0.0, 0.0)),
+            bm.verts.new((wall_x_right, wall_top, 0.0)),
+            bm.verts.new((wall_x_left, wall_top, 0.0)),
+        ]
+        for a, b in ((0, 1), (1, 2), (2, 3), (3, 0)):
+            bm.edges.new((wall_corners[a], wall_corners[b]))
+
+        # ── Handrail tube (hex cross-section in YZ, extruded along X) ──────
+        # Centred on the rail centreline at (±(half_len - rail_inset),
+        # rail_y, +clear_s) — in front of the wall plane at z=0. The tube
+        # is shorter than the wall so the wall visibly extends past it on
+        # both sides; the L-brackets sit at the tube ends, so the leftmost
+        # bracket no longer coincides with the wall's left edge.
+        rail_inset = cls.SCHEMATIC_RAIL_INSET_FRAC
+        rail_x_left = -half_len + rail_inset
+        rail_x_right = half_len - rail_inset
+        segments = 6
+        ring_left, ring_right = [], []
+        for i in range(segments):
+            theta = 2 * math.pi * i / segments
+            dy = math.cos(theta) * radius_s
+            dz = math.sin(theta) * radius_s
+            ring_left.append(bm.verts.new((rail_x_left, rail_y + dy, clear_s + dz)))
+            ring_right.append(bm.verts.new((rail_x_right, rail_y + dy, clear_s + dz)))
+        # All hex-tube edges tagged "rail_tube" so they highlight together
+        # when the railing_diameter dimension is hovered.
+        for i in range(segments):
+            j = (i + 1) % segments
+            e_left = bm.edges.new((ring_left[i], ring_left[j]))
+            e_right = bm.edges.new((ring_right[i], ring_right[j]))
+            e_axial = bm.edges.new((ring_left[i], ring_right[i]))
+            e_left[feat_layer] = b"rail_tube"
+            e_right[feat_layer] = b"rail_tube"
+            e_axial[feat_layer] = b"rail_tube"
+
+        # ── L-brackets at each rail end (rail → drop → wall) ───────────────
+        # Bracket attach points follow the rail ends, so they're pulled
+        # inward by ``rail_inset`` from the wall edges. From the rail
+        # centreline, drop ``bracket_drop`` in Y, then run perpendicular
+        # back to the wall plane (z=0). The L shape reads as a wall-mount
+        # bracket under the 3/4 tilt. Both bracket segments tagged
+        # "bracket" so they highlight when clear_width OR support_spacing
+        # is hovered (both dimensions measure features of the supports).
+        bracket_drop = 0.06
+        for x in (rail_x_left, rail_x_right):
+            v_rail = bm.verts.new((x, rail_y, clear_s))
+            v_corner = bm.verts.new((x, rail_y - bracket_drop, clear_s))
+            v_wall = bm.verts.new((x, rail_y - bracket_drop, 0.0))
+            e1 = bm.edges.new((v_rail, v_corner))
+            e2 = bm.edges.new((v_corner, v_wall))
+            e1[feat_layer] = b"bracket"
+            e2[feat_layer] = b"bracket"
+
+
 class FlipRailingPathOrder(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.flip_railing_path_order"
    bl_label = "Flip Railing Path Order"
@@ -511,6 +1137,16 @@ class EnableEditingRailingPath(bpy.types.Operator, tool.Ifc.Operator):
        [o.select_set(False) for o in context.selected_objects if o != obj]
        assert obj
        props = tool.Model.get_railing_props(obj)
+
+        # Auto-commit any in-progress parametric draft before switching to
+        # path-edit. ``set_props_kwargs_from_ifc_data`` a few lines below
+        # overwrites props with the pset's stored values — without committing
+        # first, anything the user dragged on a dimension gizmo (height,
+        # diameter, …) would be silently discarded the moment path-edit
+        # starts.
+        if props.is_editing:
+            tool.Parametric.commit_object_draft(obj, "bim.finish_editing_railing")
+
        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
        # required since we could load pset from .ifc and BIMRoofProperties won't be set
        props.set_props_kwargs_from_ifc_data(data)
@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.

 import json
-from math import cos, pi, radians, tan
-from typing import Any, Literal, Union
+from math import atan2, cos, degrees, pi, radians, tan
+from typing import Any, ClassVar, Literal, Union

 import bmesh
 import bpy
@@ -32,8 +32,11 @@ from mathutils import Quaternion, Vector

 import bonsai.core.root
 import bonsai.tool as tool
+from bonsai.bim.module.drawing import gizmos as gizmo
+from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig, IconSlot
 from bonsai.bim.module.model.data import RoofData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
+from bonsai.bim.parametric_lifecycle import CycleTypeMixin, PathPreservingEditMixin

 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRoof.htm
@@ -210,7 +213,13 @@ def generate_hipped_roof_bmesh(

    new_verts = [bm.verts.new(v) for v in verts]
    new_edges = [bm.edges.new([new_verts[vi] for vi in edge]) for edge in edges]
-    new_faces = [bm.faces.new([new_verts[vi] for vi in face]) for face in faces]
+    # Skip degenerate faces. ``bpypolyskel.polygonize`` can emit a face whose
+    # vertex list contains the same index twice on certain footprint /
+    # slope combinations (the straight-skeleton collapses two ridge events
+    # onto the same vertex). ``bm.faces.new`` rejects those with
+    # ``found the same (BMVert) used multiple times``; dropping them keeps
+    # the rest of the roof intact instead of aborting the whole rebuild.
+    new_faces = [bm.faces.new([new_verts[vi] for vi in face]) for face in faces if len(set(face)) == len(face)]

    if mode == "HEIGHT":  # Calculate the angle we ended up with.
        new_faces[0].normal_update()
@@ -396,6 +405,11 @@ def generate_hipped_roof_bmesh(
        if is_internal:
            faces_to_delete.add(face)
    bmesh.ops.delete(bm, geom=list(faces_to_delete), context="FACES")
+    # Final pass: ``remove_doubles`` + internal-face deletion above can leave
+    # the bottom slab faces flipped at low slopes, where the kernel's
+    # "outward" inference becomes ambiguous on near-flat geometry. Recompute
+    # once more on the final topology so the eave plane points down.
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
    return bm


@@ -608,61 +622,169 @@ class AddRoof(bpy.types.Operator, tool.Ifc.Operator):
        tool.Model.add_body_representation(obj)


-class EnableEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.enable_editing_roof"
-    bl_label = "Enable Editing Roof"
-    bl_options = {"REGISTER"}
+class _RoofEditMixin(PathPreservingEditMixin):
+    """Type-specific hooks for roof parametric-edit operators. Single-object
+    (active_object). ``path_data`` is preserved through the edit; the separate
+    ``Enable/Finish/CancelEditingRoofPath`` operators handle path editing."""

-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        props = tool.Model.get_roof_props(obj)
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")["data_dict"]
-        # required since we could load pset from .ifc and BIMRoofProperties won't be set
-        props.set_props_kwargs_from_ifc_data(data)
-        props.is_editing = True
-        return {"FINISHED"}
+    pset_name = "BBIM_Roof"

+    @classmethod
+    def _is_element_type(cls, element):
+        return tool.Parametric.is_roof(element)

-class CancelEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.cancel_editing_roof"
-    bl_label = "Cancel Editing Roof"
-    bl_options = {"REGISTER"}
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        return tool.Model.get_roof_props(obj)

-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")["data_dict"]
-        props = tool.Model.get_roof_props(obj)
+    @classmethod
+    def _update_pset(cls, element, data: dict) -> None:
+        update_bbim_roof_pset(element, data)

-        # restore previous settings since editing was canceled
-        props.set_props_kwargs_from_ifc_data(data)
+    @classmethod
+    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        update_roof_modifier_ifc_data(context)
+
+    @classmethod
+    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
        update_roof_modifier_bmesh(obj)

-        props.is_editing = False
-        return {"FINISHED"}
+    @classmethod
+    def _restore_viewport_after_cancel(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Rebuild the roof bmesh from the just-restored draft props so the
+        viewport reverts to the pre-edit geometry. Same helper the modal
+        edits use, just driven by the cancelled props instead of in-flight
+        drag values."""
+        update_roof_modifier_bmesh(obj)


-class FinishEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.finish_editing_roof"
-    bl_label = "Finish Editing Roof"
-    bl_options = {"REGISTER"}
+EnableEditingRoof, FinishEditingRoof, CancelEditingRoof = tool.Parametric.build_edit_lifecycle(
+    "roof",
+    _RoofEditMixin,
+    labels=(
+        ("Enable Editing Roof", ""),
+        ("Finish Editing Roof", ""),
+        ("Cancel Editing Roof", ""),
+    ),
+    module_name=__name__,
+)

-    def _execute(self, context):
-        obj = context.active_object
-        element = tool.Ifc.get_entity(obj)
-        props = tool.Model.get_roof_props(obj)

-        pset_data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")
-        path_data = pset_data["data_dict"]["path_data"]
+# Fixed horizontal run for the slope gizmo: the draggable value is the
+# vertical rise at this distance from the anchor, in the rise/run convention.
+_ROOF_SLOPE_REFERENCE_RUN = 1.0
+# One degree shy of vertical; avoids tan() blow-up when the user drags the
+# rise handle past the gizmo's anchor.
+_ROOF_MAX_SLOPE_ANGLE = pi / 2 - 0.001

-        roof_data = props.get_general_kwargs(convert_to_project_units=True)
-        roof_data["path_data"] = path_data
-        props.is_editing = False

-        update_bbim_roof_pset(element, roof_data)
-        update_roof_modifier_ifc_data(context)
-        return {"FINISHED"}
+def _roof_has_openings() -> bool:
+    """``visible_when`` predicate for the toggle_openings idle slot. True iff
+    the active object's IFC element exposes a non-empty HasOpenings inverse."""
+    obj = bpy.context.active_object
+    if obj is None:
+        return False
+    element = tool.Ifc.get_entity(obj)
+    if element is None:
+        return False
+    return tool.Geometry.has_openings(element)
+
+
+class CycleRoofGenerationMethod(bpy.types.Operator, tool.Ifc.Operator, CycleTypeMixin):
+    """Cycle the roof generation method (HEIGHT ↔ ANGLE). Shift+click cycles in reverse."""
+
+    bl_idname = "bim.cycle_roof_generation_method"
+    bl_label = "Cycle Roof Generation Method"
+    bl_options = {"REGISTER", "UNDO"}
+
+    element_checker = tool.Parametric.is_roof
+    props_getter = tool.Model.get_roof_props
+    type_literal = tool.Model.RoofGenerationMethod
+    type_attr = "generation_method"
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:
+        return self._cycle_type(context)
+
+
+class GizmoRoofEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
+    bl_idname = "OBJECT_GGT_bim_roof_edition"
+    bl_label = "Roof Editing Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    enable_editing_operator = "bim.enable_editing_roof"
+    finish_editing_operator = "bim.finish_editing_roof"
+    cancel_editing_operator = "bim.cancel_editing_roof"
+    cycle_type_operator = "bim.cycle_roof_generation_method"
+
+    # Positions for all three dimensions are set per-frame by the position
+    # override below; no static ``matrix_position`` is needed.
+    dimension_gizmo_props = [
+        DimensionGizmoConfig(
+            attr_name="height",
+            axis=(0, 0, 1),
+            min_value=0.01,
+            visibility_condition=lambda p: p.generation_method == "HEIGHT",
+        ),
+        DimensionGizmoConfig(
+            attr_name="angle",
+            axis=(0, 0, 1),
+            prop_name="Slope",
+            min_value=0.0,
+            visibility_condition=lambda p: p.generation_method == "ANGLE",
+            compute_value=lambda p: tan(p.angle) * _ROOF_SLOPE_REFERENCE_RUN,
+            apply_value=lambda p, rise: setattr(
+                p, "angle", min(_ROOF_MAX_SLOPE_ANGLE, max(0.0, atan2(rise, _ROOF_SLOPE_REFERENCE_RUN)))
+            ),
+            text_formatter=lambda p, rise: (f"{tool.Unit.format_distance(rise)} ({degrees(p.angle):.1f}°)"),
+        ),
+        DimensionGizmoConfig(
+            attr_name="roof_thickness",
+            axis=(0, 0, -1),
+            min_value=0.001,
+            # The line shows the perpendicular slab thickness (matching the
+            # pset value and the drag delta); the true vertical span is
+            # ``roof_thickness / cos(angle)``, longer than what is drawn.
+        ),
+    ]
+
+    props_getter = tool.Model.get_roof_props
+    gizmo_pref_name = "roof"
+
+    idle_slots: ClassVar[tuple[IconSlot, ...]] = (
+        IconSlot(
+            name="toggle_openings",
+            gizmo_idname="VIEW3D_GT_add_opening",
+            operator="bim.toggle_host_openings",
+            visible_when=lambda gg: _roof_has_openings(),
+        ),
+    )
+
+    @classmethod
+    def is_element_type(cls, element: ifcopenshell.entity_instance) -> bool:
+        return tool.Parametric.is_roof(element)
+
+    def _update_dimension_gizmo_positions(self, context: bpy.types.Context, mw, props) -> None:  # noqa: ARG002
+        """Anchor every dimension gizmo at the object origin. Each gizmo's
+        declared axis (height/slope along +Z, thickness along -Z) separates
+        them in 3D so they don't visually collide despite sharing a
+        position; the height + slope gizmos themselves are mutually
+        exclusive via ``visibility_condition`` on ``generation_method``."""
+        origin = Vector((0.0, 0.0, 0.0))
+        self.set_dimension_gizmo_position("height", mw, origin, (0, 0, 1))
+        self.set_dimension_gizmo_position("angle", mw, origin, (0, 0, 1))
+        self.set_dimension_gizmo_position("roof_thickness", mw, origin, (0, 0, -1))
+
+    def get_element_height(self, props) -> float:  # noqa: ARG002
+        """Object-local Z of the mesh's topmost vertex, so the pen / validate /
+        cancel / cycle row anchors visibly above sloped or stepped roof
+        bodies rather than at the parametric ``props.height`` which may not
+        match the rendered apex on ANGLE-generation roofs."""
+        obj = bpy.context.active_object
+        if obj is None or not getattr(obj, "bound_box", None):
+            return 1.0
+        return max(c[2] for c in obj.bound_box)


 class EnableEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):
@@ -271,7 +271,7 @@ class DumbSlabPlaner:
                # For instances, a 30 degrees angled extrusion with positive direction has the same extrusion direction as a
                # -150 degrees angled extrusion with negative direction. The difference lies in the object's rotation.
                # This means that things can get messy if the user changes the object x angle somehow. We have to figure out an alternative approach.
-                existing_x_angle = obj.rotation_euler.x
+                existing_x_angle = tool.Model.get_existing_x_angle(extrusion)
                existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, 0, tolerance=0.001) else existing_x_angle
                existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, pi, tolerance=0.001) else existing_x_angle
                existing_x_angle = 0 if tool.Cad.is_x(existing_x_angle, 2 * pi, tolerance=0.001) else existing_x_angle
@@ -620,6 +620,14 @@ class EnableEditingExtrusionProfile(bpy.types.Operator, tool.Ifc.Operator):
    def _execute(self, context):
        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
        obj = context.active_object
+
+        # Commit any in-progress parametric (gizmo) draft on this object
+        # before switching to profile-edit. Otherwise the in-memory draft
+        # state is overwritten when the profile mesh is imported below,
+        # silently discarding the user's pending dimension edits.
+        if feature := tool.Parametric.is_object_editing(obj):
+            tool.Parametric.commit_object_draft(obj, feature.finish_op)
+
        element = tool.Ifc.get_entity(obj)

        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
@@ -991,3 +999,74 @@ class RecalculateSlab(bpy.types.Operator, tool.Ifc.Operator):

        tool.Model.recalculate_walls(walls)
        return {"FINISHED"}
+
+
+class EnableEditingSlab(bpy.types.Operator, tool.Ifc.Operator):
+    """Open the slab disconnect-access mode. Pure UI toggle: flips
+    ``obj.BIMSlabProperties.is_editing`` so the per-wall disconnect
+    gizmos surface on the slab. ``tool.Ifc.Operator`` base because the
+    parametric framework's universal dispatcher routes through
+    ``tool.Parametric.run_bim_op``, which only accepts that subclass for
+    undo-safe lifecycle. No IFC mutation."""
+
+    bl_idname = "bim.enable_editing_slab"
+    bl_label = "Edit Slab Connections"
+    bl_description = "Show disconnect icons for every wall clipped to this slab"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        if obj is None:
+            return False
+        element = tool.Ifc.get_entity(obj)
+        return element is not None and element.is_a("IfcSlab")
+
+    def _execute(self, context):
+        context.active_object.BIMSlabProperties.is_editing = True
+        return {"FINISHED"}
+
+
+class CancelEditingSlab(bpy.types.Operator, tool.Ifc.Operator):
+    """Close the slab disconnect-access mode."""
+
+    bl_idname = "bim.cancel_editing_slab"
+    bl_label = "Close Slab Edit"
+    bl_description = "Hide the slab disconnect icons"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        if obj is None:
+            return False
+        element = tool.Ifc.get_entity(obj)
+        return element is not None and element.is_a("IfcSlab")
+
+    def _execute(self, context):
+        context.active_object.BIMSlabProperties.is_editing = False
+        return {"FINISHED"}
+
+
+class FinishEditingSlab(bpy.types.Operator, tool.Ifc.Operator):
+    """Close the slab disconnect-access mode. Same body as Cancel — slab
+    edit is a pure UI gate with no IFC draft to commit; the framework
+    requires both ``bim.finish_editing_<name>`` and
+    ``bim.cancel_editing_<name>`` to exist by name convention."""
+
+    bl_idname = "bim.finish_editing_slab"
+    bl_label = "Finish Slab Edit"
+    bl_description = "Hide the slab disconnect icons"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        if obj is None:
+            return False
+        element = tool.Ifc.get_entity(obj)
+        return element is not None and element.is_a("IfcSlab")
+
+    def _execute(self, context):
+        context.active_object.BIMSlabProperties.is_editing = False
+        return {"FINISHED"}
@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.

 import json

@@ -29,7 +31,13 @@ from mathutils import Matrix, Vector
 import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
-from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+from bonsai.bim.module.drawing.gizmos import (
+    COLOR_GREEN,
+    COLOR_RED,
+    DimensionGizmoConfig,
+    IconSlot,
+)
+from bonsai.bim.parametric_lifecycle import IntegerInputDialogMixin, PickTypeMixin
 from bonsai.tool.numeric_input import (
    IntegerInputState,
    run_integer_input_modal,
@@ -37,7 +45,7 @@ from bonsai.tool.numeric_input import (
 )

 V_ = tool.Blender.V_
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar

 from bmesh.types import BMVert
 from bpy.props import IntProperty
@@ -262,7 +270,6 @@ class FinishEditingStair(bpy.types.Operator, tool.Ifc.Operator):

        # Use the special method that includes custom_tread_lock for IFC storage
        data = props.get_props_kwargs_for_ifc_export(convert_to_project_units=True)
-        props.is_editing = False
        regenerate_stair_mesh(obj)
        tool.Model.add_body_representation(obj)

@@ -272,6 +279,7 @@ class FinishEditingStair(bpy.types.Operator, tool.Ifc.Operator):

        # update IfcStairFlight properties
        update_ifc_stair_props(obj)
+        props.is_editing = False
        return {"FINISHED"}


@@ -376,6 +384,20 @@ class AdjustStairTreads(bpy.types.Operator):
        return {"FINISHED"}


+class InputStairTreads(IntegerInputDialogMixin, bpy.types.Operator):
+    """Popup-dialog entry point for typing a new ``number_of_treads`` value.
+    Bound to the world-space ``xN`` count label in the stair edit row."""
+
+    bl_idname = "bim.input_stair_treads"
+    bl_label = "Set Number of Treads"
+    bl_description = "Type the number of treads for this stair"
+    bl_options = {"REGISTER", "UNDO"}
+
+    number_of_treads: IntProperty(name="Number of Treads", default=1, min=1)
+    attr_name = "number_of_treads"
+    props_getter = staticmethod(tool.Model.get_stair_props)
+
+
 class SetStairTreads(bpy.types.Operator):
    """Set the number of treads to a specific value."""

@@ -421,20 +443,20 @@ class SetStairTreads(bpy.types.Operator):
        return f"Number of Treads: {input_str}_{validity}  |  Enter to confirm, Esc to cancel"


-class CycleStairType(bpy.types.Operator, gizmo.CycleTypeMixin):
-    """Cycle through stair types. Shift+click to cycle in reverse."""
+class PickStairType(bpy.types.Operator, PickTypeMixin):
+    """Pick a stair type from a popup menu."""

-    bl_idname = "bim.cycle_stair_type"
-    bl_label = "Cycle Stair Type"
+    bl_idname = "bim.pick_stair_type"
+    bl_label = "Pick Stair Type"
    bl_options = {"REGISTER", "UNDO"}

-    props_getter = "get_stair_props"
+    props_getter = tool.Model.get_stair_props
    type_literal = tool.Model.StairType
    type_attr = "stair_type"
    skip_element_check = True

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


 # Tread run accessors - callbacks that delegate to BIMStairProperties methods
@@ -460,20 +482,47 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
    bl_region_type = "WINDOW"
    bl_options = {"3D", "PERSISTENT"}

-    # === Stair-Specific Icon Layout (meters) ===
-    # Additional icons for stair editing, positioned after standard icons:
-    #   [Validate] [Cancel] [Cycle] [TreadLock] [Plus] [Minus]
-    ICON_TREAD_LOCK_X = 1.24  # X position for tread lock toggle icon
-    ICON_PLUS_X = 1.61  # X position for add tread (+) icon
-    ICON_MINUS_X = 1.98  # X position for remove tread (-) icon
+    # === Stair-Specific Icon Layout ===
+    # Row order: [Validate] [Cancel] [Cycle] [TreadLock] [xN] [Plus] [Minus]
+    # The base class assigns X positions from ``feature_slots`` tuple order —
+    # adding an icon is a one-line append, no hardcoded X constant.
    ICON_PLUS_MINUS_SCALE = 0.24  # Scale for plus/minus icons (slightly larger)
    ICON_CYCLE_SCALE = 0.3  # Scale for cycle type icon
+    ICON_COUNT_LABEL_SCALE = 0.36  # Scale for the xN tread-count label
    ICON_Z_OFFSET = 0.5  # Z offset above geometry for editing icons

+    feature_slots: ClassVar[tuple[IconSlot, ...]] = (
+        IconSlot(
+            name="tread_lock",
+            gizmo_idname="VIEW3D_GT_lock",
+            variants=("open", "closed"),
+            operator="bim.toggle_stair_property",
+            color=(1.0, 1.0, 1.0),
+            operator_props=(("property_name", "custom_tread_lock"),),
+        ),
+        IconSlot(name="tread_count_label", placeholder=True),
+        IconSlot(
+            name="plus",
+            gizmo_idname="VIEW3D_GT_plus",
+            operator="bim.adjust_stair_treads",
+            scale=ICON_PLUS_MINUS_SCALE,
+            color=COLOR_GREEN,
+            operator_props=(("increment", 1),),
+        ),
+        IconSlot(
+            name="minus",
+            gizmo_idname="VIEW3D_GT_minus",
+            operator="bim.adjust_stair_treads",
+            scale=ICON_PLUS_MINUS_SCALE,
+            color=COLOR_RED,
+            operator_props=(("increment", -1),),
+        ),
+    )
+
    enable_editing_operator = "bim.enable_editing_stair"
    finish_editing_operator = "bim.finish_editing_stair"
    cancel_editing_operator = "bim.cancel_editing_stair"
-    cycle_type_operator = "bim.cycle_stair_type"
+    pick_type_operator = "bim.pick_stair_type"

    def get_icon_y_extent(self, props: "BIMStairProperties") -> tuple[float, float]:
        """Get Y extents for stair icon positioning.
@@ -578,83 +627,91 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
    ]

    # Metadata-driven dispatch for props and preferences
-    props_getter = "get_stair_props"
+    props_getter = tool.Model.get_stair_props
    gizmo_pref_name = "stair"

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

    def setup_element_specific_gizmos(self, context: bpy.types.Context) -> None:
-        """Create stair-specific icon gizmos (lock, plus, minus)."""
-        self.lock_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_lock",
-            self.COLOR_BLUE,
+        """Create the total-length lock as an open/closed pair plus the
+        ``xN`` tread-count label. Lock click toggles
+        ``props.total_length_lock``; the per-frame update hook picks which
+        member is visible. Anchored to the stair's far X end (not the edit
+        row) so it's positioned by ``_update_lock_gizmo_position`` rather
+        than the toolbar slot system.
+
+        The count label binds to ``bim.input_stair_treads`` (popup dialog)
+        for click-to-type input and sits at the X reserved by the
+        ``tread_count_label`` placeholder slot in ``feature_slots``."""
+        self.total_length_lock_open_gizmo, self.total_length_lock_closed_gizmo = self.create_icon_gizmo_lock_pair(
            "bim.toggle_stair_property",
-            prop_path="BIMStairProperties.total_length_lock",
+            self.COLOR_BLUE,
            property_name="total_length_lock",
        )
-        self.tread_lock_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_lock",
-            (1.0, 1.0, 1.0),
-            "bim.toggle_stair_property",
-            prop_path="BIMStairProperties.custom_tread_lock",
-            property_name="custom_tread_lock",
-        )
-        self.plus_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_plus", self.COLOR_GREEN, "bim.adjust_stair_treads", increment=1
-        )
-        self.minus_gizmo = self.create_icon_gizmo(
-            "VIEW3D_GT_minus", self.COLOR_RED, "bim.adjust_stair_treads", increment=-1
-        )
+        default_color, highlight_color = self.get_decoration_colors()
+        self.tread_count_label_gizmo = self.gizmos.new("BIM_GT_count_label")
+        self.tread_count_label_gizmo.use_draw_scale = False
+        self.tread_count_label_gizmo.color = default_color
+        self.tread_count_label_gizmo.color_highlight = highlight_color
+        self.tread_count_label_gizmo.alpha = 0.8
+        self.tread_count_label_gizmo.target_set_operator("bim.input_stair_treads")

-    def _refresh_element_specific(self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties") -> None:
-        """Update stair-specific lock and tread count gizmos."""
-        billboard_rot = gizmo.get_billboard_rotation(context)
-        self.update_lock_gizmo(mw, props, billboard_rot)
+    def _refresh_element_specific(
+        self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"  # noqa: ARG002
+    ) -> None:
+        """Update stair-specific lock and tread count gizmos. Lock positioning is
+        handled per-frame in the dimension-positioning hook."""
+        self.update_lock_gizmo(props)
        self.update_tread_lock_gizmo(props)
        self.update_tread_count_gizmos(props)

-    def update_lock_gizmo(self, mw: Matrix, props: "BIMStairProperties", billboard_rot: Matrix) -> None:
-        """Update lock gizmo visibility, color, and position."""
-        gizmo_prefs = self.get_gizmo_prefs()
-        if not self.update_gizmo_visibility(self.lock_gizmo, props.is_editing, gizmo_prefs.lock):
-            return  # Hidden, skip positioning
-
-        self.lock_gizmo.color = self.COLOR_RED if props.total_length_lock else self.COLOR_GREEN
-
-        total_run = props.get_total_run()
-        local_transform = (
-            Matrix.Translation(Vector((total_run + self.ICON_Z_OFFSET, -self.GIZMO_OFFSET, -self.GIZMO_OFFSET)))
-            @ billboard_rot
-            @ Matrix.Scale(self.EDITING_ICON_SCALE, 4)
-        )
-        self.lock_gizmo.matrix_basis = mw @ local_transform
+    def update_lock_gizmo(self, props: "BIMStairProperties") -> None:
+        """Show the open/closed total-length lock variant matching
+        ``props.total_length_lock``. Positioning is handled per-frame by
+        the dimension-positioning hook."""
+        if not hasattr(self, "total_length_lock_open_gizmo"):
+            return
+        if not props.is_editing:
+            self.total_length_lock_open_gizmo.hide = True
+            self.total_length_lock_closed_gizmo.hide = True
+            return
+        self.total_length_lock_open_gizmo.hide = props.total_length_lock
+        self.total_length_lock_closed_gizmo.hide = not props.total_length_lock

    def update_tread_lock_gizmo(self, props: "BIMStairProperties") -> None:
-        """Update visibility of tread lock gizmo. Positioning is handled in _update_editing_icon_positions."""
-        if not hasattr(self, "tread_lock_gizmo"):
+        """Show the open/closed lock variant matching ``props.custom_tread_lock``.
+
+        Both pair members share an X position (set by the base's slot
+        positioning); this picks which one is visible per frame so a state
+        flip can't reveal both at once."""
+        if not hasattr(self, "tread_lock_open_gizmo"):
            return
-        gizmo_prefs = self.get_gizmo_prefs()
-        self.update_gizmo_visibility(self.tread_lock_gizmo, props.is_editing, gizmo_prefs.lock)
+        if not props.is_editing:
+            self.tread_lock_open_gizmo.hide = True
+            self.tread_lock_closed_gizmo.hide = True
+            return
+        self.tread_lock_open_gizmo.hide = props.custom_tread_lock
+        self.tread_lock_closed_gizmo.hide = not props.custom_tread_lock

    def update_tread_count_gizmos(self, props: "BIMStairProperties") -> None:
-        """Update visibility of +/- tread count gizmos. Positioning is handled in _update_editing_icon_positions."""
+        """Update visibility of the +/- tread count gizmos and the ``xN``
+        label. Positioning is handled in ``_update_editing_icon_positions``."""
        if not hasattr(self, "plus_gizmo") or not hasattr(self, "minus_gizmo"):
            return
-        gizmo_prefs = self.get_gizmo_prefs()
-        self.update_gizmo_visibility(self.plus_gizmo, props.is_editing, gizmo_prefs.plus)
+        self.update_gizmo_visibility(self.plus_gizmo, props.is_editing)
        # Minus has additional condition: number_of_treads > 1
-        self.update_gizmo_visibility(
-            self.minus_gizmo, props.is_editing and props.number_of_treads > 1, gizmo_prefs.minus
-        )
+        self.update_gizmo_visibility(self.minus_gizmo, props.is_editing and props.number_of_treads > 1)
+        if hasattr(self, "tread_count_label_gizmo"):
+            self.update_gizmo_visibility(self.tread_count_label_gizmo, props.is_editing)

    def _update_dimension_gizmo_positions(
-        self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"
+        self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"  # noqa: ARG002
    ) -> None:
        """Update dimension gizmo positions based on camera view direction."""
-        viewing_from_negative_y, viewing_from_negative_x = self.get_local_view_direction(context, mw)
-        billboard_rot = gizmo.get_billboard_rotation(context)
+        viewing_from_negative_y, viewing_from_negative_x = self._frame_view_dir
+        billboard_rot = self._frame_billboard_rot
        total_run = props.get_total_run()
        riser_height = props.get_riser_height()

@@ -725,10 +782,12 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
        billboard_rot: Matrix,
        total_run: float,
    ) -> None:
-        """Update lock gizmo position based on Y view direction."""
+        """Update lock gizmo pair position based on Y view direction. Writes
+        the matrix on both members so a state flip can't reveal a stale pose."""
        y_pos = self.get_y_position_for_view(props, viewing_from_negative_y, use_offset=True)
-        self.set_icon_gizmo_position(
-            "lock_gizmo",
+        self.set_icon_gizmo_pair_position(
+            "total_length_lock_open_gizmo",
+            "total_length_lock_closed_gizmo",
            mw,
            total_run + self.ICON_Z_OFFSET,
            y_pos,
@@ -740,30 +799,47 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
    def _update_editing_icon_positions(
        self, mw: Matrix, props: "BIMStairProperties", viewing_from_negative_y: bool, billboard_rot: Matrix
    ) -> None:
-        """Update editing icon positions, flipping Y based on viewing angle."""
+        """Reposition the editing icons at stair's view-dependent Y. The base
+        class's update_editing_gizmos already placed them at the default
+        ``get_icon_y_offset`` Y — this overrides with the stair-specific
+        ``get_icon_y_for_view`` flip so the icons land on the side the
+        camera is looking from."""
        if not props.is_editing:
            return

        icon_z = props.height + self.ICON_Z_OFFSET
        y_pos = self.get_icon_y_for_view(props, viewing_from_negative_y)
+        slot_x = self._slot_x_positions()

        self.set_icon_gizmo_position("validate_gizmo", mw, 0, y_pos, icon_z, billboard_rot)
        self.set_icon_gizmo_position("cancel_gizmo", mw, self.ICON_CANCEL_X, y_pos, icon_z, billboard_rot)
        self.set_icon_gizmo_position(
            "cycle_gizmo", mw, self.ICON_CYCLE_X, y_pos, icon_z, billboard_rot, scale=self.ICON_CYCLE_SCALE
        )
-        self.set_icon_gizmo_position(
-            "tread_lock_gizmo",
+        self.set_icon_gizmo_pair_position(
+            "tread_lock_open_gizmo",
+            "tread_lock_closed_gizmo",
            mw,
-            self.ICON_TREAD_LOCK_X,
+            slot_x["tread_lock"],
            y_pos,
            icon_z - self.EDITING_ICON_SCALE / 2,
            billboard_rot,
            scale=self.EDITING_ICON_SCALE,
        )
        self.set_icon_gizmo_position(
-            "plus_gizmo", mw, self.ICON_PLUS_X, y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
+            "plus_gizmo", mw, slot_x["plus"], y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
        )
        self.set_icon_gizmo_position(
-            "minus_gizmo", mw, self.ICON_MINUS_X, y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
+            "minus_gizmo", mw, slot_x["minus"], y_pos, icon_z, billboard_rot, scale=self.ICON_PLUS_MINUS_SCALE
        )
+        if hasattr(self, "tread_count_label_gizmo"):
+            self.tread_count_label_gizmo.set_count(int(props.number_of_treads))
+            self.set_icon_gizmo_position(
+                "tread_count_label_gizmo",
+                mw,
+                slot_x["tread_count_label"],
+                y_pos,
+                icon_z,
+                billboard_rot,
+                scale=self.ICON_COUNT_LABEL_SCALE,
+            )
@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING, Any
 import bpy
 from bpy.types import Panel

+import ifcopenshell.util.unit
 import bonsai.bim
 import bonsai.tool as tool
 from bonsai.bim.helper import prop_with_search
@@ -237,11 +238,11 @@ class BIM_PT_array(bpy.types.Panel):

            for i, array in enumerate(ArrayData.data["parameters"]["data_dict"]):
                box = self.layout.box()
-                if props.is_editing == i:
+                if props.editing_item_index == i:
                    row = box.row(align=True)
                    row.prop(props, "count", icon="MOD_ARRAY")
-                    row.operator("bim.edit_array", icon="CHECKMARK", text="").item = i
-                    row.operator("bim.disable_editing_array", icon="CANCEL", text="")
+                    row.operator("bim.finish_editing_array", icon="CHECKMARK", text="")
+                    row.operator("bim.cancel_editing_array", icon="CANCEL", text="")
                    row = box.row(align=True)
                    row.prop(props, "method")
                    row = box.row(align=True)
@@ -303,6 +304,8 @@ class BIM_PT_stair(bpy.types.Panel):
            row = self.layout.row(align=True)
            row.label(text="Stair parameters", icon="IPO_CONSTANT")

+            si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+
            if props.is_editing:
                calculated_params = tool.Model.get_active_stair_calculated_params()
                row = self.layout.row(align=True)
@@ -322,22 +325,61 @@ class BIM_PT_stair(bpy.types.Panel):
                        row.label(text=f"{prop_name}:")
                        row = self.layout.row(align=True)
                        for prop_value_item in prop_value:
-                            row.label(text=str(prop_value_item))
+                            if isinstance(prop_value_item, float):
+                                row.label(text=tool.Unit.format_distance(prop_value_item * si_conversion))
+                            else:
+                                row.label(text=str(prop_value_item))
                    else:
                        row.label(text=prop_name)
-                        row.label(text=str(prop_value))
+                        if isinstance(prop_value, float):
+                            row.label(text=tool.Unit.format_distance(prop_value * si_conversion))
+                        else:
+                            row.label(text=str(prop_value))

            # calculated properties
            for prop_name, prop_value in calculated_params.items():
                row = self.layout.row(align=True)
                row.label(text=prop_name)
-                row.label(text=str(prop_value))
+                if isinstance(prop_value, float):
+                    row.label(text=tool.Unit.format_distance(prop_value * si_conversion))
+                else:
+                    row.label(text=str(prop_value))
        else:
            row = self.layout.row()
            row.label(text="No Stair Found")
            row.operator("bim.add_stair", icon="ADD", text="")


+class BIM_PT_wall(bpy.types.Panel):
+    bl_label = "Wall"
+    bl_idname = "BIM_PT_wall"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "scene"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_parent_id = "BIM_PT_tab_parametric_geometry"
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        if not obj:
+            return False
+        element = tool.Ifc.get_entity(obj)
+        return bool(element) and tool.Parametric.is_wall(element)
+
+    def draw(self, context):
+        obj = context.active_object
+        if obj is None:
+            return
+        props = tool.Model.get_wall_props(obj)
+        row = self.layout.row(align=True)
+        if props.is_editing:
+            row.operator("bim.finish_editing_wall", icon="CHECKMARK", text="Finish Editing")
+            row.operator("bim.cancel_editing_wall", icon="CANCEL", text="")
+        else:
+            row.operator("bim.enable_editing_wall", icon="GREASEPENCIL", text="Edit Wall")
+
+
 class BIM_PT_sverchok(bpy.types.Panel):
    bl_label = "Sverchok"
    bl_idname = "BIM_PT_sverchok"
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .8.5
 .8.6