Fix parametric dimension dot clicks broken by bim.cross_select BLOCKING modal

Blender fires all matching tool-keymap entries' invoke() even after an earlier entry returned RUNNING_MODAL. When cross-select is enabled, bim.cross_select (bl_options BLOCKING) goes modal on every LMB press alongside bim.click_nearest_dimension_anchor. Its BLOCKING flag causes it to win the RELEASE event, selecting the background object instead of activating the anchor dot. Fix: CrossSelect.invoke() now calls _near_dimension_dot() before going modal. If a parametric dimension anchor dot is within 15 px of the cursor it returns PASS_THROUGH, yielding to ClickNearestDimensionAnchor. Also fixes apply_cross_select_preference to preserve pre-selection entries (e.g. ClickNearestDimensionAnchor) when rebuilding tool keymaps: replaces _tool_extra_keymap (which assumed the selection block starts at index 0) with _split_tool_keymap, which searches for the selection block by operator name and returns (pre, post) slices independently. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Add CAD-style cross selection as the default for Bonsai tools
2026-08-06 16:01:36 +00:00 · 2026-06-14 18:53:51 -05:00 · 2026-06-07 17:33:34 -05:00 · 2026-05-31 07:41:03 -05:00 · 2026-05-31 07:25:58 -05:00 · 2026-05-30 21:53:13 -05:00
327 changed files with 30635 additions and 2631 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.21
+        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.21
+        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.21
+        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.21
+        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.21
+        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
@@ -24,7 +24,7 @@ jobs:
    if: |
      github.repository == 'IfcOpenShell/IfcOpenShell'
    steps:
-      - uses: mamba-org/setup-micromamba@v2 # https://github.com/mamba-org/setup-micromamba
+      - uses: mamba-org/setup-micromamba@v3 # https://github.com/mamba-org/setup-micromamba
        with:
          environment-name: test-env
          create-args: >-
@@ -84,7 +84,7 @@ jobs:
        run: |
          curl -L https://github.com/phracker/MacOSX-SDKs/releases/download/11.3/MacOSX10.13.sdk.tar.xz | tar -xvJf - -C /Users/runner/work/

-      - uses: mamba-org/setup-micromamba@v2 # https://github.com/mamba-org/setup-micromamba
+      - uses: mamba-org/setup-micromamba@v3 # https://github.com/mamba-org/setup-micromamba
        with:
          environment-name: test-env
          create-args: >-
@@ -35,7 +35,7 @@ jobs:

    -
      name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.21
+      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
@@ -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.21
+        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@v5
-      - 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@v4
+          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
@@ -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.7",
+    "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
@@ -239,10 +241,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 +262,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

@@ -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,19 @@ 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
+
+
+def _parametric_gizmo_preference_classes() -> list[type]:
+    """Resolves the registry-driven ``GizmoPreferences<X>`` classes for the
+    ``classes`` list below. ``import bonsai.tool`` is kept local to surface
+    the load-order constraint: it relies on ``from . import handler, …``
+    above having primed the
+    ``tool/ifc.py → bim/ifc.py → bim/handler.py → bonsai.tool`` cycle."""
+    import bonsai.tool as tool
+
+    return tool.Parametric.iter_gizmo_preference_classes(ui)
+

 try:
    from bonsai.translations import translations_dict
@@ -157,10 +171,12 @@ 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
+    # Per-parametric-type ``GizmoPreferences<Name>`` classes — must register
+    # before ``ui.GizmoPreferences`` which holds the matching PointerProperty
+    # fields. Driven by ``tool.Parametric.EDIT_TYPES``.
+    *_parametric_gizmo_preference_classes(),
    ui.GizmoPreferences,
+    ui.CrossSelectPreferences,
    # ui.DefaultParameters and ui.BIM_ADDON_preferences are registered separately after modules (see late_classes below)
    # Tabs panel
    ui.BIM_PT_tabs,
@@ -268,6 +284,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)
@@ -316,6 +334,10 @@ def register():
    tool.Blender.ensure_bin_in_path()
    # RestrictedContext doesn't allow accessing scene attribute, postpone it for a bit.
    bpy.app.timers.register(tool.Blender.setup_user_data_dir, first_interval=0.1)
+    # Tools are imported (and their bl_keymap baked) before preferences exist, so they
+    # default to the Cross Select keymap. Once prefs are available, apply the saved
+    # preference (no-op unless the user disabled Cross Select).
+    bpy.app.timers.register(tool.Blender.apply_cross_select_preference, first_interval=0.1)


 def unregister():
@@ -325,6 +347,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,8 +32,13 @@ 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.data import AuthoringData
@@ -41,6 +47,7 @@ from bonsai.bim.module.model.decorator import (
    SlabDirectionDecorator,
    WallAxisDecorator,
 )
+from bonsai.bim.module.model.preview_base import discard_pending_previews
 from bonsai.bim.module.nest.decorator import NestDecorator

 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -133,14 +140,32 @@ 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()

-            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
@@ -165,7 +190,9 @@ def update_bim_tool_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 +383,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, draft-flag healing, multi-instance lock probe,
+    and previews discarded so saved preview state never resurfaces on reopen."""
    global global_subscription_owner
    active_object_key = bpy.types.LayerObjects, "active"
    bpy.msgbus.subscribe_rna(
@@ -368,6 +397,24 @@ def load_post(scene):
    ifcopenshell.api.owner.settings.get_application = get_application
    AuthoringData.type_thumbnails = {}

+    tool.Parametric.heal_stale_edit_flags()
+    discard_pending_previews(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 +438,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 +462,26 @@ 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)
+    uninstall_decorator_cache_handlers()
+    try:
+        if georeference_props.should_visualise:
+            GeoreferenceDecorator.install(bpy.context)
+        if aggregate_props.aggregate_decorator:
+            AggregateDecorator.install(bpy.context)
+        if nest_props.nest_decorator:
+            NestDecorator.install(bpy.context)
+        if model_props.show_wall_axis:
+            WallAxisDecorator.install(bpy.context)
+        if model_props.show_slab_direction:
+            SlabDirectionDecorator.install(bpy.context)
+        if model_props.show_bounding_box:
+            BoundingBoxDecorator.install(bpy.context)
+    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()

                if method == "MODAL":
                    cls.modal_in_progress = False
@@ -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

@@ -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)
@@ -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),
    )
@@ -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

@@ -143,6 +145,14 @@ classes = (
    gizmos.GizmoCancel,
    gizmos.GizmoPlus,
    gizmos.GizmoMinus,
+    gizmos.GizmoMerge,
+    gizmos.GizmoSplit,
+    gizmos.GizmoExtend,
+    gizmos.GizmoExtendVertical,
+    gizmos.GizmoOffsetExterior,
+    gizmos.GizmoOffsetCenter,
+    gizmos.GizmoOffsetInterior,
+    gizmos.GizmoAddOpening,
    gizmos.GizmoCycle,
    # Drawing-specific gizmos
    gizmos.UglyDotGizmo,
@@ -16,6 +16,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was modified with the assistance of an AI coding tool.

 """
 Gizmo infrastructure for parametric BIM element editing.
@@ -511,6 +513,7 @@ class DimensionTextRenderer:
        color: tuple[float, float, float],
        offset_sign: int = 1,
        alignment: TextAlignment | str = TextAlignment.CENTER,
+        display_text: str | None = None,
    ) -> None:
        """Draw formatted dimension value text at the given screen position.

@@ -522,15 +525,20 @@ class DimensionTextRenderer:
            color: Text color (r, g, b)
            offset_sign: 1 for above/right, -1 for below/left
            alignment: TextAlignment enum value
+            display_text: Pre-formatted label. If provided, used verbatim instead of
+                formatting `value`.
        """
        # Normalize string to enum for comparison
        if isinstance(alignment, str):
            alignment = TextAlignment(alignment)

-        is_negative = value < 0
-        text = tool.Unit.format_distance(abs(value))
-        if is_negative:
-            text = "-" + text
+        if display_text is not None:
+            text = display_text
+        else:
+            is_negative = value < 0
+            text = tool.Unit.format_distance(abs(value))
+            if is_negative:
+                text = "-" + text

        font_id = 0
        font_size = tool.Blender.scale_font_size(self.VALUE_FONT_SIZE)
@@ -795,6 +803,7 @@ class DimensionRenderer:
        text_alignment: TextAlignment = TextAlignment.CENTER,
        prop_name: str | None = None,
        display_value: float | None = None,
+        display_text: str | None = None,
    ) -> None:
        """Draw complete dimension graphics in screen space.

@@ -816,6 +825,8 @@ class DimensionRenderer:
            text_alignment: TextAlignment enum for text positioning
            prop_name: Property name for tooltip (shown when highlighted)
            display_value: Value to display as text (can be negative); uses dimension_length if None
+            display_text: Pre-formatted label string. If provided, used verbatim instead of
+                formatting `display_value` via tool.Unit.format_distance.
        """
        if dimension_length < 0:
            return
@@ -935,7 +946,14 @@ class DimensionRenderer:
                )
                text_color = highlight_color if is_highlight else color
                DimensionTextRenderer.get_instance().draw_value_text(
-                    context, center_screen, perpendicular, text_value, text_color, text_offset_sign, text_alignment
+                    context,
+                    center_screen,
+                    perpendicular,
+                    text_value,
+                    text_color,
+                    text_offset_sign,
+                    text_alignment,
+                    display_text,
                )

            if is_highlight and prop_name:
@@ -1121,6 +1139,13 @@ class DimensionGizmoConfig:
            If provided, eliminates need for get_dimension_matrix_{attr_name} method.
            The returned Vector is the local-space position where the gizmo origin
            will be placed. Combined with axis to create the full transformation matrix.
+        text_formatter: Optional function(props, value) -> str for the dimension label.
+            Receives the props bag and the post-`compute_value` display value
+            (i.e. the same number `apply_value` consumes during drag — for the
+            wall slope gizmo this is the displacement, NOT the underlying
+            `x_angle`). The raw underlying attribute is accessible as
+            `getattr(props, attr_name)`. If None, falls back to the default
+            `tool.Unit.format_distance(abs(value))` with negative-sign handling.
    """

    attr_name: str
@@ -1138,6 +1163,7 @@ class DimensionGizmoConfig:
    apply_value: Callable[[Any, float], None] | None = None
    visibility_condition: Callable[[Any], bool] | None = None
    matrix_position: Callable[[Any], "Vector"] | None = None  # Optional: function(props) -> Vector position
+    text_formatter: Callable[[Any, float], str] | None = None  # Optional: function(props, value) -> label text

    def __post_init__(self):
        # Validate attr_name
@@ -1576,6 +1602,78 @@ def get_billboard_rotation(context: bpy.types.Context) -> Matrix:
    return rv3d.view_matrix.to_3x3().transposed().to_4x4()


+def billboarded_at(world_pos: Vector, billboard_rot: Matrix, scale: float = 0.5) -> Matrix:
+    """Compose the standard icon ``matrix_basis``: translate to ``world_pos``, billboard
+    to the camera, then uniformly scale. Replaces the repeated
+    ``Matrix.Translation(...) @ billboard_rot @ Matrix.Scale(scale, 4)`` pattern."""
+    return Matrix.Translation(world_pos) @ billboard_rot @ Matrix.Scale(scale, 4)
+
+
+def setup_icon_gizmo(
+    gizmo_group: bpy.types.GizmoGroup,
+    gizmo_type: str,
+    color: tuple[float, float, float],
+    highlight_color: tuple[float, float, float],
+    operator: str,
+    alpha: float = 0.8,
+) -> bpy.types.Gizmo:
+    """Create and configure a stand-alone icon gizmo with the Bonsai defaults
+    (no draw-scale, fixed alpha, click-to-operator). Use this from any
+    ``GizmoGroup.setup`` to avoid hand-rolling the same five property assignments."""
+    gizmo = gizmo_group.gizmos.new(gizmo_type)
+    gizmo.use_draw_scale = False
+    gizmo.color = color
+    gizmo.color_highlight = highlight_color
+    gizmo.alpha = alpha
+    gizmo.target_set_operator(operator)
+    return gizmo
+
+
+# --- Tris geometry helpers ----------------------------------------------------
+# Shared by the icon ``bpy.types.Gizmo`` subclasses defined later in this module.
+# Each gizmo declares a flat ``tris`` tuple of (x, y, z) vertices grouped into
+# triangles of 3; these helpers compose tris from primitives so the per-gizmo
+# definitions stay small and visually readable.
+
+
+def rect_tris(x0: float, y0: float, x1: float, y1: float) -> tuple[tuple[float, float, float], ...]:
+    """Two triangles forming an axis-aligned rectangle from ``(x0, y0)`` to ``(x1, y1)``,
+    in the Z=0 plane (the convention for icon gizmos)."""
+    return (
+        (x0, y0, 0.0),
+        (x0, y1, 0.0),
+        (x1, y1, 0.0),
+        (x0, y0, 0.0),
+        (x1, y1, 0.0),
+        (x1, y0, 0.0),
+    )
+
+
+def swap_xy_tris(
+    tris: tuple[tuple[float, float, float], ...],
+) -> tuple[tuple[float, float, float], ...]:
+    """Reflect a ``tris`` tuple across the Y=X diagonal — useful when a "vertical"
+    sibling of a "horizontal" icon should otherwise be a literal copy."""
+    return tuple((y, x, z) for x, y, z in tris)
+
+
+class TrisGizmoMixin:
+    """Mixin for stand-alone ``bpy.types.Gizmo`` classes whose only behaviour is
+    drawing a static ``tris`` triangle tuple. Subclasses set the class-level
+    ``tris`` and ``bl_idname`` attributes; the mixin supplies ``setup`` / ``draw`` /
+    ``draw_select``. Use only with gizmos that have no per-instance state beyond
+    ``custom_shape``."""
+
+    def setup(self) -> None:
+        self.custom_shape = self.new_custom_shape("TRIS", self.tris)
+
+    def draw(self, context: bpy.types.Context) -> None:
+        self.draw_custom_shape(self.custom_shape)
+
+    def draw_select(self, context: bpy.types.Context, select_id: int) -> None:
+        self.draw_custom_shape(self.custom_shape, select_id=select_id)
+
+
 def get_camera_direction(context: bpy.types.Context, position: Vector) -> Vector | None:
    """Get normalized direction from position towards camera."""
    rv3d = context.region_data
@@ -3042,6 +3140,145 @@ class GizmoMinus(bpy.types.Gizmo):
        self.draw_custom_shape(self.custom_shape, select_id=select_id)


+class GizmoMerge(TrisGizmoMixin, bpy.types.Gizmo):
+    """Two arrows pointing inward toward each other — conveys joining/merging elements."""
+
+    bl_idname = "VIEW3D_GT_merge"
+
+    __slots__ = ("custom_shape",)
+
+    # Two solid triangles pointing toward the center on the horizontal axis,
+    # plus two thin tails behind each tip to make them read as arrows rather than
+    # standalone triangles.
+    tris = (
+        # Left arrowhead pointing right (tip at x≈-0.05).
+        (-0.35, -0.20, 0.0),
+        (-0.35, 0.20, 0.0),
+        (-0.05, 0.0, 0.0),
+        # Left tail behind the arrowhead.
+        *rect_tris(-0.45, -0.06, -0.30, 0.06),
+        # Right arrowhead pointing left (tip at x≈0.05).
+        (0.35, -0.20, 0.0),
+        (0.35, 0.20, 0.0),
+        (0.05, 0.0, 0.0),
+        # Right tail behind the arrowhead.
+        *rect_tris(0.30, -0.06, 0.45, 0.06),
+    )
+
+
+class GizmoSplit(TrisGizmoMixin, bpy.types.Gizmo):
+    """Two arrows pointing outward away from each other — conveys splitting/cutting
+    one element into two. Visual inverse of `GizmoMerge`."""
+
+    bl_idname = "VIEW3D_GT_split"
+
+    __slots__ = ("custom_shape",)
+
+    # Two solid triangles pointing OUTWARD on the horizontal axis (tips at x=±0.35),
+    # with tails extending toward the centerline. The tails meet at center to form a
+    # short horizontal bar, suggesting the split point itself.
+    tris = (
+        # Left arrowhead pointing left (tip at x=-0.35).
+        (-0.05, -0.20, 0.0),
+        (-0.05, 0.20, 0.0),
+        (-0.35, 0.0, 0.0),
+        # Left tail extending toward the right (away from the tip, toward center).
+        *rect_tris(-0.05, -0.06, 0.10, 0.06),
+        # Right arrowhead pointing right (tip at x=0.35).
+        (0.05, -0.20, 0.0),
+        (0.05, 0.20, 0.0),
+        (0.35, 0.0, 0.0),
+        # Right tail extending toward the left.
+        *rect_tris(-0.10, -0.06, 0.05, 0.06),
+    )
+
+
+class GizmoExtend(TrisGizmoMixin, bpy.types.Gizmo):
+    """An arrow pointing into a vertical bar — conveys extending an element to a target
+    line (e.g. extending a wall to the 3D cursor)."""
+
+    bl_idname = "VIEW3D_GT_extend"
+
+    __slots__ = ("custom_shape",)
+
+    # Layout: thick vertical bar at the right edge (the "target") with a horizontal
+    # arrow pointing into it from the left.
+    tris = (
+        # Vertical target bar (x = 0.25 to 0.35, full height).
+        *rect_tris(0.25, -0.30, 0.35, 0.30),
+        # Arrowhead pointing right toward the bar (tip at x=0.20).
+        (-0.05, -0.18, 0.0),
+        (-0.05, 0.18, 0.0),
+        (0.20, 0.0, 0.0),
+        # Tail extending leftward from the arrowhead base.
+        *rect_tris(-0.35, -0.06, -0.05, 0.06),
+    )
+
+
+class GizmoExtendVertical(TrisGizmoMixin, bpy.types.Gizmo):
+    """Vertical sibling of `GizmoExtend` — arrow pointing UP into a horizontal
+    bar. Conveys extending an element's height to a target Z."""
+
+    bl_idname = "VIEW3D_GT_extend_vertical"
+
+    __slots__ = ("custom_shape",)
+
+    # Mechanically derived from GizmoExtend by reflecting across Y=X.
+    tris = swap_xy_tris(GizmoExtend.tris)
+
+
+def _offset_baseline_tris(mark_x: float) -> tuple[tuple[float, float, float], ...]:
+    """Shared geometry for the three offset-baseline icons: a horizontal "wall
+    section" bar with a vertical mark at ``mark_x`` indicating where the reference
+    axis sits within the wall thickness. Matches the visual convention used in the
+    Bonsai N-panel's wall Align row."""
+    return rect_tris(-0.25, -0.07, 0.25, 0.07) + rect_tris(mark_x - 0.04, -0.22, mark_x + 0.04, 0.22)
+
+
+class GizmoOffsetExterior(TrisGizmoMixin, bpy.types.Gizmo):
+    """Wall offset baseline indicator — reference axis at the exterior face (left mark)."""
+
+    bl_idname = "VIEW3D_GT_offset_exterior"
+    __slots__ = ("custom_shape",)
+    tris = _offset_baseline_tris(-0.24)
+
+
+class GizmoOffsetCenter(TrisGizmoMixin, bpy.types.Gizmo):
+    """Wall offset baseline indicator — reference axis at the centreline (middle mark)."""
+
+    bl_idname = "VIEW3D_GT_offset_center"
+    __slots__ = ("custom_shape",)
+    tris = _offset_baseline_tris(0.0)
+
+
+class GizmoOffsetInterior(TrisGizmoMixin, bpy.types.Gizmo):
+    """Wall offset baseline indicator — reference axis at the interior face (right mark)."""
+
+    bl_idname = "VIEW3D_GT_offset_interior"
+    __slots__ = ("custom_shape",)
+    tris = _offset_baseline_tris(0.24)
+
+
+class GizmoAddOpening(TrisGizmoMixin, bpy.types.Gizmo):
+    """A rectangular frame (square outline with a hole in the middle) — conveys adding an
+    opening (window/door/void) to a wall."""
+
+    bl_idname = "VIEW3D_GT_add_opening"
+
+    __slots__ = ("custom_shape",)
+
+    # Outer 0.40 × 0.40 square with a 0.25 × 0.25 inner hole, drawn as four bars
+    # forming a frame, plus a small "+" in the inner hole to convey "add".
+    tris = (
+        *rect_tris(-0.20, 0.125, 0.20, 0.20),  # Top bar
+        *rect_tris(-0.20, -0.20, 0.20, -0.125),  # Bottom bar
+        *rect_tris(-0.20, -0.125, -0.125, 0.125),  # Left bar
+        *rect_tris(0.125, -0.125, 0.20, 0.125),  # Right bar
+        *rect_tris(-0.07, -0.015, 0.07, 0.015),  # "+" horizontal stroke
+        *rect_tris(-0.015, -0.07, 0.015, 0.07),  # "+" vertical stroke
+    )
+
+
 def _generate_circular_arrow_tris() -> tuple[tuple[float, float, float], ...]:
    """Generate circular arrow geometry covering ~300 degrees."""
    triangles = []
