Fix #6652: Extend grab selection to include BBIM_Array members

When grabbing an array child, the selection now expands to include
the array parent and all sibling children before the move operator
runs. Mirrors existing behavior for aggregates and nests.

Generated with the assistance of an AI coding tool.

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

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

.github/workflows/ci-lint.yaml

@@ -27,10 +27,7 @@ jobs:
       - name: Install dependencies
         run: |
           curl -LsSf https://astral.sh/uv/install.sh | sh
-          uv tool install ruff
-          uv tool install black
-          uv tool install poethepoet
-          uv tool install ty==0.0.34
+          cat requirements-tools.txt | xargs -L1 uv tool install
 
       # black doesn't catch all syntax errors, so we check them explicitly.
       - name: Check syntax errors
@@ -58,11 +55,17 @@ 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
+      - name: ty check (venv setup)
+        run: poe ty-venv
+
+      - name: ty check (bonsai)
+        id: ty-bonsai
+        run: poe ty-bonsai
+        continue-on-error: true
+
+      - name: ty check (ios)
+        id: ty-ios
+        run: poe ty-ios
         continue-on-error: true
 
       - name: Ruff check
@@ -112,7 +115,10 @@ 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
+          if [ "${{ steps.ty-bonsai.outcome }}" != "success" ]; then
+            echo "::error::ty check (bonsai) failed, see 'ty check (bonsai)' step for the details." && ERROR=1
+          fi
+          if [ "${{ steps.ty-ios.outcome }}" != "success" ]; then
+            echo "::error::ty check (ios) failed, see 'ty check (ios)' step for the details." && ERROR=1
           fi
           exit $ERROR

.gitignore

@@ -4,6 +4,8 @@
 /_deps-vs*-x*-installed/
 /_installed-vs*-x*/
 /build/
+/build.log
+/output/
 /src/examples/build/
 # ifctester docs output
 /src/ifctester/test/build/
@@ -22,6 +24,7 @@
 __pycache__
 *.py.bak
 venv
+uv.lock
 
 # Visual Studio Code files
 .vscode

README.md

@@ -18,7 +18,7 @@ and many other libraries, CLI apps, and more. Support is also provided for auxil
 
 For more information, see:
 