@@ -3421,6 +3658,7 @@ class GizmoDimension(GizmoMovable):
        "_original_value",  # Original property value before interaction
        "_click_offset",  # Offset from dimension tip to click position (for snap correction)
        "show_extension_lines",  # Whether to show extension lines at dimension endpoints
+        "text_formatter",  # Optional (props, value) -> str to override the default dimension label
    )

    ARROW_SIZE = 10
@@ -3479,6 +3717,16 @@ class GizmoDimension(GizmoMovable):
        start_world = self.matrix_basis.translation.copy()
        end_world = start_world + axis_world * self._dimension_length

+        display_value = getattr(self, "_display_value", self._dimension_length)
+        text_formatter = getattr(self, "text_formatter", None)
+        gizmo_group = getattr(self, "gizmo_group", None)
+        display_text: str | None = None
+        if text_formatter is not None and gizmo_group is not None:
+            obj = bpy.context.active_object
+            props = gizmo_group.get_props(obj) if obj is not None else None
+            if props is not None:
+                display_text = text_formatter(props, display_value)
+
        DimensionRenderer.get_instance().draw(
            context=context,
            start_world=start_world,
@@ -3496,7 +3744,8 @@ class GizmoDimension(GizmoMovable):
            text_offset_sign=getattr(self, "text_offset_sign", 1),
            text_alignment=getattr(self, "text_alignment", TextAlignment.CENTER),
            prop_name=getattr(self, "prop_name", None),
-            display_value=getattr(self, "_display_value", self._dimension_length),
+            display_value=display_value,
+            display_text=display_text,
        )

    def _calculate_screen_endpoints(self, context: bpy.types.Context) -> tuple[Vector, Vector, Vector, float] | None:
@@ -3615,6 +3864,11 @@ class GizmoDimension(GizmoMovable):
        self._display_value = max(-10000.0, min(length, 10000.0))
        # Clamp to valid range (0 to 10000 meters is reasonable for BIM) for drawing
        self._dimension_length = max(0.0, min(abs(length), 10000.0))
+        # Smaller dimensions win selection when hit regions overlap: a long gizmo's
+        # hit box fully contains a nested short one's, so without a bias the long
+        # one wins and the short one is unreachable. The long one stays clickable
+        # at its exposed ends regardless of bias.
+        self.select_bias = -self._dimension_length

    def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set:
        """Initialize dimension gizmo interaction with click-position tracking.
@@ -3913,6 +4167,59 @@ class CycleTypeMixin:
        return {"FINISHED"}


+class BillboardingGizmoGroupMixin:
+    """Mixin for standalone ``bpy.types.GizmoGroup`` classes whose icons must billboard
+    (face the camera) and re-position every frame.
+
+    Blender calls ``GizmoGroup.refresh()`` only on state-change events (selection,
+    property change, dependency update) — not on camera rotation. A gizmo group that
+    only sets ``matrix_basis`` in ``refresh()`` will appear to "freeze" its rotation
+    at the camera angle in effect when it was last refreshed; orbiting the camera
+    leaves the icon facing the wrong way.
+
+    ``draw_prepare()`` *is* called every redraw, so the fix is to run the same
+    positioning code from both events. Rather than overriding ``refresh()`` and
+    ``draw_prepare()`` in every gizmo group that has this need, subclass this mixin
+    and implement a single ``position_gizmos(context)`` method.
+
+    Usage::
+
+        class MyGizmoGroup(bpy.types.GizmoGroup, BillboardingGizmoGroupMixin):
+            bl_idname = "..."
+            ...
+            def setup(self, context):
+                ...
+            def position_gizmos(self, context):
+                # set matrix_basis on every gizmo here, using get_billboard_rotation
+                # for any icon that should face the camera.
+                ...
+
+    ``position_gizmos`` should be idempotent — it's called twice when a state change
+    coincides with a redraw (once via ``refresh``, once via ``draw_prepare``)."""
+
+    def refresh(self, context: bpy.types.Context) -> None:
+        self.position_gizmos(context)
+
+    def draw_prepare(self, context: bpy.types.Context) -> None:
+        self.position_gizmos(context)
+
+    def setup_icon_gizmo(
+        self,
+        gizmo_type: str,
+        color: tuple[float, float, float],
+        highlight_color: tuple[float, float, float],
+        operator: str,
+        alpha: float = 0.8,
+    ) -> bpy.types.Gizmo:
+        """Convenience wrapper over `setup_icon_gizmo` for subclasses."""
+        return setup_icon_gizmo(self, gizmo_type, color, highlight_color, operator, alpha)
+
+    def position_gizmos(self, context: bpy.types.Context) -> None:
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement position_gizmos(context) when using BillboardingGizmoGroupMixin."
+        )
+
+
 class BaseParametricGizmoGroup:
    """Base mixin for parametric element gizmo groups (doors, windows, stairs, etc.).

@@ -4129,6 +4436,32 @@ class BaseParametricGizmoGroup:
            return width + (self.GIZMO_OFFSET if use_offset else 0)
        return -self.GIZMO_OFFSET if use_offset else 0

+    @staticmethod
+    def get_camera_facing_outer_y(
+        viewing_from_negative_y: bool,
+        near_y: float,
+        far_y: float,
+        gizmo_offset: float = 0.0,
+    ) -> float:
+        """Y coordinate just outside the camera-facing face of an element.
+
+        Generalises `get_y_position_for_view` for elements whose near face
+        isn't at the local origin. ``near_y`` is the local-Y of the -Y face;
+        ``far_y`` is the local-Y of the +Y face. Returns the Y just *outside* the
+        face the camera is currently looking at, pushed by ``gizmo_offset`` (use
+        ``cls.GIZMO_OFFSET`` for the standard handle gap).
+
+        Suits walls (``near_y = props.offset``, ``far_y = props.offset + props.thickness``)
+        and any other element whose section sits inside a non-zero Y band. Stair /
+        door / window can also call this once their callers pass explicit near/far
+        instead of the implicit ``width_attr`` pattern, eliminating
+        ``get_y_position_for_view``, ``get_lining_y_position_for_view`` etc. as
+        wrappers around the same shape — but they're left intact for now to avoid
+        churning code paths that already work."""
+        if viewing_from_negative_y:
+            return near_y - gizmo_offset
+        return far_y + gizmo_offset
+
    def get_icon_y_for_view(self, props, viewing_from_negative_y: bool) -> float:
        """Get Y position for editing icons based on view direction.

@@ -4224,13 +4557,13 @@ class BaseParametricGizmoGroup:
        """
        return 0.0

-    def _update_view_dependent_dimensions(self, context: bpy.types.Context, mw: Matrix, props) -> None:
+    def _update_view_dependent_dimensions(self, context: bpy.types.Context, mw: Matrix, props) -> None:  # noqa: ARG002
        """Update overall_width, overall_height, and lining_offset based on view direction.

        This base implementation handles the common pattern for door/window gizmos.
        Subclasses can override get_casing_offset() to customize behavior.
        """
-        viewing_from_negative_y, viewing_from_negative_x = self.get_local_view_direction(context, mw)
+        viewing_from_negative_y, viewing_from_negative_x = self._frame_view_dir
        y_pos = self.get_lining_y_position_for_view(props, viewing_from_negative_y)

        self.set_dimension_gizmo_position("overall_width", mw, Vector((0, y_pos, -self.GIZMO_OFFSET)), (1, 0, 0))
@@ -4309,21 +4642,15 @@ class BaseParametricGizmoGroup:

    @classmethod
    def poll(cls, context) -> bool:
-        prefs = tool.Blender.get_addon_preferences()
-        if not prefs.gizmos.draw_gizmos_in_3d_viewport:
-            return False
-
        obj = tool.Blender.get_active_object(is_selected=True)
-        if not obj:
+        if obj is None:
+            return False
+        if not tool.Blender.get_addon_preferences().gizmos.draw_gizmos_in_3d_viewport:
            return False
-
        if len(tool.Blender.get_selected_objects()) != 1:
            return False
-
        element = tool.Ifc.get_entity(obj)
-        if not element or not cls.is_element_type(element):
-            return False
-        return True
+        return bool(element) and cls.is_element_type(element)

    def setup(self, context: bpy.types.Context) -> None:
        """Template method for gizmo setup.
@@ -4343,6 +4670,19 @@ class BaseParametricGizmoGroup:
        """
        pass

+    # Frame-scoped caches primed at the top of ``refresh()`` and ``draw_prepare()``.
+    # Every per-frame helper — preferences access, view-direction lookup, billboard
+    # rotation — reads these instead of re-deriving the same values, since each
+    # gizmo group ends up needing them 2–5× per frame across its position helpers.
+    _frame_prefs: Any = None
+    _frame_view_dir: tuple[bool, bool] | None = None
+    _frame_billboard_rot: "Matrix | None" = None
+
+    def _prime_frame_caches(self, context: bpy.types.Context, mw: "Matrix") -> None:
+        self._frame_prefs = tool.Blender.get_addon_preferences()
+        self._frame_view_dir = self.get_local_view_direction(context, mw)
+        self._frame_billboard_rot = get_billboard_rotation(context)
+
    def refresh(self, context: bpy.types.Context) -> None:
        """Template method for gizmo refresh.

@@ -4357,6 +4697,7 @@ class BaseParametricGizmoGroup:

        props = self.get_props(obj)
        mw = obj.matrix_world
+        self._prime_frame_caches(context, mw)
        self.update_editing_gizmos(context, mw, props)
        self.update_dimension_gizmos(mw, props)
        self._refresh_element_specific(context, mw, props)
@@ -4364,8 +4705,10 @@ class BaseParametricGizmoGroup:
    def _refresh_element_specific(self, context: bpy.types.Context, mw: "Matrix", props) -> None:  # noqa: ARG002
        """Override for element-specific refresh logic.

-        Called after update_editing_gizmos and update_dimension_gizmos.
-        Examples: door swing gizmos, stair lock/tread/plus/minus gizmos.
+        Called from both refresh() (on state change) and draw_prepare() (per frame),
+        so any override must be idempotent and cheap. Use this to re-position or
+        re-billboard element-specific gizmos (door swing arcs, stair lock/+/- icons,
+        wall cursor icons, etc.).
        """
        pass

@@ -4385,10 +4728,11 @@ class BaseParametricGizmoGroup:
            return getattr(tool.Model, self.props_getter)(obj)
        raise NotImplementedError("Subclass must define props_getter or override get_props()")

-    @staticmethod
-    def get_addon_prefs():
-        """Get addon preferences (cached accessor)."""
-        return tool.Blender.get_addon_preferences()
+    def get_addon_prefs(self):
+        """Return the addon preferences struct. Inside ``refresh`` / ``draw_prepare``
+        the frame cache is hit; outside (e.g. ``setup``) we fall through to a fresh
+        lookup so callers don't have to know which call path they're on."""
+        return self._frame_prefs if self._frame_prefs is not None else tool.Blender.get_addon_preferences()

    def get_decoration_colors(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
        """Get default and highlight colors from preferences.
@@ -4507,8 +4851,8 @@ class BaseParametricGizmoGroup:
            scale: Gizmo scale factor (default 0.5)
        """
        if gz := self.get_gizmo_if_visible(gizmo_name):
-            local_transform = Matrix.Translation(Vector((x, y, z))) @ billboard_rot @ Matrix.Scale(scale, 4)
-            gz.matrix_basis = mw @ local_transform
+            world_pos = mw @ Vector((x, y, z))
+            gz.matrix_basis = billboarded_at(world_pos, billboard_rot, scale)

    def set_dimension_gizmo_position(
        self,
@@ -4594,28 +4938,12 @@ class BaseParametricGizmoGroup:
    ) -> bpy.types.Gizmo:
        """Create and configure an icon gizmo with standard settings.

-        Reduces boilerplate in setup_editing_gizmos.
-
-        Args:
-            gizmo_type: Blender gizmo type identifier (e.g., "VIEW3D_GT_pen")
-            color: RGB color tuple
-            operator: Operator to invoke on click
-            highlight_color: Optional highlight color (defaults to prefs selection color)
-            alpha: Gizmo alpha (default 0.8)
-
-        Returns:
-            Configured gizmo instance.
+        Thin wrapper over `setup_icon_gizmo` that defaults ``highlight_color``
+        to the addon-prefs selection color via ``get_decoration_colors``.
        """
        if highlight_color is None:
            _, highlight_color = self.get_decoration_colors()
-
-        gizmo = self.gizmos.new(gizmo_type)
-        gizmo.use_draw_scale = False
-        gizmo.color = color
-        gizmo.color_highlight = highlight_color
-        gizmo.alpha = alpha
-        gizmo.target_set_operator(operator)
-        return gizmo
+        return setup_icon_gizmo(self, gizmo_type, color, highlight_color, operator, alpha)

    def setup_editing_gizmos(self, context: bpy.types.Context) -> None:
        default_color, highlight_color = self.get_decoration_colors()
@@ -4696,6 +5024,7 @@ class BaseParametricGizmoGroup:
            gizmo.delta_scale = config.delta_scale
            gizmo.prop_name = config.prop_name  # Auto-derived in __post_init__
            gizmo.gizmo_group = self
+            gizmo.text_formatter = config.text_formatter
            gizmo.color = self.get_color_from_name(config.color)
            gizmo.color_highlight = highlight_color
            gizmo.alpha = 1.0
@@ -4723,10 +5052,9 @@ class BaseParametricGizmoGroup:

            gizmo.hide = False

-            # Priority: config.matrix_position > get_dimension_matrix_* method > Identity
+            # Priority: config.matrix_position > get_dimension_matrix_* method > Identity.
            if config.matrix_position:
-                position = config.matrix_position(props)
-                base_matrix = self.compose_gizmo_matrix(position, config.axis)
+                base_matrix = self.compose_gizmo_matrix(config.matrix_position(props), config.axis)
            else:
                matrix_method = getattr(self, f"get_dimension_matrix_{config.attr_name}", None)
                base_matrix = matrix_method(props) if matrix_method else Matrix.Identity(4)
@@ -4758,7 +5086,7 @@ class BaseParametricGizmoGroup:
        """
        return (0.0, 0.0)

-    def get_icon_y_offset(self, context: bpy.types.Context, mw: Matrix) -> float:
+    def get_icon_y_offset(self, context: bpy.types.Context, mw: Matrix) -> float:  # noqa: ARG002
        """Get Y offset for icons based on view direction.

        Uses get_icon_y_extent() to determine how far to offset icons based on
@@ -4774,8 +5102,7 @@ class BaseParametricGizmoGroup:
        props = self.get_props(obj)
        positive_extent, negative_extent = self.get_icon_y_extent(props)

-        viewing_from_negative_y, _ = self.get_local_view_direction(context, mw)
-        if viewing_from_negative_y:
+        if self._frame_view_dir[0]:
            return -negative_extent
        return positive_extent

@@ -4783,34 +5110,40 @@ class BaseParametricGizmoGroup:
        """Update editing icon gizmo positions to billboard toward camera."""
        icon_z = self.get_element_height(props) + self.ICON_Z_OFFSET
        icon_y = self.get_icon_y_offset(context, mw)
-        billboard_rot = get_billboard_rotation(context)
-
-        # This ensures icons face camera regardless of object rotation
-        local_pos_validate = Vector((self.ICON_VALIDATE_X, icon_y, icon_z))
-        world_pos_validate = mw @ local_pos_validate
-
-        icon_matrix_base = Matrix.Translation(world_pos_validate) @ billboard_rot @ Matrix.Scale(0.5, 4)
-
+        billboard_rot = self._frame_billboard_rot
+        # set_icon_gizmo_position no-ops on hidden gizmos (via get_gizmo_if_visible),
+        # so the hide flag must be set first; that gates whether the matrix is written.
        if props.is_editing:
            self.pen_gizmo.hide = True
            self.validate_gizmo.hide = self.is_gizmo_hidden_by_modal(self.validate_gizmo)
-            self.validate_gizmo.matrix_basis = icon_matrix_base
-
+            self.set_icon_gizmo_position(
+                "validate_gizmo", mw=mw, x=self.ICON_VALIDATE_X, y=icon_y, z=icon_z, billboard_rot=billboard_rot
+            )
            self.cancel_gizmo.hide = self.is_gizmo_hidden_by_modal(self.cancel_gizmo)
-            local_pos_cancel = Vector((self.ICON_VALIDATE_X + self.ICON_CANCEL_X, icon_y, icon_z))
-            world_pos_cancel = mw @ local_pos_cancel
-            self.cancel_gizmo.matrix_basis = Matrix.Translation(world_pos_cancel) @ billboard_rot @ Matrix.Scale(0.5, 4)
-
+            self.set_icon_gizmo_position(
+                "cancel_gizmo",
+                mw=mw,
+                x=self.ICON_VALIDATE_X + self.ICON_CANCEL_X,
+                y=icon_y,
+                z=icon_z,
+                billboard_rot=billboard_rot,
+            )
            if self.cycle_type_operator:
                self.cycle_gizmo.hide = self.is_gizmo_hidden_by_modal(self.cycle_gizmo)
-                local_pos_cycle = Vector((self.ICON_VALIDATE_X + self.ICON_CYCLE_X, icon_y, icon_z))
-                world_pos_cycle = mw @ local_pos_cycle
-                self.cycle_gizmo.matrix_basis = (
-                    Matrix.Translation(world_pos_cycle) @ billboard_rot @ Matrix.Scale(0.30, 4)
+                self.set_icon_gizmo_position(
+                    "cycle_gizmo",
+                    mw=mw,
+                    x=self.ICON_VALIDATE_X + self.ICON_CYCLE_X,
+                    y=icon_y,
+                    z=icon_z,
+                    billboard_rot=billboard_rot,
+                    scale=0.30,
                )
        else:
            self.pen_gizmo.hide = self.is_gizmo_hidden_by_modal(self.pen_gizmo)
-            self.pen_gizmo.matrix_basis = icon_matrix_base
+            self.set_icon_gizmo_position(
+                "pen_gizmo", mw=mw, x=self.ICON_VALIDATE_X, y=icon_y, z=icon_z, billboard_rot=billboard_rot
+            )
            self.validate_gizmo.hide = True
            self.cancel_gizmo.hide = True
            if self.cycle_type_operator:
@@ -4819,16 +5152,26 @@ class BaseParametricGizmoGroup:
    def draw_prepare(self, context: bpy.types.Context) -> None:
        """Called before drawing - updates gizmos to face camera.

-        This method updates editing gizmos and dimension gizmos.
-        Subclasses can override _update_dimension_gizmo_positions() to customize
-        dimension gizmo positioning based on view direction.
+        This method updates editing gizmos, dimension gizmos, and element-specific
+        gizmos. Subclasses can override _update_dimension_gizmo_positions() to
+        customize dimension gizmo positioning, and _refresh_element_specific() to
+        re-billboard element-specific gizmos per frame.
        """
        obj = context.active_object
        if not obj:
            return
        props = self.get_props(obj)
        mw = obj.matrix_world
+        self._prime_frame_caches(context, mw)
        self.update_editing_gizmos(context, mw, props)
+        # `update_dimension_gizmos` flips the dimension gizmos' `hide` flag
+        # based on `props.is_editing` + per-config visibility conditions.
+        # `refresh()` already calls it, but `refresh()` only fires on depsgraph
+        # events — a `finish_editing_*` operator that toggles `is_editing` to
+        # False without mutating IFC (e.g. wall no-op commit, cancel) does not
+        # trigger a depsgraph update, so without this call the dimension gizmos
+        # would stay visible until the next user input.
+        self.update_dimension_gizmos(mw, props)

        self._update_dimension_gizmo_positions(context, mw, props)

@@ -4836,6 +5179,8 @@ class BaseParametricGizmoGroup:
        for _, gizmo in self.iter_visible_dimension_gizmos():
            gizmo.draw_prepare(context)

+        self._refresh_element_specific(context, mw, props)
+
    def _update_dimension_gizmo_positions(
        self, context: bpy.types.Context, mw: "Matrix", props  # noqa: ARG002
    ) -> None:
@@ -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.",
    )
@@ -85,7 +85,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 +246,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)"
@@ -801,7 +801,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 +821,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")
@@ -1045,7 +1045,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 +1060,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 +1164,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 +1183,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
        operator: bpy.types.Operator, context: bpy.types.Context, linked: bool = False
    ) -> set["rna_enums.OperatorReturnItems"]:
        # Deep magick from the dawn of time
-        if tool.Ifc.get():
+        if tool.Ifc.get() and tool.Model.has_selected_ifc_objects(include_active=False):
            IfcStore.execute_ifc_operator(operator, context)
            return {"FINISHED"}

@@ -1287,6 +1287,11 @@ 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 +1913,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 +1931,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:
@@ -2264,6 +2269,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 +2357,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 +2366,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)
@@ -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,
@@ -67,21 +71,36 @@ classes = (
    product.MirrorElements,
    product.SetActiveType,
    workspace.Hotkey,
+    workspace.CrossSelect,
    workspace.BIM_MT_add_representation_item,
    wall.AddWallsFromSlab,
    wall.AlignWall,
+    wall.CancelEditingWall,
    wall.ChangeExtrusionDepth,
    wall.ChangeExtrusionXAngle,
    wall.ChangeLayerLength,
+    wall.CycleWallOffset,
    wall.DrawPolylineWall,
+    wall.EnableEditingWall,
+    wall.ExtendWallHeightToCursor,
    wall.ExtendWallsToUnderside,
    wall.ExtendWallsToWall,
    wall.ExtendWallsToPolylinePoint,
+    wall.ExtendWallToCursor,
+    wall.FinishEditingWall,
    wall.FlipWall,
+    wall.GizmoWallAddOpening,
+    wall.GizmoWallEdition,
+    wall.GizmoWallExtendVertically,
+    wall.GizmoWallJoinIntersection,
+    wall.JoinWallsIntersection,
    wall.MergeWall,
    wall.OffsetWalls,
    wall.RecalculateWall,
+    wall.RotateWall90,
    wall.SplitWall,
+    wall.SplitWallAtCursor,
+    wall.ToggleWallOpenings,
    wall.UnjoinWalls,
    opening.AddBoolean,
    opening.CloneOpening,
@@ -140,10 +159,12 @@ classes = (
    prop.BIMDoorProperties,
    prop.BIMRailingProperties,
    prop.BIMRoofProperties,
+    prop.BIMWallProperties,
    prop.BIMPolylineProperties,
    prop.BIMExternalParametricGeometryProperties,
    ui.BIM_PT_array,
    ui.BIM_PT_stair,
+    ui.BIM_PT_wall,
    ui.BIM_PT_sverchok,
    ui.BIM_PT_window,
    ui.BIM_PT_door,
@@ -264,12 +285,10 @@ 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
    )
@@ -281,6 +300,12 @@ def register():


 def unregister():
+    # DecorationsHandler is installed lazily by bim.show_openings; tear it down
+    # (along with its persistent depsgraph / undo / redo / load cache handlers)
+    # before the rest of unregister so those handlers can't fire against
+    # half-unloaded module state.
+    opening.DecorationsHandler.uninstall()
+
    if not bpy.app.background:
        for tool_data in reversed(tools):
            bpy.utils.unregister_tool(tool_data.tool)
@@ -288,12 +313,8 @@ 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

    bpy.app.handlers.load_post.remove(handler.load_post)
@@ -38,6 +38,7 @@ 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.window import create_bm_box, create_bm_window
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin

 if TYPE_CHECKING:
    from bonsai.bim.module.model.prop import BIMDoorProperties
@@ -566,103 +567,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.Blender.Modifier.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):
@@ -939,7 +895,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):

    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()
+        prefs = self.get_addon_prefs()
        door_gizmo_prefs = prefs.gizmos.door

        door_type_visible = self.update_gizmo_visibility(
@@ -41,8 +41,187 @@ 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"]] = {}
+
+
+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(
@@ -941,7 +1120,6 @@ class SelectBoolean(Operator):
        return {"FINISHED"}


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

@@ -951,6 +1129,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 +1138,46 @@ 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, occluded_alpha: float = 0.25, cache_key=None):
+        # One batch, two draws: front pass at full color, occluded pass at
+        # `occluded_alpha`. Save/restore depth_test matches the pattern in
+        # bim/module/structural/decorator.py so callers' state survives.
+        batch = self._get_or_build_batch(self.line_shader, "LINES", verts, edges_indices, cache_key=cache_key)
+        if batch is None:
+            return
+        original_depth_test = gpu.state.depth_test_get()
+        gpu.state.depth_test_set("LESS_EQUAL")
+        self.line_shader.uniform_float("color", color)
+        batch.draw(self.line_shader)
+        gpu.state.depth_test_set("GREATER")
+        dimmed = list(color)
+        dimmed[3] = occluded_alpha
+        self.line_shader.uniform_float("color", dimmed)
+        batch.draw(self.line_shader)
+        gpu.state.depth_test_set(original_depth_test)
+
    def __call__(self, context):
        props = tool.Model.get_model_props()
        if not props.openings:
@@ -1039,23 +1249,20 @@ class DecorationsHandler:
                self.draw_batch("LINES", verts, selected_elements_color, selected_edges)
                self.draw_batch("POINTS", unselected_vertices, unselected_elements_color)
                self.draw_batch("POINTS", selected_vertices, selected_elements_color)
+                obj.data.calc_loop_triangles()
+                tris = [tuple(t.vertices) for t in obj.data.loop_triangles]
+                self.draw_batch("TRIS", verts, transparent_color(special_elements_color), tris)
            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 +1276,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"))
@@ -421,7 +421,7 @@ class PolylineOperator:
                    tool.Polyline.calculate_x_y_and_z(context, self.input_ui, self.tool_state)

                tool.Blender.update_viewport()
-                return {"RUNNING_MODAL"}
+            return {"RUNNING_MODAL"}

    def set_offset(self, context: bpy.types.Context, relating_type: ifcopenshell.entity_instance) -> None:
        props = tool.Model.get_model_props()
@@ -461,6 +461,7 @@ class PolylineOperator:
        self.tool_state.axis_method = None
        self.tool_state.plane_method = None
        self.tool_state.mode = "Mouse"
+        tool.Raycast.clear_snap_objs()
        self.visible_objs = tool.Raycast.get_visible_objects(context)
        for obj in self.visible_objs:
            if bbox_2d := tool.Raycast.get_on_screen_2d_bounding_boxes(context, obj):
@@ -0,0 +1,206 @@
+# 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."""
+    preview = getattr(context.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)
+
+
+# --- 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)
+
+
+# --- 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="-",
    )
@@ -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
@@ -193,6 +195,32 @@ def update_stair(self: "BIMStairProperties", context: bpy.types.Context) -> None
        _get_updater("stair", "regenerate_stair_mesh")(obj)


+def update_wall(self: "BIMWallProperties", context: bpy.types.Context) -> None:
+    """Regenerate wall mesh preview when property changes. Does NOT touch IFC."""
+    obj = context.active_object
+    if obj and self.is_editing:
+        _get_updater("wall", "regenerate_wall_mesh_from_props")(obj)
+
+
+def update_wall_offset_baseline(self: "BIMWallProperties", context: bpy.types.Context) -> None:
+    """Recompute the preview-only ``offset`` when the draft baseline cycles. Does not touch IFC.
+
+    ``offset`` itself has no ``update`` callback on purpose — adding one would make
+    every baseline cycle rebuild the bmesh twice (once via offset's callback, once
+    explicitly below)."""
+    obj = context.active_object
+    if not (obj and self.is_editing):
+        return
+    t = self.thickness
+    if self.desired_offset_baseline == "CENTER":
+        self.offset = -t / 2
+    elif self.desired_offset_baseline == "INTERIOR":
+        self.offset = -t
+    else:  # EXTERIOR
+        self.offset = 0.0
+    _get_updater("wall", "regenerate_wall_mesh_from_props")(obj)
+
+
 def update_railing(self: "BIMRailingProperties", context: bpy.types.Context) -> None:
    """Regenerate railing mesh when property changes."""
    if self.is_editing:
@@ -1631,6 +1659,118 @@ class BIMRoofProperties(PropertyGroup):
            setattr(target_props, prop_name, prop_value)