-* [IfcOpenShell Website](http://ifcopenshell.org)
+* [IfcOpenShell Website](https://ifcopenshell.org)
 * [IfcOpenShell Documentation](https://docs.ifcopenshell.org)
   * [IfcOpenShell C++ Installation](https://docs.ifcopenshell.org/ifcopenshell/installation.html)
   * [IfcOpenShell Python Installation](https://docs.ifcopenshell.org/ifcopenshell-python/installation.html)

cmake/CMakeLists.txt

@@ -563,8 +563,8 @@ if(COMPILE_SCHEMA)
     # Bootstrap the parser
     message(STATUS "Compiling schema, this will take a while...")
     execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf
-        WORKING_DIRECTORY ../src/ifcexpressparser
+        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py
+        WORKING_DIRECTORY ../src/ifcopenshell-python/ifcopenshell/express
         OUTPUT_FILE express_parser.py
         RESULT_VARIABLE SUCCESS
     )
@@ -575,7 +575,7 @@ if(COMPILE_SCHEMA)
 
     # Generate code
     execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
+        COMMAND ${PYTHON_EXECUTABLE} ../ifcopenshell-python/ifcopenshell/express/express_parser.py ../../${COMPILE_SCHEMA}
         WORKING_DIRECTORY ../src/ifcparse
         OUTPUT_VARIABLE COMPILED_SCHEMA_NAME
     )

docker/.dockerignore

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

docker/.gitignore

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

docker/.ifcos_env

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

docker/Dockerfile

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

docker/README.md

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

docker/SKILL.md

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

docker/compose.yaml

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

docker/ifcos_env

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

nix/build-all.py

@@ -50,7 +50,7 @@ Used environment variables:
     - ``NO_CLEAN`` - do not clean `ifcopenshell` build directories but continue working on current build
     (installed dependencies are never cleared).
     By default option is disabled, to enable pass any value from `1`, `on`, `true`.
-    - ``IFCOS_SCHEMAS`` - schemas to be built; defaults to cmake default (IFC2X3; IFC4; IFC4X3_ADD2) - to be supplied as `2x3;4`
+    - ``IFCOS_SCHEMAS`` - schemas to be built; defaults to cmake default (8 schemas), to be supplied as `2x3;4;4x3_add2`
     - ``USE_OCCT`` - whether to use official Open CASCADE instead of Community Edition
     (`true` by default, any other value is considered `false`)
     - ``WASM_PYTHON_PATH`` - path to WASM Python installation,
@@ -155,7 +155,7 @@ MPFR_VERSION = "3.1.6"  # latest is 4.1.0
 CGAL_VERSION = "v5.6.3"
 USD_VERSION = "23.05"
 TBB_VERSION = "2021.9.0"
-ROCKSDB_VERSION = "9.11.2"
+ROCKSDB_VERSION = "10.4.2"
 ZSTD_VERSION = "1.5.7"
 # binaries
 cp = "cp"
@@ -627,9 +627,10 @@ def build_dependency(
     build_tool_args: "list[str]",
     download_url: str,
     download_name: str,
+    *,
     download_tool: Literal["py", "git"] = download_tool_default,
     revision: "Union[str, None]" = None,
-    patch: "Union[str, list[str], None]" = None,
+    patch: list[str] | None = None,
     shell=None,
     pre_compile_subs: "Sequence[tuple[str, str, str]]" = (),
     additional_files: "Union[dict[str, str], None]" = None,
@@ -714,8 +715,6 @@ def build_dependency(
                 urlretrieve(url, os.path.join(extract_dir, path))
 
     if patch is not None:
-        if isinstance(patch, str):
-            patch = [patch]
         for p in patch:
             patch_abs = (SCRIPT_PATH / p).absolute().__str__()
             if os.path.exists(patch_abs):
@@ -724,6 +723,8 @@ def build_dependency(
                 except Exception as e:
                     # Assert that the patch has already been applied
                     run(["patch", "-p1", "--batch", "--reverse", "--dry-run", "-i", patch_abs], cwd=extract_dir)
+            else:
+                raise FileNotFoundError(patch_abs)
 
     if shell is not None:
         sp.run(shell, shell=True, check=True, cwd=extract_dir)
@@ -1171,6 +1172,14 @@ if "cgal" in targets:
         os.environ["CC"] = MAC_CROSS_COMPILE_INTEL_CC
         gmp_args.extend(MAC_CROSS_COMPILE_INTEL_AUTOCONF_HOST_ARGS)
 
+    # Fixes configure failing to find a working compiler under GCC 15's default -std=gnu23.
+    # Issue presumably will be resolved in any next gmp version, but currently the last one is 6.3.0.
+    # Patch is just applying fix from upstream meantion below:
+    # https://gmplib.org/list-archives/gmp-bugs/2025-February/005561.html
+    gmp_patches = ["./patches/gmp/001-fix-std23.patch"]
+    if GMP_VERSION != "6.3.0":
+        raise Exception(f"GMP_VERSION changed to {GMP_VERSION}, check whether {gmp_patches} is still needed.")
+
     build_dependency(
         name=f"gmp-{GMP_VERSION}",
         mode="autoconf",
@@ -1178,6 +1187,7 @@ if "cgal" in targets:
         pre_compile_subs=(
             [("build/config.h", "HAVE_OBSTACK_VPRINTF 1", "HAVE_OBSTACK_VPRINTF 0")] if "wasm" in flags else []
         ),
+        patch=gmp_patches,
         # Sometimes ftp.gnu.org is very slow, use ftpmirror.gnu.org as a workaround.
         download_url="https://ftpmirror.gnu.org/gnu/gmp/",
         download_name=f"gmp-{GMP_VERSION}.tar.bz2",

nix/cache_dependencies.py

@@ -68,6 +68,7 @@ def unpack_dependencies(install_dir: Path) -> None:
 
 
 if __name__ == "__main__":
+    action = None
     if len(sys.argv) != 2 or (action := sys.argv[1].lower()) not in ("pack", "unpack"):
         print(__doc__)
         sys.exit(1)

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

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

nix/patches/occt/88af392.patch

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

nix/patches/pr622.patch

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

pyproject.toml

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

requirements-tools.txt

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

src/bcf/bcf/v3/bcfapi.py

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

src/bonsai/bonsai/bim/data/assets/default.css

@@ -24,10 +24,28 @@ a text, a tspan {  fill: blue !important;  text-decoration: underline;}
 a:hover { cursor: pointer; }
 .cut { fill: black; stroke: black; stroke-linecap: 'round'; stroke-width: 0.35; fill-rule: evenodd; }
 .projection { fill: white; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
-.surface { stroke: none; fill: #fff; fill-rule: evenodd; }
-.annotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
-.IfcAnnotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
-.IfcGeographicElement { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 1; }
+/* SVG edge classification (issue #3668): see edge-classification.md. These select directly on
+   the <path> element (each classified projection edge carries its own class), so they win over
+   the inherited .projection rule above regardless of specificity. */
+path.outline { stroke: black; stroke-width: 0.35; stroke-opacity: 1; }
+path.boundary { stroke: black; stroke-width: 0.3; stroke-opacity: 0.9; }
+path.crease { stroke: black; stroke-width: 0.25; stroke-opacity: 0.85; }
+path.sharp { stroke: black; stroke-width: 0.18; stroke-opacity: 0.7; }
+path.flush { stroke: black; stroke-width: 0.1; stroke-opacity: 0.4; }
+
+/* Debug CSS for troubleshooting edge classification */
+/*
+path.outline { stroke: black; stroke-width: 0.35; stroke-opacity: 1; }
+path.boundary { stroke: orange; stroke-width: 0.3; stroke-opacity: 0.9; }
+path.crease { stroke: green; stroke-width: 0.25; stroke-opacity: 0.85; }
+path.sharp { stroke: red; stroke-width: 0.18; stroke-opacity: 0.7; }
+path.flush { stroke: blue; stroke-width: 0.1; stroke-opacity: 0.4; }
+*/
+
+.surface {fill: white; stroke-width: 0.1;}
+.annotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.3; }
+.IfcAnnotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.3; }
+/* .IfcGeographicElement { fill: none; stroke: rgb(150, 150, 150); stroke-linecap: 'round'; stroke-dasharray: 1, 2;} */
 .PredefinedType-LINEWORK { stroke: black; stroke-width: 0.25; }
 .PredefinedType-LINEWORK.dashed { stroke-dasharray: 3, 2; }
 .PredefinedType-LINEWORK.fine { stroke-width: 0.18; stroke: #777777; }

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

@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',$,$,'EPset_Drawing','EPset_D
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#23,#22,#27,#24,#29,#30,#19,#12,#26,#9,#8,#7,#6,#4,#18,#11,#5,#20,#25,#14,#10,#17,#28,#16,#3,#21,#13,#15,#2));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#23,#22,#27,#24,#29,#30,#19,#12,#26,#9,#8,#7,#6,#4,#18,#11,#5,#20,#25,#14,#10,#17,#28,#16,#3,#21,#13,#15,#2,#31,#32,#33,#34,#35,#36));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','The scale of this drawing represented as a numerator and denominator, such as 1/100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','The scale of this drawing in human readable format, such as 1:100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -35,5 +35,11 @@ DATA;
 #28=IFCSIMPLEPROPERTYTEMPLATE('1YSnFzurrEyRNtoLdmmddP',$,'BringToFront','The objects with these SVG classes will render in front of all other objects.Ex: IfcBeam, IfcColumn',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
 #29=IFCSIMPLEPROPERTYTEMPLATE('0lP6Y8q9v2QhDnR4sT7uVx',$,'PerspectiveShiftX','Horizontal perspective camera shift stored as drawing metadata using Blender camera shift units.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
 #30=IFCSIMPLEPROPERTYTEMPLATE('2mR8b1NcW5EoFyG7hJ9kLp',$,'PerspectiveShiftY','Vertical perspective camera shift stored as drawing metadata using Blender camera shift units.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
+#31=IFCSIMPLEPROPERTYTEMPLATE('1cFVJnqT13m8ItkMHaI1tp',$,'UseEdgeClassification','Enable the boundary/outline/sharp/crease/flush SVG edge classification scheme (issue #3668). When false, drawings use the original unclassified linework.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#32=IFCSIMPLEPROPERTYTEMPLATE('2kB$mxBgnBUvhjh0Ti0c4P',$,'RenderCreases','Whether to render ''crease'' (concave) edges. Only relevant when UseEdgeClassification is enabled.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#33=IFCSIMPLEPROPERTYTEMPLATE('3MSIJNW$T8r9Hl12kk0BY$',$,'ValleyAngleMinDegrees','Minimum concave dihedral deviation from flat, in degrees, for a projection edge to be classified as ''crease'' rather than ''flush''.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
+#34=IFCSIMPLEPROPERTYTEMPLATE('2epSGfC4bFM9gb1X7zBIp4',$,'RenderSharp','Whether to render ''sharp'' (convex) edges. Only relevant when UseEdgeClassification is enabled.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#35=IFCSIMPLEPROPERTYTEMPLATE('3TZwsEjkr5WRDKcgrYzSIA',$,'RidgeAngleMinDegrees','Minimum convex dihedral deviation from flat, in degrees, for a projection edge to be classified as ''sharp'' rather than ''flush''.',.P_SINGLEVALUE.,'IfcReal',$,$,$,$,$,.READWRITE.);
+#36=IFCSIMPLEPROPERTYTEMPLATE('2Jua$lO754vgZOkBoHM2gA',$,'RenderFlush','Whether to render ''flush'' edges (dihedral deviation below both ridge/valley thresholds). Only relevant when UseEdgeClassification is enabled.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;

src/bonsai/bonsai/bim/ifc.py

@@ -46,7 +46,7 @@ IFC_CONNECTED_TYPE = Union[bpy.types.Material, bpy.types.Object]
 class OperationData(TypedDict):
     id: int
     guid: NotRequired[str]
-    obj: str
+    obj: NotRequired[str]
 
 
 class EditObjectOperationData(TypedDict):

src/bonsai/bonsai/bim/import_ifc.py

@@ -980,8 +980,13 @@ class IfcImporter:
                     if unit.Name == "METRE":
                         if not unit.Prefix:
                             bpy.context.scene.unit_settings.length_unit = "METERS"
-                        else:
+                        elif f"{unit.Prefix}METERS" in ("KILOMETERS", "CENTIMETERS", "MILLIMETERS", "MICROMETERS"):
                             bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
+                        else:
+                            # Blender's length_unit enum has no entry for other
+                            # SI prefixes (e.g. DECIMETERS), so fall back to
+                            # adaptive display instead of failing to open.
+                            bpy.context.scene.unit_settings.length_unit = "ADAPTIVE"
                 else:
                     bpy.context.scene.unit_settings.system = "IMPERIAL"
                     name = unit.Name.lower()
@@ -1098,12 +1103,14 @@ class IfcImporter:
         vertices = [[v[i], v[i + 1], v[i + 2], 1] for i in range(0, len(v), 3)]
         edges = [[e[i], e[i + 1]] for i in range(0, len(e), 2)]
         v2 = None
+        polyline = None
         for edge in edges:
             v1 = vertices[edge[0]]
             if v1 != v2:
                 polyline = curve.splines.new("POLY")
                 polyline.points[-1].co = mathutils.Vector(v1)
             v2 = vertices[edge[1]]
+            assert polyline is not None
             polyline.points.add(1)
             polyline.points[-1].co = mathutils.Vector(v2)
         edges_item_ids = ifcopenshell.util.shape.get_edges_representation_item_ids(geometry).tolist()

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

@@ -843,7 +843,6 @@ class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
                         settings = ifcopenshell.geom.settings()
                         shape = ifcopenshell.geom.create_shape(settings, opening)
                         mat = Matrix(ifcopenshell.util.shape.get_shape_matrix(shape))
-                        mat.translation = (0, 0, 0)
                         opening_bm = bmesh.new()
                         verts = ifcopenshell.util.shape.get_vertices(shape.geometry)
                         for vert in verts:
@@ -1060,6 +1059,7 @@ class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
         return tool.Ifc.get().createIfcConnectionSurfaceGeometry(surface)
 
     def export_surface(self, polygon, target_face_matrix):
+        ifc_file = tool.Ifc.get()
         x_axis = target_face_matrix.col[0][:3]
         z_axis = target_face_matrix.col[2][:3]
         p1 = target_face_matrix.translation
@@ -1072,18 +1072,20 @@ class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
         placement = builder.create_axis2_placement_3d([o / self.unit_scale for o in p1], z_axis, x_axis)
         surface.BasisSurface = tool.Ifc.get().create_entity("IfcPlane", placement)
 
-        if tool.Ifc.get().schema != "IFC2X3":
+        schema = ifc_file.schema
+        if schema != "IFC2X3":
             points = [tool.Model.convert_si_to_unit(list(co)) for co in polygon.exterior.coords]
             point_list = tool.Ifc.get().createIfcCartesianPointList2D(points)
             outer_boundary = tool.Ifc.get().createIfcIndexedPolyCurve(point_list, None, False)
 
-            inner_boundaries = []
+            inner_boundaries: list[ifcopenshell.entity_instance] = []
             for interior in polygon.interiors:
                 points = [tool.Model.convert_si_to_unit(list(co)) for co in interior.coords]
                 point_list = tool.Ifc.get().createIfcCartesianPointList2D(points)
                 inner_boundaries.append(tool.Ifc.get().createIfcIndexedPolyCurve(point_list, None, False))
         else:
-            pass  # TODO
+            # TODO:
+            raise NotImplementedError(schema)
 
         surface.OuterBoundary = outer_boundary
         surface.InnerBoundaries = inner_boundaries

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

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

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

@@ -400,6 +400,7 @@ class CadOffset(bpy.types.Operator):
         [verts.update(e.verts) for e in edges]
 
         # Use the viewport angle to determine the offset direction
+        wp = None
         for area in bpy.context.screen.areas:
             if area.type == "VIEW_3D":
                 # Don't ask me, I don't know.
@@ -409,6 +410,7 @@ class CadOffset(bpy.types.Operator):
                 z = area.spaces.active.region_3d.view_rotation @ Vector((0, 0, 1))
                 wp = Matrix([x, y, z, Vector((0, 0, 0))]).to_4x4().transposed()
                 break
+        assert wp is not None
 
         rotation = Matrix.Rotation(pi / 2, 2, "Z")
         rotation_i = Matrix.Rotation(-pi / 2, 2, "Z")

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

@@ -478,6 +478,7 @@ class ChangeClassificationLevel(bpy.types.Operator):
     def execute(self, context):
         props = tool.Classification.get_classification_props()
         props.available_library_references.clear()
+        reference = None
         for reference in IfcStore.classification_file.by_id(self.parent_id).HasReferences:
             new = props.available_library_references.add()
             new.identification = reference.Identification or ""
@@ -485,6 +486,7 @@ class ChangeClassificationLevel(bpy.types.Operator):
             new.ifc_definition_id = reference.id()
             new.has_references = bool(reference.HasReferences)
             new.referenced_source
+        assert reference
         if reference.ReferencedSource.is_a("IfcClassificationReference"):
             props.active_library_referenced_source = reference.ReferencedSource.ReferencedSource.id()
         else:

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

@@ -156,6 +156,8 @@ class CostSchedulesData:
             values = root_element.CostValues
         elif root_element.is_a("IfcConstructionResource"):
             values = root_element.BaseCosts
+        else:
+            assert False, root_element
         for cost_value in values or []:
             cls._load_cost_value(root_element, data, cost_value)
             # data["CostValues"].append(cost_value.id())

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

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

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

@@ -425,10 +425,12 @@ class BaseDecorator:
 
         blf.size(font_id, font_size_px)
 
+        w, h = None, None
         if box_alignment or center or vcenter:
             w, h = blf.dimensions(font_id, text)
 
         if box_alignment:
+            assert w is not None and h is not None
             box_alignment_offset = Vector((0, 0))
             if "bottom" in box_alignment:
                 pass
@@ -450,10 +452,12 @@ class BaseDecorator:
         else:
             # horizontal centering
             if center:
+                assert w is not None
                 pos -= Vector((cos, sin)) * w * 0.5
 
             # vertical centering
             if vcenter:
+                assert h is not None
                 pos -= Vector((-sin, cos)) * h * 0.5
 
             # side-shifting
@@ -1001,6 +1005,8 @@ class FallDecorator(BaseDecorator):
             O = A.copy()
             O.z = B.z
             run = (B - O).length
+
+            angle_tg = None
             if run != 0:
                 angle_tg = rise / run
                 angle = round(degrees(atan(angle_tg)))
@@ -1018,6 +1024,7 @@ class FallDecorator(BaseDecorator):
             elif object_type == "SLOPE_PERCENT":
                 if angle == 90:
                     return "-"
+                assert angle_tg is not None
                 return f"{round(angle_tg * 100)} %"
             return "NO DATA"
 
@@ -1249,6 +1256,7 @@ class SectionLevelDecorator(BaseDecorator):
         }
 
         # process edges
+        text_position, text_dir = None, None
         for edge in edges_original:
             v0, v1 = winspace_verts[edge[0]], winspace_verts[edge[1]]
             start_i = len(output_verts)
@@ -1554,32 +1562,39 @@ class SectionDecorator(BaseDecorator):
             v0, v1 = winspace_verts[edge[0]], winspace_verts[edge[1]]
             start_i = len(output_verts)
 
+            circle_head = None
             if display_start_circle or display_end_circle:
                 circle_head = get_circle_head(circle_size)
 
-            if display_start_symbol or display_end_symbol or connect_markers:
+            triangle_head, divider_offset, edge_dir_circle = None, None, None
+            display_symbol = display_start_symbol or display_end_symbol
+            if display_symbol or connect_markers:
                 edge_dir = (v1 - v0).normalized()
                 side = (edge_dir.yx * Vector((1, -1))).to_3d()
                 edge_dir_circle = edge_dir * circle_size
 
-            if display_start_symbol or display_end_symbol:
-                triangle_head = get_triangle_head(edge_dir, -side, triangle_length, triangle_width)
-                divider_offset = []
-                divider_offset.append(edge_dir_circle if connect_markers else edge_dir_circle * 3)
-                divider_offset.append(edge_dir_circle)
+                if display_symbol:
+                    triangle_head = get_triangle_head(edge_dir, -side, triangle_length, triangle_width)
+                    divider_offset = []
+                    divider_offset.append(edge_dir_circle if connect_markers else edge_dir_circle * 3)
+                    divider_offset.append(edge_dir_circle)
 
             if display_start_circle:
+                assert circle_head is not None
                 start_i = add_verts_sequence([v + v0 for v in circle_head], start_i, **out_kwargs, closed=True)
                 # circle middle divider
                 if not display_start_symbol:
+                    assert divider_offset is not None
                     start_i = add_verts_sequence(
                         [v0 + divider_offset[0], v0 - divider_offset[1]], start_i, **out_kwargs
                     )
 
             if display_start_symbol:
+                assert triangle_head is not None
                 start_i = add_verts_sequence([v + v0 for v in triangle_head], start_i, **out_kwargs, closed=True)
 
             if display_end_circle:
+                assert circle_head is not None
                 start_i = add_verts_sequence([v + v1 for v in circle_head], start_i, **out_kwargs, closed=True)
                 # circle middle divider
                 if not display_end_symbol:
@@ -1588,9 +1603,11 @@ class SectionDecorator(BaseDecorator):
                     )
 
             if display_end_symbol:
+                assert triangle_head is not None
                 start_i = add_verts_sequence([v + v1 for v in triangle_head], start_i, **out_kwargs, closed=True)
 
             if connect_markers:
+                assert edge_dir_circle is not None
                 gap = []
                 gap.append(edge_dir_circle if display_start_symbol else Vector((0, 0, 0)))
                 gap.append(edge_dir_circle if display_end_symbol else Vector((0, 0, 0)))
@@ -1677,6 +1694,12 @@ class CutDecorator:
         selected_elements_color = self.addon_prefs.decorator_color_selected
         self.fallback_colour = (0.3, 0.3, 0.3, 1)
 
+        # Evaluate camera movement once per redraw rather than twice per object: is_camera_moved()
+        # runs eval()/numpy on the camera matrix and, as a side effect, refreshes the stored
+        # checksum on the first True result - so calling it per object also made the second call
+        # (fill) see an already-updated checksum and skip recalculating when it shouldn't.
+        self.camera_moved = self.is_camera_moved()
+
         all_vertices = []
         all_edges = []
         selected_vertices = []
@@ -1802,23 +1825,35 @@ class CutDecorator:
 
         # Currently selected objects must be recalculated as they may be being moved / edited.
         # If the camera is selected, we also recalculate as the user may be moving the camera.
+        is_selected = obj.select_get()
+        recalc_cut = not has_cut_cache or is_selected or self.camera_moved
+        recalc_fill = not has_fill_cache or is_selected or self.camera_moved
+        if not (recalc_cut or recalc_fill):
+            return
 
-        if not has_cut_cache or obj.select_get() or self.is_camera_moved():
-            self.recalculate_cut(context, obj, element)
-        if not has_fill_cache or obj.select_get() or self.is_camera_moved():
-            self.recalculate_fill(context, obj, element)
+        # The intersection test builds a bmesh and scans every vertex; both recalculations need
+        # the same answer, so compute it once here rather than once in each.
+        is_intersecting = tool.Drawing.is_intersecting_camera(obj, context.scene.camera)
+        if recalc_cut:
+            self.recalculate_cut(context, obj, element, is_intersecting)
+        if recalc_fill:
+            self.recalculate_fill(context, obj, element, is_intersecting)
 
-    def recalculate_cut(self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
-        if tool.Drawing.is_intersecting_camera(obj, context.scene.camera):
+    def recalculate_cut(
+        self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance, is_intersecting: bool
+    ) -> None:
+        if is_intersecting:
             verts, edges = tool.Drawing.bisect_mesh(obj, context.scene.camera)
             DecoratorData.cut_cache[element.id()] = (verts, edges)
         else:
             DecoratorData.cut_cache[element.id()] = (False, False)
 
-    def recalculate_fill(self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
+    def recalculate_fill(
+        self, context, obj: bpy.types.Object, element: ifcopenshell.entity_instance, is_intersecting: bool
+    ) -> None:
         element_id = element.id()
 
-        if not tool.Drawing.is_intersecting_camera(obj, context.scene.camera):
+        if not is_intersecting:
             DecoratorData.fill_cache[element_id] = {}
             return
 
@@ -1871,6 +1906,8 @@ class CutDecorator:
             layer_set = material
             offset = 0
             sense_factor = 1
+        else:
+            assert False, material
 
         if len(layer_set.MaterialLayers) == 1:
             material = layer_set.MaterialLayers[0].Material
@@ -1897,6 +1934,8 @@ class CutDecorator:
             co = Vector((0.0, 0.0, offset))
             no = tool.Drawing.get_extrusion_vector(element).normalized()
             no = Vector([1.0, 0.0, 0.0])
+        else:
+            assert False, usage
         no *= sense_factor
         last_i = len(layer_set.MaterialLayers) - 1
 

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

@@ -189,14 +189,20 @@ def format_distance(
             if hasattr(length_unit, "Prefix") and length_unit.Prefix:
                 unit_length = length_unit.Prefix + length_unit.Name
             unit_length_mapping = {
+                "MILE": "MILES",
                 "FOOT": "FEET",
                 "INCH": "INCHES",
+                "KILOMETRE": "KILOMETERS",
                 "METRE": "METERS",
                 "DECIMETRE": "DECIMETERS",
                 "CENTIMETRE": "CENTIMETERS",
                 "MILLIMETRE": "MILLIMETERS",
+                "MICROMETRE": "MICROMETERS",
             }
-            unit_length = unit_length_mapping[unit_length]
+            # Fall through for units without a dedicated formatter (e.g.
+            # HECTOMETRE) so they use the adaptive branch instead of a
+            # KeyError (#8255).
+            unit_length = unit_length_mapping.get(unit_length, unit_length)
         # For now we only format area in IFC Units
         if area_unit := ifcopenshell.util.unit.get_project_unit(tool.Ifc.get(), "AREAUNIT"):
             area_unit_symbol = " " + ifcopenshell.util.unit.get_unit_symbol(area_unit)
@@ -219,9 +225,11 @@ def format_distance(
             unit_system, unit_length, unit_fraction = unit_mapping[custom_unit]
 
     value *= unit_scale
+    tx_dist = None
 
     # Imperial Formatting
     if unit_system == "IMPERIAL":
+        toInches = None
         if in_unit_length:
             if unit_length == "INCHES":
                 toInches = 1
@@ -235,6 +243,7 @@ def format_distance(
             toInches = 1550
             inPerFoot = 144
 
+        assert toInches is not None
         decInches = value * toInches
         decFeet = decInches / 12
 
@@ -377,6 +386,7 @@ def format_distance(
         if precision and isinstance(precision, float):
             value = precision * round(float(value) / precision)
 
+        fmt = None
         if decimal_places is not None:
             fmt = "%1." + str(decimal_places) + "f"
 
@@ -459,6 +469,7 @@ def format_distance(
         assert f"Unexpected unit_system - '{unit_system}'."
         # tx_dist = fmt % value
 
+    assert tx_dist is not None
     return tx_dist
 
 

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

@@ -698,6 +698,8 @@ class CreateDrawing(bpy.types.Operator):
                 layer_set = material
                 offset = 0
                 sense_factor = 1
+            else:
+                assert False, material
 
             camera_matrix_i = context.scene.camera.matrix_world.inverted()
 
@@ -722,7 +724,6 @@ class CreateDrawing(bpy.types.Operator):
             bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.000001)
             bmesh.ops.triangle_fill(bm, use_dissolve=True, edges=bm.edges)
 
-            prev_co = None
             if not usage:
                 sense_factor = 1  # Assume the extrusion vector points in the direction sense
                 no = tool.Drawing.get_extrusion_vector(element).normalized()
@@ -739,6 +740,8 @@ class CreateDrawing(bpy.types.Operator):
                 co = Vector((0.0, 0.0, offset))
                 no = tool.Drawing.get_extrusion_vector(element).normalized()
                 no = Vector([1.0, 0.0, 0.0])
+            else:
+                assert False, usage
             no *= sense_factor
             last_i = len(layer_set.MaterialLayers) - 1
             for i, layer in enumerate(layer_set.MaterialLayers):
@@ -906,6 +909,10 @@ class CreateDrawing(bpy.types.Operator):
         if os.path.isfile(svg_path) and self.props.should_use_linework_cache:
             return svg_path
 
+        ifc = tool.Ifc.get()
+        semantics = None
+        pairs = None
+
         # in case of printing multiple drawings we need to sync just once
         if self.sync and self.drawing_index == 0:
             with profile("sync"):
@@ -1309,6 +1316,18 @@ class CreateDrawing(bpy.types.Operator):
         self.svg_settings = ifcopenshell.geom.settings()
         self.svg_settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
         self.svg_settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.NATIVE)
+        # SVG edge classification (issue #3668). See edge-classification.md. Settings are
+        # per-drawing, stored in EPset_Drawing and read into self.cprops by import_camera_props.
+        try:
+            self.svg_settings.set("svg-use-edge-classification", self.cprops.use_edge_classification)
+            self.svg_settings.set("svg-render-crease-edges", self.cprops.render_creases)
+            self.svg_settings.set("svg-valley-angle-min-degrees", self.cprops.valley_angle_min_degrees)
+            self.svg_settings.set("svg-render-sharp-edges", self.cprops.render_sharp)
+            self.svg_settings.set("svg-ridge-angle-min-degrees", self.cprops.ridge_angle_min_degrees)
+            self.svg_settings.set("svg-emit-flush-edges", self.cprops.render_flush)
+        except Exception:
+            # Backwards compatibility with older ifcopenshell builds that don't expose these keys.
+            pass
         self.svg_buffer = ifcopenshell.geom.serializers.buffer()
         self.serialiser_settings = ifcopenshell.geom.serializer_settings()
         self.serialiser = ifcopenshell.geom.serializers.svg(
@@ -1706,6 +1725,12 @@ class CreateDrawing(bpy.types.Operator):
             key=lambda a: (
                 tool.Drawing.get_annotation_z_index(a),
                 1 if ifcopenshell.util.element.get_predefined_type(a) == "TEXT" else 0,
+                # Deterministic tiebreaker so equal-priority annotations keep a
+                # stable order across sessions. Without it the order comes from
+                # the set union above, which depends on entity hashes (and thus
+                # the file pointer), shuffling annotations between Blender
+                # restarts. See #6608.
+                a.id(),
             ),
         )
 
@@ -3580,7 +3605,7 @@ class EditSheet(bpy.types.Operator, tool.Ifc.Operator):
         if sheet.is_a("IfcDocumentInformation"):
             self.document_type = "SHEET"
             self.name = sheet.Name
-            self.identification = sheet.DocumentId if tool.Ifc.get_schema() == "IFC2X3" else sheet.Identification
+            self.identification = tool.Document.get_document_information_id(sheet)
         elif sheet.is_a("IfcDocumentReference") and tool.Drawing.get_reference_description(sheet) == "TITLEBLOCK":
             self.document_type = "TITLEBLOCK"
         else:

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

@@ -536,6 +536,50 @@ class BIMCameraProperties(PropertyGroup):
         default=True,
         update=get_update_layer_callback("has_annotation", "HasAnnotation"),
     )
+    use_edge_classification: BoolProperty(
+        name="Use Edge Classification",
+        description="Classify projection edges into boundary/outline/sharp/crease/flush "
+        "instead of drawing all linework identically. See edge-classification.md",
+        default=False,
+        update=get_update_layer_callback("use_edge_classification", "UseEdgeClassification"),
+    )
+    render_creases: BoolProperty(
+        name="Render Creases",
+        description="Render 'crease' (concave) projection edges",
+        default=True,
+        update=get_update_layer_callback("render_creases", "RenderCreases"),
+    )
+    valley_angle_min_degrees: FloatProperty(
+        name="Valley Angle Minimum",
+        description="Minimum concave dihedral deviation from flat, in degrees, for a projection "
+        "edge to be classified as 'crease' rather than 'flush'",
+        default=12.0,
+        min=0.0,
+        max=180.0,
+        update=get_update_layer_callback("valley_angle_min_degrees", "ValleyAngleMinDegrees"),
+    )
+    render_sharp: BoolProperty(
+        name="Render Sharp",
+        description="Render 'sharp' (convex) projection edges",
+        default=True,
+        update=get_update_layer_callback("render_sharp", "RenderSharp"),
+    )
+    ridge_angle_min_degrees: FloatProperty(
+        name="Ridge Angle Minimum",
+        description="Minimum convex dihedral deviation from flat, in degrees, for a projection "
+        "edge to be classified as 'sharp' rather than 'flush'",
+        default=45.0,
+        min=0.0,
+        max=180.0,
+        update=get_update_layer_callback("ridge_angle_min_degrees", "RidgeAngleMinDegrees"),
+    )
+    render_flush: BoolProperty(
+        name="Render Flush",
+        description="Render 'flush' projection edges (dihedral deviation below both ridge/valley "
+        "thresholds). Omitted by default",
+        default=False,
+        update=get_update_layer_callback("render_flush", "RenderFlush"),
+    )
     target_view: EnumProperty(
         name="Target View",
         default="PLAN_VIEW",

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

@@ -110,12 +110,14 @@ class Scheduler:
         y = self.margin
         rows = list(sheet.iter_rows())
         total_rows = len(rows)
+        x = None
         for i, row in enumerate(rows):
             # The last row may contain only null values
             if i == (total_rows - 1) and not [c for c in row if c.value is not None]:
                 continue
 
             x = self.margin
+            unmerged_height = None
             for cell in row:
                 if isinstance(cell, openpyxl.cell.cell.MergedCell):
                     column_letter = openpyxl.utils.get_column_letter(cell.column)
@@ -230,8 +232,11 @@ class Scheduler:
                 )
 
                 x += unmerged_width
+
+            assert unmerged_height is not None
             y += unmerged_height
 
+        assert x is not None
         total_width = x + self.margin
         total_height = y + self.margin
         self.svg["width"] = "{}mm".format(total_width)
@@ -375,6 +380,7 @@ class Scheduler:
         tri = 0
         stop_iterating_over_rows = False
         # TODO: row spans support?
+        x = None
         for tr in table.getElementsByType(TableRow):
             if stop_iterating_over_rows:
                 break
@@ -491,6 +497,7 @@ class Scheduler:
                 tri += 1
                 y += height
 
+        assert x is not None
         total_width = x + self.margin
         total_height = y + self.margin
         self.svg["width"] = "{}mm".format(total_width)

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

@@ -102,16 +102,16 @@ void angle_circle_head(
     in vec4 circle_start, in float circle_angle,
     in bool counterclockwise,
     out vec4 head[CIRCLE_SEGS+1], out float angle_segs) {
-    
+
     // 1 added to CIRCLE_SEGS because we're number of vertices
     // for n segments is n+1
-    
+
     float angle_d;
     angle_d = PI * 2 / CIRCLE_SEGS; // 30d
     // need to bottom clamp it to 1, otherwise it causes Blender crash at extruding the curve
     angle_segs = max(1, ceil(circle_angle / angle_d));
     angle_d = circle_angle / angle_segs;
-    
+
     for(int i = 0; i < (angle_segs + 1); i++) {
         float angle = angle_d * i;
         if (counterclockwise) {
@@ -143,7 +143,7 @@ void cross_head(in vec4 dir, in float size, out vec4 head[3]) {
 #define do_vertex(pos, e) (do_vertex_util(pos, vec2(-(e).y, (e).x) / winsize.xy))
 #define do_vertex_win(pos, e) ( do_vertex( WIN2CLIP( pos ), e ) )
 
-// if vertex is shared by two segments of the line still need to emit it twice 
+// if vertex is shared by two segments of the line still need to emit it twice
 // to avoid smoothing artifacts
 // don't forget to initialize `vec2 EDGE_DIR` for macro to work
 // `pos0` / `pos1` - vertex position in clip space
@@ -197,10 +197,13 @@ void do_circle_head(vec4 pos_w, vec4 head[CIRCLE_SEGS]) {
 
 def add_verts_sequence(verts, start_i, output_verts, output_edges, closed=False):
     """Add sequence of verts to output lists, returns next vertex index"""
+    i = None
     for i, v in enumerate(verts[:-1], start_i):
         output_verts.append(v)
         output_edges.append((i, i + 1))
     output_verts.append(verts[-1])
+    assert i is not None
+
     if closed:
         output_edges.append((i + 1, start_i))
     return i + 2
@@ -273,7 +276,7 @@ class BaseShader:
     FRAG_GLSL = """
     uniform vec4 color;
     uniform float lineWidth;
-    
+
     in float smoothline;
     out vec4 fragColor;
     void main() {

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

@@ -903,12 +903,8 @@ class SvgWriter:
                     continue
                 sheet = tool.Drawing.get_reference_document(sheet_reference)
                 if sheet:
-                    if tool.Ifc.get_schema() == "IFC2X3":
-                        reference_id = sheet_reference.ItemReference or "-"
-                        sheet_id = sheet.DocumentId or "-"
-                    else:
-                        reference_id = sheet_reference.Identification or "-"
-                        sheet_id = sheet.Identification or "-"
+                    reference_id = tool.Document.get_external_reference_id(sheet_reference) or "-"
+                    sheet_id = tool.Document.get_document_information_id(sheet) or "-"
                     return (reference_id, sheet_id)
                 break
         return ("-", "-")
@@ -1453,6 +1449,7 @@ class SvgWriter:
                     angle_tg = rise / run
                     angle = round(degrees(atan(angle_tg)))
                 else:
+                    angle_tg = None
                     angle = 90
 
                 # ues SLOPE_ANGLE as default
@@ -1466,6 +1463,7 @@ class SvgWriter:
                 elif object_type == "SLOPE_PERCENT":
                     if angle == 90:
                         return "-"
+                    assert angle_tg is not None
                     return f"{round(angle_tg * 100)} %"
 
             tag = element.Description or get_label_text()

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

@@ -113,6 +113,19 @@ class BIM_PT_camera(Panel):
             row.prop(props, "fill_mode")
             row = self.layout.row()
             row.prop(props, "cut_mode")
+
+        row = self.layout.row()
+        row.prop(props, "use_edge_classification")
+        if props.use_edge_classification:
+            row = self.layout.row()
+            row.prop(props, "render_creases")
+            row.prop(props, "valley_angle_min_degrees")
+            row = self.layout.row()
+            row.prop(props, "render_sharp")
+            row.prop(props, "ridge_angle_min_degrees")
+            row = self.layout.row()
+            row.prop(props, "render_flush")
+
         row = self.layout.row()
         row.prop(props, "width")
         row = self.layout.row()
@@ -964,14 +977,14 @@ class BIM_UL_sheets(bpy.types.UIList):
 
         if self.filter_name:
             filter_name = self.filter_name.lower()
-            active_sheet = None
+            active_sheet_index = None
             for sheet in data.sheets:
                 if sheet.is_sheet:
-                    active_sheet = sheet
                     active_sheet_index = len(flt_flags)
                 if filter_name in sheet.name.lower() or filter_name in sheet.identification.lower():
                     flt_flags.append(self.bitflag_filter_item)
                     if not sheet.is_sheet:
+                        assert active_sheet_index is not None
                         flt_flags[active_sheet_index] = self.bitflag_filter_item
                 else:
                     flt_flags.append(0)

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

@@ -75,9 +75,13 @@ class Helper:
         for face in bm.faces:
             if len(face.verts) > 4:
                 potential_faces.append(face)
+
+        # TODO: replace with next(..., None)
+        face = None
         for face in potential_faces:
             if face.normal.z < -0.1:
                 break
+        assert face is not None
 
         profile = [l.vert.index for l in face.loops]
         extrusion = self.detect_extrusion_edge(bm, face)
@@ -108,10 +112,12 @@ class Helper:
         if not potential_faces:
             potential_faces = bm.faces
 
+        # TODO: replace with next(..., None)
+        face = None
         for face in potential_faces:
             if face.normal.z < -0.1:
                 break
-
+        assert face is not None
         profile = [l.vert.index for l in face.loops]
         extrusion = self.detect_extrusion_edge(bm, face)
 
@@ -145,9 +151,12 @@ class Helper:
             if total_verts > 4:
                 potential_faces.append(face)
 
+        # TODO: replace with next(..., None)
+        face = None
         for face in potential_faces:
             if face.normal.z < -0.1:
                 break
+        assert face is not None
 
         end_faces = []
         end_face_normal = face.normal

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

@@ -581,7 +581,11 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
         if has_openings and not self.apply_openings:
             # Meshlike things with openings can only be updated without openings applied.
             if self.from_ui:
-                self.report({"ERROR"}, f"Object '{obj.name}' has openings - representation cannot be updated.")
+                self.report(
+                    {"ERROR"},
+                    f"Object '{obj.name}' has openings. "
+                    "ALT+click the button to bake the openings into the new representation.",
+                )
             return
 
         if not product.is_a("IfcGridAxis"):
@@ -3523,12 +3527,15 @@ class EditRepresentationItemShapeAspect(bpy.types.Operator, tool.Ifc.Operator):
         if props.representation_item_shape_aspect == "NEW":
             active_representation = tool.Geometry.get_active_representation(obj)
             # find IfcProductRepresentationSelect based on current representation
+            product_shape = None
             if hasattr(element, "Representation"):  # IfcProduct
                 product_shape = element.Representation
             else:  # IfcTypeProduct
                 for representation_map in element.RepresentationMaps:
                     if representation_map.MappedRepresentation == active_representation:
                         product_shape = representation_map
+            assert product_shape is not None
+
             previous_shape_aspect_id = props.active_item.shape_aspect_id
             # will be None if item didn't had a shape aspect
             previous_shape_aspect = tool.Ifc.get_entity_by_id(previous_shape_aspect_id)
@@ -3878,6 +3885,8 @@ class AddSweptAreaSolidItem(bpy.types.Operator, tool.Ifc.Operator):
             curve = builder.rectangle(size=Vector((0.5, 0.5)) / unit_scale)
         elif self.shape == "CYLINDER":
             curve = builder.circle(radius=0.25 / unit_scale)
+        else:
+            assert False, self.shape
         item = builder.extrude(
             curve,
             magnitude=0.5 / unit_scale,
@@ -4115,6 +4124,31 @@ class OverrideMoveSelect(bpy.types.Operator):
                 self.new_active_obj = obj
             return {"FINISHED"}
 
+        # Get arrays
+        ifc_file = tool.Ifc.get()
+        array_parents_to_move: list[bpy.types.Object] = []
+        for obj in list(context.selected_objects):
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
+            if not pset:
+                continue
+            parent_element = ifc_file.by_guid(pset["Parent"])
+            parent_obj = tool.Ifc.get_object(parent_element)
+            if parent_obj not in array_parents_to_move:
+                array_parents_to_move.append(parent_obj)
+            if element.GlobalId != pset["Parent"]:
+                obj.select_set(False)
+
+        if array_parents_to_move:
+            for parent_obj in array_parents_to_move:
+                parent_element = tool.Ifc.get_entity(parent_obj)
+                for array_obj in tool.Array.get_all_objects(parent_element):
+                    array_obj.select_set(True)
+                self.new_active_obj = parent_obj
+            return {"FINISHED"}
+
         # Get nests
         props = tool.Nest.get_nest_props()
         not_editing_objs = [o.obj for o in props.not_editing_objects]

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

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

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

@@ -156,6 +156,7 @@ class RadianceRender(bpy.types.Operator):
         print(f"Quality: {quality}, Detail: {detail}, Variability: {variability}")
         print(f"Output directory: {output_dir}")
 
+        hdr_image_path, hdr_mask_path, sky_map_cal_path = None, None
         if use_hdr:
             hdr_image = "noon_grass_2k.hdr"
             hdr_mask = "noon_grass_2k_mask.hdr"
@@ -254,6 +255,9 @@ class RadianceRender(bpy.types.Operator):
         # 4 0 0 -1 180
 
         if use_hdr and choose_hdr_image == "Noon":
+            assert hdr_image_path is not None
+            assert hdr_mask_path is not None
+            assert sky_map_cal_path is not None
 
             with open(sky_file_path, "w") as f:
                 f.write(sky_description_str)

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

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

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

@@ -564,6 +564,7 @@ class SelectAllArrayObjects(bpy.types.Operator):
                     except RuntimeError:
                         self.report({"ERROR"}, f"Objects that don't have an array parent, were deselected.")
                         object.select_set(False)
+                        continue
 
                     array_objects = tool.Array.get_all_objects(parent_element)
                     tool.Blender.set_objects_selection(

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

@@ -408,6 +408,8 @@ class MEPGenerator:
                     compare = tool.Cad.is_x(requested_value, fitting_value, compare_precision)
                 elif isinstance(fitting_value, list):
                     compare = tool.Cad.are_vectors_equal(requested_value, Vector(fitting_value), precision)
+                else:
+                    assert False, f"{key} {second_key}"
                 return compare
 
             ignore_keys = []
@@ -476,11 +478,13 @@ class MEPGenerator:
             if predefined_type == "OBSTRUCTION":
                 return packed_data
 
+            start_port = None
             for port in ports:
                 port_local_position = V(*port.ObjectPlacement.RelativePlacement.Location.Coordinates)
                 if tool.Cad.is_x(port_local_position.length, 0.0):
                     start_port = port
                     break
+            assert start_port is not None
 
             connected_port = tool.System.get_connected_port(start_port)
             connected_element = tool.System.get_port_relating_element(connected_port)

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

@@ -325,7 +325,7 @@ class AddOccurrence(bpy.types.Operator, tool.Ifc.Operator):
         if self.from_invoke and str(self.relating_type_id) in AuthoringData.data["relating_type_id"]:
             props.relating_type_id = str(self.relating_type_id)
 
-        building_obj = None
+        building_obj, building_element = None, None
         if len(context.selected_objects) == 1 and context.active_object:
             building_obj = context.active_object
             building_element = tool.Ifc.get_entity(building_obj)

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

@@ -593,6 +593,8 @@ class DumbProfileJoiner:
             axisl = (profile2.matrix_world.inverted() @ axis1[1]) - (profile2.matrix_world.inverted() @ axis1[0])
         elif connection1 == "ATSTART":
             axisl = (profile2.matrix_world.inverted() @ axis1[0]) - (profile2.matrix_world.inverted() @ axis1[1])
+        else:
+            assert False, connection1
         xy_angle = degrees(Vector((1, 0)).angle_signed(axisl.normalized().to_2d()))
         if xy_angle >= -135 and xy_angle <= -45:
             closest_plane = "bottom"
@@ -617,6 +619,8 @@ class DumbProfileJoiner:
                 axisl = (profile1.matrix_world.inverted() @ axis2[1]) - (profile1.matrix_world.inverted() @ axis2[0])
             elif connection2 == "ATSTART":
                 axisl = (profile1.matrix_world.inverted() @ axis2[0]) - (profile1.matrix_world.inverted() @ axis2[1])
+            else:
+                assert False, connection2
             xy_angle2 = degrees(Vector((1, 0)).angle_signed(axisl.normalized().to_2d()))
             if xy_angle2 >= -135 and xy_angle2 <= -45:
                 closest_plane2 = "bottom"
@@ -844,6 +848,8 @@ class DumbProfileJoiner:
             else:
                 y_axis = obj.matrix_world.to_quaternion() @ Vector((0, 1, 0))
                 z_axis = obj.matrix_world.to_quaternion() @ Vector((-1, 0, 0))
+        else:
+            assert False, plane
         return self.create_matrix(p, x_axis, y_axis, z_axis)
 
     def create_matrix(self, p: Vector, x: Vector, y: Vector, z: Vector) -> Matrix:

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

@@ -508,6 +508,7 @@ class EditSketchExtrusionProfile(bpy.types.Operator, tool.Ifc.Operator):
         converter.run()
 
         profile = tool.Ifc.get().createIfcArbitraryClosedProfileDef("AREA")
+        curve = None
         for path in converter.paths:
             points = []
             lines = path[0]
@@ -517,6 +518,7 @@ class EditSketchExtrusionProfile(bpy.types.Operator, tool.Ifc.Operator):
                 points.append(tool.Ifc.get().createIfcCartesianPoint(local_point))
             points.append(points[0])
             curve = tool.Ifc.get().createIfcPolyline(points)
+        assert curve
         profile.OuterCurve = curve
 
         old_profile = extrusion.SweptArea

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

@@ -1577,6 +1577,7 @@ class DumbWallJoiner:
         # Get the ATEND connection from wall1 to use it in wall2
         relating_element = None
         connections = element1.ConnectedTo
+        relating_connection, description = ..., ...
         for conn in connections:
             if conn.is_a("IfcRelConnectsPathElements") and conn.RelatingConnectionType == "ATEND":
                 relating_element = conn.RelatedElement
@@ -1591,6 +1592,7 @@ class DumbWallJoiner:
                 description = conn.Description
                 bonsai.core.geometry.remove_connection(tool.Geometry, connection=conn)
         if relating_element:
+            assert relating_connection is not ... and description is not ...
             ifcopenshell.api.geometry.connect_path(
                 tool.Ifc.get(),
                 relating_element=relating_element,

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

@@ -18,7 +18,7 @@
 
 import json
 from pathlib import Path
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 import bpy
 import ifcopenshell
@@ -122,8 +122,8 @@ class ExecuteIfcPatch(bpy.types.Operator):
         if props.should_load_from_memory and tool.Ifc.get():
             args["file"] = tool.Ifc.get()
         else:
-            args["input"] = cast(str, props.ifc_patch_input)
-            args["file"] = cast(ifcopenshell.file, ifcopenshell.open(props.ifc_patch_input))
+            args["input"] = props.ifc_patch_input
+            args["file"] = ifcopenshell.open(props.ifc_patch_input)
 
         # Store this in case the patch recipe resets the Blender session, such as by loading a new project.
         ifc_patch_output = props.ifc_patch_output or props.ifc_patch_input

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

@@ -714,6 +714,8 @@ class AppendLibraryElement(bpy.types.Operator, tool.Ifc.Operator):
             representations = element.RepresentationMaps or []
         elif element.is_a("IfcProduct"):
             representations = [element.Representation] if element.Representation else []
+        else:
+            assert False, element
         for representation in representations or []:
             for element in self.file.traverse(representation):
                 if not element.is_a("IfcRepresentationItem") or not element.StyledByItem:
@@ -1044,13 +1046,19 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
 
         return tooltip
 
-    def check_autosave_recovery(self, context: bpy.types.Context) -> set["rna_enums.OperatorReturnItems"] | None:
+    def check_autosave_recovery(self, context: bpy.types.Context) -> bool:
         if self.skip_autosave_recovery:
-            return None
+            return False
         autosaved_filepath = tool.Autosave.get_newer_autosaved_path(self.get_filepath_abs())
         if not autosaved_filepath:
-            return None
-        return bpy.ops.bim.load_autosaved_recovery_popup(
+            return False
+        # Fire-and-forget: don't propagate this popup's own RUNNING_MODAL
+        # return value up as if *this* operator were running modally too -
+        # we never call modal_handler_add() on ourselves, so the window
+        # manager would be left tracking a modal operator with no handler,
+        # corrupting its operator bookkeeping until it crashes later when
+        # the (real) popup modal handler is closed.
+        bpy.ops.bim.load_autosaved_recovery_popup(
             "INVOKE_DEFAULT",
             original_filepath=str(self.get_filepath_abs()),
             autosaved_filepath=autosaved_filepath,
@@ -1059,10 +1067,11 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
             should_start_fresh_session=self.should_start_fresh_session,
             import_without_ifc_data=self.import_without_ifc_data,
         )
+        return True
 
     def execute(self, context):
-        if recovery := self.check_autosave_recovery(context):
-            return recovery
+        if self.check_autosave_recovery(context):
+            return {"FINISHED"}
 
         if (
             tool.Blender.get_addon_preferences().save_metadata_blend_file
@@ -1177,8 +1186,8 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
 
     def invoke(self, context, event):
         if self.filepath:
-            if recovery := self.check_autosave_recovery(context):
-                return recovery
+            if self.check_autosave_recovery(context):
+                return {"FINISHED"}
             return self.execute(context)
         return ImportHelper.invoke(self, context, event)
 
@@ -2022,6 +2031,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         project_props = tool.Project.get_project_props()
         prefs = tool.Blender.get_addon_preferences()
         project_props.use_relative_project_path = self.use_relative_path
+        old_history_size, old_undo_steps = None, None
         if prefs.should_disable_undo_on_save:
             old_history_size = tool.Ifc.get().history_size
             old_undo_steps = context.preferences.edit.undo_steps
@@ -2029,6 +2039,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
             context.preferences.edit.undo_steps = 0
         IfcStore.execute_ifc_operator(self, context)
         if prefs.should_disable_undo_on_save:
+            assert old_history_size is not None and old_undo_steps is not None
             tool.Ifc.get().history_size = old_history_size
             context.preferences.edit.undo_steps = old_undo_steps
         return {"FINISHED"}
@@ -2182,8 +2193,8 @@ class LoadAutosavedRecoveryPopup(bpy.types.Operator):
             self, width=420, title="Recover Autosaved File", confirm_text="Yes"
         )
 
-    def _load(self, filepath: str, skip_recent: bool) -> set["rna_enums.OperatorReturnItems"]:
-        return bpy.ops.bim.load_project(
+    def _load_kwargs(self, filepath: str, skip_recent: bool) -> dict:
+        return dict(
             filepath=filepath,
             skip_autosave_recovery=True,  # Prevent infinite loop
             is_advanced=self.is_advanced,
@@ -2193,16 +2204,42 @@ class LoadAutosavedRecoveryPopup(bpy.types.Operator):
             skip_recent=skip_recent,
         )
 
+    @staticmethod
+    def _defer(callback) -> None:
+        def on_timer() -> None:
+            callback()
+            return None
+
+        # bim.load_project (with should_start_fresh_session, our default)
+        # calls wm.read_homefile(), which tears down the window
+        # manager/screens/regions. Calling that synchronously from this
+        # dialog's execute()/cancel() - themselves invoked from deep inside
+        # Blender's modal handling for this popup's button click - frees
+        # data that the still-on-stack caller dereferences once we return,
+        # segfaulting Blender. Deferring by one timer tick runs the reload
+        # after the popup's own modal handling has fully unwound. The
+        # callback only closes over plain values (not `self`), since the
+        # operator instance itself may no longer be valid by the time the
+        # timer fires.
+        bpy.app.timers.register(on_timer, first_interval=0.0)
+
     def execute(self, context):
-        result = self._load(self.autosaved_filepath, skip_recent=True)
-        # Re-point tracking at the original path so future saves write back
-        # to it, not "_autosaved.ifc".
-        tool.Ifc.set_path(self.original_filepath)
-        return result
+        kwargs = self._load_kwargs(self.autosaved_filepath, skip_recent=True)
+        original_filepath = self.original_filepath
+
+        def load_and_repoint() -> None:
+            bpy.ops.bim.load_project(**kwargs)
+            # Re-point tracking at the original path so future saves write
+            # back to it, not "_autosaved.ifc".
+            tool.Ifc.set_path(original_filepath)
+
+        self._defer(load_and_repoint)
+        return {"FINISHED"}
 
     def cancel(self, context):
         # Also reached via Escape or a click outside the dialog, not just Cancel.
-        self._load(self.original_filepath, skip_recent=False)
+        kwargs = self._load_kwargs(self.original_filepath, skip_recent=False)
+        self._defer(lambda: bpy.ops.bim.load_project(**kwargs))
 
 
 class AutosavePrompt(bpy.types.Operator):

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

@@ -113,6 +113,8 @@ class EditPset(bpy.types.Operator, tool.Ifc.Operator):
         elif props.active_pset_type == "QTO":
             pset = ifcopenshell.api.pset.add_qto(self.file, product=element, name=props.active_pset_name)
             props.active_pset_id = pset.id()
+        else:
+            assert False
 
         if self.properties:
             properties = json.loads(self.properties)

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

@@ -228,6 +228,8 @@ def get_qto_name(self: "PsetProperties", context: bpy.types.Context) -> tool.Ble
     if "bpy.data.objects" in pset_type:
         if prop_type == "PsetProperties":
             results = get_object_qto_name(self, context)
+        else:
+            assert False
     elif prop_type == "TaskPsetProperties":
         results = get_task_qto_names(self, context)
     elif prop_type == "ResourcePsetProperties":

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

@@ -480,6 +480,7 @@ class BIM_PT_material_psets(Panel):
     def draw(self, context):
         assert self.layout
         props = tool.Material.get_material_props()
+        ifc_definition_id = None
         if material := props.active_material:
             ifc_definition_id = material.ifc_definition_id
 

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

@@ -27,6 +27,7 @@ import ifcopenshell.api.material
 import ifcopenshell.api.pset
 import ifcopenshell.api.root
 import ifcopenshell.util.element
+import ifcopenshell.util.representation
 import ifcopenshell.util.schema
 import ifcopenshell.util.shape_builder
 import ifcopenshell.util.type
@@ -129,13 +130,25 @@ class ReassignClass(bpy.types.Operator, tool.Ifc.Operator):
             same_ifc_product = element.is_a(ifc_product)
 
             if not same_ifc_product:
-                if not (element.is_a("IfcElement") and ifc_product == "IfcElementType") and not (
-                    element.is_a("IfcElementType") and ifc_product == "IfcElement"
-                ):
-                    self.report(
-                        {"ERROR"}, f"Not supported class reassignment for object '{obj.name}' -> {ifc_product}."
+                # A spatial element (e.g. IfcSite) anchors the containment
+                # hierarchy, so only allow reassigning it to another family when
+                # it actually carries geometry - i.e. it's a real modelled thing
+                # (a bench dropped onto IfcSite -> IfcFurniture) rather than an
+                # empty spatial container we'd be turning into a loose element.
+                # IfcSpatialStructureElement covers IFC2X3, which has no
+                # IfcSpatialElement supertype.
+                is_spatial = element.is_a("IfcSpatialElement") or element.is_a("IfcSpatialStructureElement")
+                if is_spatial:
+                    has_geometry = (
+                        next(ifcopenshell.util.representation.get_representations_iter(element), None) is not None
                     )
-                    return {"CANCELLED"}
+                    if not has_geometry:
+                        self.report(
+                            {"ERROR"},
+                            f"Cannot reassign '{obj.name}' ({element.is_a()}) to {ifc_product}: "
+                            "a spatial element can only be reassigned to another class when it has geometry.",
+                        )
+                        return {"CANCELLED"}
 
             props = tool.Blender.get_object_bim_props(obj)
             props.is_reassigning_class = False
@@ -617,10 +630,13 @@ class AddElement(bpy.types.Operator, tool.Ifc.Operator):
                     local_z = wall_matrix.to_3x3() @ Vector((0, 0, 1))
                     direction_sense = getattr(usage, "DirectionSense", "POSITIVE")
 
-                    if usage.LayerSetDirection == "AXIS2":
+                    layer_set_direction = usage.LayerSetDirection
+                    if layer_set_direction == "AXIS2":
                         z_axis = tuple(local_y) if direction_sense == "POSITIVE" else tuple(-local_y)
-                    elif usage.LayerSetDirection == "AXIS3":
+                    elif layer_set_direction == "AXIS3":
                         z_axis = tuple(local_z) if direction_sense == "POSITIVE" else tuple(-local_z)
+                    else:
+                        assert False, layer_set_direction
 
                     item = builder.extrude(
                         profile,
@@ -750,6 +766,8 @@ class AddElement(bpy.types.Operator, tool.Ifc.Operator):
                         WebThickness=default_web_thickness / unit_scale,
                         FlangeThickness=default_flange_thickness / unit_scale,
                     )
+                else:
+                    assert False, representation_template
 
             rel = ifcopenshell.api.material.assign_material(
                 tool.Ifc.get(), products=[element], type="IfcMaterialProfileSet"

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

@@ -1009,6 +1009,7 @@ class ColourByProperty(Operator):
         palette = props.palette
         is_qualitative = palette in ("tab10", "paired")
 
+        colours = None
         if is_qualitative:
             colours = tool.Search.get_qualitative_palette(palette)
 
@@ -1035,6 +1036,7 @@ class ColourByProperty(Operator):
                 if value in colourscheme:
                     colourscheme[value]["total"] += 1
                 else:
+                    assert colours is not None
                     colourscheme[value] = {"colour": next(colours)[0:3], "total": 1}
                 obj.color = (*colourscheme[value]["colour"], 1)
             else:
@@ -1139,6 +1141,7 @@ class SelectByProperty(Operator):
 
         is_qualitative = palette in ("tab10", "paired")
 
+        values = None
         if not is_qualitative:
             values = []
             for colour in props.colourscheme:

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

@@ -281,11 +281,11 @@ class BIM_PT_work_schedules(Panel):
     def draw_task_operators(self) -> None:
         row = self.layout.row(align=True)
         row.alignment = "RIGHT"
-        ifc_definition_id = None
+        task, ifc_definition_id = None, None
         if self.tprops.tasks and self.props.active_task_index < len(self.tprops.tasks):
             task = self.tprops.tasks[self.props.active_task_index]
             ifc_definition_id = task.ifc_definition_id
-        if ifc_definition_id:
+        if task and ifc_definition_id:
             if self.props.active_task_id:
                 if self.props.editing_task_type == "TASKTIME":
                     row.operator("bim.edit_task_time", text="", icon="CHECKMARK")
@@ -341,6 +341,8 @@ class BIM_PT_work_schedules(Panel):
             row.prop(self.props, "other_columns", text="")
             column_type, name = self.props.other_columns.split(".")
             data_type = "string"
+        else:
+            assert False, column_type
         row.operator("bim.set_task_sort_column", text="", icon="SORTALPHA").column = f"{column_type}.{name}"
         row.prop(
             self.props, "is_sort_reversed", text="", icon="SORT_DESC" if self.props.is_sort_reversed else "SORT_ASC"

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

@@ -516,7 +516,7 @@ class SetContainerVisibility(bpy.types.Operator):
         if self.mode == "ISOLATE":
             if tool.Ifc.get_schema() == "IFC2X3":
                 containers = tool.Ifc.get().by_type("IfcSpatialStructureElement")
-            elif tool.Ifc.get_schema() != "IFC2X3":
+            else:
                 containers = set(tool.Ifc.get().by_type("IfcSpatialElement"))
                 containers -= set(tool.Ifc.get().by_type("IfcSpatialZone"))
             for container in containers:

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

@@ -125,6 +125,7 @@ class BIM_PT_spatial_decomposition(Panel):
             row.label(text="Warning: No Default Container", icon="ERROR")
         row.operator("bim.import_spatial_decomposition", icon="FILE_REFRESH", text="")
 
+        ifc_definition_id = None
         if self.props.active_container:
             ifc_definition_id = self.props.active_container.ifc_definition_id
             row = self.layout.row(align=True)
@@ -170,6 +171,7 @@ class BIM_PT_spatial_decomposition(Panel):
 
         if not self.props.active_container:
             return
+        assert ifc_definition_id is not None
 
         container_has_elements = bool(self.props.total_elements)
         if container_has_elements:

src/bonsai/bonsai/bim/module/structural/load_decoration_data.py

@@ -71,7 +71,11 @@ class LoadByDirection(TypedDict):
 
 ProcessedLoad = TypedDict(
     "ProcessedLoad",
-    {"linear loads": LoadByDirection, "max linear load": float, "discrete loads": list[list[DiscreteConfigItem]]},
+    {
+        "linear loads": dict[str, LoadByDirection] | None,
+        "max linear load": float,
+        "discrete loads": list[list[DiscreteConfigItem]],
+    },
 )
 
 
@@ -845,13 +849,16 @@ class ShaderInfo:
         v = l1[1] + fac * (pos - l1[0])
         return v
 
-    def interpolate(self, pos: float, loadinfo: list[LoadConfigItem], start: int, end: int, key: str) -> np.ndarray:
+    def interpolate(self, pos: float, loadinfo: list[LoadConfigItem], start: int, end: int) -> np.ndarray:
         """interpolate the result vectors between load poits"""
         result = np.zeros(6)
         for i in range(6):
-            value1 = [loadinfo[start]["pos"], loadinfo[start][key][i]]  # [position, force_component]
-            value2 = [loadinfo[end]["pos"], loadinfo[end][key][i]]  #      [position, force_component]
-            result[i] = self.interp1d(value1, value2, pos)  #             interpolated [position, force_component]
+            # [position, force_component]
+            value1 = [loadinfo[start]["pos"], loadinfo[start]["load values"][i]]
+            # [position, force_component]
+            value2 = [loadinfo[end]["pos"], loadinfo[end]["load values"][i]]
+            # interpolated [position, force_component]
+            result[i] = self.interp1d(value1, value2, pos)
         return result
 
     def get_before_and_after(self, pos: float, load_config_list: list[list[LoadConfigItem]]) -> dict[str, list[float]]:
@@ -895,8 +902,8 @@ class ShaderInfo:
                         load_before += config[end]["load values"]
 
                 elif end - start == 1:
-                    load_before += self.interpolate(pos, config, start, end, "load values")
-                    load_after += self.interpolate(pos, config, start, end, "load values")
+                    load_before += self.interpolate(pos, config, start, end)
+                    load_after += self.interpolate(pos, config, start, end)
                 start += 1
                 end -= 1
         return_value = {"before": load_before.tolist(), "after": load_after.tolist()}

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

@@ -102,6 +102,7 @@ class BIM_PT_styles(Panel):
 
         # style ui tools
         if active_style:
+            style = active_style
             row = self.layout.row(align=True)
             if material := style.blender_material:
                 msprops = tool.Style.get_material_style_props(material)

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

@@ -20,6 +20,7 @@ from typing import TYPE_CHECKING
 
 import bpy
 import ifcopenshell.api.attribute
+import ifcopenshell.api.material
 import ifcopenshell.api.type
 import ifcopenshell.util.element
 import ifcopenshell.util.representation
@@ -115,51 +116,96 @@ class UnassignType(bpy.types.Operator, tool.Ifc.Operator):
     if TYPE_CHECKING:
         related_object: str
 
-    def _execute(self, context):
+    @staticmethod
+    def _reattach_styles(
+        file: ifcopenshell.file, copied_entities: dict[int, ifcopenshell.entity_instance]
+    ) -> None:
+        """copy_deep only follows forward references, so IfcStyledItem (an inverse,
+        ``StyledByItem``) is not carried onto the copied geometry. Re-create a
+        styled item on each copy that points at the same presentation styles as
+        the original, so the unmapped occurrence keeps its appearance."""
+        for original_id, copied in copied_entities.items():
+            original = file.by_id(original_id)
+            for styled_item in getattr(original, "StyledByItem", None) or []:
+                file.create_entity(
+                    "IfcStyledItem",
+                    Item=copied,
+                    Styles=styled_item.Styles,
+                    Name=styled_item.Name,
+                )
+
+    @staticmethod
+    def unassign_and_unmap(obj: bpy.types.Object) -> None:
+        """Unassign the type from ``obj`` and bake a private copy of any mapped
+        representation onto it, so the occurrence keeps its geometry, styles, and
+        material once the type (the source of all three) is gone."""
+
         def exclude_callback(attribute):
             return attribute.is_a("IfcProfileDef") and attribute.ProfileName
 
-        self.file = tool.Ifc.get()
+        file = tool.Ifc.get()
+        element = tool.Ifc.get_entity(obj)
+        if not element or not element.is_a("IfcObject"):
+            return
+
+        # Capture the material inherited from the type before we sever the link,
+        # but only if the occurrence has no material of its own to override it.
+        own_material = ifcopenshell.util.element.get_material(element, should_inherit=False)
+        inherited_material = ifcopenshell.util.element.get_material(element, should_inherit=True)
+
+        ifcopenshell.api.type.unassign_type(file, related_objects=[element])
+
+        if element.Representation:
+            new_active_representation = None
+            active_representation = tool.Geometry.get_active_representation(obj)
+            active_context = active_representation.ContextOfItems
+            representations = []
+            for representation in element.Representation.Representations:
+                resolved_representation = ifcopenshell.util.representation.resolve_representation(representation)
+                if representation == resolved_representation:
+                    representations.append(representation)
+                else:
+                    # We must unmap representations, carrying over their styles.
+                    copied_entities: dict[int, ifcopenshell.entity_instance] = {}
+                    copied_representation = ifcopenshell.util.element.copy_deep(
+                        file,
+                        resolved_representation,
+                        exclude=["IfcGeometricRepresentationContext"],
+                        exclude_callback=exclude_callback,
+                        copied_entities=copied_entities,
+                    )
+                    UnassignType._reattach_styles(file, copied_entities)
+                    representations.append(copied_representation)
+                    if representation.ContextOfItems == active_context:
+                        new_active_representation = copied_representation
+            element.Representation.Representations = representations
+
+            if new_active_representation:
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc,
+                    tool.Geometry,
+                    obj=obj,
+                    representation=new_active_representation,
+                )
+
+        # Bake the inherited material down onto the occurrence now that its type
+        # link (and, in the delete-type case, the type itself) is gone. Usages are
+        # occurrence-specific and never inherited, so they need no handling here.
+        if inherited_material is not None and own_material is None:
+            material_type = inherited_material.is_a()
+            if material_type not in ("IfcMaterialLayerSetUsage", "IfcMaterialProfileSetUsage"):
+                ifcopenshell.api.material.assign_material(
+                    file, products=[element], type=material_type, material=inherited_material
+                )
+
+    def _execute(self, context):
         if self.related_object:
             related_objects = [bpy.data.objects[self.related_object]]
         else:
             related_objects = tool.Blender.get_selected_objects()
 
         for obj in related_objects:
-            element = tool.Ifc.get_entity(obj)
-            if not element or not element.is_a("IfcObject"):
-                continue
-            ifcopenshell.api.type.unassign_type(self.file, related_objects=[element])
-
-            if element.Representation:
-                new_active_representation = None
-                active_representation = tool.Geometry.get_active_representation(obj)
-                active_context = active_representation.ContextOfItems
-                representations = []
-                for representation in element.Representation.Representations:
-                    resolved_representation = ifcopenshell.util.representation.resolve_representation(representation)
-                    if representation == resolved_representation:
-                        representations.append(representation)
-                    else:
-                        # We must unmap representations.
-                        copied_representation = ifcopenshell.util.element.copy_deep(
-                            tool.Ifc.get(),
-                            resolved_representation,
-                            exclude=["IfcGeometricRepresentationContext"],
-                            exclude_callback=exclude_callback,
-                        )
-                        representations.append(copied_representation)
-                        if representation.ContextOfItems == active_context:
-                            new_active_representation = copied_representation
-                element.Representation.Representations = representations
-
-                if new_active_representation:
-                    bonsai.core.geometry.switch_representation(
-                        tool.Ifc,
-                        tool.Geometry,
-                        obj=obj,
-                        representation=new_active_representation,
-                    )
+            self.unassign_and_unmap(obj)
         return {"FINISHED"}
 
 
@@ -305,14 +351,82 @@ class SelectTypeObjects(bpy.types.Operator):
 
 class RemoveType(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.remove_type"
-    bl_label = "Remove Type"
+    bl_label = "Delete Type"
+    bl_description = (
+        "Delete this type. Its occurrences are kept but become untyped.\n\n"
+        "SHIFT+Click to also delete every occurrence of this type in the project"
+    )
     bl_options = {"REGISTER", "UNDO"}
     element: bpy.props.IntProperty()
+    also_delete_instances: bpy.props.BoolProperty(default=False, options={"SKIP_SAVE"})
+
+    if TYPE_CHECKING:
+        element: int
+        also_delete_instances: bool
+
+    @staticmethod
+    def _detach_type_material_set(element: ifcopenshell.entity_instance) -> None:
+        """Cascade-free removal of the type's IfcMaterialLayerSet / IfcMaterialProfileSet
+        association, called just before the type is deleted.
+
+        ``remove_product`` would otherwise route the type's material association
+        through ``unassign_material``, which deletes *every* usage of that set
+        across the model (documented behaviour, with an upstream TODO calling it
+        too aggressive) — stripping the material off the very occurrences we are
+        trying to keep. By unhooking the type<->set link by hand here, the type
+        has no material at delete time, so that cascade never fires and the set
+        plus the occurrences' usages survive intact."""
+        file = tool.Ifc.get()
+        material = ifcopenshell.util.element.get_material(element, should_inherit=False)
+        if not material or material.is_a() not in ("IfcMaterialLayerSet", "IfcMaterialProfileSet"):
+            return
+        for rel in list(getattr(element, "HasAssociations", None) or []):
+            if not (rel.is_a("IfcRelAssociatesMaterial") and rel.RelatingMaterial == material):
+                continue
+            remaining = [o for o in rel.RelatedObjects if o != element]
+            if remaining:
+                rel.RelatedObjects = remaining
+            else:
+                history = rel.OwnerHistory
+                file.remove(rel)
+                if history:
+                    ifcopenshell.util.element.remove_deep2(file, history)
+
+    def invoke(self, context, event):
+        self.also_delete_instances = event.shift
+        if self.also_delete_instances:
+            element = tool.Ifc.get().by_id(self.element)
+            count = len(ifcopenshell.util.element.get_types(element))
+            return context.window_manager.invoke_confirm(
+                self,
+                event,
+                title="Delete Type and Occurrences",
+                message=f"This will delete the type and all {count} of its occurrences.",
+                confirm_text="Delete",
+            )
+        return self.execute(context)
 
     def _execute(self, context):
         element = tool.Ifc.get().by_id(self.element)
+        occurrences = ifcopenshell.util.element.get_types(element)
+        if self.also_delete_instances:
+            for occurrence in occurrences:
+                occurrence_obj = tool.Ifc.get_object(occurrence)
+                if occurrence_obj:
+                    tool.Geometry.delete_ifc_object(occurrence_obj)
+        else:
+            # Keep the occurrences: bake their (previously type-mapped) geometry,
+            # styles, and inherited material onto each one so nothing is lost when
+            # the type is deleted...
+            for occurrence in occurrences:
+                occ_obj = tool.Ifc.get_object(occurrence)
+                if occ_obj:
+                    UnassignType.unassign_and_unmap(occ_obj)
+            # ...and keep any layer/profile-set material usages alive across the deletion.
+            self._detach_type_material_set(element)
         obj = tool.Ifc.get_object(element)
-        tool.Geometry.delete_ifc_object(obj)
+        if obj:
+            tool.Geometry.delete_ifc_object(obj)
 
 
 class RenameType(bpy.types.Operator, tool.Ifc.Operator):

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

@@ -144,8 +144,10 @@ class BIM_PT_type_attributes(Panel):
 
             bonsai.bim.helper.draw_attributes(props.type_attributes, layout)
         else:
-            row = layout.row()
+            row = layout.row(align=True)
             row.operator("bim.enable_editing_type_attributes", icon="GREASEPENCIL", text="Edit")
+            op = row.operator("bim.remove_type", icon="TRASH", text="")
+            op.element = TypeData.data["relating_type"]["id"]
 
             for attribute in TypeData.data["relating_type_attributes"]:
                 row = layout.row(align=True)

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

@@ -72,6 +72,7 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
 
         opening_objects = [obj for obj in selected_objects if obj != target_object]
 
+        obj1 = ...
         for opening_obj in opening_objects:
             element1 = tool.Ifc.get_entity(target_object)
             obj1 = target_object
@@ -196,6 +197,7 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
                 bpy.data.objects.remove(obj2)
 
         tool.Model.purge_scene_openings()
+        assert obj1 is not ...
         context.view_layer.objects.active = obj1
         return {"FINISHED"}
 

src/bonsai/bonsai/bim/ui.py

@@ -284,11 +284,13 @@ class GizmoPreferences(bpy.types.PropertyGroup):
         draw_gizmos_in_3d_viewport: bool
 
 
+_gizmo_pref_entry = None
 for _gizmo_pref_entry in tool.Parametric.EDIT_TYPES:
     GizmoPreferences.__annotations__[_gizmo_pref_entry.name] = BoolProperty(
         name=_gizmo_pref_entry.name.replace("_", " ").title(),
         default=True,
     )
+assert _gizmo_pref_entry is not None
 del _gizmo_pref_entry
 
 
@@ -394,12 +396,14 @@ class DefaultParameters(bpy.types.PropertyGroup):
     and gives the create operator a preset to copy from."""
 
 
+_default_params_entry = None
 for _default_params_entry in tool.Parametric.EDIT_TYPES:
     if not _default_params_entry.has_default_parameters:
         continue
     DefaultParameters.__annotations__[_default_params_entry.name] = bpy.props.PointerProperty(
         type=getattr(_model_prop, _default_params_entry.props_attr),
     )
+assert _default_params_entry is not None
 del _default_params_entry
 
 

src/bonsai/bonsai/core/covering.py

@@ -74,10 +74,11 @@ def add_instance_ceiling_covering_from_cursor(
         if not relating_type.is_a("IfcCoveringType"):
             relating_type = None
 
+    ceiling_height = None
     if selected_objects and active_obj:
-        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_obj(active_obj)
+        x, y, z, _, _ = spatial.get_x_y_z_h_mat_from_obj(active_obj)
     else:
-        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_cursor()
+        x, y, z, _, _ = spatial.get_x_y_z_h_mat_from_cursor()
         ceiling_height = covering.get_z_from_ceiling_height()
 
     space_polygon = spatial.get_space_polygon_from_context_visible_objects(x, y)
@@ -87,6 +88,7 @@ def add_instance_ceiling_covering_from_cursor(
 
     obj = spatial.create_object("Covering")
     spatial.set_obj_origin_to_cursor_position_and_zero_elevation(obj)
+    assert ceiling_height is not None
     spatial.translate_obj_to_z_location(obj, z + ceiling_height)
     spatial.assign_type_to_obj(obj)
     spatial.set_covering_representation_from_polygon(obj, space_polygon, polygon_is_si=True)
@@ -100,7 +102,9 @@ def regen_selected_covering_object(root: type[tool.Root], spatial: type[tool.Spa
     selected_objects = spatial.get_selected_objects()
 
     if selected_objects and active_obj:
-        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_obj(active_obj)
+        x, y, _, _, _ = spatial.get_x_y_z_h_mat_from_obj(active_obj)
+    else:
+        assert False, "Object has to be active and selected."
 
     space_polygon = spatial.get_space_polygon_from_context_visible_objects(x, y)
 

src/bonsai/bonsai/core/drawing.py

@@ -303,17 +303,7 @@ def add_drawing(
         ifc_representation_class=None,
     )
 
-    drawings_parent_group = None
-    for group in ifc.get().by_type("IfcGroup"):
-        if group.Name == "DRAWINGS" and group.ObjectType == "DRAWINGS":
-            drawings_parent_group = group
-            break
-
-    if not drawings_parent_group:
-        drawings_parent_group = ifc.run("group.add_group")
-        ifc.run(
-            "group.edit_group", group=drawings_parent_group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"}
-        )
+    drawings_parent_group = drawing.ensure_drawings_parent_group()
 
     group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
@@ -352,19 +342,7 @@ def add_drawing(
     )
     drawing.setup_shading_styles_path(shading_styles_path)
 
-    drawings_parent_document = None
-    for document in ifc.get().by_type("IfcDocumentInformation"):
-        if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
-            drawings_parent_document = document
-            break
-
-    if not drawings_parent_document:
-        drawings_parent_document = ifc.run("document.add_information")
-        if ifc.get_schema() == "IFC2X3":
-            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        else:
-            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        ifc.run("document.edit_information", information=drawings_parent_document, attributes=attributes)
+    drawings_parent_document = drawing.ensure_drawings_parent_document()
 
     information = ifc.run("document.add_information", parent=drawings_parent_document)
     uri = drawing.get_default_drawing_path(drawing_name)
@@ -395,17 +373,7 @@ def duplicate_drawing(
     group = drawing_tool.get_drawing_group(new_drawing)
     ifc.run("group.unassign_group", group=group, products=[new_drawing])
 
-    drawings_parent_group = None
-    for parent_group in ifc.get().by_type("IfcGroup"):
-        if parent_group.Name == "DRAWINGS" and parent_group.ObjectType == "DRAWINGS":
-            drawings_parent_group = parent_group
-            break
-
-    if not drawings_parent_group:
-        drawings_parent_group = ifc.run("group.add_group")
-        ifc.run(
-            "group.edit_group", group=drawings_parent_group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"}
-        )
+    drawings_parent_group = drawing_tool.ensure_drawings_parent_group()
 
     new_group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=new_group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
@@ -426,19 +394,7 @@ def duplicate_drawing(
     old_reference = drawing_tool.get_drawing_document(new_drawing)
     ifc.run("document.unassign_document", products=[new_drawing], document=old_reference)
 
-    drawings_parent_document = None
-    for document in ifc.get().by_type("IfcDocumentInformation"):
-        if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
-            drawings_parent_document = document
-            break
-
-    if not drawings_parent_document:
-        drawings_parent_document = ifc.run("document.add_information")
-        if ifc.get_schema() == "IFC2X3":
-            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        else:
-            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
-        ifc.run("document.edit_information", information=drawings_parent_document, attributes=attributes)
+    drawings_parent_document = drawing_tool.ensure_drawings_parent_document()
 
     information = ifc.run("document.add_information", parent=drawings_parent_document)
     uri = drawing_tool.get_default_drawing_path(drawing_name)
@@ -541,6 +497,7 @@ def add_annotation(
     drawing_tool.show_decorations()
     obj = drawing_tool.create_annotation_object(drawing, object_type)
     element = ifc.get_entity(obj)
+    relating_type_rep = None
     if not element:  # Brand new annotation
         relating_type_rep = drawing_tool.get_annotation_representation(relating_type) if relating_type else None
         element = drawing_tool.run_root_assign_class(

src/bonsai/bonsai/core/product.py

@@ -1,65 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-from __future__ import annotations
-
-import math
-from collections.abc import Iterable
-from typing import TYPE_CHECKING
-
-import bonsai.core.geometry
-
-if TYPE_CHECKING:
-    import bpy
-
-    import bonsai.tool as tool
-
-
-Z_ROTATION_ALIGNMENT_TOLERANCE = 1e-9
-
-
-def _z_rotation_diff(target_z: float, source_z: float) -> float:
-    """Signed Z-Euler difference wrapped to [-π, π]."""
-    return (target_z - source_z + math.pi) % (2 * math.pi) - math.pi
-
-
-def copy_z_rotation_to_selected(
-    ifc: type[tool.Ifc],
-    geometry: type[tool.Geometry],
-    surveyor: type[tool.Surveyor],
-    *,
-    active: bpy.types.Object,
-    targets: Iterable[bpy.types.Object],
-    flip: bool = False,
-) -> int:
-    """Apply ``active``'s Z-Euler rotation to each target."""
-    source_z = surveyor.get_z_rotation(active)  # ty: ignore[missing-argument]
-    if flip:
-        source_z += math.pi
-    rotated = 0
-    for obj in targets:
-        target_z = surveyor.get_z_rotation(obj)  # ty: ignore[missing-argument]
-        if abs(_z_rotation_diff(target_z, source_z)) < Z_ROTATION_ALIGNMENT_TOLERANCE:
-            continue
-        surveyor.set_z_rotation(obj, source_z)  # ty: ignore[missing-argument]
-        rotated += 1
-        if ifc.get_entity(obj) is not None:
-            bonsai.core.geometry.edit_object_placement(ifc, geometry, surveyor, obj=obj)
-    return rotated

src/bonsai/bonsai/core/tool.py

@@ -254,7 +254,6 @@ class Cost:
     def get_cost_schedule(cls, cost_schedule): pass
     def get_cost_value_attributes(cls): pass
     def get_cost_value_unit_component(cls): pass
-    def get_direct_cost_item_products(cls): pass
     def get_highlighted_cost_item(cls): pass
     def get_products(cls, related_object_type): pass
     def get_schedule_cost_items(cls, cost_schedule): pass
@@ -355,6 +354,8 @@ class Drawing:
     def enable_editing_schedules(cls): pass
     def enable_editing_sheets(cls): pass
     def enable_editing_text(cls, obj): pass
+    def ensure_drawings_parent_document(cls): pass
+    def ensure_drawings_parent_group(cls): pass
     def ensure_unique_drawing_name(cls, name): pass
     def ensure_unique_identification(cls, identification): pass
     def export_font_size(cls, obj): pass
@@ -1170,8 +1171,6 @@ class Style:
 @interface
 class Surveyor:
     def get_absolute_matrix(cls, obj): pass
-    def get_z_rotation(cls, obj): pass
-    def set_z_rotation(cls, obj, z): pass
 
 
 @interface

src/bonsai/bonsai/tool/autosave.py

@@ -96,9 +96,16 @@ class Autosave:
         if not cls.is_eligible():
             return
 
-        def on_timer() -> None:
+        def on_timer() -> Union[float, None]:
             cls._on_timer_expired()
-            return None
+            # Reschedule by returning the next interval rather than calling
+            # reset_timer(), which would unregister this timer from within
+            # its own callback. Blender frees the timer's internal registry
+            # entry on that manual unregister, then frees it again when the
+            # callback returns - a double free that corrupts the heap and
+            # crashes Blender shortly after (e.g. when the prompt dialog
+            # spawned below is next interacted with).
+            return cls.get_interval_seconds() if cls.is_eligible() else None
 
         global _timer_callback
         _timer_callback = on_timer
@@ -120,7 +127,6 @@ class Autosave:
                     cls.perform_backup(bpy.context)
                 except Exception as error:
                     print(f"Bonsai: autosave backup failed: {error}")
-        cls.reset_timer()
 
     @classmethod
     def perform_backup(cls, context: bpy.types.Context) -> None:

src/bonsai/bonsai/tool/brick.py

@@ -192,10 +192,9 @@ class Brick(bonsai.core.tool.Brick):
     def get_brick(cls, element: ifcopenshell.entity_instance) -> Union[str, None]:
         for rel in element.HasAssociations:
             if rel.is_a("IfcRelAssociatesLibrary"):
-                if tool.Ifc.get_schema() == "IFC2X3" and "#" in rel.RelatingLibrary.ItemReference:
-                    return rel.RelatingLibrary.ItemReference
-                if tool.Ifc.get_schema() != "IFC2X3" and "#" in rel.RelatingLibrary.Identification:
-                    return rel.RelatingLibrary.Identification
+                identification = tool.Document.get_external_reference_id(rel.RelatingLibrary)
+                if identification and "#" in identification:
+                    return identification
 
     @classmethod
     def get_brick_class(cls, element: ifcopenshell.entity_instance) -> Union[str, None]:

src/bonsai/bonsai/tool/cad.py

@@ -981,6 +981,7 @@ class Cad:
                         has_found_connected_edge = True
             loops.append(loop)
 
+        new_verts = None
         for loop in loops:
             all_verts = {v.index for e in loop for v in e.verts}
             possible_v1s = []
@@ -1084,6 +1085,7 @@ class Cad:
                     break
 
                 v1 = v2
+        assert new_verts is not None
 
         return new_verts
 

src/bonsai/bonsai/tool/cost.py

@@ -280,6 +280,8 @@ class Cost(bonsai.core.tool.Cost):
                     new = props.cost_item_processes.add()
                 elif related_object.is_a("IfcResource"):
                     new = props.cost_item_resources.add()
+                else:
+                    assert False, related_object
                 new.ifc_definition_id = related_object.id()
                 new.name = related_object.Name or "Unnamed"
 

src/bonsai/bonsai/tool/document.py

@@ -261,7 +261,8 @@ class Document(bonsai.core.tool.Document):
     def get_reference_document(cls, reference: ifcopenshell.entity_instance) -> ifcopenshell.entity_instance | None:
         # TODO: migrate to util.document and replace all instances
         if reference.file.schema == "IFC2X3":
-            return (reference.ReferenceToDocument or (None))[0]
+            reference_to_document = reference.ReferenceToDocument
+            return reference_to_document[0] if reference_to_document else None
         return reference.ReferencedDocument
 
     @classmethod

src/bonsai/bonsai/tool/drawing.py

@@ -38,6 +38,7 @@ import ifcopenshell.api.context
 import ifcopenshell.api.document
 import ifcopenshell.api.drawing
 import ifcopenshell.api.geometry
+import ifcopenshell.api.group
 import ifcopenshell.api.pset
 import ifcopenshell.api.root
 import ifcopenshell.geom
@@ -773,6 +774,32 @@ class Drawing(bonsai.core.tool.Drawing):
     def get_drawing_target_view(cls, drawing: ifcopenshell.entity_instance) -> str:
         return ifcopenshell.util.element.get_psets(drawing).get("EPset_Drawing", {}).get("TargetView", "MODEL_VIEW")
 
+    @classmethod
+    def ensure_drawings_parent_document(cls) -> ifcopenshell.entity_instance:
+        ifc_file = tool.Ifc.get()
+        for document in ifc_file.by_type("IfcDocumentInformation"):
+            if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
+                return document
+        document = ifcopenshell.api.document.add_information(ifc_file)
+        if ifc_file.schema == "IFC2X3":
+            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
+        else:
+            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
+        ifcopenshell.api.document.edit_information(ifc_file, information=document, attributes=attributes)
+        return document
+
+    @classmethod
+    def ensure_drawings_parent_group(cls) -> ifcopenshell.entity_instance:
+        ifc_file = tool.Ifc.get()
+        for group in ifc_file.by_type("IfcGroup"):
+            if group.Name == "DRAWINGS" and group.ObjectType == "DRAWINGS":
+                return group
+        group = ifcopenshell.api.group.add_group(ifc_file)
+        ifcopenshell.api.group.edit_group(
+            ifc_file, group=group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"}
+        )
+        return group
+
     @classmethod
     def get_group_elements(cls, group: ifcopenshell.entity_instance) -> list[ifcopenshell.entity_instance]:
         for rel in group.IsGroupedBy or []:
@@ -1045,6 +1072,12 @@ class Drawing(bonsai.core.tool.Drawing):
         camera_props.has_annotation = True
         camera_props.target_view = "PLAN_VIEW"
         camera_props.is_nts = False
+        camera_props.use_edge_classification = False
+        camera_props.render_creases = True
+        camera_props.valley_angle_min_degrees = 12.0
+        camera_props.render_sharp = True
+        camera_props.ridge_angle_min_degrees = 45.0
+        camera_props.render_flush = False
         camera.shift_x = 0.0
         camera.shift_y = 0.0
 
@@ -1074,6 +1107,18 @@ class Drawing(bonsai.core.tool.Drawing):
                 camera_props.has_annotation = bool(pset["HasAnnotation"])
             if "IsNTS" in pset:
                 camera_props.is_nts = bool(pset["IsNTS"])
+            if "UseEdgeClassification" in pset:
+                camera_props.use_edge_classification = bool(pset["UseEdgeClassification"])
+            if "RenderCreases" in pset:
+                camera_props.render_creases = bool(pset["RenderCreases"])
+            if "ValleyAngleMinDegrees" in pset:
+                camera_props.valley_angle_min_degrees = float(pset["ValleyAngleMinDegrees"])
+            if "RenderSharp" in pset:
+                camera_props.render_sharp = bool(pset["RenderSharp"])
+            if "RidgeAngleMinDegrees" in pset:
+                camera_props.ridge_angle_min_degrees = float(pset["RidgeAngleMinDegrees"])
+            if "RenderFlush" in pset:
+                camera_props.render_flush = bool(pset["RenderFlush"])
             if "DPI" in pset:
                 camera_props.dpi = int(pset["DPI"])
             if "LineworkMode" in pset:
@@ -1140,10 +1185,7 @@ class Drawing(bonsai.core.tool.Drawing):
             new = documents_collection.add()
             new.ifc_definition_id = schedule.id()
             new.name = schedule.Name or "Unnamed"
-            if tool.Ifc.get_schema() == "IFC2X3":
-                new.identification = schedule.DocumentId
-            else:
-                new.identification = schedule.Identification
+            new.identification = tool.Document.get_document_information_id(schedule) or ""
 
     @classmethod
     def get_sheet_identification(cls, sheet: ifcopenshell.entity_instance) -> str:
@@ -1184,10 +1226,7 @@ class Drawing(bonsai.core.tool.Drawing):
                 new.ifc_definition_id = reference.id()
                 new.is_sheet = False
 
-                if tool.Ifc.get_schema() == "IFC2X3":
-                    new.identification = reference.ItemReference or ""
-                else:
-                    new.identification = reference.Identification or ""
+                new.identification = tool.Document.get_external_reference_id(reference) or ""
 
                 new.name = os.path.basename(reference.Location)
                 new.reference_type = reference_description
@@ -2423,9 +2462,8 @@ class Drawing(bonsai.core.tool.Drawing):
     def get_reference_document(
         cls, reference: ifcopenshell.entity_instance
     ) -> Union[ifcopenshell.entity_instance, None]:
-        if tool.Ifc.get_schema() == "IFC2X3":
-            return reference.ReferenceToDocument[0]
-        return reference.ReferencedDocument
+        # TODO: migrate to document.get_reference_document.
+        return tool.Document.get_reference_document(reference)
 
     @classmethod
     def select_assigned_product(cls, context: bpy.types.Context) -> None:
@@ -2555,16 +2593,15 @@ class Drawing(bonsai.core.tool.Drawing):
             if not obj:
                 continue
             current_representation = tool.Geometry.get_active_representation(obj)
+            current_representation_subcontext = None
             if current_representation:
                 subcontext = current_representation.ContextOfItems
                 current_representation_subcontext = tool.Geometry.get_subcontext_parameters(subcontext)
 
-            has_context = False
             for subcontext in subcontexts:
                 # prioritize already active representation if it matches the subcontext
                 # (element could have multiple representations in the same subcontext)
-                if current_representation and subcontext == current_representation_subcontext:
-                    has_context = True
+                if current_representation_subcontext and subcontext == current_representation_subcontext:
                     break
                 priority_representation = ifcopenshell.util.representation.get_representation(element, *subcontext)
                 if priority_representation:
@@ -2574,7 +2611,6 @@ class Drawing(bonsai.core.tool.Drawing):
                         obj=obj,
                         representation=priority_representation,
                     )
-                    has_context = True
                     break
 
         linked_handles: set[bpy.types.Object] = set()

src/bonsai/bonsai/tool/feature.py

@@ -23,7 +23,6 @@ from typing import TYPE_CHECKING
 
 import bpy
 import ifcopenshell.api.feature
-import ifcopenshell.util.representation
 
 import bonsai.core.geometry
 import bonsai.core.tool
@@ -50,6 +49,7 @@ class Feature(bonsai.core.tool.Feature):
                 has_visible_openings = True
                 break
 
+        element_had_openings = None
         for feature_obj in feature_objs:
             feature_element = tool.Ifc.get_entity(feature_obj)
 
@@ -58,7 +58,6 @@ class Feature(bonsai.core.tool.Feature):
                 bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=featured_obj)
 
             element_had_openings = tool.Geometry.has_openings(featured_element)
-            body_context = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body")
             ifcopenshell.api.feature.add_feature(tool.Ifc.get(), feature=feature_element, element=featured_element)
 
             if tool.Ifc.is_moved(feature_obj):
@@ -73,6 +72,7 @@ class Feature(bonsai.core.tool.Feature):
             if voided_obj.data:
                 if tool.Ifc.is_edited(voided_obj):
                     voided_element_ = tool.Ifc.get_entity(voided_obj)
+                    assert element_had_openings is not None
                     if element_had_openings or (voided_element_ != featured_element and voided_element_.HasOpenings):
                         voided_obj.scale = (1.0, 1.0, 1.0)
                         tool.Ifc.finish_edit(voided_obj)

src/bonsai/bonsai/tool/geometry.py

@@ -33,7 +33,6 @@ from typing import (
     Optional,
     TypeGuard,
     Union,
-    cast,
     get_args,
 )
 
@@ -758,6 +757,7 @@ class Geometry(bonsai.core.tool.Geometry):
             # its centroid not obscured (tested via raycasting) by any other
             # face.
             distance = max(obj.dimensions.xyz)
+            min_y, max_z = None, None
             if axis == "+Z":
                 max_z = max([co[2] for co in obj.bound_box]) + 0.002
                 direction = Vector((0, 0, -1))
@@ -772,8 +772,10 @@ class Geometry(bonsai.core.tool.Geometry):
                 if direction.dot(face.normal) > 0:
                     continue
                 if axis == "+Z":
+                    assert max_z is not None
                     face_centroid_at_max = Vector((*face.calc_center_median().xy, max_z))
                 elif axis == "-Y":
+                    assert min_y is not None
                     centroid = face.calc_center_median()
                     face_centroid_at_max = Vector((centroid.x, min_y, centroid.z))
                 face_centroid_at_max = obj.matrix_world @ face_centroid_at_max
@@ -1886,6 +1888,7 @@ class Geometry(bonsai.core.tool.Geometry):
         """NOTE: we assume that all items belonged to the same representation and to the same shape aspect"""
         ifc_file = tool.Ifc.get()
         previous_shape_aspect = None
+        base_representation = None
         for inverse in ifc_file.get_inverse(representation_items[0]):
             if inverse.is_a("IfcShapeRepresentation"):
                 if inverse.OfShapeAspect:
@@ -1895,6 +1898,7 @@ class Geometry(bonsai.core.tool.Geometry):
                     previous_shape_aspect = inverse.OfShapeAspect[0]
                 else:
                     base_representation = inverse
+        assert base_representation
 
         # remove item from previous shape aspect
         if previous_shape_aspect:
@@ -2187,7 +2191,7 @@ class Geometry(bonsai.core.tool.Geometry):
             setattr(item, attribute.name, attribute.get_value())
 
         if item.is_a("IfcSweptAreaSolid"):
-            item_profile = cast(str, props.item_profile)
+            item_profile = props.item_profile
             profile = item.SweptArea
             profile_name: Union[str, None] = profile.ProfileName
             if item_profile == "-":
@@ -2212,6 +2216,7 @@ class Geometry(bonsai.core.tool.Geometry):
         assert item
         obj.data.clear_geometry()
 
+        cartesian_point_offset = None
         if item.is_a("IfcHalfSpaceSolid"):
             bm = bmesh.new()
             bmesh.ops.create_grid(bm, size=0.5)

src/bonsai/bonsai/tool/ifcgit.py

@@ -29,6 +29,7 @@ from typing import TYPE_CHECKING, Any, Union
 
 import bpy
 
+import bonsai.core.tool
 import bonsai.tool as tool
 from bonsai.bim import import_ifc
 from bonsai.bim.ifc import IfcStore
@@ -50,7 +51,7 @@ if TYPE_CHECKING:
     from bonsai.bim.module.ifcgit.prop import IfcGitProperties
 
 
-class IfcGit:
+class IfcGit(bonsai.core.tool.IfcGit):
     STEP_IDS = dict[str, set[int]]
 
     @classmethod

src/bonsai/bonsai/tool/loader.py

@@ -197,7 +197,6 @@ class Loader(bonsai.core.tool.Loader):
         cls, blender_material: bpy.types.Material, surface_style: ifcopenshell.entity_instance
     ) -> None:
         surface_style = cls.surface_style_to_dict(surface_style)
-        surface_style: dict[str, Any]
 
         cls.create_surface_style_shading(blender_material, surface_style)
 
@@ -1088,18 +1087,21 @@ class Loader(bonsai.core.tool.Loader):
         bm = bmesh.new()
         bm.from_mesh(mesh)
         prev_co = None
-        if usage.LayerSetDirection == "AXIS2":
+        layer_set_direction = usage.LayerSetDirection
+        if layer_set_direction == "AXIS2":
             co = Vector((0.0, offset, 0.0))
             no = cls.get_extrusion_vector(element).normalized()
             no = no.cross(Vector([1.0, 0.0, 0.0]))
-        elif usage.LayerSetDirection == "AXIS3":
+        elif layer_set_direction == "AXIS3":
             co = Vector((0.0, 0.0, offset))
             no = cls.get_extrusion_vector(element).normalized()
             no = Vector([0.0, 0.0, 1.0])
-        elif usage.LayerSetDirection == "AXIS1":
+        elif layer_set_direction == "AXIS1":
             co = Vector((0.0, 0.0, offset))
             no = cls.get_extrusion_vector(element).normalized()
             no = Vector([1.0, 0.0, 0.0])
+        else:
+            assert False, layer_set_direction
         no *= sense_factor
         # Cache this
         body = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body", "MODEL_VIEW")
@@ -1109,6 +1111,7 @@ class Loader(bonsai.core.tool.Loader):
             if style := tool.Ifc.get_entity(material):
                 styles[style] = i
         last_i = len(layer_set.MaterialLayers) - 1
+        bisect_geom = None
         for i, layer in enumerate(layer_set.MaterialLayers):
             if i != last_i:
                 prev_co = co.copy()
@@ -1122,6 +1125,7 @@ class Loader(bonsai.core.tool.Loader):
             if (material_index := styles.get(style, None)) is None:
                 material_index = len(mesh.materials)
                 mesh.materials.append(tool.Ifc.get_object(style))
+            assert bisect_geom is not None
             if i == last_i:
                 for face in bisect_geom["geom"]:
                     if isinstance(face, bmesh.types.BMFace):
@@ -1287,6 +1291,7 @@ class Loader(bonsai.core.tool.Loader):
             polyline.material_index = material_index
             return polyline
 
+        item = None
         for item_data, item_style in zip(rep_items, item_styles):
             item = item_data["item"]
 
@@ -1314,6 +1319,7 @@ class Loader(bonsai.core.tool.Loader):
                 polyline.points.add(1)
                 polyline.points[-1].co = native_data["matrix"] @ Vector(v2)
 
+        assert item is not None
         curve.bevel_depth = unit_scale * item.Radius
         thickness = None
         if (inner_radius := item.InnerRadius) and (thickness := max(item.Radius - inner_radius, 0)):

src/bonsai/bonsai/tool/misc.py

@@ -112,10 +112,14 @@ class Misc(bonsai.core.tool.Misc):
         reading data and never writing, to avoid the possibility of corrupting user preferences.
         """
 
+        # Byte offset of UserDef.user_menus within the UserDef C struct, per (major, minor)
+        # Blender version. Shifts whenever UserDef's fields change, so must be re-derived
+        # per version (e.g. from that Blender build's SDNA).
         OFFSET_USER_MENUS: dict[tuple[int, int], int] = {
             (4, 5): 10032,
             (5, 0): 10032,
             (5, 1): 10032,
+            (5, 2): 10800,
         }
 
         @classmethod
@@ -216,10 +220,12 @@ class Misc(bonsai.core.tool.Misc):
                         related_objects.append((element, ifcopenshell.util.placement.get_storey_elevation(element)))
         related_objects = sorted(related_objects, key=lambda e: e[1])
         storey_elevation = None
+        i = None
         for i, related_object in enumerate(related_objects):
             if related_object[0] == storey:
                 storey_elevation = related_object[1]
                 break
+        assert i is not None
         if i + total_storeys < len(related_objects):
             next_storey_elevation = related_objects[i + total_storeys][1]
             unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())

src/bonsai/bonsai/tool/parametric.py

@@ -641,6 +641,8 @@ del _edit_type_names
 # call sites can reference ``tool.Parametric.ROOF`` directly. Renaming a
 # registry entry renames the constant; a typo at the call site surfaces as
 # AttributeError at module load.
+_entry = None
 for _entry in Parametric.EDIT_TYPES:
     setattr(Parametric, _entry.name.upper(), _entry)
+assert _entry is not None
 del _entry

src/bonsai/bonsai/tool/polyline.py

@@ -168,6 +168,7 @@ class Polyline(bonsai.core.tool.Polyline):
         distance = (mouse_vector - last_point).length
         if distance < 0:
             return
+        angle, orientation_angle, angle_round_threshold = None, None
         if distance > 0:
             angle = tool.Cad.angle_3_vectors(
                 second_to_last_point, last_point, mouse_vector, new_angle=None, degrees=True
@@ -188,6 +189,7 @@ class Polyline(bonsai.core.tool.Polyline):
             angle = 0
             orientation_angle = 0
         if input_ui:
+            assert angle is not None and orientation_angle is not None and angle_round_threshold is not None
             if should_round:
                 angle_snap = tool.Snap.get_angle_snap_value(context)
                 angle = angle_snap * round(angle / angle_snap) if distance < angle_round_threshold else angle

src/bonsai/bonsai/tool/project.py

@@ -370,18 +370,21 @@ class Project(bonsai.core.tool.Project):
         props = cls.get_project_props()
         active_library_breadcrumb = props.get_active_library_breadcrumb()
         change_back = False
+        breadcrumb = None
         if active_library_breadcrumb:
             name = active_library_breadcrumb.name
             breadcrumb_type = active_library_breadcrumb.breadcrumb_type
             library_id = active_library_breadcrumb.library_id
+            breadcrumb = (name, breadcrumb_type, library_id)
             change_back = True
 
         bpy.ops.bim.rewind_library()
         if change_back:
+            assert breadcrumb
             bpy.ops.bim.change_library_element(
-                element_name=name,
-                breadcrumb_type=breadcrumb_type,
-                library_id=library_id,
+                element_name=breadcrumb[0],
+                breadcrumb_type=breadcrumb[1],
+                library_id=breadcrumb[2],
             )
 
     @classmethod

src/bonsai/bonsai/tool/pset.py

@@ -124,6 +124,9 @@ class Pset(bonsai.core.tool.Pset):
             return bpy.context.scene.GroupPsetProperties
         elif obj_type == "Zone":
             return bpy.context.scene.ZonePsetProperties
+        elif obj_type == "Cost":
+            # No psets for cost items currently.
+            assert False, obj_type
         assert_never(obj_type)
 
     @classmethod

src/bonsai/bonsai/tool/raycast.py

@@ -232,7 +232,7 @@ class Raycast(bonsai.core.tool.Raycast):
         return final_2d, v2
 
     @classmethod
-    def intersect_mouse_2d_bounding_box(cls, mouse_pos: tuple[int, int], bbox: list[float, float, float, float]):
+    def intersect_mouse_2d_bounding_box(cls, mouse_pos: tuple[int, int], bbox: list[float]):
         x, y = mouse_pos
         xmin, xmax, ymin, ymax = bbox
 

src/bonsai/bonsai/tool/search.py

@@ -505,6 +505,8 @@ class Search(bonsai.core.tool.Search):
                 (0.773, 0.922, 0.816),
                 (0.871, 0.957, 0.894),
             ]
+        else:
+            assert False, theme
 
         if value < min_val:
             value = min_val
@@ -574,8 +576,10 @@ class ImportFilterQueryTransformer(lark.Transformer):
         new = self.filter_groups.add()
         global_ids = []
         is_first_group = len(self.filter_groups) == 1
+        new2 = None
         for filter_index, arg in enumerate(args):
             if arg["type"] == "instance" and global_ids:
+                assert new2
                 if "bpy.data.texts" in new2.value:
                     data_name = new2.value.split("bpy.data.texts")[1][2:-2]
                     bpy.data.texts[data_name].write("," + arg["value"])

src/bonsai/bonsai/tool/sequence.py

@@ -23,7 +23,7 @@ import re
 from collections.abc import Iterable
 from datetime import datetime
 from datetime import time as datetime_time
-from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union, assert_never
 
 import bpy
 import ifcopenshell
@@ -1127,7 +1127,8 @@ class Sequence(bonsai.core.tool.Sequence):
 
     @classmethod
     def load_default_animation_color_scheme(cls):
-        groups = {
+        GroupType = Literal["CREATION", "OPERATION", "MOVEMENT_TO", "DESTRUCTION", "MOVEMENT_FROM", "USERDEFINED"]
+        groups: dict[GroupType, dict[str, Any]] = {
             "CREATION": {
                 "PredefinedType": ["CONSTRUCTION", "INSTALLATION"],
                 "Color": (0.0, 1.0, 0.0),
@@ -1167,6 +1168,8 @@ class Sequence(bonsai.core.tool.Sequence):
                     predefined_type_item2 = props.task_output_colors.add()
                     predefined_type_item2.name = predefined_type
                     predefined_type_item2.color = data["Color"]
+                else:
+                    assert_never(group)
                 # TO DO: consider cases where users confuses inputs and outputs
                 predefined_type_item.name = predefined_type
                 predefined_type_item.color = data["Color"]

src/bonsai/bonsai/tool/snap.py

@@ -225,6 +225,7 @@ class Snap(bonsai.core.tool.Snap):
         # Get axis that are closer than the stick factor threshold
         elegible_axis = []
 
+        axis = None
         for axis in snap_axis:
             if not axis:
                 continue
@@ -326,6 +327,7 @@ class Snap(bonsai.core.tool.Snap):
         detected_snaps: list[dict[str, Any]] = []
 
         def select_plane_method():
+            plane_origin, plane_normal = None, None
             if not last_polyline_point:
                 plane_origin = Vector((0, 0, 0))
                 plane_normal = Vector((0, 0, 1))
@@ -357,6 +359,7 @@ class Snap(bonsai.core.tool.Snap):
                     plane_origin = Vector((last_polyline_point.x, last_polyline_point.y, last_polyline_point.z))
                 plane_normal = Vector((1, 0, 0))
 
+            assert plane_origin and plane_normal
             plane_normal = tool.Polyline.use_transform_orientations(plane_normal)
             return plane_origin, plane_normal
 
@@ -583,6 +586,7 @@ class Snap(bonsai.core.tool.Snap):
 
         snaps_by_group = filter_snapping_points_by_group(detected_snaps)
         edges = []  # Get edges to create edge-intersection snap
+        axis_start, axis_end = ..., ...
         for snapping_point in snaps_by_group:
             if snapping_point["group"] in {"Polyline", "Measure", "Wireframe", "Object"}:
                 if snapping_point["type"] == "Edge":
@@ -607,6 +611,7 @@ class Snap(bonsai.core.tool.Snap):
                 if point["type"] == "Axis":
                     if ordered_snaps[0]["type"] not in {"Axis", "Plane"}:
                         obj = ordered_snaps[0]["object"]
+                        assert axis_start is not ... and axis_end is not ...
                         mixed_snap = cls.mix_snap_and_axis(ordered_snaps[0], axis_start, axis_end)
                         for mixed_point in mixed_snap:
                             snap_point = {

src/bonsai/bonsai/tool/spatial.py

@@ -304,12 +304,14 @@ class Spatial(bonsai.core.tool.Spatial):
 
             while True:
                 has_parent = None
+                new_current_results = None
                 for key in current_results:
                     if flat_key.startswith(key):
                         has_parent = True
                         new_current_results = current_results[key]["children"]
                         break
                 if has_parent:
+                    assert new_current_results is not None
                     current_results = new_current_results
                 else:
                     break
@@ -978,19 +980,24 @@ class Spatial(bonsai.core.tool.Spatial):
         interiors_list = []
 
         if union_geom.geom_type == "MultiPolygon":
+            poly = None
             for poly in union_geom.geoms:
                 interiors_list = cls.get_poly_valid_interior_list(
                     poly=poly, min_area=min_area, interiors_list=interiors_list
                 )
 
+            assert poly
             new_poly = Polygon(poly.exterior.coords, holes=interiors_list)
 
-        if union_geom.geom_type == "Polygon":
+        elif union_geom.geom_type == "Polygon":
             interiors_list = cls.get_poly_valid_interior_list(
                 poly=union_geom, min_area=min_area, interiors_list=interiors_list
             )
             new_poly = Polygon(union_geom.exterior.coords, holes=interiors_list)
 
+        else:
+            assert False, union_geom.geom_type
+
         return new_poly
 
     @classmethod

src/bonsai/bonsai/tool/style.py

@@ -360,6 +360,10 @@ class Style(bonsai.core.tool.Style):
         material_output = tool.Blender.get_material_node(obj, "OUTPUT_MATERIAL", {"is_active_output": True})
         surface_output = get_input_node(material_output, "Surface")
 
+        # TODO: this variable is not really needed,
+        # just workaround a for ty issue detecting unresolved refs.
+        bsdf = None
+
         if surface_output and surface_output.type == "MIX_SHADER":
             mix_shader = surface_output
             if (
@@ -388,6 +392,7 @@ class Style(bonsai.core.tool.Style):
                 and (bsdf := get_input_node(surface_output, input_index=1, of_type="BSDF_PRINCIPLED"))
             )
         ):
+            assert bsdf
             report(f"Because of {BLUE}BSDF_PRINCIPLED{R} node reflectance method identified as {BLUE}PHYSICAL{R}")
             attributes["ReflectanceMethod"] = "NOTDEFINED" if tool.Ifc.get_schema() != "IFC4X3" else "PHYSICAL"
 

src/bonsai/docs/_templates/sidebar/brand.html

@@ -38,8 +38,8 @@ Hope your day's going well. :)
 <script>
   // Define the mapping of versions to URLs
   const versionURLs = {
-    stable: 'http://docs.bonsaibim.org/',
-    unstable: 'http://docs-unstable.bonsaibim.org/',
+    stable: 'https://docs.bonsaibim.org/',
+    unstable: 'https://docs-unstable.bonsaibim.org/',
     // Add more versions here as needed
   };
 

src/bonsai/docs/guides/development/maintenance.rst

@@ -44,8 +44,6 @@ When a new Blender version is released and supported:
 
    * - File
      - What to update
-   * - ``.github/workflows/ci-bonsai.yml``
-     - ``pyver`` matrix
    * - ``.github/workflows/ci-bonsai-daily.yml``
      - Blender download URL
 
@@ -61,6 +59,10 @@ When Blender ships with a new Python version:
      - What to update
    * - ``.github/workflows/ci-lint.yaml``
      - ``MIN_BLENDER_PY_VERSION``
+   * - ``.github/workflows/ci-bonsai.yml``
+     - ``pyver`` matrix
+   * - ``.github/workflows/ci-bonsai-daily.yml``
+     - ``pyver`` matrix
    * - ``.github/scripts/publish-bonsai-releases.py``
      - ``CURRENT_PYTHON_VERSION``
    * - ``src/bonsai/Makefile``

src/bonsai/docs/quickstart/create_model.rst

@@ -77,18 +77,3 @@ the image below. Three simple open source online viewers you can test with are
 <https://3dviewer.net/>`__.
 
 .. image:: images/ifc-pipeline.png
-
-Placing occurrences of an element type
---------------------------------------
-
-TODO
-
-Changing the locations of elements
-----------------------------------
-
-TODO
-
-Modeling a simple building
---------------------------
-
-TODO

src/bonsai/pyproject.toml

@@ -18,12 +18,6 @@ dependencies = [
     "ifcopenshell",
 ]
 
-[project.optional-dependencies]
-dev = [
-  "pytest-blender",
-  "pytest-bdd",
-]
-
 [project.urls]
 Homepage = "http://bonsaibim.org"
 Documentation = "https://docs.bonsaibim.org"

src/bonsai/requirements-dev.txt

@@ -0,0 +1,3 @@
+pytest
+pytest-blender
+pytest-bdd

src/bonsai/scripts/bonsai_translations.py

@@ -216,6 +216,7 @@ def update_translations_from_po(po_directory: Path, translations_module: Path):
 
 
 if BPY_IS_LOADED:
+    import bpy
 
     class SetupTranslationUI(bpy.types.Operator):
         bl_idname = "bim.setup_translation_ui"

src/bonsai/scripts/classifications/brick_classifiction.py

@@ -82,6 +82,7 @@ class Generator:
                 }
                 """.replace("{entity}", location.split("#")[-1]))
             # filter parents for the brick entity
+            parent = None
             for row in query:
                 parent = row.get("parent").toPython()
                 if "brickschema.org" in parent and parent in references.keys():

src/bonsai/scripts/dev_environment.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """Setup Bonsai Development Environment.
 
 Script links existing Bonsai installation to the provided IfcOpenShell repository.
@@ -78,7 +79,8 @@ BONSAI_PATH = find_bonsai_path()
 # ---------------------------
 
 # Never changed by user.
-PYTHON_VERSION = "3.13" if BLENDER_VERSION == "5.1" else "3.11"
+BLENDER_VERSION_INT = tuple(map(int, BLENDER_VERSION.split(".")))
+PYTHON_VERSION = "3.13" if BLENDER_VERSION_INT >= (5, 1) else "3.11"
 PACKAGE_PATH = BLENDER_PATH / rf"extensions/.local/lib/python{PYTHON_VERSION}/site-packages"
 
 

src/bonsai/scripts/generate_furniture_library.py

@@ -1036,6 +1036,7 @@ class LibraryGenerator:
             seat_width_offset = 0.7 * width / 2 if cistern_depth else width / 2
             seat_start_width_offset = 0.6 * width
 
+            cistern_3d = None
             if cistern_height:
                 cistern = builder.rectangle(size=V(width, cistern_depth), position=shift_to_center)
                 cistern_3d = ifcopenshell.util.element.copy_deep(self.file, cistern)
@@ -1118,6 +1119,7 @@ class LibraryGenerator:
 
             # cistern
             if cistern_height:
+                assert cistern_3d
                 cistern_3d = builder.extrude(
                     cistern_3d, cistern_height + seat_level / 2, position=V(0, 0, seat_level / 2)
                 )