+class BIMWallProperties(PropertyGroup):
+    """Transient draft state for parametric wall gizmo editing.
+
+    Populated from IFC on `bim.enable_editing_wall`, mutated by gizmo drags during edit
+    (preview only — no IFC writes), and either committed by `bim.finish_editing_wall`
+    or discarded by `bim.cancel_editing_wall`.
+
+    The `snap_*` fields are the values captured on enable; `finish_editing_wall` compares
+    current vs snap to skip unchanged params and guarantee a no-op session leaves the
+    IFC file byte-identical.
+    """
+
+    is_editing: bpy.props.BoolProperty(
+        default=False,
+        description="True while wall parametric edit mode is active.",
+    )
+    mesh_dirty: bpy.props.BoolProperty(
+        default=False,
+        options={"HIDDEN", "SKIP_SAVE"},
+        description=(
+            "True while the visible mesh is the preview box; cleared once the real "
+            "IFC-derived geometry is restored (on commit or cancel)."
+        ),
+    )
+    length: bpy.props.FloatProperty(
+        name="Length",
+        default=1.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_wall,
+        description="Wall length along its reference axis (preview value; committed on finish).",
+    )
+    height: bpy.props.FloatProperty(
+        name="Height",
+        default=3.0,
+        min=0.01,
+        subtype="DISTANCE",
+        update=update_wall,
+        description="Wall vertical height (preview value; committed on finish).",
+    )
+    x_angle: bpy.props.FloatProperty(
+        name="Slope (X Angle)",
+        default=0.0,
+        soft_min=-math.pi / 3,
+        soft_max=math.pi / 3,
+        subtype="ANGLE",
+        update=update_wall,
+        description="Slope angle: tilt of the wall's top face along +Y (preview value; committed on finish).",
+    )
+    thickness: bpy.props.FloatProperty(
+        name="Thickness",
+        default=0.2,
+        min=0.001,
+        subtype="DISTANCE",
+        description="Wall thickness captured from IFC at edit-enable; not gizmo-bound.",
+    )
+    offset: bpy.props.FloatProperty(
+        name="Offset",
+        default=0.0,
+        subtype="DISTANCE",
+        description="Layer-set offset captured from IFC at edit-enable; driven by desired_offset_baseline.",
+    )
+    desired_offset_baseline: bpy.props.EnumProperty(
+        items=[
+            ("EXTERIOR", "Exterior", "Reference axis at the exterior face"),
+            ("CENTER", "Center", "Reference axis at the wall centreline"),
+            ("INTERIOR", "Interior", "Reference axis at the interior face"),
+        ],
+        name="Desired Offset Baseline",
+        default="CENTER",
+        update=update_wall_offset_baseline,
+        description="Which face of the wall the reference axis aligns to (preview value; committed on finish).",
+    )
+    anchor_x: bpy.props.FloatProperty(
+        default=0.0,
+        subtype="DISTANCE",
+        description="Local-X of the wall's axis polyline start, so the preview box lands where the IFC mesh does.",
+    )
+
+    snap_length: bpy.props.FloatProperty(description="Snapshot of length at edit-enable; commit skips no-op writes.")
+    snap_height: bpy.props.FloatProperty(description="Snapshot of height at edit-enable; commit skips no-op writes.")
+    snap_thickness: bpy.props.FloatProperty(
+        description="Snapshot of thickness at edit-enable; commit skips no-op writes."
+    )
+    snap_offset: bpy.props.FloatProperty(description="Snapshot of offset at edit-enable; commit skips no-op writes.")
+    snap_x_angle: bpy.props.FloatProperty(
+        subtype="ANGLE",
+        description="Snapshot of x_angle at edit-enable; commit skips no-op writes.",
+    )
+    snap_offset_baseline: bpy.props.StringProperty(
+        default="",
+        description="Snapshot of desired_offset_baseline at edit-enable; commit skips no-op writes.",
+    )
+
+    if TYPE_CHECKING:
+        is_editing: bool
+        mesh_dirty: bool
+        length: float
+        height: float
+        x_angle: float
+        thickness: float
+        offset: float
+        desired_offset_baseline: Literal["EXTERIOR", "CENTER", "INTERIOR"]
+        anchor_x: float
+        snap_length: float
+        snap_height: float
+        snap_thickness: float
+        snap_offset: float
+        snap_x_angle: float
+        snap_offset_baseline: str
+
+
 class SnapMousePoint(PropertyGroup):
    x: bpy.props.FloatProperty(name="X")
    y: bpy.props.FloatProperty(name="Y")
@@ -1729,20 +1869,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 +1890,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,
@@ -34,6 +34,7 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.model.data import RailingData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
+from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin

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

        representation_data = {
-            "railing_type": props.railing_type,
            "context": body,
            "railing_path": railing_path,
            "use_manual_supports": props.use_manual_supports,
@@ -406,66 +406,65 @@ class CopyRailingParameters(bpy.types.Operator, tool.Ifc.Operator):
        return {"FINISHED"}


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

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

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

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

-
-class CancelEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.cancel_editing_railing"
-    bl_label = "Cancel Editing Railing"
-    bl_options = {"REGISTER"}
-
-    def _execute(self, context):
-        obj = context.active_object
-        assert obj
-        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
-        props = tool.Model.get_railing_props(obj)
-
-        # restore previous settings since editing was canceled
-        props.set_props_kwargs_from_ifc_data(data)
+    @classmethod
+    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
        update_railing_modifier_bmesh(context)

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

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

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

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

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

-        update_bbim_railing_pset(element, railing_data)
-        update_railing_modifier_ifc_data(context)
-        return {"FINISHED"}
+    def _execute(self, context):
+        return self._cancel_targets(context)
+
+
+class FinishEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.finish_editing_railing"
+    bl_label = "Finish Editing Railing"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        return self._finish_targets(context)


 class FlipRailingPathOrder(bpy.types.Operator, tool.Ifc.Operator):
@@ -34,6 +34,7 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.model.data import RoofData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
+from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin

 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRoof.htm
@@ -608,61 +609,59 @@ 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.Blender.Modifier.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"}

-
-class FinishEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.finish_editing_roof"
-    bl_label = "Finish Editing Roof"
-    bl_options = {"REGISTER"}
+class EnableEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_roof"
+    bl_label = "Enable Editing Roof"
+    bl_options = {"REGISTER", "UNDO"}

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

-        pset_data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")
-        path_data = pset_data["data_dict"]["path_data"]

-        roof_data = props.get_general_kwargs(convert_to_project_units=True)
-        roof_data["path_data"] = path_data
-        props.is_editing = False
+class CancelEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.cancel_editing_roof"
+    bl_label = "Cancel Editing Roof"
+    bl_options = {"REGISTER", "UNDO"}

-        update_bbim_roof_pset(element, roof_data)
-        update_roof_modifier_ifc_data(context)
-        return {"FINISHED"}
+    def _execute(self, context):
+        return self._cancel_targets(context)
+
+
+class FinishEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.finish_editing_roof"
+    bl_label = "Finish Editing Roof"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        return self._finish_targets(context)


 class EnableEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):
@@ -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

@@ -262,7 +264,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 +273,7 @@ class FinishEditingStair(bpy.types.Operator, tool.Ifc.Operator):

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


@@ -608,29 +610,23 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
            "VIEW3D_GT_minus", self.COLOR_RED, "bim.adjust_stair_treads", increment=-1
        )

-    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."""
+    def update_lock_gizmo(self, props: "BIMStairProperties") -> None:
+        """Update lock gizmo color and visibility. Positioning is handled
+        per-frame by the dimension-positioning hook."""
        gizmo_prefs = self.get_gizmo_prefs()
        if not self.update_gizmo_visibility(self.lock_gizmo, props.is_editing, gizmo_prefs.lock):
-            return  # Hidden, skip positioning
-
+            return  # Hidden, skip color update
        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_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"):
@@ -650,11 +646,11 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
        )

    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()

@@ -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
@@ -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.Blender.Modifier.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"
@@ -39,6 +39,7 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
+from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin

 if TYPE_CHECKING:
    from bonsai.bim.module.model.prop import BIMWindowProperties
@@ -482,90 +483,53 @@ class AddWindow(bpy.types.Operator, tool.Ifc.Operator):
        return {"FINISHED"}


-class CancelEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
+class _WindowEditMixin(FeatureModifierEditMixin):
+    """Type-specific hooks for window parametric-edit operators. Single-object
+    by design (window edits target the active object only)."""
+
+    pset_name = "BBIM_Window"
+
+    @classmethod
+    def _is_element_type(cls, element):
+        return tool.Blender.Modifier.is_window(element)
+
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        return tool.Model.get_window_props(obj)
+
+    @classmethod
+    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        update_window_modifier_representation(context)
+
+
+class CancelEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.cancel_editing_window"
    bl_label = "Cancel Editing Window"
    bl_description = "Cancel editing and revert window parameters to their previous values"
-    bl_options = {"REGISTER"}
+    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context: bpy.types.Context) -> set[str]:
-        obj = context.active_object
-        assert obj
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "Data"))
-        data.update(data.pop("lining_properties"))
-        data.update(data.pop("panel_properties"))
-        props = tool.Model.get_window_props(obj)
-        props.set_props_kwargs_from_ifc_data(data)
-
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        bonsai.core.geometry.switch_representation(
-            tool.Ifc,
-            tool.Geometry,
-            obj=obj,
-            representation=body,
-        )
-
-        props.is_editing = False
-        return {"FINISHED"}
+        return self._cancel_targets(context)


-class FinishEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.finish_editing_window"
    bl_label = "Finish Editing Window"
    bl_description = "Apply changes and finish editing window parameters"
-    bl_options = {"REGISTER"}
+    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context: bpy.types.Context) -> set[str]:
-        obj = context.active_object
-        assert obj
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        props = tool.Model.get_window_props(obj)
-
-        window_data = props.get_general_kwargs(convert_to_project_units=True)
-        lining_props = props.get_lining_kwargs(convert_to_project_units=True)
-        panel_props = props.get_panel_kwargs(convert_to_project_units=True)
-
-        window_data["lining_properties"] = lining_props
-        window_data["panel_properties"] = panel_props
-
-        props.is_editing = False
-
-        update_window_modifier_representation(context)
-        element_type = ifcopenshell.util.element.get_type(element)
-        if element_type:
-            tool.Model.mark_thumbnail_for_update(element_type)
-
-        pset = tool.Pset.get_element_pset(element, "BBIM_Window")
-        window_data = tool.Ifc.get().createIfcText(json.dumps(window_data, default=list))
-        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": window_data})
-        return {"FINISHED"}
+        return self._finish_targets(context)


-class EnableEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.enable_editing_window"
    bl_label = "Enable Editing Window"
    bl_description = "Enter edit mode to modify window parameters interactively"
-    bl_options = {"REGISTER"}
+    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context: bpy.types.Context) -> set[str]:
-        obj = context.active_object
-        assert obj
-        props = tool.Model.get_window_props(obj)
-        element = tool.Ifc.get_entity(obj)
-        assert element
-        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "Data"))
-        data.update(data.pop("lining_properties"))
-        data.update(data.pop("panel_properties"))
-        data.update(tool.Model.get_constituents_props_data(element))
-
-        # required since we could load pset from .ifc and BIMWindowProperties won't be set
-        props.set_props_kwargs_from_ifc_data(data)
-
-        props.is_editing = True
-        return {"FINISHED"}
+        return self._enable_targets(context)


 class RemoveWindow(bpy.types.Operator, tool.Ifc.Operator):
@@ -17,12 +17,18 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.

 import os
+import bmesh
+import gpu
+import numpy as np
 from functools import partial
 from typing import Optional, Union

 import bpy
 import bpy.utils.previews
 from bpy.types import Menu, WorkSpaceTool
+from bpy_extras import view3d_utils
+from gpu_extras.batch import batch_for_shader
+from mathutils import Vector

 import bonsai.core.model as core
 import bonsai.tool as tool
@@ -841,7 +847,7 @@ class EditObjectUI:
        row = cls.layout.row(align=True)
        row.separator()
        row.label(text="Operations") if ui_context != "TOOL_HEADER" else row
-        cls.draw_regen_operations(row)
+        cls.draw_regen_operations(row, ui_context)

        if AuthoringData.data["active_material_usage"] == "LAYER2":
            row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
@@ -943,7 +949,7 @@ class EditObjectUI:
            if "LAYER2" in AuthoringData.data["selected_material_usages"]:
                row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
                add_layout_hotkey_operator(
-                    cls.layout, "Extend To Underside", "S_E", bpy.ops.bim.extend_to_underside.__doc__, ui_context
+                    cls.layout, "Extend To Underside", "S_E", bpy.ops.bim.extend_walls_to_underside.__doc__, ui_context
                )

        if AuthoringData.data["is_flippable_element"]:
@@ -962,20 +968,14 @@ class EditObjectUI:
        return row

    @classmethod
-    def draw_regen_operations(cls, row):
-        custom_icon = custom_icon_previews.get("REGEN", custom_icon_previews["IFC"]).icon_id
-
+    def draw_regen_operations(cls, row, ui_context):
        if AuthoringData.data["is_regenable_element"]:
-            op = row.operator("bim.hotkey", text="", icon_value=custom_icon)
-            description = "Recalculate Element Geometry\nHotkey: S G"
-            op.hotkey = "S_G"
-            op.description = description.strip()
+            row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
+            add_layout_hotkey_operator(row, "Regen", "S_G", "Recalculate Element Geometry", ui_context)

        if PortData.data["total_ports"] > 0:
-            op = row.operator("bim.hotkey", text="", icon_value=custom_icon)
-            description = f"{bpy.ops.bim.regenerate_distribution_element.__doc__}\n\nHotkey: S G"
-            op.hotkey = "S_G"
-            op.description = description.strip()
+            row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
+            add_layout_hotkey_operator(row, "Regen", "S_G", bpy.ops.bim.regenerate_distribution_element.__doc__, ui_context)

    @classmethod
    def draw_void(cls, context, row):
@@ -1494,5 +1494,442 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
            )


+# ==============================================================================
+# CAD/Rhino-style box selection ("Cross Select").
+#
+# The selection logic below is ported from the GPL-3.0 "Blender Cross Select"
+# add-on by RARA, CYX, Witty.Ming and Shuimeng
+# (https://github.com/theoryshaw/Blender-Cross-Select), reduced to box-only mode
+# and adapted to read its settings from Bonsai's add-on preferences. It is wired
+# into every Bonsai tool via ``tool.Blender.get_default_selection_keypmap()``.
+#
+# Dragging the box left-to-right performs a "window" selection (only elements
+# fully enclosed by the box are selected); dragging right-to-left performs a
+# "crossing" selection (anything the box touches is selected).
+# ==============================================================================
+
+
+def _cs_is_point_in_rect(point: tuple[float, float], rect: tuple[tuple[float, float], tuple[float, float]]) -> bool:
+    x, y = point
+    return rect[0][0] <= x <= rect[1][0] and rect[0][1] <= y <= rect[1][1]
+
+
+def _cs_ccw(a, b, c) -> bool:
+    return (c[1] - a[1]) * (b[0] - a[0]) > (b[1] - a[1]) * (c[0] - a[0])
+
+
+def _cs_segments_intersect(a, b, c, d) -> bool:
+    return _cs_ccw(a, c, d) != _cs_ccw(b, c, d) and _cs_ccw(a, b, c) != _cs_ccw(a, b, d)
+
+
+def _cs_is_segment_intersecting_rect(p1, p2, rect) -> bool:
+    min_x, min_y = rect[0]
+    max_x, max_y = rect[1]
+    if max(p1.x, p2.x) < min_x or min(p1.x, p2.x) > max_x or max(p1.y, p2.y) < min_y or min(p1.y, p2.y) > max_y:
+        return False
+    r1, r2, r3, r4 = (min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)
+    line_start, line_end = (p1.x, p1.y), (p2.x, p2.y)
+    return (
+        _cs_segments_intersect(line_start, line_end, r1, r2)
+        or _cs_segments_intersect(line_start, line_end, r2, r3)
+        or _cs_segments_intersect(line_start, line_end, r3, r4)
+        or _cs_segments_intersect(line_start, line_end, r4, r1)
+    )
+
+
+def _cs_make_3d_to_region_2d(verts, matrix_world, region, region_data, use_smart_sampling=True) -> list[Vector]:
+    """Batch-project a sequence of 3D vertices to 2D region coordinates using numpy."""
+    vlen = len(verts)
+    if vlen == 0:
+        return []
+    perspective_matrix = region_data.perspective_matrix
+    if use_smart_sampling:
+        step = max(1, 1 + ((vlen - 1) // 1000) * 10)
+        coords_3d = np.array([verts[i].co.to_tuple() for i in range(0, vlen, step)])
+    else:
+        coords_3d = np.array([v.co.to_tuple() for v in verts])
+    coords_3d = np.hstack((coords_3d, np.ones((coords_3d.shape[0], 1))))
+    coords_3d = np.dot(coords_3d, np.array(matrix_world.transposed()))
+    coords_2d = np.dot(coords_3d, np.array(perspective_matrix.transposed()))
+    coords_2d /= coords_2d[:, 3].reshape(-1, 1)
+    coords_2d[:, 0] = (coords_2d[:, 0] + 1) * 0.5 * region.width
+    coords_2d[:, 1] = (coords_2d[:, 1] + 1) * 0.5 * region.height
+    return [Vector((co[0], co[1])) for co in coords_2d]
+
+
+def _cs_get_sampled_coords(obj, context) -> list[Vector]:
+    if obj.type == "MESH" and obj.data.vertices:
+        return _cs_make_3d_to_region_2d(
+            obj.data.vertices, obj.matrix_world, context.region, context.region_data, use_smart_sampling=True
+        )
+    co = view3d_utils.location_3d_to_region_2d(context.region, context.region_data, obj.matrix_world @ Vector((0, 0, 0)))
+    return [co] if co else []
+
+
+def _cs_is_object_in_rect(obj, context, rect) -> bool:
+    """True when every sampled vertex of ``obj`` projects inside ``rect`` (window match)."""
+    coords = _cs_get_sampled_coords(obj, context)
+    if not coords:
+        return False
+    return all(_cs_is_point_in_rect((co.x, co.y), rect) for co in coords)
+
+
+def _cs_draw_callback_px(operator, context) -> None:
+    if not operator.is_dragging:
+        return
+    cs_prefs = operator.cs_prefs
+    try:
+        shader = gpu.shader.from_builtin("UNIFORM_COLOR")
+    except Exception:
+        shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
+
+    gpu.state.blend_set("ALPHA")
+    gpu.state.line_width_set(cs_prefs.line_width)
+
+    if not operator.enabled:
+        # Disabled: selection is native, so draw a neutral (non-directional) box.
+        color = (1.0, 1.0, 1.0, 1.0)
+        line_style = "DASHED"
+    elif operator.select_mode == "FULLY":
+        color = (*cs_prefs.fully_color, 1.0)
+        line_style = "SOLID"
+    else:
+        color = (*cs_prefs.partial_color, 1.0)
+        line_style = "DASHED"
+
+    min_x, max_x, min_y, max_y = operator.box_path
+    vertices = (
+        (min_x, min_y),
+        (max_x, min_y),
+        (max_x, max_y),
+        (min_x, max_y),
+        (min_x, min_y),
+    )
+    shader.bind()
+    shader.uniform_float("color", color)
+    if line_style == "SOLID":
+        batch_for_shader(shader, "LINE_STRIP", {"pos": vertices}).draw(shader)
+    else:
+        dash_length, gap_length = 10, 5
+        dash_vertices = []
+        for i in range(len(vertices) - 1):
+            start = Vector(vertices[i])
+            end = Vector(vertices[i + 1])
+            line_dir = (end - start).normalized()
+            line_length = (end - start).length
+            num_dashes = int(line_length // (dash_length + gap_length))
+            for j in range(num_dashes):
+                dash_start = start + line_dir * (j * (dash_length + gap_length))
+                dash_end = dash_start + line_dir * dash_length
+                if (dash_end - start).length > line_length:
+                    dash_end = end
+                dash_vertices.extend([dash_start, dash_end])
+            remaining = line_length - num_dashes * (dash_length + gap_length)
+            if remaining > 0:
+                dash_start = start + line_dir * (num_dashes * (dash_length + gap_length))
+                dash_end = dash_start + line_dir * min(dash_length, remaining)
+                dash_vertices.extend([dash_start, dash_end])
+        if dash_vertices:
+            batch_for_shader(shader, "LINES", {"pos": dash_vertices}).draw(shader)
+
+    gpu.state.line_width_set(1.0)
+    gpu.state.blend_set("NONE")
+
+
+class CrossSelect(bpy.types.Operator):
+    bl_idname = "bim.cross_select"
+    bl_label = "Cross Select"
+    bl_options = {"REGISTER", "BLOCKING", "UNDO"}
+    bl_description = (
+        "CAD/Rhino-style box selection.\n\n"
+        "Drag left to right: window (only fully-enclosed elements)\n"
+        "Drag right to left: crossing (anything the box touches)\n\n"
+        "Shift: add to selection\nCtrl: subtract from selection"
+    )
+
+    DRAG_THRESHOLD = 5
+
+    def invoke(self, context, event):
+        # Yield to ClickNearestDimensionAnchor when a parametric dimension dot
+        # is near the cursor.  Blender fires all matching tool-keymap entries'
+        # invoke() even after an earlier entry returned RUNNING_MODAL, so without
+        # this check our BLOCKING modal would win over click_nearest's modal and
+        # prevent the dot from turning blue.
+        if self._near_dimension_dot(context, event):
+            return {"PASS_THROUGH"}
+
+        self.cs_prefs = tool.Blender.get_addon_preferences().cross_select
+        self.enabled = self.cs_prefs.enabled
+        self.start_mouse = (event.mouse_region_x, event.mouse_region_y)
+        self.end_mouse = self.start_mouse
+        self.is_dragging = False
+        self.select_mode = "FULLY"  # "FULLY" (window) or "HALF" (crossing)
+        self.operation = "SET"
+        self.draw_handle = None
+        self.box_path = (0, 0, 0, 0)  # (min_x, max_x, min_y, max_y)
+        context.window_manager.modal_handler_add(self)
+        return {"RUNNING_MODAL"}
+
+    @staticmethod
+    def _near_dimension_dot(context, event) -> bool:
+        """Return True if the click is within 15 px of a parametric dimension anchor dot."""
+        try:
+            import ifcopenshell.util.element as _ue
+            from bpy_extras.view3d_utils import location_3d_to_region_2d
+
+            region = next(
+                (r for a in context.screen.areas if a.type == "VIEW_3D" for r in a.regions if r.type == "WINDOW"),
+                None,
+            )
+            rv3d = next(
+                (s.region_3d for a in context.screen.areas if a.type == "VIEW_3D" for s in a.spaces if s.type == "VIEW_3D"),
+                None,
+            )
+            if not region or not rv3d:
+                return False
+
+            cx = event.mouse_x - region.x
+            cy = event.mouse_y - region.y
+            r2 = 15 ** 2
+
+            for obj in context.scene.objects:
+                if obj.type != "CURVE" or not obj.visible_get():
+                    continue
+                elem = tool.Ifc.get_entity(obj) if tool.Ifc.get() else None
+                if not elem or not elem.is_a("IfcAnnotation"):
+                    continue
+                pset = _ue.get_pset(elem, "BBIM_Dimension")
+                if not pset or not pset.get("Anchors"):
+                    continue
+                if not obj.data.splines:
+                    continue
+                for pt in obj.data.splines[0].points:
+                    sp = location_3d_to_region_2d(region, rv3d, obj.matrix_world @ pt.co.to_3d())
+                    if sp and (cx - sp.x) ** 2 + (cy - sp.y) ** 2 < r2:
+                        return True
+        except Exception:
+            pass
+        return False
+
+    def modal(self, context, event):
+        if event.shift:
+            self.operation = "ADD"
+        elif event.ctrl:
+            self.operation = "SUB"
+        else:
+            self.operation = "SET"
+
+        if event.type == "MOUSEMOVE":
+            if not self.is_dragging:
+                delta = Vector((event.mouse_region_x, event.mouse_region_y)) - Vector(self.start_mouse)
+                if delta.length > self.DRAG_THRESHOLD:
+                    self._start_dragging(context)
+            if self.is_dragging:
+                self._update_drag_position(event)
+                context.area.tag_redraw()
+
+        if event.type == "LEFTMOUSE" and event.value == "RELEASE":
+            if self.is_dragging:
+                self._finish_box_select(context)
+            else:
+                self._handle_single_click(context, event)
+            return {"FINISHED"}
+
+        if event.type in {"RIGHTMOUSE", "ESC"}:
+            self._cleanup_drawing()
+            context.area.tag_redraw()
+            return {"CANCELLED"}
+
+        return {"RUNNING_MODAL"}
+
+    def _start_dragging(self, context):
+        self.is_dragging = True
+        self.draw_handle = bpy.types.SpaceView3D.draw_handler_add(
+            _cs_draw_callback_px, (self, context), "WINDOW", "POST_PIXEL"
+        )
+        context.area.tag_redraw()
+
+    def _update_drag_position(self, event):
+        self.end_mouse = (event.mouse_region_x, event.mouse_region_y)
+        # Dragging rightward selects only fully-enclosed elements (window),
+        # dragging leftward selects anything touched (crossing).
+        self.select_mode = "FULLY" if self.end_mouse[0] > self.start_mouse[0] else "HALF"
+        x1, y1 = self.start_mouse
+        x2, y2 = self.end_mouse
+        self.box_path = (min(x1, x2), max(x1, x2), min(y1, y2), max(y1, y2))
+
+    def _cleanup_drawing(self):
+        if self.draw_handle:
+            bpy.types.SpaceView3D.draw_handler_remove(self.draw_handle, "WINDOW")
+            self.draw_handle = None
+
+    def _finish_box_select(self, context):
+        self._cleanup_drawing()
+        min_x, max_x, min_y, max_y = self.box_path
+
+        # Cross-select disabled: reproduce Blender's native box selection.
+        if not self.enabled:
+            bpy.ops.view3d.select_box(
+                wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode=self.operation
+            )
+            context.area.tag_redraw()
+            return
+
+        if context.mode == "OBJECT":
+            self._process_selection_object(context)
+        elif context.mode == "EDIT_MESH":
+            self._process_selection_edit(context)
+        context.area.tag_redraw()
+
+    # --- Object mode ---------------------------------------------------------
+    def _process_selection_object(self, context):
+        original_selection = set(context.selected_objects)
+
+        # Use the native box select to collect everything the box touches.
+        bpy.ops.object.select_all(action="DESELECT")
+        min_x, max_x, min_y, max_y = self.box_path
+        bpy.ops.view3d.select_box(wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode="ADD")
+        touched_objects = set(context.selected_objects)
+
+        # Filter touched objects by the window/crossing rule.
+        rect = ((min_x, min_y), (max_x, max_y))
+        if self.select_mode == "HALF":
+            valid_selection = touched_objects
+        else:
+            valid_selection = {obj for obj in touched_objects if _cs_is_object_in_rect(obj, context, rect)}
+
+        if self.operation == "SET":
+            final_selected = valid_selection
+        elif self.operation == "ADD":
+            final_selected = original_selection | valid_selection
+        else:  # SUB
+            final_selected = original_selection - valid_selection
+
+        bpy.ops.object.select_all(action="DESELECT")
+        for obj in final_selected:
+            obj.select_set(True)
+
+    # --- Edit mesh mode ------------------------------------------------------
+    def _process_selection_edit(self, context):
+        if hasattr(context, "objects_in_mode_unique_data"):
+            edit_objs = [obj for obj in context.objects_in_mode_unique_data if obj.type == "MESH"]
+        elif hasattr(context, "objects_in_mode"):
+            edit_objs = [obj for obj in context.objects_in_mode if obj.type == "MESH"]
+        else:
+            obj = context.edit_object
+            edit_objs = [obj] if obj and obj.type == "MESH" else []
+        if not edit_objs:
+            return
+
+        is_vert, is_edge, is_face = context.tool_settings.mesh_select_mode
+        min_x, max_x, min_y, max_y = self.box_path
+
+        # Vertex mode (and crossing face mode) match Blender's native box select.
+        if is_vert or (is_face and self.select_mode == "HALF"):
+            bpy.ops.view3d.select_box(
+                wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode=self.operation
+            )
+            return
+
+        element_key = "edges" if is_edge else "faces"
+        bm_cache = {}
+        original = {}
+        for obj in edit_objs:
+            bm = bmesh.from_edit_mesh(obj.data)
+            bm.verts.ensure_lookup_table()
+            bm.edges.ensure_lookup_table()
+            bm.faces.ensure_lookup_table()
+            bm_cache[obj] = bm
+            elems = bm.edges if is_edge else bm.faces
+            original[obj] = {ele for ele in elems if ele.select}
+
+        # Collect every element the box touches via native box select on faces+edges.
+        bpy.ops.mesh.select_all(action="DESELECT")
+        for temp_select_mode in ((False, False, True), (False, True, False)):
+            context.tool_settings.mesh_select_mode = temp_select_mode
+            bpy.ops.view3d.select_box(wait_for_input=False, xmin=min_x, xmax=max_x, ymin=min_y, ymax=max_y, mode="ADD")
+        context.tool_settings.mesh_select_mode = (is_vert, is_edge, is_face)
+
+        rect = ((min_x, min_y), (max_x, max_y))
+        valid = {}
+        for obj, bm in bm_cache.items():
+            elems = bm.edges if is_edge else bm.faces
+            touched = {ele for ele in elems if ele.select}
+            valid[obj] = {ele for ele in touched if self._is_element_valid(context, obj, rect, ele, element_key)}
+
+        final = {}
+        for obj in edit_objs:
+            if self.operation == "SET":
+                final[obj] = valid[obj]
+            elif self.operation == "ADD":
+                final[obj] = original[obj] | valid[obj]
+            else:  # SUB
+                final[obj] = original[obj] - valid[obj]
+
+        bpy.ops.mesh.select_all(action="DESELECT")
+        if is_edge:
+            for obj, bm in bm_cache.items():
+                for e in final[obj]:
+                    e.select = True
+                    for f in e.link_faces:
+                        if f.select:
+                            continue
+                        if all(edge in final[obj] for edge in f.edges):
+                            f.select = True
+                bmesh.update_edit_mesh(obj.data)
+        else:
+            for obj, bm in bm_cache.items():
+                for f in final[obj]:
+                    f.select = True
+                bmesh.update_edit_mesh(obj.data)
+
+    def _is_element_valid(self, context, obj, rect, ele, ele_type):
+        region = context.region
+        rv3d = context.region_data
+        matrix = obj.matrix_world
+        vert_2d = []
+        all_inside = True
+        any_inside = False
+        for v in ele.verts:
+            co_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, matrix @ v.co)
+            if not co_2d:
+                all_inside = False
+                continue
+            vert_2d.append(co_2d)
+            if _cs_is_point_in_rect((co_2d.x, co_2d.y), rect):
+                any_inside = True
+            else:
+                all_inside = False
+
+        if self.select_mode == "FULLY":
+            return all_inside
+        if any_inside:
+            return True
+        # Crossing: element edges intersecting the box border also count.
+        n = len(vert_2d)
+        if ele_type == "edges":
+            return n == 2 and _cs_is_segment_intersecting_rect(vert_2d[0], vert_2d[1], rect)
+        for i in range(n):
+            if _cs_is_segment_intersecting_rect(vert_2d[i], vert_2d[(i + 1) % n], rect):
+                return True
+        return False
+
+    def _handle_single_click(self, context, event):
+        # A plain click uses Blender's native pick selection. ``deselect_all`` clears
+        # the selection when clicking empty space (in both Object and Edit Mesh modes),
+        # matching Blender's default selection tool; Shift toggles and Ctrl deselects.
+        try:
+            bpy.ops.view3d.select(
+                "INVOKE_DEFAULT",
+                extend=event.shift,
+                deselect=event.ctrl,
+                toggle=False,
+                deselect_all=not (event.shift or event.ctrl),
+                location=(event.mouse_region_x, event.mouse_region_y),
+            )
+        except Exception:
+            pass
+
+
 custom_icon_previews = None
 display_mode = None
@@ -101,7 +101,7 @@ class NestDecorator:
        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()
@@ -33,7 +33,7 @@ class EnableEditingPerson(bpy.types.Operator):
    bl_idname = "bim.enable_editing_person"
    bl_label = "Enable Editing Person"
    bl_options = {"REGISTER", "UNDO"}
-    person: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    person: bpy.props.IntProperty()

    if TYPE_CHECKING:
        person: int
@@ -75,7 +75,7 @@ class RemovePerson(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_person"
    bl_label = "Remove Person"
    bl_options = {"REGISTER", "UNDO"}
-    person: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    person: bpy.props.IntProperty()

    if TYPE_CHECKING:
        person: int
@@ -88,7 +88,7 @@ class AddPersonAttribute(bpy.types.Operator):
    bl_idname = "bim.add_person_attribute"
    bl_label = "Add Person Attribute"
    bl_options = {"REGISTER", "UNDO"}
-    name: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    name: bpy.props.EnumProperty(
        items=tuple((i, i, "") for i in get_args(tool.Owner.PersonAttributeType)),
    )

@@ -104,10 +104,10 @@ class RemovePersonAttribute(bpy.types.Operator):
    bl_idname = "bim.remove_person_attribute"
    bl_label = "Remove Person Attribute"
    bl_options = {"REGISTER", "UNDO"}
-    name: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    name: bpy.props.EnumProperty(
        items=tuple((i, i, "") for i in get_args(tool.Owner.PersonAttributeType)),
    )
-    id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    id: bpy.props.IntProperty()

    if TYPE_CHECKING:
        name: tool.Owner.PersonAttributeType  # pyright: ignore[reportIncompatibleVariableOverride]
@@ -122,7 +122,7 @@ class EnableEditingRole(bpy.types.Operator):
    bl_idname = "bim.enable_editing_role"
    bl_label = "Enable Editing Role"
    bl_options = {"REGISTER", "UNDO"}
-    role: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    role: bpy.props.IntProperty()

    if TYPE_CHECKING:
        role: int
@@ -146,7 +146,7 @@ class AddRole(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_role"
    bl_label = "Add Role"
    bl_options = {"REGISTER", "UNDO"}
-    parent: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    parent: bpy.props.IntProperty()

    if TYPE_CHECKING:
        parent: int
@@ -168,7 +168,7 @@ class RemoveRole(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_role"
    bl_label = "Remove Role"
    bl_options = {"REGISTER", "UNDO"}
-    role: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    role: bpy.props.IntProperty()

    if TYPE_CHECKING:
        role: int
@@ -181,8 +181,8 @@ class AddAddress(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_address"
    bl_label = "Add Address"
    bl_options = {"REGISTER", "UNDO"}
-    parent: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    ifc_class: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    parent: bpy.props.IntProperty()
+    ifc_class: bpy.props.EnumProperty(
        items=tuple((i, i, "") for i in get_args(ADDRESS_TYPE)),
    )

@@ -198,7 +198,7 @@ class AddAddressAttribute(bpy.types.Operator):
    bl_idname = "bim.add_address_attribute"
    bl_label = "Add Address Attribute"
    bl_options = {"REGISTER", "UNDO"}
-    name: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    name: bpy.props.EnumProperty(
        items=tuple((i, i, "") for i in get_args(tool.Owner.AddressAttributeType)),
    )

@@ -214,10 +214,10 @@ class RemoveAddressAttribute(bpy.types.Operator):
    bl_idname = "bim.remove_address_attribute"
    bl_label = "Remove Address Attribute"
    bl_options = {"REGISTER", "UNDO"}
-    name: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    name: bpy.props.EnumProperty(
        items=tuple((i, i, "") for i in get_args(tool.Owner.AddressAttributeType)),
    )
-    id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    id: bpy.props.IntProperty()

    if TYPE_CHECKING:
        name: tool.Owner.AddressAttributeType  # pyright: ignore[reportIncompatibleVariableOverride]
@@ -232,7 +232,7 @@ class EnableEditingAddress(bpy.types.Operator):
    bl_idname = "bim.enable_editing_address"
    bl_label = "Enable Editing Address"
    bl_options = {"REGISTER", "UNDO"}
-    address: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    address: bpy.props.IntProperty()

    if TYPE_CHECKING:
        address: int
@@ -265,7 +265,7 @@ class RemoveAddress(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_address"
    bl_label = "Remove Address"
    bl_options = {"REGISTER", "UNDO"}
-    address: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    address: bpy.props.IntProperty()

    if TYPE_CHECKING:
        address: int
@@ -278,7 +278,7 @@ class EnableEditingOrganisation(bpy.types.Operator):
    bl_idname = "bim.enable_editing_organisation"
    bl_label = "Enable Editing Organisation"
    bl_options = {"REGISTER", "UNDO"}
-    organisation: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    organisation: bpy.props.IntProperty()

    if TYPE_CHECKING:
        organisation: int
@@ -320,7 +320,7 @@ class RemoveOrganisation(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_organisation"
    bl_label = "Remove Organisation"
    bl_options = {"REGISTER", "UNDO"}
-    organisation: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    organisation: bpy.props.IntProperty()

    if TYPE_CHECKING:
        organisation: int
@@ -333,8 +333,8 @@ class AddPersonAndOrganisation(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_person_and_organisation"
    bl_label = "Add Person And Organisation"
    bl_options = {"REGISTER", "UNDO"}
-    person: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    organisation: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    person: bpy.props.IntProperty()
+    organisation: bpy.props.IntProperty()

    if TYPE_CHECKING:
        person: int
@@ -350,7 +350,7 @@ class RemovePersonAndOrganisation(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_person_and_organisation"
    bl_label = "Remove Person And Organisation"
    bl_options = {"REGISTER", "UNDO"}
-    person_and_organisation: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    person_and_organisation: bpy.props.IntProperty()

    if TYPE_CHECKING:
        person_and_organisation: int
@@ -365,7 +365,7 @@ class SetUser(bpy.types.Operator):
    bl_idname = "bim.set_user"
    bl_label = "Set User"
    bl_options = {"REGISTER", "UNDO"}
-    user: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    user: bpy.props.IntProperty()

    if TYPE_CHECKING:
        user: int
@@ -401,7 +401,7 @@ class EnableEditingActor(bpy.types.Operator):
    bl_idname = "bim.enable_editing_actor"
    bl_label = "Enable Editing Actor"
    bl_options = {"REGISTER", "UNDO"}
-    actor: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    actor: bpy.props.IntProperty()

    if TYPE_CHECKING:
        actor: int
@@ -434,7 +434,7 @@ class RemoveActor(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_actor"
    bl_label = "Remove Actor"
    bl_options = {"REGISTER", "UNDO"}
-    actor: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    actor: bpy.props.IntProperty()

    if TYPE_CHECKING:
        actor: int
@@ -447,7 +447,7 @@ class AssignActor(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.assign_actor"
    bl_label = "Assign Actor"
    bl_options = {"REGISTER", "UNDO"}
-    actor: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    actor: bpy.props.IntProperty()

    if TYPE_CHECKING:
        actor: int
@@ -462,7 +462,7 @@ class UnassignActor(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.unassign_actor"
    bl_label = "Unassign Actor"
    bl_options = {"REGISTER", "UNDO"}
-    actor: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    actor: bpy.props.IntProperty()

    if TYPE_CHECKING:
        actor: int
@@ -481,7 +481,7 @@ class RemoveApplication(bpy.types.Operator, tool.Ifc.Operator):
        "Remove provided IfcApplication."
        "\n\nFor safety will only work on applications without inverses (they are typically marked as '(unused)'."
    )
-    application_id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    application_id: bpy.props.IntProperty()

    if TYPE_CHECKING:
        application_id: int
@@ -525,7 +525,7 @@ class EnableEditingApplication(bpy.types.Operator):
    bl_idname = "bim.enable_editing_application"
    bl_label = "Enable Editing Application"
    bl_options = {"REGISTER", "UNDO"}
-    application_id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    application_id: bpy.props.IntProperty()

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

 import datetime
 import json
@@ -86,9 +88,7 @@ class NewProject(bpy.types.Operator):
    bl_label = "New Project"
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Start a new IFC project in a fresh session"
-    preset: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
-        items=[(i, i, "") for i in get_args(PresetType)]
-    )
+    preset: bpy.props.EnumProperty(items=[(i, i, "") for i in get_args(PresetType)])

    if TYPE_CHECKING:
        preset: PresetType
@@ -178,13 +178,9 @@ class SelectLibraryFile(bpy.types.Operator, IFCFileSelector, ImportHelper):
    bl_description = (
        "Select an IFC file that can be used as a library.\n\nALT+click to reload the current loaded library file."
    )
-    filter_glob: bpy.props.StringProperty(
-        default="*.ifc;*.ifczip;*.ifcxml", options={"HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
-    append_all: bpy.props.BoolProperty(default=False)  # pyright: ignore[reportRedeclaration]
-    use_relative_path: bpy.props.BoolProperty(
-        name="Use Relative Path", default=False
-    )  # pyright: ignore[reportRedeclaration]
+    filter_glob: bpy.props.StringProperty(default="*.ifc;*.ifczip;*.ifcxml", options={"HIDDEN"})
+    append_all: bpy.props.BoolProperty(default=False)
+    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=False)

    if TYPE_CHECKING:
        filter_glob: str
@@ -568,7 +564,7 @@ class AppendLibraryElementByQuery(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.append_library_element_by_query"
    bl_label = "Append Library Element By Query"

-    query: bpy.props.StringProperty(name="Query")  # pyright: ignore[reportRedeclaration]
+    query: bpy.props.StringProperty(name="Query")

    if TYPE_CHECKING:
        query: str
@@ -600,11 +596,9 @@ class AppendLibraryElement(bpy.types.Operator, tool.Ifc.Operator):
        "Append element to the current project.\n\n"
        "ALT+CLICK to skip reusing materials, profiles, styles based on their name (may result in duplicates)"
    )
-    definition: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    prop_index: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    assume_unique_by_name: bpy.props.BoolProperty(
-        name="Assume Unique By Name", default=True, options={"SKIP_SAVE"}
-    )  # pyright: ignore[reportRedeclaration]
+    definition: bpy.props.IntProperty()
+    prop_index: bpy.props.IntProperty()
+    assume_unique_by_name: bpy.props.BoolProperty(name="Assume Unique By Name", default=True, options={"SKIP_SAVE"})

    if TYPE_CHECKING:
        definition: int
@@ -959,28 +953,24 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
    bl_label = "Load Project"
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Load an existing IFC project"
-    filepath: bpy.props.StringProperty(
-        subtype="FILE_PATH", options={"SKIP_SAVE"}
-    )  # pyright: ignore[reportRedeclaration]
-    filter_glob: bpy.props.StringProperty(
-        default="*.ifc;*.ifczip;*.ifcxml;*.ifcsqlite", options={"HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
-    is_advanced: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    filepath: bpy.props.StringProperty(subtype="FILE_PATH", options={"SKIP_SAVE"})
+    filter_glob: bpy.props.StringProperty(default="*.ifc;*.ifczip;*.ifcxml;*.ifcsqlite", options={"HIDDEN"})
+    is_advanced: bpy.props.BoolProperty(
        name="Enable Advanced Mode",
        description="Load IFC file with advanced settings. Checking this option will skip loading IFC file and will open advanced load settings",
        default=False,
    )
-    use_relative_path: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    use_relative_path: bpy.props.BoolProperty(
        name="Use Relative Path",
        description="Store the IFC project path relative to the .blend file. Requires .blend file to be saved",
        default=False,
    )
-    should_start_fresh_session: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    should_start_fresh_session: bpy.props.BoolProperty(
        name="Should Start Fresh Session",
        description="Clear current Blender session before loading IFC. Not supported with 'Use Relative Path' option",
        default=True,
    )
-    import_without_ifc_data: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    import_without_ifc_data: bpy.props.BoolProperty(
        name="Import Without IFC Data",
        description=(
            "Import IFC objects as Blender objects without any IFC metadata and authoring capabilities."
@@ -988,9 +978,7 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
        ),
        default=False,
    )
-    use_detailed_tooltip: bpy.props.BoolProperty(
-        default=False, options={"HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
+    use_detailed_tooltip: bpy.props.BoolProperty(default=False, options={"HIDDEN"})
    filename_ext = ".ifc"

    if TYPE_CHECKING:
@@ -1102,7 +1090,7 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
        else:
            return self.finish_loading_project(context)

-    def finish_loading_project(self, context):
+    def finish_loading_project(self, context: bpy.types.Context) -> set["rna_enums.OperatorReturnItems"]:
        try:
            filepath = self.get_filepath()
            if not self.is_existing_ifc_file():
@@ -1300,7 +1288,7 @@ class ToggleFilterCategories(bpy.types.Operator):
    bl_idname = "bim.toggle_filter_categories"
    bl_label = "Toggle Filter Categories"
    bl_options = {"REGISTER", "UNDO"}
-    should_select: bpy.props.BoolProperty(name="Should Select", default=True)  # pyright: ignore[reportRedeclaration]
+    should_select: bpy.props.BoolProperty(name="Should Select", default=True)

    if TYPE_CHECKING:
        should_select: bool
@@ -1327,7 +1315,7 @@ class LinkIfc(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
        default=False,
    )
    use_cache: bpy.props.BoolProperty(name="Use Cache", default=True)
-    query: bpy.props.StringProperty(  # pyright: ignore[reportRedeclaration]
+    query: bpy.props.StringProperty(
        name="Query",
        description=(
            "Custom selector query to use to load element from a linked model. E.g. 'IfcElement'.\n\n"
@@ -1404,7 +1392,7 @@ class UnlinkIfc(bpy.types.Operator, tool.Ifc.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Remove the selected file from the link list"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")

    if TYPE_CHECKING:
        link_index: int
@@ -1428,7 +1416,7 @@ class UnloadLink(bpy.types.Operator, tool.Ifc.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Unload the selected linked file"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")

    if TYPE_CHECKING:
        link_index: int
@@ -1454,9 +1442,9 @@ class LoadLink(bpy.types.Operator, tool.Ifc.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Load the selected file"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
-    use_cache: bpy.props.BoolProperty(name="Use Cache", default=True)  # pyright: ignore[reportRedeclaration]
-    query: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")
+    use_cache: bpy.props.BoolProperty(name="Use Cache", default=True)
+    query: bpy.props.StringProperty()

    if TYPE_CHECKING:
        link_index: int
@@ -1631,7 +1619,7 @@ class ReloadLink(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Reload the selected file"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")

    if TYPE_CHECKING:
        link_index: int
@@ -1647,7 +1635,7 @@ class ToggleLinkSelectability(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Toggle selectability"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")

    if TYPE_CHECKING:
        link_index: int
@@ -1679,8 +1667,8 @@ class ToggleLinkVisibility(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Toggle visibility between SOLID and WIREFRAME"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
-    mode: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")
+    mode: bpy.props.EnumProperty(
        name="Visibility Mode",
        items=((i, i, "") for i in ("WIREFRAME", "VISIBLE")),
    )
@@ -1821,7 +1809,7 @@ class SelectLinkHandle(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Select link empty object handle"

-    link_index: bpy.props.IntProperty(name="Link Index")  # pyright: ignore[reportRedeclaration]
+    link_index: bpy.props.IntProperty(name="Link Index")

    if TYPE_CHECKING:
        link_index: int
@@ -1843,7 +1831,7 @@ class SelectLinkedModelElement(bpy.types.Operator):
    bl_options = {"REGISTER"}
    bl_description = "Select an element in the currently selected linked model by providing GlobalId."

-    guid: bpy.props.StringProperty(name="GlobalId")  # pyright: ignore[reportRedeclaration]
+    guid: bpy.props.StringProperty(name="GlobalId")

    if TYPE_CHECKING:
        guid: str
@@ -1882,21 +1870,11 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
    bl_options = {"REGISTER", "UNDO"}
    filename_ext = ".ifc"
    supported_filexts = (".ifc", ".ifczip", ".ifcjson")
-    filter_glob: bpy.props.StringProperty(
-        default=";".join(f"*{ext}" for ext in supported_filexts), options={"HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
-    json_version: bpy.props.EnumProperty(
-        items=[("4", "4", ""), ("5a", "5a", "")], name="IFC JSON Version"
-    )  # pyright: ignore[reportRedeclaration]
-    json_compact: bpy.props.BoolProperty(
-        name="Export Compact IFCJSON", default=False
-    )  # pyright: ignore[reportRedeclaration]
-    should_save_as: bpy.props.BoolProperty(
-        name="Should Save As", default=False, options={"HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
-    use_relative_path: bpy.props.BoolProperty(
-        name="Use Relative Path", default=False
-    )  # pyright: ignore[reportRedeclaration]
+    filter_glob: bpy.props.StringProperty(default=";".join(f"*{ext}" for ext in supported_filexts), options={"HIDDEN"})
+    json_version: bpy.props.EnumProperty(items=[("4", "4", ""), ("5a", "5a", "")], name="IFC JSON Version")
+    json_compact: bpy.props.BoolProperty(name="Export Compact IFCJSON", default=False)
+    should_save_as: bpy.props.BoolProperty(name="Should Save As", default=False, options={"HIDDEN"})
+    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=False)

    if TYPE_CHECKING:
        filter_glob: str
@@ -1927,11 +1905,11 @@ class ExportIFC(bpy.types.Operator, ExportHelper):

        self.use_relative_path = tool.Project.get_project_props().use_relative_project_path
        props = tool.Blender.get_bim_props()
-        if (filepath := props.ifc_file) and not self.should_save_as:
-            self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(filepath)))
-            return self.execute(context)
-
-        return ExportHelper.invoke(self, context, event)
+        filepath = props.ifc_file
+        if not filepath or self.should_save_as:
+            return ExportHelper.invoke(self, context, event)
+        self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(filepath)))
+        return self.execute(context)

    def check(self, context):
        # ExportHelper is automatically adjusting suffix to `filename_ext`.
@@ -1957,6 +1935,16 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
        return {"FINISHED"}

    def _execute(self, context):
+        committed, failed_commits = tool.Parametric.commit_pending_edits()
+        # Suffix is appended to the IFC save-success report below so the auto-commit
+        # info isn't immediately overwritten by the success message in Blender's
+        # status bar (only the latest self.report({"INFO"}, ...) sticks).
+        commit_suffix = f" (auto-committed {committed} pending parametric edit(s))" if committed else ""
+        if failed_commits:
+            names = ", ".join(o.name for o in failed_commits)
+            msg = f"Auto-commit failed for {len(failed_commits)} object(s): {names}"
+            print(f"Bonsai: {msg} (their drafts are NOT saved to the IFC file).")
+            self.report({"ERROR"}, msg)
        start = time.time()
        logger = logging.getLogger("ExportIFC")
        path_log = tool.Blender.get_data_dir_path("process.log")
@@ -2025,7 +2013,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
                    blendmetadata_path = output_file + suffix
                self.report(
                    {"INFO"},
-                    f'IFC Project "{os.path.basename(output_file)}" And Metadata File Saved to: {os.path.basename(blendmetadata_path)}',
+                    f'IFC Project "{os.path.basename(output_file)}" And Metadata File Saved to: {os.path.basename(blendmetadata_path)}{commit_suffix}',
                )
            except Exception as e:
                self.report({"ERROR"}, f"Failed to save blend metadata file: {e}")
@@ -2035,7 +2023,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
                bpy.ops.wm.save_mainfile(filepath=bpy.data.filepath)
            self.report(
                {"INFO"},
-                f'IFC Project "{os.path.basename(output_file)}" {"" if not save_blend_file else "And Current Blend File Are"} Saved',
+                f'IFC Project "{os.path.basename(output_file)}" {"" if not save_blend_file else "And Current Blend File Are"} Saved{commit_suffix}',
            )

        bonsai.bim.handler.refresh_ui_data()
@@ -2053,7 +2041,7 @@ class LoadLinkedProject(bpy.types.Operator, ImportHelper):
    bl_description = "Operator is used to load a project .cache.blend to then link it to the IFC file."
    bl_options = {"REGISTER", "UNDO"}

-    query: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    query: bpy.props.StringProperty()
    """See ``bim.link_ifc``."""

    if TYPE_CHECKING:
@@ -2443,8 +2431,8 @@ class HideQueriedLinkedElement(bpy.types.Operator):
    )
    bl_options = {"REGISTER", "UNDO"}

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

    if TYPE_CHECKING:
        unhide_all: bool
@@ -2918,12 +2906,8 @@ class IFCFileHandlerOperator(bpy.types.Operator):
    bl_label = "Import .ifc file"
    bl_options = {"REGISTER", "UNDO", "INTERNAL"}

-    directory: bpy.props.StringProperty(
-        subtype="FILE_PATH", options={"SKIP_SAVE", "HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
-    files: bpy.props.CollectionProperty(
-        type=bpy.types.OperatorFileListElement, options={"SKIP_SAVE", "HIDDEN"}
-    )  # pyright: ignore[reportRedeclaration]
+    directory: bpy.props.StringProperty(subtype="FILE_PATH", options={"SKIP_SAVE", "HIDDEN"})
+    files: bpy.props.CollectionProperty(type=bpy.types.OperatorFileListElement, options={"SKIP_SAVE", "HIDDEN"})

    if TYPE_CHECKING:
        directory: str
@@ -2978,7 +2962,7 @@ class MeasureTool(bpy.types.Operator, PolylineOperator):
    bl_label = "Measure Tool"
    bl_options = {"REGISTER", "UNDO"}

-    measure_type: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    measure_type: bpy.props.StringProperty()

    if TYPE_CHECKING:
        measure_type: str
@@ -3077,7 +3061,7 @@ class MeasureFaceAreaTool(bpy.types.Operator, PolylineOperator):
    bl_label = "Measure Face Area Tool"
    bl_options = {"REGISTER", "UNDO"}

-    measure_type: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    measure_type: bpy.props.StringProperty()

    if TYPE_CHECKING:
        measure_type: str
@@ -3379,7 +3363,7 @@ class LoadBlendMetadataAndIFC(bpy.types.Operator):
    bl_idname = "bim.load_blend_metadata_and_ifc"
    bl_label = "Load Blend Metadata and IFC"
    bl_options = {"REGISTER", "UNDO"}
-    filepath: bpy.props.StringProperty(name="IFC File Path", default="")  # pyright: ignore[reportRedeclaration]
+    filepath: bpy.props.StringProperty(name="IFC File Path", default="")

    if TYPE_CHECKING:
        filepath: str
@@ -345,7 +345,7 @@ class BIMProjectProperties(PropertyGroup):
        ),
        default=False,
    )
-    should_cache: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    should_cache: BoolProperty(
        name="Cache",
        description=(
            "Cache loaded geometry to .h5 file in your cache directory (see in preferences) "
@@ -19,6 +19,7 @@
 from __future__ import annotations

 import os
+import shutil
 from typing import TYPE_CHECKING

 import bpy
@@ -384,6 +385,18 @@ class BIM_PT_new_project_wizard(Panel):
        row = self.layout.row()
        row.operator("bim.create_project")

+        if shutil.which("git"):
+            git_props = context.scene.IfcGitProperties
+            box = self.layout.box()
+            row = box.row()
+            row.label(text="Clone a remote Git repository")
+            row = box.row()
+            row.prop(git_props, "remote_url")
+            row = box.row()
+            row.prop(git_props, "local_folder")
+            row = box.row()
+            row.operator("ifcgit.clone_repo", icon="IMPORT")
+

 class BIM_PT_project_library(Panel):
    bl_label = "Project Library"
@@ -240,7 +240,7 @@ class CopyPropertyToSelection(bpy.types.Operator, tool.Ifc.Operator):
    bl_label = "Copy Property To Selection"
    bl_options = {"REGISTER", "UNDO"}

-    name: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    name: bpy.props.StringProperty()

    if TYPE_CHECKING:
        name: str
@@ -280,10 +280,10 @@ class BIM_OT_add_property_to_edit(bpy.types.Operator):
    bl_label = "Add Property to Edit"
    bl_idname = "bim.add_property_to_edit"
    bl_options = {"REGISTER", "UNDO"}
-    option: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    option: bpy.props.EnumProperty(
        items=[(t, t, "") for t in tool.Pset.BULK_OPERATION_TYPES],
    )
-    index: bpy.props.IntProperty(default=-1)  # pyright: ignore[reportRedeclaration]
+    index: bpy.props.IntProperty(default=-1)

    if TYPE_CHECKING:
        option: tool.Pset.BulkOperationType
@@ -307,9 +307,9 @@ class BIM_OT_remove_property_to_edit(bpy.types.Operator):
    bl_label = "Remove Property from Editing"
    bl_idname = "bim.remove_property_to_edit"
    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
-    index2: bpy.props.IntProperty(default=-1)  # pyright: ignore[reportRedeclaration]
-    option: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    index: bpy.props.IntProperty()
+    index2: bpy.props.IntProperty(default=-1)
+    option: bpy.props.EnumProperty(
        items=[(t, t, "") for t in tool.Pset.BULK_OPERATION_TYPES],
    )

@@ -336,7 +336,7 @@ class BIM_OT_bulk_edit_clear_list(bpy.types.Operator):
    bl_label = "Clear List of Properties"
    bl_idname = "bim.pset_bulk_edit_clear_list"
    bl_options = {"REGISTER", "UNDO"}
-    option: bpy.props.EnumProperty(  # pyright: ignore[reportRedeclaration]
+    option: bpy.props.EnumProperty(
        items=[(t, t, "") for t in tool.Pset.BULK_OPERATION_TYPES],
    )

@@ -368,9 +368,9 @@ class GlobalPsetProperties(PropertyGroup):
    qto_filter: StringProperty(name="Qto Filter", options={"TEXTEDIT_UPDATE"})

    # Bulk operations.
-    psets_to_delete: CollectionProperty(type=DeletePsetEntry)  # pyright: ignore[reportRedeclaration]
-    psets_to_rename: CollectionProperty(type=RenamePropertyEntry)  # pyright: ignore[reportRedeclaration]
-    psets_to_add_edit: CollectionProperty(type=AddEditPropertyEntry)  # pyright: ignore[reportRedeclaration]
+    psets_to_delete: CollectionProperty(type=DeletePsetEntry)
+    psets_to_rename: CollectionProperty(type=RenamePropertyEntry)
+    psets_to_add_edit: CollectionProperty(type=AddEditPropertyEntry)

    if TYPE_CHECKING:
        pset_filter: str
@@ -799,7 +799,7 @@ class SelectQueryElements(Operator):
    bl_description = "Select elements matching an provided selector query"
    bl_options = {"REGISTER", "UNDO"}

-    query: StringProperty(name="Query")  # pyright: ignore[reportRedeclaration]
+    query: StringProperty(name="Query")

    if TYPE_CHECKING:
        query: str
@@ -829,12 +829,12 @@ class SaveSearch(Operator, tool.Ifc.Operator):
        # Extra item so it will be easy to select current text.
        return [text] + SaveSearch.name_search_items

-    name: StringProperty(  # pyright: ignore[reportRedeclaration]
+    name: StringProperty(
        name="Name",
        search=get_name_search_items,
        search_options={"SORT"},
    )
-    module: StringProperty()  # pyright: ignore[reportRedeclaration]
+    module: StringProperty()

    def update_use_all_ifcgroups(self, context: object = None) -> None:
        ifc_file = tool.Ifc.get()
@@ -845,7 +845,7 @@ class SaveSearch(Operator, tool.Ifc.Operator):
        }
        self.name_search_items[:] = natsorted(groups)

-    use_all_ifcgroups: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    use_all_ifcgroups: BoolProperty(
        name="Use Any IfcGroup",
        description=(
            "By default we're targeting only IfcGroups with SEARCH ObjectType "
@@ -106,7 +106,7 @@ class ActivateStatusFilters(bpy.types.Operator):
    bl_description = "Filter and display objects based on currently selected IFC statuses"
    bl_options = {"REGISTER", "UNDO"}

-    only_if_enabled: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    only_if_enabled: bpy.props.BoolProperty(
        name="Only If Filters are Enabled",
        description="Activate status filters only in case if they were enabled from the UI before.",
        default=False,
@@ -137,7 +137,7 @@ class SelectStatusFilter(bpy.types.Operator):
    bl_description = "Select elements with currently selected status"
    bl_options = {"REGISTER", "UNDO"}

-    status: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    status: bpy.props.StringProperty()

    if TYPE_CHECKING:
        status: tool.Sequence.ElementStatusUI
@@ -156,7 +156,7 @@ class AssignStatus(bpy.types.Operator, tool.Ifc.Operator):
    bl_description = "Assign status to the selected elements.\n\nAlt+CLICK to unassign the status."
    bl_options = {"REGISTER", "UNDO"}

-    should_override_previous_status: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    should_override_previous_status: bpy.props.BoolProperty(
        name="Override Previous Status",
        description=(
            "Whether assigning new status should override previous one.\n\n"
@@ -165,8 +165,8 @@ class AssignStatus(bpy.types.Operator, tool.Ifc.Operator):
        ),
        default=True,
    )
-    status: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
-    should_unassign_status: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    status: bpy.props.StringProperty()
+    should_unassign_status: bpy.props.BoolProperty(
        options={"SKIP_SAVE"},
    )

@@ -415,7 +415,7 @@ class CopyWorkSchedule(bpy.types.Operator, tool.Ifc.Operator):
    bl_label = "Copy Work Schedule"
    bl_description = "Create a duplicate of the provided work schedule."
    bl_options = {"REGISTER", "UNDO"}
-    work_schedule: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    work_schedule: bpy.props.IntProperty()

    if TYPE_CHECKING:
        work_schedule: int
@@ -412,7 +412,7 @@ WorkPlanEditingType = Literal["-", "ATTRIBUTES", "SCHEDULES", "WORK_SCHEDULE", "

 class BIMWorkPlanProperties(PropertyGroup):
    work_plan_attributes: CollectionProperty(name="Work Plan Attributes", type=Attribute)
-    editing_type: EnumProperty(  # pyright: ignore[reportRedeclaration]
+    editing_type: EnumProperty(
        items=[(i, i, "") for i in get_args(WorkPlanEditingType)],
    )
    work_plans: CollectionProperty(name="Work Plans", type=WorkPlan)
@@ -430,8 +430,8 @@ class BIMWorkPlanProperties(PropertyGroup):


 class IFCStatus(PropertyGroup):
-    name: StringProperty()  # pyright: ignore[reportRedeclaration]
-    is_visible: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    name: StringProperty()
+    is_visible: BoolProperty(
        name="Is Visible", default=True, update=lambda x, y: (None, bpy.ops.bim.activate_status_filters())[0]
    )

@@ -220,7 +220,7 @@ class CopyToContainer(bpy.types.Operator, tool.Ifc.Operator):
    bl_label = "Copy to Container"
    bl_options = {"REGISTER", "UNDO"}

-    container: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    container: bpy.props.IntProperty()

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


@@ -167,7 +167,7 @@ class EnableEditingStructuralBoundaryCondition(bpy.types.Operator):
    bl_idname = "bim.enable_editing_structural_boundary_condition"
    bl_label = "Enable Editing Structural Boundary Condition"
    bl_options = {"REGISTER", "UNDO"}
-    boundary_condition: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    boundary_condition: bpy.props.IntProperty()

    if TYPE_CHECKING:
        boundary_condition: int
@@ -186,7 +186,7 @@ class EditStructuralBoundaryCondition(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.edit_structural_boundary_condition"
    bl_label = "Edit Structural Boundary Condition"
    bl_options = {"REGISTER", "UNDO"}
-    connection: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    connection: bpy.props.IntProperty()

    if TYPE_CHECKING:
        connection: int
@@ -917,7 +917,7 @@ class EnableEditingBoundaryCondition(bpy.types.Operator):
    bl_idname = "bim.enable_editing_boundary_condition"
    bl_label = "Enable Editing Boundary Condition"
    bl_options = {"REGISTER", "UNDO"}
-    boundary_condition: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    boundary_condition: bpy.props.IntProperty()

    if TYPE_CHECKING:
        boundary_condition: int
@@ -83,7 +83,7 @@ class DecorationShader:
        PARALLEL DISTRIBUTED FORCE,
        DISTRIBUTED MOMENT,
        """
-        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")  # ty:ignore[too-many-positional-arguments]
+        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
        vert_out.smooth("VEC3", "forces")
        vert_out.smooth("VEC3", "co")

@@ -203,7 +203,7 @@ class DecorationShader:
        """param: pattern: type of pattern
        SINGLE FORCE,
        SINGLE MOMENT"""
-        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")  # ty: ignore[too-many-positional-arguments]
+        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
        vert_out.smooth("VEC3", "co")

        shader_info = gpu.types.GPUShaderCreateInfo()
@@ -253,7 +253,7 @@ class DecorationShader:

    def get_planar_shader(self) -> gpu.types.GPUShader:
        """shader for planar loads"""
-        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")  # ty: ignore[too-many-positional-arguments]
+        vert_out = gpu.types.GPUStageInterfaceInfo("my_interface")
        vert_out.smooth("VEC3", "co")

        shader_info = gpu.types.GPUShaderCreateInfo()
@@ -118,6 +118,19 @@ def update_shader_graph(self: Union["Texture", "BIMStylesProperties"], context:
    tool.Loader.create_surface_style_with_textures(material, shading_data, textures_data)


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

-    parent_system_id: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    parent_system_id: bpy.props.IntProperty()

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


 def add_object_button(self, context):
@@ -26,16 +26,16 @@ from bpy.types import PropertyGroup


 class WebProperties(PropertyGroup):
-    webserver_port: IntProperty(  # pyright: ignore[reportRedeclaration]
+    webserver_port: IntProperty(
        name="Webserver Port",
        min=0,
        max=65535,
    )
-    is_running: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    is_running: BoolProperty(
        name="Webserver Running Status",
        default=False,
    )
-    is_connected: BoolProperty(  # pyright: ignore[reportRedeclaration]
+    is_connected: BoolProperty(
        name="Connection Status",
        default=False,
    )
@@ -159,9 +159,9 @@ class SelectURIAttribute(bpy.types.Operator, ImportHelper):
    bl_label = "Select URI Attribute"
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Select a local file"
-    attribute_data_path: bpy.props.StringProperty(name="Data Path")  # pyright: ignore[reportRedeclaration]
+    attribute_data_path: bpy.props.StringProperty(name="Data Path")
    """Full data path to `Attribute`/string property."""
-    use_relative_path: bpy.props.BoolProperty(  # pyright: ignore[reportRedeclaration]
+    use_relative_path: bpy.props.BoolProperty(
        name="Use Relative Path",
        default=False,
    )
@@ -601,7 +601,7 @@ class CreateMacBonsaiApp(bpy.types.Operator):
        "ALT+click to uninstall Bonsai app if it was installed previously."
    )

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

    if TYPE_CHECKING:
        uninstall: bool
@@ -1667,7 +1667,7 @@ class BIM_OT_attribute_add_subitem(bpy.types.Operator):
    bl_description = "Add subitem to the current attribute"
    bl_options = {"REGISTER", "UNDO"}

-    data_path: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    data_path: bpy.props.StringProperty()
    """Full data path."""

    if TYPE_CHECKING:
@@ -1691,9 +1691,9 @@ class BIM_OT_attribute_remove_subitem(bpy.types.Operator):
    bl_description = "Add subitem to the current attribute"
    bl_options = {"REGISTER", "UNDO"}

-    data_path: bpy.props.StringProperty()  # pyright: ignore[reportRedeclaration]
+    data_path: bpy.props.StringProperty()
    """Full data path."""
-    index: bpy.props.IntProperty()  # pyright: ignore[reportRedeclaration]
+    index: bpy.props.IntProperty()

    if TYPE_CHECKING:
        data_path: str
@@ -0,0 +1,462 @@
+# Bonsai - OpenBIM Blender Add-on
+# Copyright (C) 2026
+#
+# This file is part of Bonsai.
+#
+# Bonsai is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Bonsai is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This file was generated with the assistance of an AI coding tool.
+
+"""Shared operator mixins for parametric-edit operators.
+
+Edit-lifecycle mixins (Enable / Finish / Cancel):
+    `FeatureModifierEditMixin` — door, window (BBIM_<Type> pset; nested
+        lining/panel properties; Finish + Cancel route through
+        ``ifcopenshell.api.feature``).
+    `PathPreservingEditMixin` — railing, roof (path_data preserved across
+        edit; only general kwargs are user-editable).
+
+Pattern selection (which approach a new feature should adopt):
+    Every parametric edit lifecycle commits to one of three patterns. Pick by
+    answering "does the feature share the Enable→Finish→Cancel shape that
+    one of the existing mixins already encodes?":
+
+    A. Inherit one of the shared mixins below and route through
+       `tool.Parametric.build_edit_lifecycle`:
+
+       - `FeatureModifierEditMixin` when the feature stores its pset as
+         `{general fields} + {lining_properties: {...}} + {panel_properties: {...}}`
+         and Finish must call a per-type `update_<type>_modifier_representation`.
+
+       - `PathPreservingEditMixin` when the feature's pset carries a
+         `path_data` field that survives general-kwarg edits untouched, with
+         a separate Enable/Finish/Cancel lifecycle for path editing itself.
+
+    B. Write a per-feature mixin that subclasses `ParametricEditMixinBase`
+       and provides `_enable_targets` / `_finish_targets` / `_cancel_targets`,
+       then route through `build_edit_lifecycle`. Pick this when the
+       feature's pset roundtrip or representation handling diverges from the
+       shared mixins but the Enable→Finish→Cancel shape still fits.
+
+    C. Declare standalone Enable/Finish/Cancel Operator subclasses (no
+       factory) when the feature's parameter-change logic is sufficiently
+       unique that even a per-feature mixin would force optional hooks or
+       dead branches. Such operators MUST call the matrix_world drift
+       helpers (`tool.Geometry.commit_placement_if_moved` on Enable/Finish,
+       `tool.Geometry.restore_or_rebaseline_placement` on Cancel) — the
+       drift contract is enforced uniformly regardless of which pattern the
+       operators adopt.
+
+    The authoritative list of registered parametric types — and which use
+    `build_edit_lifecycle` vs. standalone operators — lives in
+    `tool/parametric.py`'s `EDIT_TYPES` and is enforced by the registry
+    contract tests in `test/bim/test_parametric_registry.py`.
+
+This module hosts operator-side mixins that import ``bonsai.tool`` freely.
+The lightweight parametric registry consumed at addon-enable time must stay
+free of such imports and lives separately in ``tool/parametric.py``."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import TYPE_CHECKING, ClassVar
+
+import bpy
+import ifcopenshell.util.element
+from bpy.app.handlers import persistent
+
+import bonsai.core.geometry
+import bonsai.tool as tool
+
+if TYPE_CHECKING:
+    from ifcopenshell import entity_instance
+
+
+class ParametricEditMixinBase:
+    """Common scaffolding for parametric edit-lifecycle mixins.
+
+    Each per-type subclass provides four hooks:
+
+        ``pset_name``: BBIM_<Type> pset identifier
+        ``_is_element_type(element)``: IFC element predicate
+        ``_get_props(obj)``: PropertyGroup accessor
+        ``_iter_targets(context)``: list of objects to act on (default: ``[active_object]``)
+
+    Drift handling is built in: pre-edit matrix_world drift commits to IFC on
+    Enable, in-edit drag commits on Finish, and Cancel restores the committed
+    IFC placement. This prevents an uncommitted drag from disappearing on
+    Finish or snapping back on Cancel.
+
+    Operator subclasses call one of ``_enable_targets`` / ``_finish_targets`` /
+    ``_cancel_targets`` from their ``_execute`` method."""
+
+    pset_name: ClassVar[str]
+
+    @classmethod
+    def _iter_targets(cls, context: bpy.types.Context) -> list[bpy.types.Object]:
+        obj = context.active_object
+        return [obj] if obj else []
+
+    @classmethod
+    def _is_element_type(cls, element: entity_instance) -> bool:
+        raise NotImplementedError
+
+    @classmethod
+    def _get_props(cls, obj: bpy.types.Object):
+        raise NotImplementedError
+
+    @classmethod
+    def _resolve(cls, obj: bpy.types.Object):
+        """Look up ``(element, props)`` for ``obj`` if it matches this type, else None.
+
+        Common predicate guard for every lifecycle method — collapses the
+        ``element = tool.Ifc.get_entity(obj); assert element; if not is_<type>(element): return``
+        triplet into one call."""
+        element = tool.Ifc.get_entity(obj)
+        if not element or not cls._is_element_type(element):
+            return None
+        return element, cls._get_props(obj)
+
+    @classmethod
+    def _handle_drift_on_enable(cls, obj: bpy.types.Object) -> None:
+        tool.Geometry.commit_placement_if_moved(obj, apply_scale=False)
+
+    @classmethod
+    def _handle_drift_on_finish(cls, obj: bpy.types.Object) -> None:
+        tool.Geometry.commit_placement_if_moved(obj)
+
+    @classmethod
+    def _handle_drift_on_cancel(cls, obj: bpy.types.Object, element: entity_instance) -> None:
+        tool.Geometry.restore_or_rebaseline_placement(obj, element)
+
+    @classmethod
+    def _mark_type_thumbnail_dirty(cls, element: entity_instance) -> None:
+        """Mark the element's type's preview thumbnail for refresh so the
+        property-panel preview reflects post-edit geometry. No-op for
+        occurrences without a backing type."""
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            tool.Model.mark_thumbnail_for_update(element_type)
+
+
+class FeatureModifierEditMixin(ParametricEditMixinBase):
+    """Lifecycle for door- and window-style parametric modifier operators.
+
+    Enable:
+        Read BBIM_<Type> pset JSON → unwrap ``lining_properties`` and
+        ``panel_properties`` → merge constituents data → set draft props →
+        ``is_editing = True``.
+
+    Finish:
+        Gather ``general / lining / panel`` kwargs (project units) → nest →
+        ``is_editing = False`` → call ``_update_modifier_representation`` →
+        mark thumbnail → write back to BBIM_<Type> pset via
+        ``ifcopenshell.api.pset.edit_pset``.
+
+    Cancel:
+        Read BBIM_<Type> pset JSON → unwrap → restore draft props →
+        ``switch_representation`` to the Body representation →
+        ``is_editing = False``."""
+
+    @classmethod
+    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Hook: call the per-type ``update_<type>_modifier_representation``."""
+        raise NotImplementedError
+
+    @classmethod
+    def _enable_one(cls, obj: bpy.types.Object) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        cls._handle_drift_on_enable(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, cls.pset_name, "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        data.update(tool.Model.get_constituents_props_data(element))
+        # required since the pset can be loaded from .ifc and the PropertyGroup
+        # would otherwise still hold its default values
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    @classmethod
+    def _finish_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        data = props.get_general_kwargs(convert_to_project_units=True)
+        data["lining_properties"] = props.get_lining_kwargs(convert_to_project_units=True)
+        data["panel_properties"] = props.get_panel_kwargs(convert_to_project_units=True)
+        cls._update_modifier_representation(obj, context)
+        cls._mark_type_thumbnail_dirty(element)
+        tool.Pset.write_bbim_data(element, cls.pset_name, data)
+        cls._handle_drift_on_finish(obj)
+        # Set only on success: if any IFC op above raised, the user's draft survives for retry.
+        props.is_editing = False
+
+    @classmethod
+    def _cancel_one(cls, obj: bpy.types.Object) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        # Cancel must always clear is_editing — leaving it True after a
+        # restore-failure would block the user from re-entering edit mode and
+        # the next save's stale-flag heal would silently roll back the
+        # cancellation. Wrap the restore in try/finally so the flag flips
+        # even on partial failure.
+        try:
+            data = json.loads(ifcopenshell.util.element.get_pset(element, cls.pset_name, "Data"))
+            data.update(data.pop("lining_properties"))
+            data.update(data.pop("panel_properties"))
+            props.set_props_kwargs_from_ifc_data(data)
+            body = tool.Geometry.get_body_representation(element)
+            bonsai.core.geometry.switch_representation(tool.Ifc, tool.Geometry, obj=obj, representation=body)
+            cls._handle_drift_on_cancel(obj, element)
+        finally:
+            props.is_editing = False
+
+    def _enable_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._enable_one(obj)
+        return {"FINISHED"}
+
+    def _finish_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._finish_one(obj, context)
+        return {"FINISHED"}
+
+    def _cancel_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._cancel_one(obj)
+        return {"FINISHED"}
+
+
+class PathPreservingEditMixin(ParametricEditMixinBase):
+    """Lifecycle for railing- and roof-style parametric modifier operators.
+
+    Distinctive: ``path_data`` is part of the BBIM_<Type> pset but is **not**
+    user-editable through this lifecycle — it survives the edit untouched, only
+    general kwargs are diffed. (Path editing has its own separate operator
+    pair, ``Enable/Finish/CancelEditing<Type>Path``, out of scope here.)
+
+    Enable:
+        Fetch pset data via ``tool.Model.get_modeling_bbim_pset_data`` → set
+        draft props → ``is_editing = True``. The subclass post-load hook
+        can reshape the dict to fit the PropertyGroup's storage layout
+        (e.g., pre-serialise a structured pset value to JSON for a
+        ``StringProperty`` field).
+
+    Finish:
+        Read fresh pset → keep ``path_data`` → gather ``general`` kwargs
+        (project units) → reassemble → ``is_editing = False`` → call
+        ``_update_pset`` (per-type pset writer) → call ``_update_modifier_ifc_data``
+        (per-type geometry commit).
+
+    Cancel:
+        Read fresh pset → restore draft props → call
+        ``_restore_viewport_after_cancel`` (per-type viewport restore — typically
+        rebuilds the bmesh preview, but subclasses may load a different
+        representation entirely) → ``is_editing = False``."""
+
+    @classmethod
+    def _post_load_data(cls, data: dict) -> dict:
+        """Hook: optionally transform the pset data dict after loading and before
+        passing to ``set_props_kwargs_from_ifc_data``. Default: pass-through.
+
+        Override when the PropertyGroup stores a structured pset field as a
+        serialised primitive — e.g., a list/dict value mapped onto a
+        ``StringProperty`` requires JSON-encoding here."""
+        return data
+
+    @classmethod
+    def _update_pset(cls, element: entity_instance, data: dict) -> None:
+        """Hook: per-type pset writer (``update_bbim_<type>_pset``)."""
+        raise NotImplementedError
+
+    @classmethod
+    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Hook: per-type ``update_<type>_modifier_ifc_data`` — commits the
+        modified geometry to IFC. Signature accepts ``(obj, context)`` so
+        subclasses can forward either argument to their existing helper."""
+        raise NotImplementedError
+
+    @classmethod
+    def _restore_viewport_after_cancel(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        """Hook: restore the viewport mesh to match the just-restored draft props.
+
+        Most subclasses rebuild a bmesh preview from props. Subclasses whose
+        committed IFC representation diverges from the preview may switch
+        the mesh back to the committed representation instead."""
+        raise NotImplementedError
+
+    @classmethod
+    def _enable_one(cls, obj: bpy.types.Object) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        _element, props = resolved
+        cls._handle_drift_on_enable(obj)
+        data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)["data_dict"]
+        data = cls._post_load_data(data)
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    @classmethod
+    def _finish_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        pset_data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)
+        stored = pset_data["data_dict"]
+        data = props.get_general_kwargs(convert_to_project_units=True)
+        data["path_data"] = stored["path_data"]
+        # Skip the pset commit when the draft is identical to the stored pset:
+        # an Enable → Finish-without-changes cycle should not pollute the
+        # representation list or burn an undo entry. Drift commit still runs
+        # unconditionally — matrix_world drift is independent of pset content.
+        if data != stored:
+            cls._update_pset(element, data)
+            cls._update_modifier_ifc_data(obj, context)
+            cls._mark_type_thumbnail_dirty(element)
+        cls._handle_drift_on_finish(obj)
+        # Set only on success: if any IFC op above raised, the user's draft survives for retry.
+        props.is_editing = False
+
+    @classmethod
+    def _cancel_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
+        resolved = cls._resolve(obj)
+        if resolved is None:
+            return
+        element, props = resolved
+        try:
+            pset_data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)
+            stored = pset_data["data_dict"]
+            draft = props.get_general_kwargs(convert_to_project_units=True)
+            draft["path_data"] = stored["path_data"]
+            nothing_changed = draft == stored
+            data = cls._post_load_data(stored)
+            props.set_props_kwargs_from_ifc_data(data)
+            # Skip the viewport rebuild on a no-op cancel: the mesh on screen is
+            # still the committed representation, and the per-type viewport-restore
+            # hook may be expensive (some subclasses reload a high-poly IFC
+            # representation rather than rebuild a preview mesh).
+            if not nothing_changed:
+                cls._restore_viewport_after_cancel(obj, context)
+            cls._handle_drift_on_cancel(obj, element)
+        finally:
+            # Always clear the flag — see ``FeatureModifierEditMixin._cancel_one``
+            # for the rationale.
+            props.is_editing = False
+
+    def _enable_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._enable_one(obj)
+        return {"FINISHED"}
+
+    def _finish_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._finish_one(obj, context)
+        return {"FINISHED"}
+
+    def _cancel_targets(self, context: bpy.types.Context) -> set[str]:
+        for obj in self._iter_targets(context):
+            self._cancel_one(obj, context)
+        return {"FINISHED"}
+
+
+# --- Undo-resync registry ----------------------------------------------------
+#
+# Per-type regenerators called from ``resync_parametric_drafts_after_undo``
+# (wired into ``bim/handler.py:undo_post`` and ``redo_post``) so the preview
+# mesh of an in-progress parametric draft repaints after Ctrl+Z / Ctrl+Shift+Z.
+#
+# Each regenerator is a one-line lazy-import + call. Lazy imports because
+# ``bonsai.bim.parametric_lifecycle`` loads before ``bim/module/model/*``
+# at addon enable; a module-level import would cycle. Each function-local
+# import lands at first call, after the feature module has registered.
+#
+# Types with no entry — door, window, railing, etc. — are IFC-derived: undo
+# of an IFC mutation already restores the entity, and ``switch_representation``
+# repaints the mesh as a side effect of the next refresh. They don't need a
+# bespoke preview regenerator.
+
+
+def _wall_undo_regenerator(obj: bpy.types.Object) -> None:
+    from bonsai.bim.module.model.wall import regenerate_wall_mesh_from_props
+
+    regenerate_wall_mesh_from_props(obj)
+
+
+def _stair_undo_regenerator(obj: bpy.types.Object) -> None:
+    from bonsai.bim.module.model.stair import regenerate_stair_mesh
+
+    regenerate_stair_mesh(obj)
+
+
+def _roof_undo_regenerator(obj: bpy.types.Object) -> None:
+    from bonsai.bim.module.model.roof import update_roof_modifier_bmesh
+
+    update_roof_modifier_bmesh(obj)
+
+
+UNDO_REGENERATORS: dict[str, Callable[[bpy.types.Object], None]] = {
+    "wall": _wall_undo_regenerator,
+    "stair": _stair_undo_regenerator,
+    "roof": _roof_undo_regenerator,
+}
+
+
+def resync_parametric_drafts_after_undo() -> None:
+    """Re-render preview meshes for every parametric draft currently active.
+
+    Walks all objects, skips any not in a registered parametric edit,
+    dispatches to the per-type regenerator in ``UNDO_REGENERATORS``. A type
+    without an entry is left alone — its preview is either already correct
+    (IFC-derived) or has no draft preview mesh."""
+    for obj in bpy.data.objects:
+        feature = tool.Parametric.is_object_editing(obj)
+        if feature is None:
+            continue
+        regenerator = UNDO_REGENERATORS.get(feature.name)
+        if regenerator is None:
+            continue
+        regenerator(obj)
+    tool.Blender.update_all_viewports()
+
+
+@persistent
+def _resync_on_undo(scene: bpy.types.Scene) -> None:
+    resync_parametric_drafts_after_undo()
+
+
+def install_parametric_lifecycle_handlers() -> None:
+    """Append the undo-resync callback to undo_post and redo_post; idempotent.
+
+    Caller must invoke this AFTER appending the central undo/redo handlers so
+    regenerators see restored IFC state — bpy.app.handlers fire in append order."""
+    for hook in (bpy.app.handlers.undo_post, bpy.app.handlers.redo_post):
+        if _resync_on_undo not in hook:
+            hook.append(_resync_on_undo)
+
+
+def uninstall_parametric_lifecycle_handlers() -> None:
+    for hook in (bpy.app.handlers.undo_post, bpy.app.handlers.redo_post):
+        try:
+            hook.remove(_resync_on_undo)
+        except ValueError:
+            pass
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .8.5
 .8.6