Update opening-template dev-note

Reflect void-propagation-to-all-occurrences and adjusted-extrusion
preservation added to #8200 since the note was seeded.

Generated with the assistance of an AI coding tool.

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

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

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

.github/workflows/ci-lint.yaml

@@ -27,7 +27,10 @@ jobs:
       - name: Install dependencies
         run: |
           curl -LsSf https://astral.sh/uv/install.sh | sh
-          cat requirements-tools.txt | xargs -L1 uv tool install
+          uv tool install ruff
+          uv tool install black
+          uv tool install poethepoet
+          uv tool install ty==0.0.34
 
       # black doesn't catch all syntax errors, so we check them explicitly.
       - name: Check syntax errors

.gitignore

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

AGENTS.md

@@ -129,6 +129,21 @@ on CI to catch formatting issues.
   within each package under `src/`.
 - Run the existing test suite for the package you modified before submitting.
 
+## In-Progress Feature Notes
+
+Living design and working notes for unmerged feature branches live in
+[`docs/dev-notes/`](docs/dev-notes/), one Markdown file per feature, named after the
+branch. They capture the problem, the design decisions and the *why*, and what still
+needs testing — so collaborators (and their AI agents) can pick up the context behind a
+branch. Because the note is committed on the branch, it travels with the PR.
+
+- Before working on a feature branch, read its note in `docs/dev-notes/` if one exists.
+- Keep the note current as the PR is refined.
+- These are not user documentation; at merge they are removed or their durable parts
+  promoted to code comments / permanent docs.
+
+See [`docs/dev-notes/README.md`](docs/dev-notes/README.md) for details.
+
 ## Architecture Quick Reference
 
 ### Directory Structure

cmake/CMakeLists.txt

@@ -27,14 +27,13 @@ endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON) # not necessary, but encouraged
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-# The VERSION file in the repository root is the single source of truth for the
-# release version. Read it unconditionally so a plain source build reports the
-# real version through buildinfo.cpp instead of the stale hardcoded 0.8.0
-# fallback (see #8164). VERSION_OVERRIDE still controls the branch name used
-# when ADD_COMMIT_SHA embeds a commit sha.
-file(READ "../VERSION" "RELEASE_VERSION_")
-string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
-message(STATUS "Detected version '${RELEASE_VERSION}'")
+if(VERSION_OVERRIDE)
+    file(READ "../VERSION" "RELEASE_VERSION_")
+    string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
+    message(STATUS "Detected version '${RELEASE_VERSION}'")
+else()
+    set(RELEASE_VERSION "0.8.0")
+endif()
 
 add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
 
@@ -314,12 +313,8 @@ if(WASM_BUILD)
 else()
     # @todo review this, shouldn't this be all possible header-only now?
     # ... or rewritten using C++17 features?
-    # Boost.System has been header-only since 1.69 and its compiled stub library
-    # was dropped in newer Boost, so requesting it as a component makes
-    # find_package fail on Boost 1.70 and up (for example Boost 1.90). It is
-    # still pulled in transitively by thread / iostreams where needed, so do not
-    # request it explicitly.
     set(BOOST_COMPONENTS
+        system
         program_options
         regex
         thread
@@ -563,8 +558,8 @@ if(COMPILE_SCHEMA)
     # Bootstrap the parser
     message(STATUS "Compiling schema, this will take a while...")
     execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py
-        WORKING_DIRECTORY ../src/ifcopenshell-python/ifcopenshell/express
+        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf
+        WORKING_DIRECTORY ../src/ifcexpressparser
         OUTPUT_FILE express_parser.py
         RESULT_VARIABLE SUCCESS
     )
@@ -575,7 +570,7 @@ if(COMPILE_SCHEMA)
 
     # Generate code
     execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} ../ifcopenshell-python/ifcopenshell/express/express_parser.py ../../${COMPILE_SCHEMA}
+        COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
         WORKING_DIRECTORY ../src/ifcparse
         OUTPUT_VARIABLE COMPILED_SCHEMA_NAME
     )
@@ -665,11 +660,6 @@ if(ADD_COMMIT_SHA)
     endif()
 endif(ADD_COMMIT_SHA)
 
-# Always expose the release version (from the VERSION file) to buildinfo.cpp so
-# that a build without commit-sha info reports the correct version instead of a
-# stale hardcoded fallback. See #8164.
-target_compile_definitions(IfcParse PRIVATE IFCOPENSHELL_VERSION_STRING=${RELEASE_VERSION})
-
 if(MSVC)
     # @todo still needs to be understood better, but the cgal and cgal-simple kernel cause multiply defined boost lambda placeholders _1 ... _3
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /FORCE:MULTIPLE")

docker/.dockerignore

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

docker/.gitignore

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

docker/.ifcos_env

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

docker/Dockerfile

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

docker/README.md

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

docker/SKILL.md

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

docker/compose.yaml

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

docker/ifcos_env

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

docs/dev-notes/README.md

@@ -0,0 +1,28 @@
+<!-- This file was generated with the assistance of an AI coding tool. -->
+
+# Developer notes (in-progress features)
+
+This directory holds **living design/working notes for unmerged feature branches**,
+one Markdown file per feature, named after its branch (e.g.
+`opening-template-on-type.md`).
+
+## Purpose
+
+A shared scratchpad so collaborators — and the AI agents they work with — can pick up
+the context behind an in-progress branch: the problem, the design decisions and the
+*why*, dead ends already ruled out, and what still needs testing. Because the note is
+committed on the branch, it travels with the PR and shows up in the diff, so it is
+discoverable without anyone being told where to look.
+
+## How to use it (humans and agents)
+
+- **Before working on a feature branch**, read its note here if one exists.
+- **As the PR is refined**, keep the note current — append decisions, correct things
+  that changed, update the test checklist.
+- **One file per feature**, named after the branch.
+
+## Lifecycle
+
+These are *not* permanent user documentation. When a PR merges, either remove its note
+or promote the durable parts (the load-bearing "why") into code comments or the regular
+docs, so stale notes do not accumulate on the default branch.

docs/dev-notes/opening-template-on-type.md

@@ -0,0 +1,165 @@
+<!-- This file was generated with the assistance of an AI coding tool. -->
+
+# Opening template on type — preserving custom openings across duplicate_type / append
+
+> **Living dev note** for the `opening-template-on-type` branch/PR. Read before working
+> on the feature; append decisions and findings as the PR is refined. This is *not* user
+> documentation — at merge it is removed or its durable parts promoted to code comments.
+> See [README.md](README.md) for the convention.
+
+## Problem
+
+`bpy.ops.bim.duplicate_type` and `bpy.ops.bim.append_library_element` lose a custom
+`IfcOpeningElement` body (e.g. an `IfcPolygonalFaceSet`/tessellation) and replace it
+with a generated extrusion. Root cause: the only mechanism that preserved a custom
+opening was "copy it from a sibling occurrence of the same type"
+(`get_existing_opening_occurrence_if_any`), which returns nothing for a brand-new
+type. `generate_opening_from_filling` then always builds an extrusion (profile or
+bbox), discarding the custom geometry.
+
+## Key facts established
+
+- IFC-level `root.copy_class` already `copy_deep`s opening representations; the loss
+  happens on the Bonsai side (the `regenerate_from_type` listener on
+  `type.assign_type`, and placement-time generation).
+- Opening occurrences of one type already **share** a single `IfcRepresentationMap`
+  via mapped representations — that is why editing one void edits them all
+  (see `tool.Model.unshare_opening_representation` docstring). Bonsai shares, it does
+  not copy. The shared map just has no durable home (it is hosted implicitly by
+  whichever occurrence exists), so it does not survive to a new type.
+- IFC4 ADD2 TC1 `IfcShapeRepresentation`: identifier **`Reference`** = "3D
+  representation that is **not part of the Body representation** ... used, e.g., for
+  opening geometries ... excluded from an implicit Boolean operation." Schema-valid;
+  `IfcTypeProduct` has no uniqueness rule on `RepresentationMaps` (only
+  `ApplicableOccurrence`). So a `Reference` map can sit beside the `Body` map.
+- The geometry kernel selects an opening's geometry **by context, not by
+  `RepresentationIdentifier`** (`mapping::representation_of`, `ifcgeom/mapping/mapping.cpp`).
+  So a `Reference`-identified opening in the Body context still booleans correctly.
+  Nothing in Bonsai reads `"Reference"` to *skip* applying an opening.
+- Caveat: IFC has no type-level void (`IfcRelVoidsElement` is occurrence-only). The
+  "opening template on type" is therefore a Bonsai convention using a spec-valid
+  identifier; other tools see a harmless extra `Reference` rep they ignore. The
+  regeneration smarts are Bonsai-only by necessity.
+
+## Design
+
+Store the shared opening body on the **type** as a `Reference` representation map.
+Because `bim.duplicate_type` (`tool.Root.copy_representation`) and
+`append_type_product` both copy a type's `RepresentationMaps`, the template survives
+both. Occurrence openings map over the same map, so editing a void rewrites the
+shared map = updates the type template in one stroke (no separate write-back needed).
+
+`map_type_representations` must skip `Reference` maps so the window/door occurrence
+does not receive the opening shape as its own Body (the kernel would otherwise pick
+arbitrarily between the real Body and the opening rep). The skip is both required and
+spec-endorsed ("not part of the Body representation").
+
+### Body-context coexistence (Option A)
+
+The template lives in the **Body** subcontext (required: the instance opening that maps
+over it must resolve in Body context for the geometry kernel to subtract it). So the
+type holds two reps in one context: the `Body` window body and the `Reference` opening
+template. Per IFC, `Reference` is a *RepresentationIdentifier value used within the Body
+context*, not a separate context - so we keep it there and disambiguate elsewhere:
+
+- The representations panel now shows `RepresentationIdentifier` as its own column
+  (`geometry/data.py`, `geometry/ui.py`) so the two Body-context reps are
+  distinguishable (`Model | Body | MODEL_VIEW | Reference | Tessellation`). The panel
+  column previously read "Body" because it shows `ContextOfItems.ContextIdentifier`,
+  not the representation's identifier.
+- `Geometry.reimport_element_representations` type branch now renders the requested
+  `base_representation` instead of `get_representation(element, context)`, which matched
+  only by context and returned the window body when switching to the `Reference` rep.
+  This is what makes "switch to the Reference row" actually show the void on the type.
+
+### Precedence in `generate_opening_from_filling`
+type `Reference` template → (existing sibling occurrence, checked by callers) →
+type `Profile` extrusion → bbox extrusion.
+
+### Type switching (assign_type)
+
+On `type.assign_type` the opening is rebuilt to reflect the **assigned** type's void.
+Two listeners in `model/handler.py`:
+
+- **pre** `Bonsai.Opening.PreserveOnTypeChange` → `preserve_opening_on_type_change`:
+  before the filling moves to the new type, `promote_opening_to_type(old_type)` anchors
+  the old type's custom void as a template, so it isn't lost when (possibly the last)
+  occurrence is regenerated. Idempotent; custom voids only.
+- **post** `Bonsai.Opening.RegenerateFromType` → `regenerate_from_type` →
+  `_regenerate_from_type`: rebuilds from the new type's template / sibling / extrusion.
+  The old PR1 "preserve custom" guard was **removed** here — it kept the previous type's
+  void on a switch (wrong), and the template now makes preservation unnecessary.
+
+NOTE: upstream `v0.8.0` landed `assign_type` changes + new `test_assign_type_*` tests
+(merged under this branch's base). The listeners ride on top of that — re-test the
+switch/edit round-trips against the new `assign_type`.
+
+### Write-back on void edit
+
+Editing an occurrence's void writes the new geometry back to the type's `Reference`
+template via `update_type_template_from_opening` (creates the template if absent), then
+**re-maps every occurrence's opening onto the template** and reloads the affected host walls
+(`switch_representation`) so they re-boolean. The re-map (`_remap_opening_to_template`) is the
+key part: an earlier version only re-pointed a *pre-existing* shared map, so siblings whose
+openings were **independent** (their own `IfcRepresentationMap`, never sharing the template)
+didn't follow — the common real-world case. Now they do. Hooked at both commit paths:
+`UpdateRepresentation._execute` (the `edited_objs` path) and
+`OverrideModeSetObject` after `edit_representation_item` (the in-place item edit). The
+older `edit_openings`/`is_edited` path also calls it. `set_type_opening_representation`
+has replace semantics (one `Reference` map per type).
+
+### Preserving adjusted extrusions (duplicate_type)
+
+`is_opening_representation_custom` only flags *non-extrusion* geometry (tessellation, brep,
+CSG) as worth preserving — a proxy for "not regenerable". That mis-classifies a *manually
+adjusted* extrusion, which is still an `IfcExtrudedAreaSolid`, so a hand-tweaked extrusion
+opening was reset to the default on `duplicate_type`.
+
+`promote_opening_to_type` now gates on `should_preserve_opening` = custom **or**
+`_is_adjusted_extrusion`. The latter generates the default (`generate_opening_from_filling`,
+which yields the default since no template exists at promote time) *transiently*, compares the
+two bodies' axis-aligned bounding boxes (1 mm tolerance) via the geom engine, then removes the
+temporary default. Divergence ⇒ the extrusion was adjusted ⇒ promote it; a plain default
+matches ⇒ left regenerable (not frozen — see the "freeze" discussion). Scoped to the duplicate
+path so the generate-and-compare stays out of the hot predicate. Limitation: bbox comparison
+misses a shape change that preserves the bbox (upgrade to a vertex-set compare if needed).
+
+## Status — implemented (manually verified in Blender)
+
+- core `map_type_representations.py`: skip `Reference` maps.
+- `model/opening.py`: `get_/set_type_opening_representation`, `promote_opening_to_type`,
+  `update_type_template_from_opening` (+ `_remap_opening_to_template`),
+  `preserve_opening_on_type_change`, `should_preserve_opening` (+ `_is_adjusted_extrusion`,
+  `_representation_bbox`); `generate_opening_from_filling` consults the template; PR1 guard
+  removed from `_regenerate_from_type`.
+- `model/handler.py`: pre + post assign_type listeners.
+- `type/operator.py` `DuplicateType`: promote before copy.
+- `project/operator.py` `AppendLibraryElement`: `harvest_opening_template`.
+- `geometry/operator.py`: write-back hooks in `UpdateRepresentation` and
+  `OverrideModeSetObject`; `reimport_element_representations` renders the requested rep.
+- `geometry/data.py` + `geometry/ui.py`: `RepresentationIdentifier` column + headers.
+
+Branch `opening-template-on-type` (#8200): initial feature commit + the #7916 build-conflict
+ancestry-merge + void-propagation-to-all-occurrences + adjusted-extrusion preservation. The
+`docs/dev-notes/` convention itself lives on the stacked branch `dev-notes-system` (#8201).
+
+Still **deferred:** explicit "Apply/Reset to type" operators + a "diverges from type"
+indicator; import never auto-writes back. `update_simple_openings` still keeps its
+`is_opening_representation_custom` guard (array propagation, same type — left as-is).
+
+## Things to test / verify
+
+- Duplicated/appended type's new occurrence gets the faceset void and it **cuts** the
+  wall (kernel selects opening geom by context, so a `Reference`-id rep still booleans).
+- `harvest_opening_template` cross-file `file.add`: no duplicate
+  `IfcGeometricRepresentationContext` left behind; units (kernel doesn't rescale rep
+  coords — same assumption as `append_asset`).
+- Switch X→Y→X round-trip restores each type's void; switching to a plain (template-less)
+  type gives its default extrusion, not the previous faceset.
+- Edit a void → type's `Reference` row updates; **all** occurrences follow (including ones
+  that had independent openings) and their host walls re-boolean; survives duplicate.
+- `duplicate_type` on a type whose extrusion opening was **manually adjusted** → Type B keeps
+  the adjusted extrusion; a type with a plain/default extrusion stays regenerable (not frozen).
+- Three write-back hooks are intentional (different commit paths) — candidate for
+  consolidation in review.
+- Re-test against upstream's new `assign_type` (see NOTE under "Type switching").

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

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

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

nix/patches/occt/88af392.patch

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

nix/patches/pr622.patch

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

pyproject.toml

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

requirements-tools.txt

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

src/bonsai/bonsai/bim/handler.py

@@ -320,11 +320,9 @@ def loadIfcStore(scene: bpy.types.Scene) -> None:
     IfcStore.purge()
     refresh_ui_data()
     if not tool.Ifc.get():
-        tool.Autosave.cancel_timer()
         return
     tool.Ifc.schema()
     IfcStore.relink_all_objects()
-    tool.Autosave.reset_timer()
 
 
 @persistent

src/bonsai/bonsai/bim/ifc.py

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

src/bonsai/bonsai/bim/import_ifc.py

@@ -980,13 +980,8 @@ class IfcImporter:
                     if unit.Name == "METRE":
                         if not unit.Prefix:
                             bpy.context.scene.unit_settings.length_unit = "METERS"
-                        elif f"{unit.Prefix}METERS" in ("KILOMETERS", "CENTIMETERS", "MILLIMETERS", "MICROMETERS"):
-                            bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
                         else:
-                            # Blender's length_unit enum has no entry for other
-                            # SI prefixes (e.g. DECIMETERS), so fall back to
-                            # adaptive display instead of failing to open.
-                            bpy.context.scene.unit_settings.length_unit = "ADAPTIVE"
+                            bpy.context.scene.unit_settings.length_unit = f"{unit.Prefix}METERS"
                 else:
                     bpy.context.scene.unit_settings.system = "IMPERIAL"
                     name = unit.Name.lower()

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

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

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

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

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

@@ -82,15 +82,7 @@ import math
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass
 from enum import Enum
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    ClassVar,
-    Literal,
-    Optional,
-    Protocol,
-    runtime_checkable,
-)
+from typing import Any, ClassVar, Literal, Optional, Protocol, runtime_checkable
 
 import blf
 import bpy
@@ -113,9 +105,6 @@ from mathutils.kdtree import KDTree
 import bonsai.tool as tool
 from bonsai.bim.module.drawing.shaders import ExtrusionGuidesShader
 
-if TYPE_CHECKING:
-    import bmesh
-
 SNAP_POINT_SIZE = 10.0
 SNAP_POINT_COLOR = (1.0, 0.5, 0.0, 1.0)
 SNAP_MAX_RADIUS = 50.0
@@ -2046,9 +2035,7 @@ class TexturedQuadGizmoMixin(StaticTrisGizmoMixin):
 
     def setup(self) -> None:
         super().setup()
-        from bonsai.bim.module.drawing import (
-            gizmo_textures,  # ty: ignore[unresolved-import]
-        )
+        from bonsai.bim.module.drawing import gizmo_textures
 
         self._quad_batch = batch_for_shader(
             gizmo_textures.get_shader(),
@@ -2057,9 +2044,7 @@ class TexturedQuadGizmoMixin(StaticTrisGizmoMixin):
         )
 
     def draw(self, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.drawing import (
-            gizmo_textures,  # ty: ignore[unresolved-import]
-        )
+        from bonsai.bim.module.drawing import gizmo_textures
 
         texture = gizmo_textures.get_icon_texture(self.icon_name)
         if texture is None:

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

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

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

@@ -951,12 +951,6 @@ class CreateDrawing(bpy.types.Operator):
         tree = ifcopenshell.geom.tree()
         tree.enable_face_styles(True)
 
-        # Accumulated across every file in the loop below (main model plus any
-        # linked models) so the SHAPELY fill pass after the loop covers all of
-        # them, not just whichever file happened to be processed last.
-        raycast_objs = set()
-        elements_with_faces = set()
-
         for ifc_path, (ifc, link_matrix) in files.items():
             # Don't use draw.main() just whilst we're prototyping and experimenting
             # TODO: hash paths are never used
@@ -966,24 +960,13 @@ class CreateDrawing(bpy.types.Operator):
             self.serialiser.setFile(ifc)
             drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element, ifc_file=ifc)
 
-            if self.cprops.fill_mode == "SHAPELY":
-                for element in drawing_elements.copy():
-                    if element.is_a("IfcAnnotation"):
-                        continue
-                    obj = tool.Ifc.get_object(element)
-                    if obj and obj.type == "MESH" and len(obj.data.polygons):
-                        elements_with_faces.add(element.GlobalId)
-                        raycast_objs.add(obj)
-
             # Get all representation contexts to see what we're dealing with.
             # Drawings only draw bodies and annotations (and facetation, due to a Revit bug).
             # A drawing prioritises a target view context first, followed by a model view context as a fallback.
             # Specifically for PLAN_VIEW and REFLECTED_PLAN_VIEW, any Plan context is also prioritised.
             contexts = self.get_linework_contexts(ifc, target_view)
             self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view, link_matrix)
-            self.serialize_contexts_elements(
-                ifc, tree, contexts, "annotation", drawing_elements, target_view, link_matrix
-            )
+            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view, link_matrix)
 
             if tool.Ifc.get() == ifc and self.camera_element not in drawing_elements:
                 with profile("Camera element"):
@@ -1050,6 +1033,16 @@ class CreateDrawing(bpy.types.Operator):
             # shapely variant
             group = root.find("{http://www.w3.org/2000/svg}g")
 
+            raycast_objs = set()
+            elements_with_faces = set()
+            for element in drawing_elements.copy():
+                if element.is_a("IfcAnnotation"):
+                    continue
+                obj = tool.Ifc.get_object(element)
+                if obj and obj.type == "MESH" and len(obj.data.polygons):
+                    elements_with_faces.add(element.GlobalId)
+                    raycast_objs.add(obj)
+
             projections = root.xpath(
                 ".//svg:g[contains(@class, 'projection')]", namespaces={"svg": "http://www.w3.org/2000/svg"}
             )
@@ -1706,12 +1699,6 @@ class CreateDrawing(bpy.types.Operator):
             key=lambda a: (
                 tool.Drawing.get_annotation_z_index(a),
                 1 if ifcopenshell.util.element.get_predefined_type(a) == "TEXT" else 0,
-                # Deterministic tiebreaker so equal-priority annotations keep a
-                # stable order across sessions. Without it the order comes from
-                # the set union above, which depends on entity hashes (and thus
-                # the file pointer), shuffling annotations between Blender
-                # restarts. See #6608.
-                a.id(),
             ),
         )
 
@@ -2349,9 +2336,7 @@ class ActivateDrawingBase(tool.Ifc.Operator):
         "Activates the selected drawing view.\n\n"
         + "ALT+CLICK to keep the viewport position.\n\n"
         + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views, "
-        + "then select their cameras (the first selected drawing's camera becomes active).\n\n"
-        + "SHIFT+CTRL+ALT+CLICK to do the same but also select the annotations, not just the cameras"
+        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views"
     )
 
     drawing: bpy.props.IntProperty()
@@ -2373,25 +2358,16 @@ class ActivateDrawingBase(tool.Ifc.Operator):
         default=False,
         options={"SKIP_SAVE"},
     )
-    include_annotations_in_selection: bpy.props.BoolProperty(
-        name="Include Annotations In Selection",
-        description="Also select the loaded annotation objects, not just the drawing cameras.",
-        default=False,
-        options={"SKIP_SAVE"},
-    )
 
     if TYPE_CHECKING:
         drawing: int
         should_view_from_camera: bool
         use_quick_preview: bool
         load_selected_annotations: bool
-        include_annotations_in_selection: bool
 
     def invoke(self, context, event) -> set["rna_enums.OperatorReturnItems"]:
         if event.type == "LEFTMOUSE" and event.shift and event.ctrl:
             self.load_selected_annotations = True
-            if event.alt:
-                self.include_annotations_in_selection = True
             return self.execute(context)
         if event.type == "LEFTMOUSE" and event.alt:
             self.should_view_from_camera = False
@@ -2406,34 +2382,15 @@ class ActivateDrawingBase(tool.Ifc.Operator):
             bpy.ops.bim.load_drawings()
 
         if self.load_selected_annotations:
-            objs_to_select = []
-            active_camera = None
             for d in props.drawings:
                 if not (d.is_drawing and d.is_selected):
                     continue
                 selected_drawing = tool.Ifc.get().by_id(d.ifc_definition_id)
                 # Importing the camera (if missing) ensures the drawing's
                 # collection exists so the annotations get collected into it.
-                if not (camera := tool.Ifc.get_object(selected_drawing)):
-                    camera = tool.Drawing.import_drawing(selected_drawing)
-                group = tool.Drawing.get_drawing_group(selected_drawing)
-                tool.Drawing.import_annotations_in_group(group)
-
-                if active_camera is None:
-                    active_camera = camera
-                objs_to_select.append(camera)
-                if self.include_annotations_in_selection:
-                    for element in tool.Drawing.get_group_elements(group) or []:
-                        if element.is_a("IfcAnnotation") and element.ObjectType != "DRAWING":
-                            if annotation_obj := tool.Ifc.get_object(element):
-                                objs_to_select.append(annotation_obj)
-
-            # Select the checked drawings' objects, with the first drawing's camera as active.
-            bpy.ops.object.select_all(action="DESELECT")
-            for obj in objs_to_select:
-                obj.select_set(True)
-            if active_camera is not None:
-                context.view_layer.objects.active = active_camera
+                if not tool.Ifc.get_object(selected_drawing):
+                    tool.Drawing.import_drawing(selected_drawing)
+                tool.Drawing.import_annotations_in_group(tool.Drawing.get_drawing_group(selected_drawing))
             return {"FINISHED"}
 
         drawing = tool.Ifc.get().by_id(self.drawing)
@@ -2522,9 +2479,7 @@ class ActivateDrawing(bpy.types.Operator, ActivateDrawingBase):
         "Activates the selected drawing view.\n\n"
         + "ALT+CLICK to keep the viewport position.\n\n"
         + "SHIFT+CLICK to load a quick preview of the drawing view.\n\n"
-        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views, "
-        + "then select their cameras (the first selected drawing's camera becomes active).\n\n"
-        + "SHIFT+CTRL+ALT+CLICK to do the same but also select the annotations, not just the cameras"
+        + "SHIFT+CTRL+CLICK to load the annotations of all selected drawings without switching views"
     )
 
 
@@ -3586,7 +3541,7 @@ class EditSheet(bpy.types.Operator, tool.Ifc.Operator):
         if sheet.is_a("IfcDocumentInformation"):
             self.document_type = "SHEET"
             self.name = sheet.Name
-            self.identification = tool.Document.get_document_information_id(sheet)
+            self.identification = sheet.DocumentId if tool.Ifc.get_schema() == "IFC2X3" else sheet.Identification
         elif sheet.is_a("IfcDocumentReference") and tool.Drawing.get_reference_description(sheet) == "TITLEBLOCK":
             self.document_type = "TITLEBLOCK"
         else:

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

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

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

@@ -69,6 +69,7 @@ classes = (
     operator.RemoveRepresentation,
     operator.RemoveRepresentationItem,
     operator.RemoveRepresentationItemFromShapeAspect,
+    operator.SelectByRepresentationType,
     operator.SelectConnection,
     operator.SelectRepresentationItem,
     operator.SwitchRepresentation,

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

@@ -138,6 +138,11 @@ class RepresentationsData:
                 "ContextType": representation.ContextOfItems.ContextType or "",
                 "ContextIdentifier": "",
                 "TargetView": "",
+                # The representation's own identifier (e.g. 'Body', 'Reference'), which is
+                # distinct from the subcontext's ContextIdentifier above. Two reps can share
+                # one context (e.g. a Body body and a Reference opening template), so showing
+                # this lets them be told apart in the panel.
+                "RepresentationIdentifier": representation.RepresentationIdentifier or "",
                 "RepresentationType": representation_type or "",
                 "is_active": is_active,
             }

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

@@ -418,6 +418,55 @@ class SelectConnection(bpy.types.Operator, tool.Ifc.Operator):
         core.select_connection(tool.Geometry, connection=tool.Ifc.get().by_id(self.connection))
 
 
+class SelectByRepresentationType(bpy.types.Operator):
+    bl_idname = "bim.select_by_representation_type"
+    bl_label = "Select By Representation Type"
+    bl_description = (
+        "Select objects whose active representation matches this type. "
+        "Ctrl+Click to also include objects that have this type in any representation (active or not)"
+    )
+    bl_options = {"REGISTER", "UNDO"}
+    representation_type: bpy.props.StringProperty()
+    select_inactive: bpy.props.BoolProperty(default=False, options={"SKIP_SAVE"})
+
+    def invoke(self, context, event):
+        self.select_inactive = event.ctrl
+        return self.execute(context)
+
+    def execute(self, context):
+        ifc = tool.Ifc.get()
+        if not ifc:
+            return {"CANCELLED"}
+        # Strip the "*" suffix used for mapped/resolved representations.
+        target_type = self.representation_type.rstrip("*")
+        matched = 0
+        for obj in context.visible_objects:
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                obj.select_set(False)
+                continue
+            if self.select_inactive:
+                # Ctrl: match any representation on the element, active or not.
+                has_type = any(
+                    (ifcopenshell.util.representation.resolve_representation(rep).RepresentationType or "") == target_type
+                    for rep in ifcopenshell.util.representation.get_representations_iter(element)
+                )
+            else:
+                # Default: match only the currently active (displayed) representation.
+                active_rep = tool.Geometry.get_active_representation(obj)
+                if active_rep is None:
+                    obj.select_set(False)
+                    continue
+                resolved = ifcopenshell.util.representation.resolve_representation(active_rep)
+                has_type = (resolved.RepresentationType or "") == target_type
+            obj.select_set(has_type)
+            if has_type:
+                matched += 1
+        mode = "any representation" if self.select_inactive else "active representation"
+        self.report({"INFO"}, f"Selected {matched} object(s) with RepresentationType '{target_type}' ({mode})")
+        return {"FINISHED"}
+
+
 class RemoveConnection(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.remove_connection"
     bl_label = "Remove Connection"
@@ -710,6 +759,16 @@ class UpdateRepresentation(bpy.types.Operator, tool.Ifc.Operator):
         if mprops.ifc_parameters:
             core.get_representation_ifc_parameters(tool.Geometry, obj=obj)
 
+        # Persist an edited opening void onto its filling type's 'Reference' template so the
+        # change survives type duplication/append/switching and propagates to siblings. This
+        # catches the edited_objs commit path; the in-place item edit is caught in
+        # bim.override_mode_set_object.
+        edited_element = tool.Ifc.get_entity(obj)
+        if edited_element and edited_element.is_a("IfcOpeningElement"):
+            from bonsai.bim.module.model.opening import FilledOpeningGenerator
+
+            FilledOpeningGenerator().update_type_template_from_opening(edited_element)
+
 
 class UpdateParametricRepresentation(bpy.types.Operator):
     bl_idname = "bim.update_parametric_representation"
@@ -2489,6 +2548,15 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
                 return bpy.ops.bim.edit_boundary_geometry()
             elif tool.Geometry.is_representation_item(context.active_object):
                 self.edit_representation_item(context.active_object)
+                # If we just edited an opening's void item, persist the new shape onto the
+                # filling type's 'Reference' template so it survives type duplication/append/
+                # switching and propagates to siblings.
+                rep_obj = tool.Geometry.get_geometry_props().representation_obj
+                edited_element = tool.Ifc.get_entity(rep_obj) if rep_obj else None
+                if edited_element and edited_element.is_a("IfcOpeningElement"):
+                    from bonsai.bim.module.model.opening import FilledOpeningGenerator
+
+                    FilledOpeningGenerator().update_type_template_from_opening(edited_element)
                 tool.Root.reload_item_decorator()
                 # So you can keep hitting tab to cycle out of edit mode
                 context.active_object.select_set(False)

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

@@ -148,12 +148,29 @@ class BIM_PT_representations(Panel):
             self.layout.label(text="No Representations Found")
             return
 
+        header = self.layout.row(align=True)
+        header.label(text="Context")
+        header.label(text="Subcontext")
+        header.label(text="View")
+        header.label(text="Identifier")
+        header.label(text="Type")
+        # Blank icon cells reserve the same width as the switch/remove buttons below so the
+        # text columns line up with the data rows.
+        header.label(text="", icon="BLANK1")
+        header.label(text="", icon="BLANK1")
+
         for representation in RepresentationsData.data["representations"]:
             row = self.layout.row(align=True)
             row.label(text=representation["ContextType"])
             row.label(text=representation["ContextIdentifier"])
             row.label(text=representation["TargetView"])
-            row.label(text=representation["RepresentationType"])
+            row.label(text=representation["RepresentationIdentifier"])
+            op = row.operator(
+                "bim.select_by_representation_type",
+                text=representation["RepresentationType"],
+                emboss=False,
+            )
+            op.representation_type = representation["RepresentationType"]
             op = row.operator(
                 "bim.switch_representation",
                 icon="FILE_REFRESH" if representation["is_active"] else "OUTLINER_DATA_MESH",

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

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

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

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

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

@@ -27,7 +27,6 @@ import bonsai.tool as tool
 from . import (
     array,
     covering,
-    decorator,
     door,
     external,
     grid,

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

@@ -329,7 +329,6 @@ class _ArrayEditMixin(ParametricEditMixinBase):
         # Unhide the (possibly newly-regenerated) children so the user sees
         # the committed result. Mirrors the hide in ``_enable_one``.
         cls._set_children_visibility(element, hidden=False)
-        tool.Array.select_only_parent(obj, context)
 
     @classmethod
     def _cancel_one(cls, obj: bpy.types.Object) -> None:
@@ -422,9 +421,9 @@ class RegenerateArray(bpy.types.Operator, tool.Ifc.Operator):
         pset = ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array")
         arrays = json.loads(pset["Data"])
         pset = tool.Ifc.get().by_id(pset["id"])
-        # Coalesce host recuts across the child-delete loop, the regenerate,
-        # and the per-child opening mirror: each fans out its own host body
-        # recut without the batch wrapper.
+        # Coalesce host recuts: the child-delete loop, the regenerate, and the
+        # per-child opening mirror all touch the same host body. Without batching,
+        # an N-child wipe-then-regen costs N+1 recuts; this collapses to one.
         with tool.Geometry.batch_host_recut():
             for array in arrays:
                 for child in set(array["children"]):
@@ -443,8 +442,6 @@ class RegenerateArray(bpy.types.Operator, tool.Ifc.Operator):
             tool.Model.regenerate_array(parent, arrays)
             tool.Array.constrain_children_to_parent(parent_element)
 
-        tool.Array.select_only_parent(parent, context)
-
 
 class RemoveArray(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.remove_array"

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

@@ -41,6 +41,12 @@ def load_post(*args):
         profile.DumbProfileRegenerator().regenerate_from_profile,
     )
 
+    ifcopenshell.api.add_pre_listener(
+        "type.assign_type",
+        "Bonsai.Opening.PreserveOnTypeChange",
+        opening.FilledOpeningGenerator().preserve_opening_on_type_change,
+    )
+
     ifcopenshell.api.add_post_listener(
         "type.assign_type",
         "Bonsai.Opening.RegenerateFromType",

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

@@ -38,7 +38,6 @@ import numpy as np
 from ifcopenshell.util.shape_builder import ShapeBuilder
 from mathutils import Matrix, Vector
 
-import bonsai.core.geometry
 import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
@@ -1678,11 +1677,6 @@ def _n_mep_selected(n: int) -> bool:
         element = tool.Ifc.get_entity(selected_obj)
         if element is None or not tool.System.is_mep_element(element):
             return False
-        # Array children mirror their parent's port topology. Writable MEP
-        # actions on a child get wiped by the next array regen, so gate the
-        # icons out at the visibility layer.
-        if tool.Array.is_array_child(element):
-            return False
     return True
 
 
@@ -2561,8 +2555,6 @@ def _active_is_flow_segment(obj: bpy.types.Object) -> bool:
     element = tool.Ifc.get_entity(obj)
     if element is None or not element.is_a("IfcFlowSegment"):
         return False
-    if tool.Array.is_array_child(element):
-        return False
     return tool.System.has_parametric_body(element)
 
 
@@ -2592,8 +2584,6 @@ def _active_is_bend_fitting(obj: bpy.types.Object) -> bool:
     element = tool.Ifc.get_entity(obj)
     if not _is_bend_fitting(element):
         return False
-    if tool.Array.is_array_child(element):
-        return False
     element_type = ifcopenshell.util.element.get_type(element)
     if element_type is None:
         return False

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

@@ -420,6 +420,25 @@ class FilledOpeningGenerator:
 
                 tool.Geometry.recut_host(voided_obj, representation)
 
+    def preserve_opening_on_type_change(
+        self, usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]
+    ) -> None:
+        """Pre-listener for type.assign_type: anchor the old type's void before reassigning.
+
+        A custom void that lives only on an occurrence (the type has no 'Reference'
+        template) would be lost when that occurrence is moved to another type - the
+        post-assign regeneration replaces it. Promoting it onto its current type first
+        keeps it durable, so switching back later restores it. Idempotent and only acts on
+        genuinely custom (non-extrusion) voids.
+        """
+        relating_type = settings.get("relating_type")
+        for related_object in settings.get("related_objects") or []:
+            if not getattr(related_object, "FillsVoids", None):
+                continue
+            old_type = ifcopenshell.util.element.get_type(related_object)
+            if old_type and old_type != relating_type:
+                self.promote_opening_to_type(old_type)
+
     def regenerate_from_type(self, usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
         relating_type = settings["relating_type"]
 
@@ -437,6 +456,13 @@ class FilledOpeningGenerator:
         opening = filling.FillsVoids[0].RelatingOpeningElement
         voided_element = opening.VoidsElements[0].RelatingBuildingElement
 
+        # Always regenerate the opening to reflect the *assigned* type's void: its
+        # 'Reference' template if it has one (generate_opening_from_filling consults it),
+        # else a sibling occurrence's opening, else a generated extrusion. We deliberately
+        # do NOT preserve the previous type's custom void on a type change - a custom void
+        # now survives duplicate_type/append by being anchored on the type as a template
+        # (promote_opening_to_type / harvest), so keeping the old void here would just show
+        # the wrong type's opening (e.g. switching to a plain type would keep the faceset).
         opening_rep = ifcopenshell.util.representation.get_representation(opening, "Model", "Body", "MODEL_VIEW")
         ifcopenshell.api.geometry.unassign_representation(tool.Ifc.get(), product=opening, representation=opening_rep)
         ifcopenshell.api.geometry.remove_representation(tool.Ifc.get(), representation=opening_rep)
@@ -493,6 +519,14 @@ class FilledOpeningGenerator:
         profile = None
         filling_type = ifcopenshell.util.element.get_type(filling)
         if filling_type:
+            # A stored opening template (e.g. a custom IfcPolygonalFaceSet carried
+            # across bim.duplicate_type / append) takes priority over generating a
+            # default extrusion. Returning the shared template representation lets the
+            # caller's map_representation reuse its IfcRepresentationMap, so this
+            # opening stays in sync with the type template and its sibling occurrences.
+            opening_template = self.get_type_opening_representation(filling_type)
+            if opening_template is not None:
+                return opening_template
             profile = ifcopenshell.util.representation.get_representation(
                 filling_type, "Model", "Profile", "ELEVATION_VIEW"
             )
@@ -590,6 +624,228 @@ class FilledOpeningGenerator:
                 return True
         return False
 
+    def is_opening_representation_custom(self, opening: ifcopenshell.entity_instance) -> bool:
+        """Whether the opening's Body has user-authored geometry rather than a generated extrusion.
+
+        Openings produced by ``generate_opening_from_filling`` always consist of a
+        single ``IfcExtrudedAreaSolid``. Anything else (a tessellation such as an
+        ``IfcPolygonalFaceSet``, a brep, a CSG solid, etc.) was authored by the user
+        and must not be silently replaced with a default extrusion.
+        """
+        representation = ifcopenshell.util.representation.get_representation(opening, "Model", "Body", "MODEL_VIEW")
+        if not representation:
+            return False
+        representation = ifcopenshell.util.representation.resolve_representation(representation)
+        return any(not item.is_a("IfcExtrudedAreaSolid") for item in representation.Items)
+
+    def should_preserve_opening(self, opening: ifcopenshell.entity_instance) -> bool:
+        """Whether an opening's geometry is worth anchoring on the type as a template.
+
+        True for user-authored geometry (a tessellation, brep, etc.) or a *manually adjusted*
+        extrusion - one that no longer matches the default ``generate_opening_from_filling``
+        would produce for its filling. A plain generated extrusion is regenerable, so it
+        returns False and is left to regenerate.
+        """
+        if self.is_opening_representation_custom(opening):
+            return True
+        return self._is_adjusted_extrusion(opening)
+
+    def _is_adjusted_extrusion(self, opening: ifcopenshell.entity_instance) -> bool:
+        """Whether the opening's extrusion diverges from the default for its filling.
+
+        Generates the default transiently, compares the axis-aligned bounding boxes of the
+        two bodies (both in the opening's local frame), then removes the temporary default.
+        A conservative False is returned when the default cannot be computed.
+        """
+        filling = opening.HasFillings[0].RelatedBuildingElement if getattr(opening, "HasFillings", None) else None
+        filling_obj = tool.Ifc.get_object(filling) if filling else None
+        current = ifcopenshell.util.representation.get_representation(opening, "Model", "Body", "MODEL_VIEW")
+        if not filling_obj or current is None:
+            return False
+        current = ifcopenshell.util.representation.resolve_representation(current)
+        default_representation = self.generate_opening_from_filling(filling, filling_obj)
+        try:
+            settings = ifcopenshell.geom.settings()
+            current_bbox = self._representation_bbox(settings, current)
+            default_bbox = self._representation_bbox(settings, default_representation)
+        finally:
+            ifcopenshell.api.geometry.remove_representation(tool.Ifc.get(), representation=default_representation)
+        if current_bbox is None or default_bbox is None:
+            return False
+        (cur_min, cur_max), (def_min, def_max) = current_bbox, default_bbox
+        tolerance = 1e-3  # 1 mm; differing extents/position => manually adjusted
+        return bool(np.any(np.abs(cur_min - def_min) > tolerance) or np.any(np.abs(cur_max - def_max) > tolerance))
+
+    @staticmethod
+    def _representation_bbox(settings: Any, representation: ifcopenshell.entity_instance):
+        try:
+            geometry = ifcopenshell.geom.create_shape(settings, representation)
+        except Exception:
+            return None
+        verts = ifcopenshell.util.shape.get_vertices(geometry)
+        if len(verts) == 0:
+            return None
+        return verts.min(axis=0), verts.max(axis=0)
+
+    def get_type_opening_representation(
+        self, filling_type: ifcopenshell.entity_instance
+    ) -> Union[ifcopenshell.entity_instance, None]:
+        """Return the type's stored opening template (its 'Reference' representation), if any.
+
+        The template is the shared opening body anchored on the type as a
+        'Reference'-identified representation map (see
+        :meth:`set_type_opening_representation`). Storing it on the type lets a
+        custom opening survive ``bim.duplicate_type`` and project append, which copy
+        the type's ``RepresentationMaps`` but not an opening shared only between
+        occurrences.
+        """
+        for representation_map in filling_type.RepresentationMaps or []:
+            representation = representation_map.MappedRepresentation
+            if representation.RepresentationIdentifier == "Reference":
+                return representation
+
+    def set_type_opening_representation(
+        self, filling_type: ifcopenshell.entity_instance, representation: ifcopenshell.entity_instance
+    ) -> None:
+        """Anchor an opening body representation on the type as its 'Reference' template.
+
+        ``representation`` is tagged 'Reference' (so it is excluded from the
+        occurrence body geometry, see
+        ``ifcopenshell.api.type.map_type_representations``) and the
+        ``IfcRepresentationMap`` wrapping it is registered in the type's
+        ``RepresentationMaps``, replacing any previous 'Reference' map. The existing map
+        is reused when present so that occurrences mapping over it stay in sync with the
+        type template. Idempotent.
+        """
+        ifc_file = tool.Ifc.get()
+        representation.RepresentationIdentifier = "Reference"
+        representation_map = next(
+            (i for i in ifc_file.get_inverse(representation) if i.is_a("IfcRepresentationMap")), None
+        )
+        if representation_map is None:
+            mapping_origin = ifc_file.createIfcAxis2Placement3D(
+                ifc_file.createIfcCartesianPoint((0.0, 0.0, 0.0)),
+                ifc_file.createIfcDirection((0.0, 0.0, 1.0)),
+                ifc_file.createIfcDirection((1.0, 0.0, 0.0)),
+            )
+            representation_map = ifc_file.createIfcRepresentationMap(mapping_origin, representation)
+        # Keep all non-'Reference' maps (Body, Annotation, ...) plus this one, dropping any
+        # previous 'Reference' template so the type carries exactly one.
+        new_maps = [
+            m
+            for m in (filling_type.RepresentationMaps or [])
+            if m == representation_map or m.MappedRepresentation.RepresentationIdentifier != "Reference"
+        ]
+        if representation_map not in new_maps:
+            new_maps.append(representation_map)
+        filling_type.RepresentationMaps = new_maps
+
+    def update_type_template_from_opening(self, opening: ifcopenshell.entity_instance) -> None:
+        """Write an edited opening's geometry back to its filling type's 'Reference' template.
+
+        After a user edits an opening's void shape, anchor the new geometry on the type so
+        the change is durable (survives duplicate_type/append and switching the type away
+        and back) and propagates to sibling occurrences. Only acts on custom (non-extrusion)
+        geometry; a re-generated extrusion needs no template.
+        """
+        if not getattr(opening, "HasFillings", None) or not self.is_opening_representation_custom(opening):
+            return
+        ifc_file = tool.Ifc.get()
+        new_representation = ifcopenshell.util.representation.get_representation(opening, "Model", "Body", "MODEL_VIEW")
+        if not new_representation:
+            return
+        new_representation = ifcopenshell.util.representation.resolve_representation(new_representation)
+        voided_objs_to_reload: set[bpy.types.Object] = set()
+        for rel in opening.HasFillings:
+            filling_type = ifcopenshell.util.element.get_type(rel.RelatedBuildingElement)
+            if not filling_type:
+                continue
+            old_template = self.get_type_opening_representation(filling_type)
+            if old_template is not None and old_template != new_representation:
+                # The edit gave this opening its own geometry; re-point the shared template
+                # map - and therefore every sibling occurrence mapping over it - at the
+                # edited geometry, then drop the now-orphaned old template.
+                for inverse in ifc_file.get_inverse(old_template):
+                    if inverse.is_a("IfcRepresentationMap"):
+                        inverse.MappedRepresentation = new_representation
+                ifcopenshell.api.geometry.remove_representation(ifc_file, representation=old_template)
+            self.set_type_opening_representation(filling_type, new_representation)
+
+            # Re-map every other occurrence's opening onto the type template so the edit
+            # propagates even to siblings that have their own independent opening geometry
+            # (i.e. openings that never shared the template's IfcRepresentationMap).
+            for occurrence in ifcopenshell.util.element.get_types(filling_type):
+                sibling_opening = (
+                    occurrence.FillsVoids[0].RelatingOpeningElement
+                    if getattr(occurrence, "FillsVoids", None)
+                    else None
+                )
+                if not sibling_opening or sibling_opening == opening:
+                    continue
+                if not self._remap_opening_to_template(sibling_opening, new_representation):
+                    continue
+                if sibling_opening.VoidsElements:
+                    voided_element = sibling_opening.VoidsElements[0].RelatingBuildingElement
+                    for part in ifcopenshell.util.element.get_parts(voided_element) or [voided_element]:
+                        if voided_obj := tool.Ifc.get_object(part):
+                            voided_objs_to_reload.add(voided_obj)
+
+        # Reload affected host objects so the viewport re-booleans with the propagated void.
+        for voided_obj in voided_objs_to_reload:
+            representation = tool.Geometry.get_active_representation(voided_obj)
+            if representation:
+                bonsai.core.geometry.switch_representation(
+                    tool.Ifc, tool.Geometry, obj=voided_obj, representation=representation
+                )
+
+    def _remap_opening_to_template(
+        self, opening: ifcopenshell.entity_instance, template_representation: ifcopenshell.entity_instance
+    ) -> bool:
+        """Point an opening's Body at the shared type template, purging its old standalone body.
+
+        :return: True if the opening was changed, False if it already maps over the template.
+        """
+        ifc_file = tool.Ifc.get()
+        old_body = ifcopenshell.util.representation.get_representation(opening, "Model", "Body", "MODEL_VIEW")
+        if old_body is not None and (
+            ifcopenshell.util.representation.resolve_representation(old_body) == template_representation
+        ):
+            return False
+        mapped_representation = ifcopenshell.api.geometry.map_representation(
+            ifc_file, representation=template_representation
+        )
+        # The mapped wrapper is the opening's own Body (the 'Reference' identifier belongs to
+        # the type template it maps over, not to the occurrence's representation).
+        mapped_representation.RepresentationIdentifier = "Body"
+        if old_body is not None:
+            ifcopenshell.api.geometry.unassign_representation(ifc_file, product=opening, representation=old_body)
+            ifcopenshell.api.geometry.remove_representation(ifc_file, representation=old_body)
+        ifcopenshell.api.geometry.assign_representation(ifc_file, product=opening, representation=mapped_representation)
+        return True
+
+    def promote_opening_to_type(self, filling_type: ifcopenshell.entity_instance) -> None:
+        """Promote a custom opening from an occurrence to a 'Reference' template on the type.
+
+        Called before a type is copied (``bim.duplicate_type``) so that a custom
+        (non-extrusion) opening, currently shared only between occurrences, is
+        anchored on the type itself and therefore carried to the copy. No-op if the
+        type already has a template or has no custom opening to promote.
+        """
+        if self.get_type_opening_representation(filling_type):
+            return
+        for occurrence in ifcopenshell.util.element.get_types(filling_type):
+            if not getattr(occurrence, "FillsVoids", None):
+                continue
+            opening = occurrence.FillsVoids[0].RelatingOpeningElement
+            if not self.should_preserve_opening(opening):
+                continue
+            representation = ifcopenshell.util.representation.get_representation(
+                opening, "Model", "Body", "MODEL_VIEW"
+            )
+            representation = ifcopenshell.util.representation.resolve_representation(representation)
+            self.set_type_opening_representation(filling_type, representation)
+            return
+
     def get_existing_opening_occurrence_if_any(
         self, filling: ifcopenshell.entity_instance
     ) -> Union[ifcopenshell.entity_instance, None]:
@@ -1000,6 +1256,9 @@ class EditOpenings(Operator, tool.Ifc.Operator):
                     building_objs.update(similar_openings_building_objs)
                     if opening_edited:
                         tool.Geometry.run_geometry_update_representation(obj=opening_obj)
+                        # Persist the edited void onto the filling type's 'Reference' template so
+                        # it survives type duplication/append/switching and propagates to siblings.
+                        self.update_type_template_from_opening(opening_element)
                     else:
                         bonsai.core.geometry.edit_object_placement(
                             tool.Ifc, tool.Geometry, tool.Surveyor, obj=opening_obj

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

@@ -138,7 +138,7 @@ def update_bbim_railing_pset(element: ifcopenshell.entity_instance, railing_data
 
 def generate_wall_mounted_handrail_preview(
     obj: bpy.types.Object,
-    props: "prop.BIMRailingProperties",
+    props: "BIMRailingProperties",
     path_data: dict[str, Any],
     si_conversion: float,
 ) -> None:
@@ -860,9 +860,7 @@ class GizmoRailingSchematic(bpy.types.GizmoGroup, gizmo.BaseSchematicGizmoGroup)
         terminal_world = anchor + billboard_rot @ view_rotation @ terminal_local
         self.terminal_gizmo.matrix_basis = gizmo.billboarded_at(terminal_world, billboard_rot, 0.18)
 
-    def update_editing_gizmos(
-        self, context: bpy.types.Context, mw: "Matrix", props: "prop.BIMRailingProperties"
-    ) -> None:
+    def update_editing_gizmos(self, context: bpy.types.Context, mw: "Matrix", props: "BIMRailingProperties") -> None:
         """Hide the pen gizmo while polyline path-edit is active; reposition the cycle icon.
 
         The base class shows the pen gizmo whenever ``is_editing`` is False,

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

@@ -18,7 +18,7 @@
 
 import json
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 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"] = props.ifc_patch_input
-            args["file"] = ifcopenshell.open(props.ifc_patch_input)
+            args["input"] = cast(str, props.ifc_patch_input)
+            args["file"] = cast(ifcopenshell.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/__init__.py

@@ -18,8 +18,6 @@
 
 import bpy
 
-import bonsai.tool as tool
-
 from . import decorator, gizmo, operator, prop, ui, workspace
 
 classes = (
@@ -60,8 +58,6 @@ classes = (
     operator.LinkIfc,
     operator.LoadBlendMetadataAndIFC,
     operator.LoadLink,
-    operator.AutosavePrompt,
-    operator.LoadAutosavedRecoveryPopup,
     operator.LoadLinkedProject,
     operator.LoadProject,
     operator.LoadProjectElements,
@@ -140,7 +136,6 @@ def register():
 def unregister():
     if not bpy.app.background:
         bpy.utils.unregister_tool(workspace.ExploreTool)
-    tool.Autosave.cancel_timer()
     del bpy.types.Scene.BIMProjectProperties
     del bpy.types.Scene.MeasureToolSettings
     bpy.app.handlers.load_post.remove(decorator.toggle_decorations_on_load)

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

@@ -633,6 +633,7 @@ class AppendLibraryElement(bpy.types.Operator, tool.Ifc.Operator):
         if not element:
             return {"FINISHED"}
         if element.is_a("IfcTypeProduct"):
+            self.harvest_opening_template(element, library_file)
             self.import_type_from_ifc(element, context)
         elif element.is_a("IfcProduct"):
             # NOTE: Non-types are not exposed in UI directly
@@ -658,6 +659,57 @@ class AppendLibraryElement(bpy.types.Operator, tool.Ifc.Operator):
         bonsai.bim.handler.refresh_ui_data()
         return {"FINISHED"}
 
+    def harvest_opening_template(
+        self, type_element: ifcopenshell.entity_instance, library_file: ifcopenshell.file
+    ) -> None:
+        """Seed the appended type's 'Reference' opening template from a library instance.
+
+        A type carries no opening of its own (openings are occurrence-level via
+        IfcRelVoidsElement), so a custom opening would otherwise be lost on append and
+        regenerated as a default extrusion when occurrences are placed. If the library
+        file has an instance of this type whose opening is custom (non-extrusion), copy
+        that opening body onto the appended type as its 'Reference' template. No-op when
+        the type already carries a template (e.g. a Bonsai-authored library) or the
+        library has no such instance.
+        """
+        from bonsai.bim.module.model.opening import FilledOpeningGenerator
+
+        generator = FilledOpeningGenerator()
+        if generator.get_type_opening_representation(type_element):
+            return
+
+        library_type = library_file.by_id(self.definition)
+        if not library_type.is_a("IfcTypeProduct"):
+            return
+
+        for occurrence in ifcopenshell.util.element.get_types(library_type):
+            if not getattr(occurrence, "FillsVoids", None):
+                continue
+            opening = occurrence.FillsVoids[0].RelatingOpeningElement
+            library_representation = ifcopenshell.util.representation.get_representation(
+                opening, "Model", "Body", "MODEL_VIEW"
+            )
+            if not library_representation:
+                continue
+            library_representation = ifcopenshell.util.representation.resolve_representation(library_representation)
+            if all(item.is_a("IfcExtrudedAreaSolid") for item in library_representation.Items):
+                continue  # A generated extrusion - nothing custom worth preserving.
+
+            project_file = tool.Ifc.get()
+            representation = project_file.add(library_representation)
+            # file.add brings the library's own representation context across; point the
+            # copy at the project's Body context and drop the now-orphaned duplicate.
+            body_context = ifcopenshell.util.representation.get_context(
+                project_file, "Model", "Body", "MODEL_VIEW"
+            )
+            if body_context and representation.ContextOfItems != body_context:
+                orphan_context = representation.ContextOfItems
+                representation.ContextOfItems = body_context
+                if not project_file.get_inverse(orphan_context):
+                    project_file.remove(orphan_context)
+            generator.set_type_opening_representation(type_element, representation)
+            return
+
     def import_material_from_ifc(self, element: ifcopenshell.entity_instance, context: bpy.types.Context) -> None:
         self.file = tool.Ifc.get()
         logger = logging.getLogger("ImportIFC")
@@ -985,10 +1037,8 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
         ),
         default=False,
     )
-    skip_autosave_recovery: bpy.props.BoolProperty(default=False, options={"HIDDEN", "SKIP_SAVE"})
     use_detailed_tooltip: bpy.props.BoolProperty(default=False, options={"HIDDEN"})
     filename_ext = ".ifc"
-    skip_recent: bpy.props.BoolProperty(default=False, options={"HIDDEN", "SKIP_SAVE"})
 
     if TYPE_CHECKING:
         filepath: str
@@ -997,7 +1047,6 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
         use_relative_path: bool
         should_start_fresh_session: bool
         import_without_ifc_data: bool
-        skip_autosave_recovery: bool
         use_detailed_tooltip: bool
 
     @classmethod
@@ -1044,33 +1093,7 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
 
         return tooltip
 
-    def check_autosave_recovery(self, context: bpy.types.Context) -> bool:
-        if self.skip_autosave_recovery:
-            return False
-        autosaved_filepath = tool.Autosave.get_newer_autosaved_path(self.get_filepath_abs())
-        if not autosaved_filepath:
-            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,
-            is_advanced=self.is_advanced,
-            use_relative_path=self.use_relative_path,
-            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 self.check_autosave_recovery(context):
-            return {"FINISHED"}
-
         if (
             tool.Blender.get_addon_preferences().save_metadata_blend_file
             and self.should_start_fresh_session
@@ -1165,8 +1188,7 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
             props.should_save_metadata_for_this_file = metadata_doc is not None
 
             tool.Blender.register_toolbar()
-            if not self.skip_recent:
-                tool.Project.add_recent_ifc_project(self.get_filepath_abs())
+            tool.Project.add_recent_ifc_project(self.get_filepath_abs())
 
             if self.is_advanced:
                 pass
@@ -1179,13 +1201,10 @@ class LoadProject(bpy.types.Operator, IFCFileSelector, ImportHelper):
         except:
             bonsai.last_error = traceback.format_exc()
             raise
-        tool.Autosave.reset_timer()
         return {"FINISHED"}
 
     def invoke(self, context, event):
         if self.filepath:
-            if self.check_autosave_recovery(context):
-                return {"FINISHED"}
             return self.execute(context)
         return ImportHelper.invoke(self, context, event)
 
@@ -1327,11 +1346,6 @@ class LoadProjectElements(bpy.types.Operator):
             if element.IsDecomposedBy:
                 for subelement in element.IsDecomposedBy[0].RelatedObjects:
                     decomposed_elements.add(subelement)
-            # IfcSurfaceFeature (e.g. road markings) adhere to a host element
-            # via IfcRelAdheresToElement, a [1:1] hierarchical relationship in
-            # the same family as aggregation, containment and nesting (IFC4.3).
-            for rel in getattr(element, "HasSurfaceFeatures", ()):
-                decomposed_elements.update(rel.RelatedSurfaceFeatures)
         if decomposed_elements:
             self.append_decomposed_elements(decomposed_elements)
         elements.update(decomposed_elements)
@@ -1980,7 +1994,6 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
     json_compact: bpy.props.BoolProperty(name="Export Compact IFCJSON", default=False)
     should_save_as: bpy.props.BoolProperty(name="Should Save As", default=False, options={"HIDDEN"})
     use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=False)
-    skip_recent: bpy.props.BoolProperty(default=False, options={"HIDDEN", "SKIP_SAVE"})
 
     if TYPE_CHECKING:
         filter_glob: str
@@ -2041,18 +2054,6 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         return {"FINISHED"}
 
     def _execute(self, context):
-        project_props = tool.Project.get_project_props()
-        project_props.use_relative_project_path = self.use_relative_path
-
-        # Fallback if filepath is not set
-        if not getattr(self, "filepath", None) or self.filepath.strip() in ("", ".ifc"):
-            props = tool.Blender.get_bim_props()
-            if props.ifc_file:
-                self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(props.ifc_file)))
-            else:
-                self.report({"ERROR"}, "No filepath available for saving.")
-                return {"CANCELLED"}
-
         committed, failed_commits = tool.Parametric.commit_pending_edits()
         # Previews are session-transient — discard rather than commit. Sibling
         # gizmo polls gate on each preview's is_active flag, and a stuck flag
@@ -2115,8 +2116,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         settings.logger.info("Export finished in {:.2f} seconds".format(time.time() - start))
         print("Export finished in {:.2f} seconds".format(time.time() - start))
         # New project created in Bonsai should be in recent projects too.
-        if not self.skip_recent:
-            tool.Project.add_recent_ifc_project(Path(output_file))
+        tool.Project.add_recent_ifc_project(Path(output_file))
         props = tool.Project.get_project_props()
         if props.use_relative_project_path and bpy.data.is_saved:
             output_file = os.path.relpath(output_file, bpy.path.abspath("//"))
@@ -2150,7 +2150,6 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
             )
 
         bonsai.bim.handler.refresh_ui_data()
-        tool.Autosave.reset_timer()
 
     @classmethod
     def description(cls, context, properties):
@@ -2159,123 +2158,6 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         return "Save the IFC file.  Will save both .IFC/.BLEND files if synced together"
 
 
-class LoadAutosavedRecoveryPopup(bpy.types.Operator):
-    bl_idname = "bim.load_autosaved_recovery_popup"
-    bl_label = "Recover Autosaved File"
-    bl_options = {"REGISTER", "UNDO"}
-
-    original_filepath: bpy.props.StringProperty(options={"SKIP_SAVE"})
-    autosaved_filepath: bpy.props.StringProperty(options={"SKIP_SAVE"})
-    is_advanced: bpy.props.BoolProperty(default=False, options={"SKIP_SAVE"})
-    use_relative_path: bpy.props.BoolProperty(default=False, options={"SKIP_SAVE"})
-    should_start_fresh_session: bpy.props.BoolProperty(default=True, options={"SKIP_SAVE"})
-    import_without_ifc_data: bpy.props.BoolProperty(default=False, options={"SKIP_SAVE"})
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="A newer autosaved copy was found:", icon="INFO")
-        layout.label(text=os.path.basename(self.autosaved_filepath))
-        layout.separator()
-        layout.label(text="Do you want to load the autosaved version instead?")
-        layout.label(text="(Cancel will load the original)")
-
-    def invoke(self, context, event):
-        # invoke_props_dialog is modal - unlike invoke_popup/popup_menu, it
-        # isn't dismissed by the mouse simply leaving its bounds. It always
-        # renders both a fixed "Cancel" button and this confirm_text one, so
-        # the question is framed as Yes/Cancel rather than adding separate
-        # Load buttons on top.
-        return context.window_manager.invoke_props_dialog(
-            self, width=420, title="Recover Autosaved File", confirm_text="Yes"
-        )
-
-    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,
-            use_relative_path=self.use_relative_path,
-            should_start_fresh_session=self.should_start_fresh_session,
-            import_without_ifc_data=self.import_without_ifc_data,
-            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):
-        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.
-        kwargs = self._load_kwargs(self.original_filepath, skip_recent=False)
-        self._defer(lambda: bpy.ops.bim.load_project(**kwargs))
-
-
-class AutosavePrompt(bpy.types.Operator):
-    bl_idname = "bim.autosave_prompt"
-    bl_label = "Autosave Reminder"
-    bl_options = set()
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(
-            self, width=400, confirm_text="Save", title="Autosave Reminder"
-        )
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="The autosave timer has expired.", icon="INFO")
-        layout.label(text="Would you like to save your IFC project now?")
-
-    def execute(self, context):
-        # Get current IFC path
-        props = tool.Blender.get_bim_props()
-        current_ifc_path = props.ifc_file
-
-        if not current_ifc_path:
-            self.report({"WARNING"}, "No IFC file path set. Please save manually.")
-            tool.Autosave.reset_timer()
-            return {"CANCELLED"}
-
-        # Call save_project with explicit filepath using EXEC_DEFAULT
-        result = bpy.ops.bim.save_project(
-            "EXEC_DEFAULT", filepath=current_ifc_path, should_save_as=False, skip_recent=True
-        )
-
-        tool.Autosave.reset_timer()
-        return result
-
-    def cancel(self, context):
-        tool.Autosave.reset_timer()
-        return {"CANCELLED"}
-
-
 class LoadLinkedProject(bpy.types.Operator, ImportHelper):
     bl_idname = "bim.load_linked_project"
     bl_label = "Load Project For Viewing Only"

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

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

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

@@ -375,6 +375,14 @@ class DuplicateType(bpy.types.Operator, tool.Ifc.Operator):
         obj = tool.Ifc.get_object(element)
         if not obj:
             return {"FINISHED"}
+        # Anchor any custom (non-extrusion) opening on the source type before the
+        # copy so it is carried to the duplicate as a 'Reference' template, rather
+        # than regenerated as a default extrusion on the new type's occurrences.
+        if element.is_a("IfcElementType"):
+            from bonsai.bim.module.model.opening import FilledOpeningGenerator
+
+            FilledOpeningGenerator().promote_opening_to_type(element)
+
         new_obj = obj.copy()
         if obj.data:
             new_obj.data = obj.data.copy()

src/bonsai/bonsai/bim/ui.py

@@ -577,43 +577,6 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
     should_disable_undo_on_save: BoolProperty(
         name="Disable Undo When Saving (Faster saves, no undo for you!)", default=False
     )
-
-    def update_autosave_settings(self, context: bpy.types.Context) -> None:
-        if self.autosave_enabled:
-            tool.Autosave.reset_timer()
-        else:
-            tool.Autosave.cancel_timer()
-
-    autosave_enabled: BoolProperty(
-        name="Enable IFC Autosave Timer",
-        description="Periodically remind you to save or automatically create a backup copy of the IFC file",
-        default=False,
-        update=update_autosave_settings,
-    )
-    autosave_interval_minutes: bpy.props.IntProperty(
-        name="Autosave Interval (Minutes)",
-        description="Time between autosave reminders or backups. The timer resets whenever you open or save a project",
-        default=10,
-        min=1,
-        max=1440,
-        update=update_autosave_settings,
-    )
-    autosave_mode: bpy.props.EnumProperty(
-        name="Autosave Mode",
-        items=[
-            (
-                "PROMPT",
-                "Prompt to Save",
-                "Show a dialog offering to save the IFC project when the timer expires",
-            ),
-            (
-                "BACKUP",
-                "Automatic Backup",
-                "Save a backup copy as filename_autosaved.ifc when the timer expires",
-            ),
-        ],
-        default="PROMPT",
-    )
     should_stream: BoolProperty(name="Stream Data From IFC-SPF (Only for advanced users)", default=False)
     should_always_cache: BoolProperty(
         name="Always Cache Geometry",
@@ -726,9 +689,6 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         bsdd_load_test_dictionaries: bool
         bsdd_baseurl: str
         should_disable_undo_on_save: bool
-        autosave_enabled: bool
-        autosave_interval_minutes: int
-        autosave_mode: Literal["PROMPT", "BACKUP"]
         should_stream: bool
         should_always_cache: bool
         occurrence_name_style: Literal["CLASS", "TYPE", "CUSTOM"]
@@ -877,12 +837,6 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
     def draw_other_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "opening_focus_opacity")
         layout.prop(self, "should_disable_undo_on_save")
-        layout.separator()
-        layout.label(text="Autosave:")
-        layout.prop(self, "autosave_enabled")
-        if self.autosave_enabled:
-            layout.prop(self, "autosave_interval_minutes")
-            layout.prop(self, "autosave_mode")
         layout.prop(self, "should_stream")
         layout.prop(self, "should_always_cache")
         layout.label(text="bSDD:")

src/bonsai/bonsai/core/drawing.py

@@ -302,15 +302,9 @@ def add_drawing(
         context=drawing.get_body_context(),
         ifc_representation_class=None,
     )
-
-    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"})
     ifc.run("group.assign_group", group=group, products=[element])
-
-    ifc.run("group.assign_group", group=drawings_parent_group, products=[group])
-
     collector.assign(camera)
     pset = ifc.run("pset.add_pset", product=element, name="EPset_Drawing")
     if drawing.get_unit_system() == "METRIC":
@@ -341,10 +335,7 @@ def add_drawing(
         },
     )
     drawing.setup_shading_styles_path(shading_styles_path)
-
-    drawings_parent_document = drawing.ensure_drawings_parent_document()
-
-    information = ifc.run("document.add_information", parent=drawings_parent_document)
+    information = ifc.run("document.add_information")
     uri = drawing.get_default_drawing_path(drawing_name)
     reference = ifc.run("document.add_reference", information=information)
     if ifc.get_schema() == "IFC2X3":
@@ -372,13 +363,9 @@ def duplicate_drawing(
     drawing_tool.set_name(new_drawing, drawing_name)
     group = drawing_tool.get_drawing_group(new_drawing)
     ifc.run("group.unassign_group", group=group, products=[new_drawing])
-
-    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"})
     ifc.run("group.assign_group", group=new_group, products=[new_drawing])
-    ifc.run("group.assign_group", group=drawings_parent_group, products=[new_group])
     if should_duplicate_annotations:
         new_annotations: list[ifcopenshell.entity_instance] = []
         annotation_objs = [ifc.get_object(a) for a in drawing_tool.get_group_elements(group) if a != drawing]
@@ -394,9 +381,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 = drawing_tool.ensure_drawings_parent_document()
-
-    information = ifc.run("document.add_information", parent=drawings_parent_document)
+    information = ifc.run("document.add_information")
     uri = drawing_tool.get_default_drawing_path(drawing_name)
     reference = ifc.run("document.add_reference", information=information)
     if ifc.get_schema() == "IFC2X3":

src/bonsai/bonsai/core/product.py

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

src/bonsai/bonsai/core/tool.py

@@ -254,6 +254,7 @@ 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
@@ -354,8 +355,6 @@ 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
@@ -805,7 +804,7 @@ class Profile:
 
 @interface
 class Parametric:
-    def get_geom_generation(cls): pass
+    def get_geom_generation(cls) -> int: pass
     def refresh_post_commit(cls, operator) -> None: pass
 
 
@@ -1171,6 +1170,8 @@ class Style:
 @interface
 class Surveyor:
     def get_absolute_matrix(cls, obj): pass
+    def get_z_rotation(cls, obj): pass
+    def set_z_rotation(cls, obj, z): pass
 
 
 @interface

src/bonsai/bonsai/tool/__init__.py

@@ -80,6 +80,3 @@ from bonsai.tool.type import Type
 from bonsai.tool.unit import Unit
 from bonsai.tool.wall import Wall
 from bonsai.tool.web import Web
-
-# Have to move after import of tool.drawing
-from bonsai.tool.autosave import Autosave  # isort: skip

src/bonsai/bonsai/tool/array.py

@@ -178,25 +178,6 @@ class Array(bonsai.core.tool.Array):
         element_root = cls.get_array_root_guid(element)
         return [o for o in occurrences if cls.get_array_root_guid(o) == element_root]
 
-    @classmethod
-    def select_only_parent(cls, parent_obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        """Post-condition for the user-facing regenerate and finish-edit paths:
-        only ``parent_obj`` is selected + active. Grow and shrink otherwise
-        diverge on which objects stay selected, surfacing an inconsistency."""
-        tool.Blender.select_and_activate_single_object(context, parent_obj)
-
-    @classmethod
-    def is_array_child(cls, element: entity_instance) -> bool:
-        """True when ``element`` is a child of a parametric array — has a
-        BBIM_Array pset whose Parent GUID points to a different element.
-        Lighter than ``get_child_layer_index`` (no ``by_guid`` lookup, no
-        Data parse); suitable for per-element checks in draw handlers."""
-        pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
-        if not pset:
-            return False
-        parent_guid = pset.get("Parent")
-        return bool(parent_guid) and parent_guid != element.GlobalId
-
     @classmethod
     def get_child_layer_index(cls, child_element: entity_instance) -> int | None:
         """Index of the layer that produced ``child_element``, or ``None``

src/bonsai/bonsai/tool/autosave.py

@@ -1,194 +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 atexit
-import logging
-import os
-from collections.abc import Callable
-from pathlib import Path
-from typing import Union
-
-import bpy
-
-import bonsai.tool as tool
-from bonsai.bim import export_ifc
-from bonsai.bim.module.model import preview_base
-
-AUTOSAVING_SUFFIX = "_autosaving.ifc"
-AUTOSAVED_SUFFIX = "_autosaved.ifc"
-
-_timer_callback: Union[Callable[[], None], None] = None
-# See cleanup_stale_autosave() for why this is a cached plain string rather
-# than looked up live.
-_active_ifc_path_cache: Union[str, None] = None
-
-
-class Autosave:
-    @classmethod
-    def get_paths(cls, ifc_path: Union[str, Path]) -> tuple[Path, Path, Path]:
-        path = Path(ifc_path)
-        stem = path.stem if path.suffix.lower() == ".ifc" else path.name
-        parent = path.parent
-        main_path = path if path.suffix.lower() == ".ifc" else parent / f"{stem}.ifc"
-        autosaving_path = parent / f"{stem}{AUTOSAVING_SUFFIX}"
-        autosaved_path = parent / f"{stem}{AUTOSAVED_SUFFIX}"
-        return main_path, autosaving_path, autosaved_path
-
-    @classmethod
-    def get_active_ifc_path(cls) -> Union[Path, None]:
-        props = tool.Blender.get_bim_props()
-        if not props.ifc_file:
-            return None
-        path = tool.Blender.ensure_blender_path_is_abs(Path(props.ifc_file))
-        if path.suffix.lower() != ".ifc":
-            return None
-        return path
-
-    @classmethod
-    def _update_active_ifc_path_cache(cls) -> None:
-        global _active_ifc_path_cache
-        ifc_path = cls.get_active_ifc_path()
-        _active_ifc_path_cache = ifc_path.as_posix() if ifc_path is not None else None
-
-    @classmethod
-    def is_enabled(cls) -> bool:
-        return bool(tool.Blender.get_addon_preferences().autosave_enabled)
-
-    @classmethod
-    def get_interval_seconds(cls) -> float:
-        minutes = tool.Blender.get_addon_preferences().autosave_interval_minutes
-        return max(1.0, float(minutes) * 60.0)
-
-    @classmethod
-    def is_eligible(cls) -> bool:
-        return cls.is_enabled() and tool.Ifc.get() is not None and cls.get_active_ifc_path() is not None
-
-    @classmethod
-    def cancel_timer(cls) -> None:
-        global _timer_callback
-        if _timer_callback is not None and bpy.app.timers.is_registered(_timer_callback):
-            bpy.app.timers.unregister(_timer_callback)
-        _timer_callback = None
-
-    @classmethod
-    def reset_timer(cls) -> None:
-        cls.cancel_timer()
-        cls._update_active_ifc_path_cache()
-        if not cls.is_eligible():
-            return
-
-        def on_timer() -> Union[float, None]:
-            cls._on_timer_expired()
-            # 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
-        bpy.app.timers.register(on_timer, first_interval=cls.get_interval_seconds())
-
-    @classmethod
-    def _on_timer_expired(cls) -> None:
-        if not cls.is_eligible():
-            return
-
-        prefs = tool.Blender.get_addon_preferences()
-        bim_props = tool.Blender.get_bim_props()
-
-        if bim_props.is_dirty:
-            if prefs.autosave_mode == "PROMPT":
-                bpy.ops.bim.autosave_prompt("INVOKE_DEFAULT")
-            elif prefs.autosave_mode == "BACKUP":
-                try:
-                    cls.perform_backup(bpy.context)
-                except Exception as error:
-                    print(f"Bonsai: autosave backup failed: {error}")
-
-    @classmethod
-    def perform_backup(cls, context: bpy.types.Context) -> None:
-        ifc_path = cls.get_active_ifc_path()
-        if ifc_path is None:
-            return
-
-        _, autosaving_path, autosaved_path = cls.get_paths(ifc_path)
-        autosaving_path.parent.mkdir(parents=True, exist_ok=True)
-
-        tool.Parametric.commit_pending_edits()
-        preview_base.discard_pending_previews(context.scene)
-
-        logger = logging.getLogger("ExportIFC")
-        output_file = autosaving_path.as_posix().replace("\\", "/")
-        settings = export_ifc.IfcExportSettings.factory(context, output_file, logger)
-        export_ifc.IfcExporter(settings).export()
-
-        try:
-            os.replace(autosaving_path, autosaved_path)
-        except OSError:
-            if autosaving_path.is_file():
-                autosaving_path.unlink(missing_ok=True)
-            raise
-
-    @classmethod
-    def get_newer_autosaved_path(cls, ifc_path: Union[str, Path]) -> Union[str, None]:
-        path = Path(ifc_path)
-        if path.suffix.lower() != ".ifc" or not path.is_file():
-            return None
-
-        _, _, autosaved_path = cls.get_paths(path)
-        if not autosaved_path.is_file():
-            return None
-        if autosaved_path.stat().st_mtime > path.stat().st_mtime:
-            return autosaved_path.as_posix().replace("\\", "/")
-        return None
-
-    @classmethod
-    def cleanup_stale_autosave(cls) -> None:
-        """Remove the active IFC's autosave file(s) on a graceful shutdown.
-
-        Registered via `atexit`, which only runs on a normal interpreter
-        shutdown - never on an actual crash. So a deliberate quit (whether
-        the user saved or chose "don't save") clears the recovery file and
-        won't prompt on next startup, while a genuine crash leaves it in
-        place for recovery, since no atexit callbacks fire then.
-
-        Deliberately reads only `_active_ifc_path_cache` - a plain string
-        kept up to date by `reset_timer()` - rather than touching `bpy` here.
-        By the time `atexit` fires, Blender's own C++ side is torn down far
-        enough that even reading `bpy.context.scene` aborts the process
-        (std::bad_optional_access) instead of raising a catchable exception.
-        """
-        if _active_ifc_path_cache is None:
-            return
-        try:
-            _, autosaving_path, autosaved_path = cls.get_paths(_active_ifc_path_cache)
-            autosaving_path.unlink(missing_ok=True)
-            autosaved_path.unlink(missing_ok=True)
-        except Exception:
-            pass
-
-
-atexit.register(Autosave.cleanup_stale_autosave)

src/bonsai/bonsai/tool/brick.py

@@ -192,9 +192,10 @@ 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"):
-                identification = tool.Document.get_external_reference_id(rel.RelatingLibrary)
-                if identification and "#" in identification:
-                    return identification
+                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
 
     @classmethod
     def get_brick_class(cls, element: ifcopenshell.entity_instance) -> Union[str, None]:

src/bonsai/bonsai/tool/document.py

@@ -261,8 +261,7 @@ 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":
-            reference_to_document = reference.ReferenceToDocument
-            return reference_to_document[0] if reference_to_document else None
+            return (reference.ReferenceToDocument or (None))[0]
         return reference.ReferencedDocument
 
     @classmethod

src/bonsai/bonsai/tool/drawing.py

@@ -38,7 +38,6 @@ 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
@@ -774,32 +773,6 @@ 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 []:
@@ -1167,7 +1140,10 @@ class Drawing(bonsai.core.tool.Drawing):
             new = documents_collection.add()
             new.ifc_definition_id = schedule.id()
             new.name = schedule.Name or "Unnamed"
-            new.identification = tool.Document.get_document_information_id(schedule) or ""
+            if tool.Ifc.get_schema() == "IFC2X3":
+                new.identification = schedule.DocumentId
+            else:
+                new.identification = schedule.Identification
 
     @classmethod
     def get_sheet_identification(cls, sheet: ifcopenshell.entity_instance) -> str:
@@ -1208,7 +1184,10 @@ class Drawing(bonsai.core.tool.Drawing):
                 new.ifc_definition_id = reference.id()
                 new.is_sheet = False
 
-                new.identification = tool.Document.get_external_reference_id(reference) or ""
+                if tool.Ifc.get_schema() == "IFC2X3":
+                    new.identification = reference.ItemReference or ""
+                else:
+                    new.identification = reference.Identification or ""
 
                 new.name = os.path.basename(reference.Location)
                 new.reference_type = reference_description
@@ -2444,8 +2423,9 @@ class Drawing(bonsai.core.tool.Drawing):
     def get_reference_document(
         cls, reference: ifcopenshell.entity_instance
     ) -> Union[ifcopenshell.entity_instance, None]:
-        # TODO: migrate to document.get_reference_document.
-        return tool.Document.get_reference_document(reference)
+        if tool.Ifc.get_schema() == "IFC2X3":
+            return reference.ReferenceToDocument[0]
+        return reference.ReferencedDocument
 
     @classmethod
     def select_assigned_product(cls, context: bpy.types.Context) -> None:

src/bonsai/bonsai/tool/duplicate.py

@@ -248,30 +248,32 @@ class Duplicate(bonsai.core.tool.Duplicate):
         old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
     ) -> None:
         for element, data in relationship.items():
-            new_relating_elements = old_to_new.get(data.relating_element) or []
-            new_related_elements = old_to_new.get(data.related_element) or []
+            try:
+                new_relating_element = old_to_new.get(data.relating_element)[0]
+                new_related_element = old_to_new.get(data.related_element)[0]
+            except (KeyError, IndexError, TypeError):
+                continue
+            new_rel = tool.Ifc.run(
+                "geometry.connect_path",
+                relating_element=new_relating_element,
+                related_element=new_related_element,
+                relating_connection=data.relating_connection_type,
+                related_connection=data.related_connection_type,
+            )
             # connect_path hardcodes priorities to []; restore them post-hoc.
             priority_attrs: dict[str, Any] = {}
             if data.relating_priorities:
                 priority_attrs["RelatingPriorities"] = data.relating_priorities
             if data.related_priorities:
                 priority_attrs["RelatedPriorities"] = data.related_priorities
-            for new_relating_element, new_related_element in zip(new_relating_elements, new_related_elements):
-                new_rel = tool.Ifc.run(
-                    "geometry.connect_path",
-                    relating_element=new_relating_element,
-                    related_element=new_related_element,
-                    relating_connection=data.relating_connection_type,
-                    related_connection=data.related_connection_type,
-                )
-                if new_rel is not None and priority_attrs:
-                    try:
-                        tool.Ifc.run("attribute.edit_attributes", product=new_rel, attributes=priority_attrs)
-                    except (RuntimeError, ifcopenshell.Error) as e:
-                        cls._emit_warning(
-                            f"connection priority restore failed for {new_rel}; "
-                            f"duplicate has empty RelatingPriorities/RelatedPriorities: {e}"
-                        )
+            if new_rel is not None and priority_attrs:
+                try:
+                    tool.Ifc.run("attribute.edit_attributes", product=new_rel, attributes=priority_attrs)
+                except (RuntimeError, ifcopenshell.Error) as e:
+                    cls._emit_warning(
+                        f"connection priority restore failed for {new_rel}; "
+                        f"duplicate has empty RelatingPriorities/RelatedPriorities: {e}"
+                    )
 
     @classmethod
     def recreate_port_connections(
@@ -281,43 +283,46 @@ class Duplicate(bonsai.core.tool.Duplicate):
     ) -> None:
         """Recreate ``IfcRelConnectsPorts`` between duplicates; skip records whose duplicate's port count diverges from the snapshot."""
         for relating_element, records in snapshot.by_element.items():
-            new_relatings = old_to_new.get(relating_element) or []
-            expected_relating = snapshot.port_counts.get(relating_element)
             for record in records:
                 related_element = record.related_element
-                new_relateds = old_to_new.get(related_element) or []
+                try:
+                    new_relating = old_to_new[relating_element][0]
+                    new_related = old_to_new[related_element][0]
+                except (KeyError, IndexError):
+                    continue
+
+                new_relating_ports = tool.System.get_ports(new_relating)
+                new_related_ports = tool.System.get_ports(new_related)
+
+                expected_relating = snapshot.port_counts.get(relating_element)
+                if expected_relating is not None and len(new_relating_ports) != expected_relating:
+                    cls._emit_warning(
+                        f"port reconnect skipped — duplicate has {len(new_relating_ports)} ports, "
+                        f"snapshot had {expected_relating}"
+                    )
+                    continue
                 expected_related = snapshot.port_counts.get(related_element)
-                for new_relating, new_related in zip(new_relatings, new_relateds):
-                    new_relating_ports = tool.System.get_ports(new_relating)
-                    new_related_ports = tool.System.get_ports(new_related)
+                if expected_related is not None and len(new_related_ports) != expected_related:
+                    cls._emit_warning(
+                        f"port reconnect skipped — duplicate has {len(new_related_ports)} ports, "
+                        f"snapshot had {expected_related}"
+                    )
+                    continue
 
-                    if expected_relating is not None and len(new_relating_ports) != expected_relating:
-                        cls._emit_warning(
-                            f"port reconnect skipped — duplicate has {len(new_relating_ports)} ports, "
-                            f"snapshot had {expected_relating}"
-                        )
-                        continue
-                    if expected_related is not None and len(new_related_ports) != expected_related:
-                        cls._emit_warning(
-                            f"port reconnect skipped — duplicate has {len(new_related_ports)} ports, "
-                            f"snapshot had {expected_related}"
-                        )
-                        continue
-
-                    try:
-                        new_port_a = new_relating_ports[record.relating_port_index]
-                        new_port_b = new_related_ports[record.related_port_index]
-                    except IndexError:
-                        cls._emit_warning(
-                            f"port reconnect skipped — record references port index past the duplicate's port list"
-                        )
-                        continue
-                    try:
-                        tool.Ifc.run(
-                            "system.connect_port",
-                            port1=new_port_a,
-                            port2=new_port_b,
-                            direction=record.direction or "NOTDEFINED",
-                        )
-                    except (RuntimeError, ifcopenshell.Error) as e:
-                        cls._emit_warning(f"port reconnect failed between duplicates: {e}")
+                try:
+                    new_port_a = new_relating_ports[record.relating_port_index]
+                    new_port_b = new_related_ports[record.related_port_index]
+                except IndexError:
+                    cls._emit_warning(
+                        f"port reconnect skipped — record references port index past the duplicate's port list"
+                    )
+                    continue
+                try:
+                    tool.Ifc.run(
+                        "system.connect_port",
+                        port1=new_port_a,
+                        port2=new_port_b,
+                        direction=record.direction or "NOTDEFINED",
+                    )
+                except (RuntimeError, ifcopenshell.Error) as e:
+                    cls._emit_warning(f"port reconnect failed between duplicates: {e}")

src/bonsai/bonsai/tool/geometry.py

@@ -33,6 +33,7 @@ from typing import (
     Optional,
     TypeGuard,
     Union,
+    cast,
     get_args,
 )
 
@@ -162,21 +163,13 @@ class Geometry(bonsai.core.tool.Geometry):
                 cls._host_update_queue = {}
                 cls._host_recut_queue = {}
                 for voided_obj in update_queue.values():
-                    try:
-                        if not voided_obj or not voided_obj.data:
-                            continue
-                    except ReferenceError:
-                        # Blender object was deleted while the batch was open
-                        # (e.g. user removed it via the outliner mid-op).
+                    if not voided_obj or not voided_obj.data:
                         continue
                     if tool.Ifc.get_entity(voided_obj) is None:
                         continue
                     bpy.ops.bim.update_representation(obj=voided_obj.name)
                 for voided_obj, _ in recut_queue.values():
-                    try:
-                        if not voided_obj or not voided_obj.data:
-                            continue
-                    except ReferenceError:
+                    if not voided_obj or not voided_obj.data:
                         continue
                     if tool.Ifc.get_entity(voided_obj) is None:
                         continue
@@ -1213,7 +1206,23 @@ class Geometry(bonsai.core.tool.Geometry):
 
         for element in element_types:
             if obj := tool.Ifc.get_object(element):
-                if representation := ifcopenshell.util.representation.get_representation(element, context):
+                # A type may hold several representations in one context (e.g. a 'Body' body
+                # plus a 'Reference' opening template), and get_representation() matches only
+                # by context. When base_representation is one of this type's own
+                # representations - i.e. we are reimporting it directly, such as switching to
+                # the Reference rep - render exactly that, otherwise the context lookup could
+                # return the wrong one. But element_types also contains each occurrence's
+                # type (see above), for which base_representation is not theirs; fall back to
+                # the context lookup there (and skip, as before, when it has none).
+                type_representations = [
+                    ifcopenshell.util.representation.resolve_representation(rm.MappedRepresentation)
+                    for rm in (element.RepresentationMaps or [])
+                ]
+                if base_representation in type_representations:
+                    representation = base_representation
+                else:
+                    representation = ifcopenshell.util.representation.get_representation(element, context)
+                if representation:
                     geometry = ifcopenshell.geom.create_shape(settings, representation)
                     mesh_name = tool.Loader.get_mesh_name_from_shape(geometry)
                     mesh = meshes.get(mesh_name)
@@ -2186,7 +2195,7 @@ class Geometry(bonsai.core.tool.Geometry):
             setattr(item, attribute.name, attribute.get_value())
 
         if item.is_a("IfcSweptAreaSolid"):
-            item_profile = props.item_profile
+            item_profile = cast(str, props.item_profile)
             profile = item.SweptArea
             profile_name: Union[str, None] = profile.ProfileName
             if item_profile == "-":
@@ -2488,16 +2497,99 @@ class Geometry(bonsai.core.tool.Geometry):
         old_obj_name_to_new_obj_name: dict[str, str] = {}
 
         for obj in objects_to_duplicate:
-            new_active = cls._duplicate_ifc_object_once(
-                obj,
-                active_object,
-                linked,
-                arrays_to_duplicate,
-                old_to_new,
-                old_obj_name_to_new_obj_name,
-            )
-            if new_active is not None:
-                new_active_obj = new_active
+            element = tool.Ifc.get_entity(obj)
+            if element:
+                if element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
+                    tool.Blender.deselect_object(obj)
+                    continue  # For now, don't copy drawings until we stabilise a bit more. It's tricky.
+                elif tool.Geometry.is_locked(element):
+                    tool.Blender.deselect_object(obj)
+                    continue
+            elif tool.Geometry.is_representation_item(obj):
+                cls.duplicate_ifc_item(obj)
+                continue
+
+            tracked_opening_type = tool.Model.get_tracked_opening_type(obj)
+            is_tracked_opening = bool(tracked_opening_type)
+            keep_data_linked = linked and not element and not is_tracked_opening
+
+            # Prior to duplicating, sync the object placement to make decomposition recreation more stable.
+            cls.commit_placement_if_moved(obj, apply_scale=False)
+
+            new_obj = obj.copy()
+            temp_data = None
+
+            # Currently for optimization we do not apply pending changes (scale or changed .data)
+            # to the original and duplicated objects.
+            # Keep new object edited if original is.
+            if tool.Ifc.is_edited(obj, ignore_scale=True):
+                tool.Ifc.edit(new_obj)
+
+            if obj.data and not keep_data_linked:
+                # assure root.copy_class won't replace the previous mesh globally
+                temp_data = obj.data.copy()
+                new_obj.data = temp_data
+
+                # Unlink from previous boolean element
+                # and keep object tracked for decorations.
+                if is_tracked_opening:
+                    mprops = tool.Geometry.get_mesh_props(new_obj.data)
+                    mprops.ifc_boolean_id = 0
+                    tool.Root.add_tracked_opening(new_obj, tracked_opening_type)
+
+            if obj == active_object:
+                new_active_obj = new_obj
+            for collection in obj.users_collection:
+                collection.objects.link(new_obj)
+            obj.select_set(False)
+            new_obj.select_set(True)
+            old_obj_name_to_new_obj_name[obj.name] = new_obj.name
+
+            if not element:
+                continue
+
+            # clear object's collection so it will be able to have it's own
+            tool.Blender.get_object_bim_props(new_obj).collection = None
+            # copy the actual class
+            new = bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
+
+            # clean up the orphaned mesh with ifc id of the original object to avoid confusion
+            # IfcGridAxis keeps the same mesh data (it's pointing to ifc id 0, so it's not a problem)
+            if new and temp_data and not new.is_a("IfcGridAxis"):
+                if new.is_a("IfcRelSpaceBoundary"):
+                    surface = new.ConnectionGeometry.SurfaceOnRelatingElement
+                    temp_data.name = f"0/{surface.id()}"
+                    tool.Ifc.link(surface, temp_data)
+                else:
+                    tool.Blender.remove_data_block(temp_data)
+
+            if new:
+                # TODO: handle array data for other cases of duplication
+                array_data = arrays_to_duplicate.get(obj, None)
+                tool.Model.handle_array_on_copied_element(new, array_data)
+                if array_data:
+                    for child in tool.Array.get_all_children_objects(new):
+                        child.select_set(True)
+
+                # TODO: add new array children to recreate their decomposition too
+                old_to_new[element] = [new]
+                if new.is_a("IfcRelSpaceBoundary"):
+                    tool.Boundary.decorate_boundary(new_obj)
+                # Slab-trim booleans (from extend_walls_to_underside) belong to
+                # the source wall's connection, not the copy. Strip them so the
+                # duplicate reverts to its pre-clip extrusion — mirrors the way
+                # filling rels are dropped while manual booleans persist on copy.
+                # Reload the body when something was stripped so the viewport
+                # immediately shows the unclipped geometry; otherwise the user
+                # sees a stale mesh until they Shift+G, which is easy to miss.
+                if new.is_a("IfcWall"):
+                    if tool.Model.strip_underside_booleans(new):
+                        tool.Model.reload_body_representation(new_obj)
+                    # HasOpenings rels don't follow object duplication, so
+                    # the duplicate's body must rebuild to match its current
+                    # opening set.
+                    else:
+                        tool.Model.regenerate_wall(new_obj)
 
         # Remap Blender parent relationships for duplicated objects
         for old_obj_name, new_obj_name in old_obj_name_to_new_obj_name.items():
@@ -2525,211 +2617,10 @@ class Geometry(bonsai.core.tool.Geometry):
         # Recreate decompositions
         tool.Duplicate.recreate_decompositions(decomposition_relationships, old_to_new)
         cls.remove_linked_aggregate_data(old_to_new)
-
-        # In-loop regenerate_wall runs before recreate_connections, so any new
-        # walls that just received an IfcRelConnectsPathElements have stale
-        # junction geometry — recalculate them now that their connection graph
-        # is complete.
-        cls._recalculate_walls_with_new_connections(old_to_new)
-
         bonsai.bim.handler.refresh_ui_data()
         tool.Root.reload_grid_decorator()
         return old_to_new, new_active_obj or active_object
 
-    @classmethod
-    def duplicate_ifc_object_n_times(
-        cls, source: bpy.types.Object, count: int
-    ) -> dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]:
-        """N-way duplicate of a single source.
-
-        Same per-copy semantics as duplicate_ifc_objects (IFC class copy,
-        decomposition + connection recreation, body regen for walls), but
-        bypasses the set() dedupe and the arrays_to_duplicate pre-scan so
-        callers building a fresh array don't pay per-call overhead N times.
-        Returns the same old_to_new dict shape, with the source element
-        mapping to the N new entities."""
-        if count <= 0:
-            return {}
-
-        sources = {source}
-        decomposition_relationships = tool.Duplicate.get_decomposition_relationships(sources)
-        connection_relationships = tool.Duplicate.get_connection_relationships(sources)
-        port_connection_snapshot = tool.Duplicate.get_port_connection_relationships(sources)
-        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]] = {}
-        old_obj_name_to_new_obj_name: dict[str, str] = {}
-
-        for _ in range(count):
-            cls._duplicate_ifc_object_once(
-                source,
-                None,
-                False,
-                {},
-                old_to_new,
-                old_obj_name_to_new_obj_name,
-                keep_source_selected=True,
-            )
-
-        for old_obj_name, new_obj_name in old_obj_name_to_new_obj_name.items():
-            new_obj = bpy.data.objects.get(new_obj_name)
-            if new_obj and new_obj.parent and new_obj.parent.name in old_obj_name_to_new_obj_name:
-                world_matrix = new_obj.matrix_world.copy()
-                new_parent_name = old_obj_name_to_new_obj_name[new_obj.parent.name]
-                new_parent = bpy.data.objects.get(new_parent_name)
-                if new_parent:
-                    new_obj.parent = new_parent
-                    new_obj.matrix_world = world_matrix
-
-        for old in old_to_new.keys():
-            if old.is_a("IfcElementAssembly"):
-                tool.Root.recreate_aggregate(old_to_new)
-
-        cls.remove_old_connections(old_to_new)
-        tool.Duplicate.recreate_connections(connection_relationships, old_to_new)
-        tool.Duplicate.recreate_port_connections(port_connection_snapshot, old_to_new)
-        tool.Duplicate.recreate_decompositions(decomposition_relationships, old_to_new)
-        cls.remove_linked_aggregate_data(old_to_new)
-        cls._recalculate_walls_with_new_connections(old_to_new)
-        bonsai.bim.handler.refresh_ui_data()
-        tool.Root.reload_grid_decorator()
-        return old_to_new
-
-    @classmethod
-    def _duplicate_ifc_object_once(
-        cls,
-        obj: bpy.types.Object,
-        active_object: Optional[bpy.types.Object],
-        linked: bool,
-        arrays_to_duplicate: dict[bpy.types.Object, Any],
-        old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]],
-        old_obj_name_to_new_obj_name: dict[str, str],
-        keep_source_selected: bool = False,
-    ) -> Optional[bpy.types.Object]:
-        """Per-source body of the duplicate flow. Mutates old_to_new and
-        old_obj_name_to_new_obj_name in place. Returns new_obj when obj is
-        the active_object, else None.
-
-        keep_source_selected: when True, skip the source deselect so batched
-        callers can run N iterations without N×2 select flips and without
-        needing a post-loop restore on the source."""
-        new_active_obj: Optional[bpy.types.Object] = None
-        element = tool.Ifc.get_entity(obj)
-        if element:
-            if element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
-                tool.Blender.deselect_object(obj)
-                return None  # For now, don't copy drawings until we stabilise a bit more. It's tricky.
-            elif tool.Geometry.is_locked(element):
-                tool.Blender.deselect_object(obj)
-                return None
-        elif tool.Geometry.is_representation_item(obj):
-            cls.duplicate_ifc_item(obj)
-            return None
-
-        tracked_opening_type = tool.Model.get_tracked_opening_type(obj)
-        is_tracked_opening = bool(tracked_opening_type)
-        keep_data_linked = linked and not element and not is_tracked_opening
-
-        # Prior to duplicating, sync the object placement to make decomposition recreation more stable.
-        cls.commit_placement_if_moved(obj, apply_scale=False)
-
-        new_obj = obj.copy()
-        temp_data = None
-
-        # Currently for optimization we do not apply pending changes (scale or changed .data)
-        # to the original and duplicated objects.
-        # Keep new object edited if original is.
-        if tool.Ifc.is_edited(obj, ignore_scale=True):
-            tool.Ifc.edit(new_obj)
-
-        if obj.data and not keep_data_linked:
-            # assure root.copy_class won't replace the previous mesh globally
-            temp_data = obj.data.copy()
-            new_obj.data = temp_data
-
-            # Unlink from previous boolean element
-            # and keep object tracked for decorations.
-            if is_tracked_opening:
-                mprops = tool.Geometry.get_mesh_props(new_obj.data)
-                mprops.ifc_boolean_id = 0
-                tool.Root.add_tracked_opening(new_obj, tracked_opening_type)
-
-        if obj == active_object:
-            new_active_obj = new_obj
-        for collection in obj.users_collection:
-            collection.objects.link(new_obj)
-        if not keep_source_selected:
-            obj.select_set(False)
-        new_obj.select_set(True)
-        old_obj_name_to_new_obj_name[obj.name] = new_obj.name
-
-        if not element:
-            return new_active_obj
-
-        # clear object's collection so it will be able to have it's own
-        tool.Blender.get_object_bim_props(new_obj).collection = None
-        # copy the actual class
-        new = bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
-
-        # clean up the orphaned mesh with ifc id of the original object to avoid confusion
-        # IfcGridAxis keeps the same mesh data (it's pointing to ifc id 0, so it's not a problem)
-        if new and temp_data and not new.is_a("IfcGridAxis"):
-            if new.is_a("IfcRelSpaceBoundary"):
-                surface = new.ConnectionGeometry.SurfaceOnRelatingElement
-                temp_data.name = f"0/{surface.id()}"
-                tool.Ifc.link(surface, temp_data)
-            else:
-                tool.Blender.remove_data_block(temp_data)
-
-        if new:
-            # TODO: handle array data for other cases of duplication
-            array_data = arrays_to_duplicate.get(obj, None)
-            tool.Model.handle_array_on_copied_element(new, array_data)
-            if array_data:
-                for child in tool.Array.get_all_children_objects(new):
-                    child.select_set(True)
-
-            # TODO: add new array children to recreate their decomposition too
-            old_to_new.setdefault(element, []).append(new)
-            if new.is_a("IfcRelSpaceBoundary"):
-                tool.Boundary.decorate_boundary(new_obj)
-            # Slab-trim booleans (from extend_walls_to_underside) belong to
-            # the source wall's connection, not the copy. Strip them so the
-            # duplicate reverts to its pre-clip extrusion — mirrors the way
-            # filling rels are dropped while manual booleans persist on copy.
-            # Reload the body when something was stripped so the viewport
-            # immediately shows the unclipped geometry; otherwise the user
-            # sees a stale mesh until they Shift+G, which is easy to miss.
-            if new.is_a("IfcWall"):
-                if tool.Model.strip_underside_booleans(new):
-                    tool.Model.reload_body_representation(new_obj)
-                # HasOpenings rels don't follow object duplication, so
-                # the duplicate's body must rebuild to match its current
-                # opening set.
-                else:
-                    tool.Model.regenerate_wall(new_obj)
-
-        return new_active_obj
-
-    @classmethod
-    def _recalculate_walls_with_new_connections(
-        cls, old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]
-    ) -> None:
-        """Recalculate new IfcWall duplicates that just received an
-        ``IfcRelConnectsPathElements``. The in-loop ``regenerate_wall`` runs
-        before ``recreate_connections``, so wall body geometry doesn't reflect
-        the junction until this second pass."""
-        walls_to_recalc: list[bpy.types.Object] = []
-        for new_list in old_to_new.values():
-            for new_entity in new_list:
-                if not new_entity.is_a("IfcWall"):
-                    continue
-                if not (getattr(new_entity, "ConnectedTo", None) or getattr(new_entity, "ConnectedFrom", None)):
-                    continue
-                new_obj = tool.Ifc.get_object(new_entity)
-                if new_obj is not None:
-                    walls_to_recalc.append(new_obj)
-        if walls_to_recalc:
-            tool.Model.recalculate_walls(walls_to_recalc)
-
     @classmethod
     def duplicate_ifc_item(cls, obj: bpy.types.Object) -> None:
         props = tool.Geometry.get_geometry_props()

src/bonsai/bonsai/tool/ifcgit.py

@@ -29,7 +29,6 @@ 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
@@ -51,7 +50,7 @@ if TYPE_CHECKING:
     from bonsai.bim.module.ifcgit.prop import IfcGitProperties
 
 
-class IfcGit(bonsai.core.tool.IfcGit):
+class IfcGit:
     STEP_IDS = dict[str, set[int]]
 
     @classmethod

src/bonsai/bonsai/tool/loader.py

@@ -197,6 +197,7 @@ 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)
 

src/bonsai/bonsai/tool/misc.py

@@ -112,14 +112,10 @@ 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

src/bonsai/bonsai/tool/model.py

@@ -59,7 +59,6 @@ from ifcopenshell.util.shape_builder import ShapeBuilder, np_to_3d
 from mathutils import Matrix, Vector
 
 import bonsai.core.geometry
-import bonsai.core.model
 import bonsai.core.tool
 import bonsai.tool as tool
 from bonsai.bim import import_ifc
@@ -618,7 +617,7 @@ class Model(bonsai.core.tool.Model):
 
             cls.edges.extend([(i, i + 1) for i in range(offset, len(cls.vertices) - 1)])
             if is_closed:
-                cls.edges.append((len(cls.vertices) - 1, offset))  # Close the loop
+                cls.edges[-1] = (len(cls.vertices) - 1, offset)  # Close the loop
 
         elif curve.is_a("IfcCompositeCurve"):
             # This is a first pass incomplete implementation only for simple polylines, and misses many details.
@@ -1248,35 +1247,6 @@ class Model(bonsai.core.tool.Model):
         with tool.Geometry.batch_host_recut():
             cls._regenerate_array_body(parent_obj, data, array_layers_to_apply)
 
-    @classmethod
-    def _prune_orphan_array_children(cls, array: dict[str, Any]) -> None:
-        """Drop GUIDs from ``array['children']`` whose IFC entity or Blender
-        object is no longer alive, and cascade-remove the orphan IFC entity
-        if it still exists. Outliner / keyboard delete of a Bonsai-managed
-        object bypasses ``bim.delete``'s cascade, leaving dangling opening
-        and filling references that later confuse regen and crash the
-        ``batch_host_recut`` drain."""
-        live_guids: list[str] = []
-        ifc_file = tool.Ifc.get()
-        for guid in array["children"]:
-            try:
-                element = ifc_file.by_guid(guid)
-            except RuntimeError:
-                continue
-            obj = tool.Ifc.get_object(element)
-            try:
-                is_live = obj is not None and obj.data is not None
-            except ReferenceError:
-                is_live = False
-            if is_live:
-                live_guids.append(guid)
-                continue
-            try:
-                ifcopenshell.api.root.remove_product(ifc_file, product=element)
-            except (RuntimeError, ifcopenshell.Error):
-                pass
-        array["children"] = live_guids
-
     @classmethod
     def _regenerate_array_body(
         cls, parent_obj: bpy.types.Object, data: list[dict[str, Any]], array_layers_to_apply: Iterable[int]
@@ -1292,7 +1262,6 @@ class Model(bonsai.core.tool.Model):
         obj_stack = [parent_obj]
 
         for array_i, array in enumerate(data):
-            cls._prune_orphan_array_children(array)
             child_i = 0
             existing_children = set(array["children"])
             total_existing_children = len(array["children"])
@@ -1306,14 +1275,6 @@ class Model(bonsai.core.tool.Model):
             else:
                 base_offset = Vector([array["x"], array["y"], array["z"]]) * unit_scale
 
-            target_new_in_this_layer = (array["count"] - 1) * len(obj_stack)
-            missing_count = max(0, target_new_in_this_layer - total_existing_children)
-            new_entities_pool: list[ifcopenshell.entity_instance] = []
-            if missing_count > 0:
-                batch_old_to_new = tool.Geometry.duplicate_ifc_object_n_times(parent_obj, missing_count)
-                new_entities_pool = batch_old_to_new.get(parent_element, [])
-            new_entities_iter = iter(new_entities_pool)
-
             for i in range(array["count"]):
                 if i == 0:
                     continue
@@ -1331,13 +1292,8 @@ class Model(bonsai.core.tool.Model):
                         child_obj = tool.Ifc.get_object(child_element)
                         assert child_obj
                     except (IndexError, RuntimeError, AssertionError):
-                        try:
-                            child_element = next(new_entities_iter)
-                        except StopIteration:
-                            # Stale-GUID mid-list left the pool exhausted; fall back
-                            # to a one-off duplicate so the layer can still complete.
-                            old_to_new, _ = tool.Geometry.duplicate_ifc_objects([parent_obj])
-                            child_element = next(iter(old_to_new.values()))[0]
+                        old_to_new, _ = tool.Geometry.duplicate_ifc_objects([parent_obj])
+                        child_element = next(iter(old_to_new.values()))[0]
                         child_obj = tool.Ifc.get_object(child_element)
 
                     # add child pset
@@ -1405,7 +1361,14 @@ class Model(bonsai.core.tool.Model):
             tool.Ifc.get(), pset=pset, properties={"Data": json_data, "Parent": parent_element.GlobalId}
         )
 
-        tool.Blender.set_object_selection(parent_obj, True)
+        # Post-condition: parent is selected on return. duplicate_ifc_objects
+        # deselects the source on every call inside the regen loop; without
+        # this restore, callers get a deselected parent for arrays with N >= 2.
+        # TODO: batch the per-child duplicate_ifc_objects([parent]) calls into
+        # a single N-way duplicate — N depsgraph churns + N select/deselect
+        # flips is wasteful, and a batched duplicate would also remove the
+        # need for this restore.
+        parent_obj.select_set(True)
 
     @classmethod
     def mirror_parent_void_fillings_to_children(
@@ -2161,6 +2124,13 @@ class Model(bonsai.core.tool.Model):
             if voided_obj is not None:
                 voided_objs.add(voided_obj)
 
+            # Preserve user-authored opening geometry (e.g. an IfcPolygonalFaceSet
+            # or other tessellation) instead of replacing it with a default extrusion.
+            from bonsai.bim.module.model.opening import FilledOpeningGenerator
+
+            if FilledOpeningGenerator().is_opening_representation_custom(opening):
+                continue
+
             body = tool.Geometry.get_body_representation(opening)
             if body is None:
                 continue

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]):
+    def intersect_mouse_2d_bounding_box(cls, mouse_pos: tuple[int, int], bbox: list[float, float, float, float]):
         x, y = mouse_pos
         xmin, xmax, ymin, ymax = bbox
 

src/bonsai/bonsai/tool/root.py

@@ -373,37 +373,35 @@ class Root(bonsai.core.tool.Root):
                 try:
                     new_aggregate = old_to_new[old_aggregate]
                 except:
-                    for new_entity in new:
-                        bonsai.core.aggregate.unassign_object(
-                            tool.Ifc,
-                            tool.Aggregate,
-                            tool.Collector,
-                            relating_obj=tool.Ifc.get_object(old_aggregate),
-                            related_obj=tool.Ifc.get_object(new_entity),
-                        )
-                    continue
-
-                for new_entity in new:
-                    bonsai.core.aggregate.assign_object(
+                    bonsai.core.aggregate.unassign_object(
                         tool.Ifc,
                         tool.Aggregate,
                         tool.Collector,
-                        relating_obj=tool.Ifc.get_object(new_aggregate[0]),
-                        related_obj=tool.Ifc.get_object(new_entity),
+                        relating_obj=tool.Ifc.get_object(old_aggregate),
+                        related_obj=tool.Ifc.get_object(new[0]),
                     )
+                    continue
 
-                    # Make sure that the array children also get reassigned to the correct aggregate
-                    pset = ifcopenshell.util.element.get_pset(new_entity, "BBIM_Array")
-                    if pset:
-                        array_children = tool.Array.get_all_children_objects(new_entity)
-                        for obj in array_children:
-                            bonsai.core.aggregate.assign_object(
-                                tool.Ifc,
-                                tool.Aggregate,
-                                tool.Collector,
-                                relating_obj=tool.Ifc.get_object(new_aggregate[0]),
-                                related_obj=tool.Ifc.get_object(tool.Ifc.get_entity(obj)),
-                            )
+                bonsai.core.aggregate.assign_object(
+                    tool.Ifc,
+                    tool.Aggregate,
+                    tool.Collector,
+                    relating_obj=tool.Ifc.get_object(new_aggregate[0]),
+                    related_obj=tool.Ifc.get_object(new[0]),
+                )
+
+                # Make sure that the array children also get reassigned to the correct aggregate
+                pset = ifcopenshell.util.element.get_pset(new[0], "BBIM_Array")
+                if pset:
+                    array_children = tool.Array.get_all_children_objects(new[0])
+                    for obj in array_children:
+                        bonsai.core.aggregate.assign_object(
+                            tool.Ifc,
+                            tool.Aggregate,
+                            tool.Collector,
+                            relating_obj=tool.Ifc.get_object(new_aggregate[0]),
+                            related_obj=tool.Ifc.get_object(tool.Ifc.get_entity(obj)),
+                        )
 
         if new_aggregate is None:
             return

src/bonsai/bonsai/tool/system.py

@@ -357,13 +357,6 @@ class System(bonsai.core.tool.System):
             if not cls.is_mep_element(element):
                 continue
 
-            # Array children inherit port topology from their parent's IFC
-            # entity, but their positions are derived — drawing ports on every
-            # copy of an arrayed segment doubles up markers and misleads the
-            # user into thinking each copy has its own port network.
-            if tool.Array.is_array_child(element):
-                continue
-
             selected_element = element in connected_elements
             verts_pos = []
 

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: 'https://docs.bonsaibim.org/',
-    unstable: 'https://docs-unstable.bonsaibim.org/',
+    stable: 'http://docs.bonsaibim.org/',
+    unstable: 'http://docs-unstable.bonsaibim.org/',
     // Add more versions here as needed
   };
 

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

@@ -44,6 +44,8 @@ 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
 
@@ -59,10 +61,6 @@ 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,3 +77,18 @@ 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,6 +18,12 @@ 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

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

src/bonsai/scripts/dev_environment.py

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

src/bonsai/test/bim/feature/boolean.feature

@@ -12,7 +12,7 @@ Scenario: Ensure added booleans are marked as manual
     And I click "OK"
     And the object "IfcFurniture/Unnamed" exists
     And I toggle edit mode
-    And the object "Item/IfcExtrudedAreaSolid/73" exists
+    And the object "Item/IfcExtrudedAreaSolid/77" exists
     And I open the "Add Item" menu
     When I click "Half Space Solid"
     And the object "Item/IfcHalfSpaceSolid/90" exists
@@ -33,7 +33,7 @@ Scenario: Ensure removed booleans are unmarked as manual
     And I click "OK"
     And the object "IfcFurniture/Unnamed" exists
     And I toggle edit mode
-    And the object "Item/IfcExtrudedAreaSolid/73" exists
+    And the object "Item/IfcExtrudedAreaSolid/77" exists
     And I open the "Add Item" menu
     And I click "Half Space Solid"
     And I deselect all objects

src/bonsai/test/bim/feature/root.feature

@@ -24,7 +24,7 @@ Scenario: Add element - an element with no geometry
     When I click "OK"
     And I select the object "IfcFurniture/Unnamed"
     And I toggle edit mode
-    Then the object "Item/IfcExtrudedAreaSolid/73" exists
+    Then the object "Item/IfcExtrudedAreaSolid/77" exists
 
 Scenario: Add element - an element with extrusion geometry
     Given an empty IFC project
@@ -36,7 +36,7 @@ Scenario: Add element - an element with extrusion geometry
     When I click "OK"
     And I select the object "IfcFurniture/Unnamed"
     And I toggle edit mode
-    Then the object "Item/IfcExtrudedAreaSolid/73" exists
+    Then the object "Item/IfcExtrudedAreaSolid/77" exists
 
 Scenario: Add element - an element with custom tessellation geometry
     Given an empty IFC project
@@ -48,7 +48,7 @@ Scenario: Add element - an element with custom tessellation geometry
     When I click "OK"
     And I select the object "IfcFurniture/Unnamed"
     And I toggle edit mode
-    Then the object "Item/IfcPolygonalFaceSet/72" exists
+    Then the object "Item/IfcPolygonalFaceSet/76" exists
 
 Scenario: Add element - an element with tessellation geometry from an object
     Given an empty IFC project
@@ -62,8 +62,8 @@ Scenario: Add element - an element with tessellation geometry from an object
     When I click "OK"
     And I select the object "IfcFurniture/Unnamed"
     And I toggle edit mode
-    Then the object "Item/IfcPolygonalFaceSet/72" exists
-    And the object "Item/IfcPolygonalFaceSet/72" dimensions are "2,2,2"
+    Then the object "Item/IfcPolygonalFaceSet/76" exists
+    And the object "Item/IfcPolygonalFaceSet/76" dimensions are "2,2,2"
 
 Scenario: Reassign class
     Given an empty IFC project

src/bonsai/test/bim/feature/structural.feature

@@ -12,7 +12,7 @@ Scenario: Add element - a structural point connection
     And I make the collection "IfcStructuralItem" visible
     And I select the object "IfcStructuralPointConnection/Foo"
     And I toggle edit mode
-    Then the object "Item/IfcVertexPoint/65" exists
+    Then the object "Item/IfcVertexPoint/69" exists
 
 Scenario: Add element - a structural curve member
     Given an empty IFC project
@@ -25,7 +25,7 @@ Scenario: Add element - a structural curve member
     And I make the collection "IfcStructuralItem" visible
     And I select the object "IfcStructuralCurveMember/Foo"
     And I toggle edit mode
-    Then the object "Item/IfcEdge/68" exists
+    Then the object "Item/IfcEdge/72" exists
 
 Scenario: Add element - a structural surface member
     Given an empty IFC project
@@ -38,7 +38,7 @@ Scenario: Add element - a structural surface member
     And I make the collection "IfcStructuralItem" visible
     And I select the object "IfcStructuralSurfaceMember/Foo"
     And I toggle edit mode
-    Then the object "Item/IfcFace/70" exists
+    Then the object "Item/IfcFace/74" exists
 
 Scenario: Load structural analysis models
     Given an empty IFC project

src/bonsai/test/bim/module/model/test_array_batch_recut.py

@@ -35,7 +35,6 @@ from unittest.mock import Mock, patch
 
 import bpy
 import ifcopenshell
-import ifcopenshell.api.pset
 import pytest
 
 import bonsai.tool as tool

src/bonsai/test/bim/module/model/test_array_duplicate_batched.py

@@ -1,716 +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.
-
-"""Tests for the batched array-duplicate path.
-
-`tool.Geometry.duplicate_ifc_object_n_times` lifts the per-call overhead of
-`duplicate_ifc_objects` (snapshot, UI refresh, decorator reload, select
-flips) out of the per-child loop in `_regenerate_array_body`. These tests
-pin three contracts:
-
-1. N-way batched duplicate produces N distinct entities mapped from the
-   source under `old_to_new[source_element]`, and the source object stays
-   selected throughout (no per-iteration deselect).
-2. Per-layer batching collapses the N independent UI refreshes into one.
-3. End-to-end array regen still yields the same number and shape of
-   children as the per-call baseline."""
-
-import json
-from unittest.mock import patch
-
-import bpy
-import ifcopenshell
-import ifcopenshell.api.pset
-import ifcopenshell.util.element
-import pytest
-
-import bonsai.tool as tool
-from test.bim.bootstrap import NewFile
-
-pytestmark = pytest.mark.model
-
-
-def _build_actuator(name: str = "Actuator") -> tuple[bpy.types.Object, ifcopenshell.entity_instance]:
-    """Minimal IfcActuator + cube — matches the test_array_batch_recut.py shape."""
-    bpy.ops.bim.create_project()
-    bpy.ops.mesh.primitive_cube_add()
-    obj = bpy.context.active_object
-    obj.name = name
-    rprops = tool.Root.get_root_props()
-    rprops.ifc_product = "IfcElement"
-    bpy.ops.bim.assign_class(ifc_class="IfcActuator", predefined_type="ELECTRICACTUATOR", userdefined_type="")
-    element = tool.Ifc.get_entity(obj)
-    return obj, element
-
-
-def _build_actuator_with_array_pset(
-    count: int, x: float = 1.0
-) -> tuple[bpy.types.Object, ifcopenshell.entity_instance, list[dict]]:
-    obj, element = _build_actuator()
-    parent_data = [
-        {
-            "children": [],
-            "count": count,
-            "method": "OFFSET",
-            "x": x,
-            "y": 0.0,
-            "z": 0.0,
-            "use_local_space": False,
-            "sync_children": False,
-        }
-    ]
-    pset = ifcopenshell.api.pset.add_pset(tool.Ifc.get(), product=element, name="BBIM_Array")
-    ifcopenshell.api.pset.edit_pset(
-        tool.Ifc.get(),
-        pset=pset,
-        properties={"Data": json.dumps(parent_data), "Parent": element.GlobalId},
-    )
-    return obj, element, parent_data
-
-
-class TestDuplicateIfcObjectNTimes(NewFile):
-    def test_returns_empty_dict_for_zero_count(self):
-        obj, _ = _build_actuator()
-        result = tool.Geometry.duplicate_ifc_object_n_times(obj, 0)
-        assert result == {}
-
-    def test_returns_empty_dict_for_negative_count(self):
-        obj, _ = _build_actuator()
-        result = tool.Geometry.duplicate_ifc_object_n_times(obj, -3)
-        assert result == {}
-
-    def test_produces_n_distinct_entities(self):
-        obj, element = _build_actuator()
-        result = tool.Geometry.duplicate_ifc_object_n_times(obj, 5)
-        new_entities = result.get(element)
-        assert new_entities is not None
-        assert len(new_entities) == 5
-        assert len({e.id() for e in new_entities}) == 5
-        for new_entity in new_entities:
-            assert new_entity.is_a("IfcActuator")
-            assert new_entity.GlobalId != element.GlobalId
-
-    def test_source_stays_selected_after_batch(self):
-        obj, _ = _build_actuator()
-        obj.select_set(True)
-        tool.Geometry.duplicate_ifc_object_n_times(obj, 4)
-        assert obj in bpy.context.selected_objects, "source object must remain selected across batched duplicates"
-
-    def test_each_new_entity_has_blender_object(self):
-        obj, element = _build_actuator()
-        result = tool.Geometry.duplicate_ifc_object_n_times(obj, 3)
-        for new_entity in result[element]:
-            new_obj = tool.Ifc.get_object(new_entity)
-            assert new_obj is not None
-            assert new_obj is not obj
-
-
-class TestBatchedRefreshUIDataCallCount(NewFile):
-    def test_n_times_calls_refresh_ui_data_once(self):
-        obj, _ = _build_actuator()
-        with patch("bonsai.bim.handler.refresh_ui_data") as refresh_mock:
-            tool.Geometry.duplicate_ifc_object_n_times(obj, 8)
-        assert (
-            refresh_mock.call_count == 1
-        ), f"batched 8-way duplicate must call refresh_ui_data once, got {refresh_mock.call_count}"
-
-    def test_n_times_calls_reload_grid_decorator_once(self):
-        obj, _ = _build_actuator()
-        with patch.object(tool.Root, "reload_grid_decorator") as reload_mock:
-            tool.Geometry.duplicate_ifc_object_n_times(obj, 8)
-        assert reload_mock.call_count == 1
-
-
-class TestRegenerateArrayEndToEnd(NewFile):
-    def test_regenerate_array_creates_expected_children(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=8)
-        bpy.context.view_layer.objects.active = obj
-        tool.Model.regenerate_array(obj, parent_data)
-
-        layer = parent_data[0]
-        assert len(layer["children"]) == 7, "8-element array means 7 new children (parent + 7)"
-        for child_guid in layer["children"]:
-            child_element = tool.Ifc.get().by_guid(child_guid)
-            assert child_element is not None
-            assert child_element.is_a("IfcActuator")
-            child_pset = ifcopenshell.util.element.get_pset(child_element, "BBIM_Array")
-            assert child_pset is not None
-            assert child_pset["Parent"] == element.GlobalId
-
-    def test_regenerate_array_parent_stays_selected(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=4)
-        bpy.context.view_layer.objects.active = obj
-        obj.select_set(True)
-        tool.Model.regenerate_array(obj, parent_data)
-        assert (
-            obj in bpy.context.selected_objects
-        ), "regenerate_array must leave parent_obj selected on return (post-condition)"
-
-    def test_regen_operator_leaves_only_parent_selected_and_active(self):
-        """Post-condition parity between grow and shrink for the user-facing
-        ``bim.regenerate_array`` operator: only the parent is selected + active;
-        every child is deselected. Pre-fix the grow path left new children
-        selected, creating inconsistency with the shrink path.
-
-        Scoped to the operator, not the tool method — ``remove_array`` and
-        ``apply_array`` also invoke ``tool.Model.regenerate_array`` internally
-        but expect a different post-selection state (children stay selected
-        for user follow-up work)."""
-        obj, element, parent_data = _build_actuator_with_array_pset(count=6)
-        bpy.context.view_layer.objects.active = obj
-        obj.select_set(True)
-        bpy.ops.bim.regenerate_array()
-
-        assert obj in bpy.context.selected_objects
-        assert bpy.context.view_layer.objects.active is obj
-        parent_pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
-        parent_data_after = json.loads(parent_pset["Data"])
-        for child_guid in parent_data_after[0]["children"]:
-            child_element = tool.Ifc.get().by_guid(child_guid)
-            child_obj = tool.Ifc.get_object(child_element)
-            assert (
-                child_obj not in bpy.context.selected_objects
-            ), f"child {child_obj.name} must be deselected on regenerate_array return"
-
-    def test_regen_operator_after_shrink_still_leaves_only_parent_selected(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=6)
-        bpy.context.view_layer.objects.active = obj
-        bpy.ops.bim.regenerate_array()
-
-        parent_pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
-        arrays = json.loads(parent_pset["Data"])
-        arrays[0]["count"] = 3
-        pset_entity = tool.Ifc.get().by_id(parent_pset["id"])
-        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset_entity, properties={"Data": json.dumps(arrays)})
-        bpy.ops.bim.regenerate_array()
-
-        assert obj in bpy.context.selected_objects
-        assert bpy.context.view_layer.objects.active is obj
-        parent_pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
-        arrays_after = json.loads(parent_pset["Data"])
-        for child_guid in arrays_after[0]["children"]:
-            child_element = tool.Ifc.get().by_guid(child_guid)
-            child_obj = tool.Ifc.get_object(child_element)
-            assert child_obj not in bpy.context.selected_objects
-
-    def test_regenerate_array_child_positions_match_offset(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=4, x=2.5)
-        bpy.context.view_layer.objects.active = obj
-        parent_x = obj.matrix_world.translation.x
-        tool.Model.regenerate_array(obj, parent_data)
-
-        layer = parent_data[0]
-        for i, child_guid in enumerate(layer["children"], start=1):
-            child_element = tool.Ifc.get().by_guid(child_guid)
-            child_obj = tool.Ifc.get_object(child_element)
-            expected_x = parent_x + 2.5 * i
-            assert child_obj.matrix_world.translation.x == pytest.approx(
-                expected_x
-            ), f"child {i}: expected x≈{expected_x}, got {child_obj.matrix_world.translation.x}"
-
-
-class TestRegenerateArrayUIRefreshCoalesces(NewFile):
-    def test_n_children_grow_calls_refresh_ui_data_once_per_layer(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=8)
-        bpy.context.view_layer.objects.active = obj
-        with patch("bonsai.bim.handler.refresh_ui_data") as refresh_mock:
-            tool.Model.regenerate_array(obj, parent_data)
-        assert refresh_mock.call_count == 1, (
-            "growing an array layer from 0 to 7 children must call refresh_ui_data once, "
-            f"got {refresh_mock.call_count}"
-        )
-
-    def test_n_children_grow_calls_reload_grid_decorator_once_per_layer(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=8)
-        bpy.context.view_layer.objects.active = obj
-        with patch.object(tool.Root, "reload_grid_decorator") as reload_mock:
-            tool.Model.regenerate_array(obj, parent_data)
-        assert reload_mock.call_count == 1
-
-
-class TestRecreateAggregateIteratesAllNew(NewFile):
-    """Pins the [0]-indexing sweep in tool/root.py recreate_aggregate. When the
-    new-list has N>1 entries (the batched-duplicate shape), every entry must be
-    aggregate-assigned, not just new[0]."""
-
-    def test_iterates_assign_object_per_new_entity_when_old_has_aggregate(self):
-        from unittest.mock import Mock
-
-        old_assembly = Mock()
-        old_assembly.is_a = lambda c: c == "IfcElementAssembly"
-        old_parent_aggregate = Mock()
-        old_parent_aggregate.is_a = lambda c: False
-
-        new_assemblies = [Mock(), Mock(), Mock()]
-        new_parent_aggregate = [Mock()]
-
-        old_to_new = {old_assembly: new_assemblies, old_parent_aggregate: new_parent_aggregate}
-
-        with patch(
-            "ifcopenshell.util.element.get_aggregate",
-            side_effect=lambda e: old_parent_aggregate if e is old_assembly else None,
-        ), patch("bonsai.core.aggregate.assign_object") as assign_mock, patch(
-            "ifcopenshell.util.element.get_pset", return_value=None
-        ), patch.object(
-            tool.Ifc, "get_object", side_effect=lambda e: Mock(spec=bpy.types.Object)
-        ), patch.object(
-            tool.Blender, "select_and_activate_single_object"
-        ):
-            tool.Root.recreate_aggregate(old_to_new)
-
-        assert (
-            assign_mock.call_count == 3
-        ), f"recreate_aggregate must assign each of N new entities (not just new[0]); got {assign_mock.call_count}"
-
-    def test_iterates_unassign_object_per_new_entity_when_aggregate_missing(self):
-        from unittest.mock import Mock
-
-        old_assembly = Mock()
-        old_assembly.is_a = lambda c: c == "IfcElementAssembly"
-        old_parent_aggregate = Mock()
-
-        new_assemblies = [Mock(), Mock(), Mock()]
-        old_to_new = {old_assembly: new_assemblies}  # parent aggregate NOT in old_to_new
-
-        with patch(
-            "ifcopenshell.util.element.get_aggregate",
-            side_effect=lambda e: old_parent_aggregate if e is old_assembly else None,
-        ), patch("bonsai.core.aggregate.unassign_object") as unassign_mock, patch.object(
-            tool.Ifc, "get_object", side_effect=lambda e: Mock(spec=bpy.types.Object)
-        ):
-            tool.Root.recreate_aggregate(old_to_new)
-
-        assert unassign_mock.call_count == 3, (
-            f"recreate_aggregate must unassign each of N new entities when parent aggregate is missing; "
-            f"got {unassign_mock.call_count}"
-        )
-
-
-class TestRecreateConnectionsZipsPairs(NewFile):
-    """Pins the [0]-indexing sweep in tool/duplicate.py recreate_connections. When
-    both sides of a connection are duplicated N times, zip-pair the N new
-    relating with N new related; when only one side is duplicated, skip."""
-
-    def _make_connection_data(self):
-        from unittest.mock import Mock
-
-        from bonsai.tool.duplicate import ConnectionRecord
-
-        return ConnectionRecord(
-            type="path",
-            relating_element=Mock(),
-            related_element=Mock(),
-            relating_connection_type="ATSTART",
-            related_connection_type="ATEND",
-            relating_priorities=[],
-            related_priorities=[],
-        )
-
-    def test_zips_n_pairs_when_both_sides_duplicated(self):
-        from unittest.mock import Mock
-
-        data = self._make_connection_data()
-        old_to_new = {
-            data.relating_element: [Mock(), Mock(), Mock()],
-            data.related_element: [Mock(), Mock(), Mock()],
-        }
-        relationship = {Mock(): data}
-
-        with patch.object(tool.Ifc, "run", return_value=None) as run_mock:
-            tool.Duplicate.recreate_connections(relationship, old_to_new)
-
-        connect_calls = [c for c in run_mock.call_args_list if c.args and c.args[0] == "geometry.connect_path"]
-        assert (
-            len(connect_calls) == 3
-        ), f"zip-pair must create 3 connect_path calls for 3-vs-3 batched duplicate; got {len(connect_calls)}"
-
-    def test_skips_when_other_side_not_duplicated(self):
-        from unittest.mock import Mock
-
-        data = self._make_connection_data()
-        # Only relating side is in old_to_new; related side was NOT duplicated.
-        old_to_new = {data.relating_element: [Mock(), Mock(), Mock()]}
-        relationship = {Mock(): data}
-
-        with patch.object(tool.Ifc, "run", return_value=None) as run_mock:
-            tool.Duplicate.recreate_connections(relationship, old_to_new)
-
-        connect_calls = [c for c in run_mock.call_args_list if c.args and c.args[0] == "geometry.connect_path"]
-        assert (
-            connect_calls == []
-        ), "when only one side of a connection is in old_to_new, no connections should be recreated"
-
-    def test_single_pair_case_unchanged(self):
-        """Pre-sweep behavior (1 source -> 1 new) must still work — zip with two 1-element lists."""
-        from unittest.mock import Mock
-
-        data = self._make_connection_data()
-        old_to_new = {
-            data.relating_element: [Mock()],
-            data.related_element: [Mock()],
-        }
-        relationship = {Mock(): data}
-
-        with patch.object(tool.Ifc, "run", return_value=None) as run_mock:
-            tool.Duplicate.recreate_connections(relationship, old_to_new)
-
-        connect_calls = [c for c in run_mock.call_args_list if c.args and c.args[0] == "geometry.connect_path"]
-        assert len(connect_calls) == 1
-
-
-class TestRecalculateWallsWithNewConnections(NewFile):
-    """Pins the post-connection wall recalc: after ``recreate_connections``
-    wires new IfcRelConnectsPathElements onto duplicated walls, the wall
-    bodies must be re-recalculated because the in-loop ``regenerate_wall``
-    fired before the connections existed. Otherwise the junction geometry
-    stays stale and the user has to manually regen."""
-
-    def test_walls_with_new_connections_are_recalculated(self):
-        from unittest.mock import Mock
-
-        wall_new = Mock()
-        wall_new.is_a = lambda c: c == "IfcWall"
-        wall_new.ConnectedTo = [Mock()]
-        wall_new.ConnectedFrom = []
-
-        wall_obj = Mock(spec=bpy.types.Object)
-        old_to_new = {Mock(): [wall_new]}
-
-        with patch.object(tool.Ifc, "get_object", return_value=wall_obj), patch.object(
-            tool.Model, "recalculate_walls"
-        ) as recalc_mock:
-            tool.Geometry._recalculate_walls_with_new_connections(old_to_new)
-
-        assert recalc_mock.call_count == 1
-        assert recalc_mock.call_args.args[0] == [wall_obj]
-
-    def test_walls_without_connections_are_skipped(self):
-        from unittest.mock import Mock
-
-        wall_new = Mock()
-        wall_new.is_a = lambda c: c == "IfcWall"
-        wall_new.ConnectedTo = []
-        wall_new.ConnectedFrom = []
-
-        old_to_new = {Mock(): [wall_new]}
-
-        with patch.object(tool.Ifc, "get_object", return_value=Mock(spec=bpy.types.Object)), patch.object(
-            tool.Model, "recalculate_walls"
-        ) as recalc_mock:
-            tool.Geometry._recalculate_walls_with_new_connections(old_to_new)
-
-        assert recalc_mock.call_count == 0, "walls with no new connections must not trigger a recalc pass"
-
-    def test_non_wall_entities_are_skipped(self):
-        from unittest.mock import Mock
-
-        actuator_new = Mock()
-        actuator_new.is_a = lambda c: c == "IfcActuator"
-        actuator_new.ConnectedTo = [Mock()]
-
-        old_to_new = {Mock(): [actuator_new]}
-
-        with patch.object(tool.Ifc, "get_object", return_value=Mock(spec=bpy.types.Object)), patch.object(
-            tool.Model, "recalculate_walls"
-        ) as recalc_mock:
-            tool.Geometry._recalculate_walls_with_new_connections(old_to_new)
-
-        assert recalc_mock.call_count == 0
-
-    def test_multiple_new_walls_collected_into_one_call(self):
-        from unittest.mock import Mock
-
-        wall_a_new = Mock()
-        wall_a_new.is_a = lambda c: c == "IfcWall"
-        wall_a_new.ConnectedTo = [Mock()]
-        wall_a_new.ConnectedFrom = []
-        wall_b_new = Mock()
-        wall_b_new.is_a = lambda c: c == "IfcWall"
-        wall_b_new.ConnectedTo = []
-        wall_b_new.ConnectedFrom = [Mock()]
-
-        objs = {wall_a_new: Mock(spec=bpy.types.Object), wall_b_new: Mock(spec=bpy.types.Object)}
-        old_to_new = {Mock(): [wall_a_new], Mock(): [wall_b_new]}
-
-        with patch.object(tool.Ifc, "get_object", side_effect=lambda e: objs.get(e)), patch.object(
-            tool.Model, "recalculate_walls"
-        ) as recalc_mock:
-            tool.Geometry._recalculate_walls_with_new_connections(old_to_new)
-
-        assert recalc_mock.call_count == 1
-        assert set(recalc_mock.call_args.args[0]) == {objs[wall_a_new], objs[wall_b_new]}
-
-
-class TestMEPActionGuardsAgainstArrayChildren(NewFile):
-    """Pins the array-child guards on the three MEP-action visibility helpers.
-    Writable MEP actions (add fitting, remove terminal, join, re-edit bend)
-    applied to an array child get wiped by the next regen — gating the icons
-    at the visibility layer prevents that footgun."""
-
-    def test_active_is_flow_segment_returns_false_for_array_child(self):
-        from unittest.mock import Mock
-
-        from bonsai.bim.module.model.mep import _active_is_flow_segment
-
-        obj = Mock(spec=bpy.types.Object)
-        element = Mock()
-        element.is_a = lambda c: c == "IfcFlowSegment"
-
-        with patch.object(tool.Ifc, "get_entity", return_value=element), patch.object(
-            tool.Array, "is_array_child", return_value=True
-        ), patch.object(tool.System, "has_parametric_body", return_value=True):
-            assert _active_is_flow_segment(obj) is False
-
-    def test_active_is_flow_segment_true_for_non_array_parent(self):
-        from unittest.mock import Mock
-
-        from bonsai.bim.module.model.mep import _active_is_flow_segment
-
-        obj = Mock(spec=bpy.types.Object)
-        element = Mock()
-        element.is_a = lambda c: c == "IfcFlowSegment"
-
-        with patch.object(tool.Ifc, "get_entity", return_value=element), patch.object(
-            tool.Array, "is_array_child", return_value=False
-        ), patch.object(tool.System, "has_parametric_body", return_value=True):
-            assert _active_is_flow_segment(obj) is True
-
-    def test_active_is_bend_fitting_returns_false_for_array_child(self):
-        from unittest.mock import Mock
-
-        from bonsai.bim.module.model.mep import _active_is_bend_fitting
-
-        obj = Mock(spec=bpy.types.Object)
-        element = Mock()
-
-        with patch.object(tool.Ifc, "get_entity", return_value=element), patch(
-            "bonsai.bim.module.model.mep._is_bend_fitting", return_value=True
-        ), patch.object(tool.Array, "is_array_child", return_value=True):
-            assert _active_is_bend_fitting(obj) is False
-
-    def test_n_mep_selected_returns_false_when_any_selected_is_array_child(self):
-        from unittest.mock import Mock
-
-        from bonsai.bim.module.model.mep import _n_mep_selected
-
-        obj_a = Mock(spec=bpy.types.Object)
-        obj_b = Mock(spec=bpy.types.Object)
-        element_a = Mock()
-        element_b = Mock()
-
-        def is_array_child(el):
-            return el is element_b
-
-        with patch.object(tool.Blender, "get_selected_objects", return_value=[obj_a, obj_b]), patch.object(
-            tool.Ifc, "get_entity", side_effect=lambda o: element_a if o is obj_a else element_b
-        ), patch.object(tool.System, "is_mep_element", return_value=True), patch.object(
-            tool.Array, "is_array_child", side_effect=is_array_child
-        ):
-            assert _n_mep_selected(2) is False
-
-
-class TestSelectOnlyParent(NewFile):
-    """Pins ``tool.Array.select_only_parent`` — the shared helper wired into
-    both ``bim.regenerate_array`` and ``bim.finish_editing_array`` so the
-    grow / shrink / edit-commit paths converge on the same post-condition:
-    only the parent is selected + active."""
-
-    def test_deselects_children_selects_and_activates_parent(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=4)
-        bpy.context.view_layer.objects.active = obj
-        obj.select_set(True)
-        tool.Model.regenerate_array(obj, parent_data)
-        for child_guid in parent_data[0]["children"]:
-            child_element = tool.Ifc.get().by_guid(child_guid)
-            child_obj = tool.Ifc.get_object(child_element)
-            child_obj.select_set(True)
-
-        tool.Array.select_only_parent(obj, bpy.context)
-
-        assert obj in bpy.context.selected_objects
-        assert bpy.context.view_layer.objects.active is obj
-        for child_guid in parent_data[0]["children"]:
-            child_element = tool.Ifc.get().by_guid(child_guid)
-            child_obj = tool.Ifc.get_object(child_element)
-            assert child_obj not in bpy.context.selected_objects
-
-
-class TestIsArrayChild(NewFile):
-    """Pins ``tool.Array.is_array_child`` — the light helper used by the port
-    decorator (and any future per-element guard) to skip array children."""
-
-    def test_returns_false_when_no_bbim_array_pset(self):
-        from unittest.mock import Mock
-
-        element = Mock()
-        with patch("ifcopenshell.util.element.get_pset", return_value=None):
-            assert tool.Array.is_array_child(element) is False
-
-    def test_returns_false_on_the_array_parent_itself(self):
-        from unittest.mock import Mock
-
-        element = Mock()
-        element.GlobalId = "PARENT_GUID"
-        with patch("ifcopenshell.util.element.get_pset", return_value={"Parent": "PARENT_GUID"}):
-            assert tool.Array.is_array_child(element) is False
-
-    def test_returns_true_when_parent_guid_points_elsewhere(self):
-        from unittest.mock import Mock
-
-        element = Mock()
-        element.GlobalId = "CHILD_GUID"
-        with patch("ifcopenshell.util.element.get_pset", return_value={"Parent": "PARENT_GUID"}):
-            assert tool.Array.is_array_child(element) is True
-
-
-class TestOrphanArrayChildPrune(NewFile):
-    """Outliner / keyboard delete of a Bonsai-managed array child bypasses
-    ``bim.delete``'s cascade, leaving the IFC entity and its opening / filling
-    refs behind. Regen must prune these orphans before the main loop or the
-    stale registry entry corrupts the ``batch_host_recut`` drain."""
-
-    def test_orphan_ifc_entity_pruned_from_children_list(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=4)
-        bpy.context.view_layer.objects.active = obj
-        tool.Model.regenerate_array(obj, parent_data)
-        assert len(parent_data[0]["children"]) == 3
-
-        orphan_guid = parent_data[0]["children"][1]
-        orphan_element = tool.Ifc.get().by_guid(orphan_guid)
-        orphan_obj = tool.Ifc.get_object(orphan_element)
-        assert orphan_obj is not None
-        bpy.data.objects.remove(orphan_obj, do_unlink=True)
-
-        tool.Model.regenerate_array(obj, parent_data)
-
-        assert (
-            orphan_guid not in parent_data[0]["children"]
-        ), "orphan GUID must be pruned from array['children'] once its Blender object is dead"
-        try:
-            still_there = tool.Ifc.get().by_guid(orphan_guid)
-        except RuntimeError:
-            still_there = None
-        assert still_there is None, "orphan IFC entity must be cascade-removed, not left as a leak"
-
-    def test_regen_completes_when_child_deleted_outside_bim_cascade(self):
-        obj, element, parent_data = _build_actuator_with_array_pset(count=6)
-        bpy.context.view_layer.objects.active = obj
-        tool.Model.regenerate_array(obj, parent_data)
-
-        victim_guid = parent_data[0]["children"][2]
-        victim_element = tool.Ifc.get().by_guid(victim_guid)
-        victim_obj = tool.Ifc.get_object(victim_element)
-        bpy.data.objects.remove(victim_obj, do_unlink=True)
-
-        tool.Model.regenerate_array(obj, parent_data)
-
-        assert len(parent_data[0]["children"]) == 5, "regen must rebuild to the target count after pruning the orphan"
-        for guid in parent_data[0]["children"]:
-            child = tool.Ifc.get().by_guid(guid)
-            child_obj = tool.Ifc.get_object(child)
-            assert child_obj is not None, "every surviving child must have a live Blender object"
-
-
-class TestRecreatePortConnectionsZipsPairs(NewFile):
-    """Pins the [0]-indexing sweep in tool/duplicate.py recreate_port_connections.
-    When both sides of a port-to-port connection are duplicated N times, the
-    connection must be recreated on every pair of new siblings — not just the
-    first. Matters for arrayed MEP segments (pipes / ducts / cables) where each
-    child in the array should stay connected to its neighbour after regen."""
-
-    def _make_snapshot(self, relating_element, records, port_counts):
-        from bonsai.tool.duplicate import PortConnectionSnapshot
-
-        return PortConnectionSnapshot(
-            by_element={relating_element: records},
-            port_counts=port_counts,
-        )
-
-    def _make_record(self, related_element, relating_port_index=0, related_port_index=0, direction="SOURCE"):
-        from bonsai.tool.duplicate import PortConnectionRecord
-
-        return PortConnectionRecord(
-            relating_port_index=relating_port_index,
-            related_element=related_element,
-            related_port_index=related_port_index,
-            direction=direction,
-        )
-
-    def test_zips_n_pairs_when_both_sides_duplicated(self):
-        from unittest.mock import Mock
-
-        relating_old = Mock()
-        related_old = Mock()
-        record = self._make_record(related_old)
-        snapshot = self._make_snapshot(relating_old, [record], port_counts={})
-
-        old_to_new = {
-            relating_old: [Mock(), Mock(), Mock()],
-            related_old: [Mock(), Mock(), Mock()],
-        }
-
-        fake_ports = [Mock(), Mock()]
-        with patch.object(tool.System, "get_ports", return_value=fake_ports), patch.object(
-            tool.Ifc, "run", return_value=None
-        ) as run_mock:
-            tool.Duplicate.recreate_port_connections(snapshot, old_to_new)
-
-        connect_calls = [c for c in run_mock.call_args_list if c.args and c.args[0] == "system.connect_port"]
-        assert (
-            len(connect_calls) == 3
-        ), f"zip-pair must create 3 connect_port calls for 3-vs-3 batched MEP duplicate; got {len(connect_calls)}"
-
-    def test_skips_when_other_side_not_duplicated(self):
-        from unittest.mock import Mock
-
-        relating_old = Mock()
-        related_old = Mock()
-        record = self._make_record(related_old)
-        snapshot = self._make_snapshot(relating_old, [record], port_counts={})
-
-        # Only relating side is in old_to_new.
-        old_to_new = {relating_old: [Mock(), Mock(), Mock()]}
-
-        with patch.object(tool.System, "get_ports", return_value=[Mock()]), patch.object(
-            tool.Ifc, "run", return_value=None
-        ) as run_mock:
-            tool.Duplicate.recreate_port_connections(snapshot, old_to_new)
-
-        connect_calls = [c for c in run_mock.call_args_list if c.args and c.args[0] == "system.connect_port"]
-        assert connect_calls == [], "when only one side is in old_to_new, no port connections should be recreated"
-
-    def test_single_pair_case_unchanged(self):
-        """Pre-sweep behavior (1 source -> 1 new) must still work — zip with two 1-element lists."""
-        from unittest.mock import Mock
-
-        relating_old = Mock()
-        related_old = Mock()
-        record = self._make_record(related_old)
-        snapshot = self._make_snapshot(relating_old, [record], port_counts={})
-
-        old_to_new = {relating_old: [Mock()], related_old: [Mock()]}
-
-        with patch.object(tool.System, "get_ports", return_value=[Mock()]), patch.object(
-            tool.Ifc, "run", return_value=None
-        ) as run_mock:
-            tool.Duplicate.recreate_port_connections(snapshot, old_to_new)
-
-        connect_calls = [c for c in run_mock.call_args_list if c.args and c.args[0] == "system.connect_port"]
-        assert len(connect_calls) == 1

src/bonsai/test/bim/module/model/test_mep_actions_visibility.py

@@ -346,9 +346,7 @@ def test_active_is_flow_segment_classifies_segment_vs_fitting():
     fitting_elem.is_a = lambda c: c == "IfcFlowFitting"
 
     plain = Mock()
-    with patch("bonsai.bim.module.model.mep.tool.System.has_parametric_body", return_value=True), patch(
-        "bonsai.bim.module.model.mep.tool.Array.is_array_child", return_value=False
-    ):
+    with patch("bonsai.bim.module.model.mep.tool.System.has_parametric_body", return_value=True):
         with patch("bonsai.bim.module.model.mep.tool.Ifc.get_entity", return_value=segment_elem):
             assert _active_is_flow_segment(plain) is True
         with patch("bonsai.bim.module.model.mep.tool.Ifc.get_entity", return_value=fitting_elem):

src/bonsai/test/bim/module/model/test_mep_distribution_fit_smoke.py

@@ -146,9 +146,7 @@ def test_fit_flow_segments_with_single_segment_dispatches_obstruction():
         mep.tool.Model, "get_flow_segment_profile", return_value=segment_profile
     ), patch.object(mep.MEPAddObstruction, "_execute", return_value=None) as obstruction, patch.object(
         mep.MEPAddBend, "_execute", return_value=None
-    ) as bend, patch.object(
-        mep.MEPAddTransition, "_execute", return_value=None
-    ) as transition:
+    ) as bend, patch.object(mep.MEPAddTransition, "_execute", return_value=None) as transition:
         mep.FitFlowSegments._execute(op, context=context)
 
     assert obstruction.call_count == 1
@@ -180,9 +178,7 @@ def test_fit_flow_segments_refuses_mixed_pipe_and_duct():
         mep.tool.Model, "get_flow_segment_profile", return_value=profile
     ), patch.object(mep.MEPAddObstruction, "_execute", return_value=None) as obstruction, patch.object(
         mep.MEPAddBend, "_execute", return_value=None
-    ) as bend, patch.object(
-        mep.MEPAddTransition, "_execute", return_value=None
-    ) as transition:
+    ) as bend, patch.object(mep.MEPAddTransition, "_execute", return_value=None) as transition:
         mep.FitFlowSegments._execute(op, context=context)
 
     obstruction.assert_not_called()

src/bonsai/test/bim/module/model/test_mep_segment_edition.py

@@ -173,9 +173,8 @@ def test_gizmo_group_class_wiring(gizmo_cls_name, bl_idname, is_element_predicat
     predicate = getattr(tool.Parametric, is_element_predicate)
     fake_element = Mock()
     fake_element.is_a.return_value = True
-    with (
-        patch.object(tool.Parametric, is_element_predicate, side_effect=predicate) as p,
-        patch.object(tool.System, "has_parametric_body", return_value=True),
+    with patch.object(tool.Parametric, is_element_predicate, side_effect=predicate) as p, patch.object(
+        tool.System, "has_parametric_body", return_value=True
     ):
         cls.is_element_type(fake_element)
     assert p.called, f"{gizmo_cls_name}.is_element_type did not delegate to Parametric.{is_element_predicate}"

src/bonsai/test/bim/module/project/test_autosave.py

@@ -1,68 +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.
-
-import os
-import time
-from pathlib import Path
-
-import pytest
-
-from bonsai.tool.autosave import AUTOSAVED_SUFFIX, AUTOSAVING_SUFFIX, Autosave
-
-pytestmark = pytest.mark.project
-
-
-class TestAutosavePaths:
-    def test_get_paths_for_ifc_file(self):
-        main_path, autosaving_path, autosaved_path = Autosave.get_paths("/tmp/myfile.ifc")
-        assert main_path == Path("/tmp/myfile.ifc")
-        assert autosaving_path == Path(f"/tmp/myfile{AUTOSAVING_SUFFIX}")
-        assert autosaved_path == Path(f"/tmp/myfile{AUTOSAVED_SUFFIX}")
-
-    def test_get_newer_autosaved_path_when_missing(self, tmp_path):
-        ifc_path = tmp_path / "myfile.ifc"
-        ifc_path.write_text("ifc")
-        assert Autosave.get_newer_autosaved_path(ifc_path) is None
-
-    def test_get_newer_autosaved_path_when_older(self, tmp_path):
-        ifc_path = tmp_path / "myfile.ifc"
-        autosaved_path = tmp_path / f"myfile{AUTOSAVED_SUFFIX}"
-        ifc_path.write_text("ifc")
-        autosaved_path.write_text("autosaved")
-        past = time.time() - 10
-        os.utime(ifc_path, (past, past))
-        os.utime(autosaved_path, (time.time(), time.time()))
-        assert Autosave.get_newer_autosaved_path(ifc_path) == autosaved_path.as_posix()
-
-    def test_get_newer_autosaved_path_when_not_newer(self, tmp_path):
-        ifc_path = tmp_path / "myfile.ifc"
-        autosaved_path = tmp_path / f"myfile{AUTOSAVED_SUFFIX}"
-        ifc_path.write_text("ifc")
-        autosaved_path.write_text("autosaved")
-        now = time.time()
-        os.utime(ifc_path, (now, now))
-        past = now - 10
-        os.utime(autosaved_path, (past, past))
-        assert Autosave.get_newer_autosaved_path(ifc_path) is None
-
-    def test_get_newer_autosaved_path_ignores_non_ifc(self, tmp_path):
-        path = tmp_path / "myfile.ifczip"
-        path.write_text("zip")
-        assert Autosave.get_newer_autosaved_path(path) is None

src/bonsai/test/bim/test_feature.py

@@ -30,7 +30,7 @@ from collections.abc import Generator
 from inspect import signature
 from math import radians
 from pathlib import Path
-from typing import Any, Union, cast
+from typing import Any, Union
 
 import bpy
 import ifcopenshell
@@ -140,7 +140,7 @@ class PanelSpy:
             else:
                 props = kwargs.get("data")
                 name = kwargs.get("property")
-            props = cast(bpy.types.bpy_struct, props)
+            props: bpy.types.bpy_struct
             text = kwargs.get("text", props.bl_rna.properties[name].name)
             icon = kwargs.get("icon", None)
             prop_type = props.bl_rna.properties[name].type

src/bonsai/test/bim/test_preview_cancel_ops_forward_compat.py

@@ -139,5 +139,6 @@ def test_every_cancel_ops_entry_has_a_real_preview_propertygroup() -> None:
     orphaned = [attr for attr, _op in preview_base.PREVIEW_CANCEL_OPS if attr not in declared_attrs]
     assert not orphaned, (
         "PREVIEW_CANCEL_OPS contains entries whose PointerProperty child no longer "
-        f"exists on {UMBRELLA_CLASS}. Drop the stale tuple(s):\n  " + "\n  ".join(orphaned)
+        f"exists on {UMBRELLA_CLASS}. Drop the stale tuple(s):\n  "
+        + "\n  ".join(orphaned)
     )

src/bonsai/test/core/test_drawing.py

@@ -347,13 +347,11 @@ class TestAddDrawing:
             context="context",
             ifc_representation_class=None,
         ).should_be_called().will_return("element")
-        drawing.ensure_drawings_parent_group().should_be_called().will_return("drawings_parent_group")
         ifc.run("group.add_group").should_be_called().will_return("group")
         ifc.run(
             "group.edit_group", group="group", attributes={"Name": "name", "ObjectType": "DRAWING"}
         ).should_be_called()
         ifc.run("group.assign_group", group="group", products=["element"]).should_be_called()
-        ifc.run("group.assign_group", group="drawings_parent_group", products=["group"]).should_be_called()
         collector.assign("obj").should_be_called()
         ifc.run("pset.add_pset", product="element", name="EPset_Drawing").should_be_called().will_return("pset")
         drawing.get_default_drawing_resource_path("Stylesheet").should_be_called().will_return("stylesheet.css")
@@ -383,11 +381,8 @@ class TestAddDrawing:
                 "CurrentShadingStyle": "Blender Default",
             },
         ).should_be_called()
-        drawing.ensure_drawings_parent_document().should_be_called().will_return("drawings_parent_document")
         drawing.get_default_drawing_path("name").should_be_called().will_return("uri")
-        ifc.run("document.add_information", parent="drawings_parent_document").should_be_called().will_return(
-            "information"
-        )
+        ifc.run("document.add_information").should_be_called().will_return("information")
         ifc.run("document.add_reference", information="information").should_be_called().will_return("reference")
         ifc.get_schema().should_be_called().will_return("IFC4")
         ifc.run(
@@ -411,13 +406,11 @@ class TestDuplicateDrawing:
         drawing.set_name("new_drawing", "unique_name").should_be_called()
         drawing.get_drawing_group("new_drawing").should_be_called().will_return("group")
         ifc.run("group.unassign_group", group="group", products=["new_drawing"]).should_be_called()
-        drawing.ensure_drawings_parent_group().should_be_called().will_return("drawings_parent_group")
         ifc.run("group.add_group").should_be_called().will_return("new_group")
         ifc.run(
             "group.edit_group", group="new_group", attributes={"Name": "unique_name", "ObjectType": "DRAWING"}
         ).should_be_called()
         ifc.run("group.assign_group", group="new_group", products=["new_drawing"]).should_be_called()
-        ifc.run("group.assign_group", group="drawings_parent_group", products=["new_group"]).should_be_called()
         drawing.get_group_elements("group").should_be_called().will_return(["drawing", "annotation"])
         ifc.get_object("annotation").should_be_called().will_return("annotation_obj")
         geometry.duplicate_ifc_objects(["annotation_obj"]).should_be_called().will_return(
@@ -432,10 +425,7 @@ class TestDuplicateDrawing:
         drawing.get_drawing_document("new_drawing").should_be_called().will_return("old_reference")
         ifc.run("document.unassign_document", products=["new_drawing"], document="old_reference").should_be_called()
 
-        drawing.ensure_drawings_parent_document().should_be_called().will_return("drawings_parent_document")
-        ifc.run("document.add_information", parent="drawings_parent_document").should_be_called().will_return(
-            "information"
-        )
+        ifc.run("document.add_information").should_be_called().will_return("information")
         ifc.run("document.add_reference", information="information").should_be_called().will_return("reference")
         ifc.get_schema().should_be_called().will_return("IFC4")
         drawing.get_default_drawing_path("unique_name").should_be_called().will_return("drawing_path")

src/bonsai/test/modal/test_modal.py

@@ -24,7 +24,6 @@ import time
 
 import bpy
 import ifcopenshell
-import ifcopenshell.util.element
 import pytest
 
 from bonsai import tool as tool

src/bonsai/test/tool/test_blender.py

@@ -203,7 +203,6 @@ class TestGetDebugInfo(NewFile):
         "bonsai_version",
         "bonsai_commit_hash",
         "bonsai_commit_date",
-        "bonsai_git_branch",
         "last_actions",
         "last_error",
     }

src/bonsai/test/tool/test_geometry_batch_host_recut.py

@@ -164,62 +164,6 @@ def test_stale_element_skipped_at_drain():
     assert recut.call_count == 0
 
 
-class _DeadStructRNA:
-    """Simulates a Blender object whose StructRNA has been removed — every
-    attribute access raises ReferenceError. Enqueue this as voided_obj to
-    reproduce the outliner-mid-batch-delete crash."""
-
-    def __getattr__(self, name):
-        raise ReferenceError("StructRNA of type Object has been removed")
-
-    def __bool__(self):
-        raise ReferenceError("StructRNA of type Object has been removed")
-
-
-def test_dead_structrna_recut_skipped_at_drain():
-    """Blender object is deleted while the batch is open (outliner delete +
-    manual DEL bypass the bim.delete cascade). The drain must skip it silently
-    — not raise — so unrelated hosts in the same batch still get their recut."""
-    from bonsai import tool
-
-    dead_obj = _DeadStructRNA()
-    live_obj = _mock_voided_obj("LiveWall")
-    rep = Mock()
-
-    def get_entity(obj):
-        # Called only when the guard clears — for the dead ref, guard short-circuits first.
-        return _mock_element(2)
-
-    with patch("bonsai.core.geometry.switch_representation") as recut, patch.object(
-        tool.Ifc, "get_entity", side_effect=get_entity
-    ), patch.object(tool.Geometry, "get_active_representation", return_value=rep):
-        with tool.Geometry.batch_host_recut():
-            tool.Geometry._host_recut_queue[999] = (dead_obj, rep)
-            tool.Geometry.recut_host(live_obj, rep)
-
-    assert recut.call_count == 1, "live host must still get its recut despite a dead sibling in the queue"
-    drained_obj = recut.call_args.kwargs["obj"]
-    assert drained_obj is live_obj
-
-
-def test_dead_structrna_update_skipped_at_drain():
-    """Same guarantee for update_representation drain path."""
-    from bonsai import tool
-
-    dead_obj = _DeadStructRNA()
-    live_obj = _mock_voided_obj("LiveWall")
-    bpy_ops_mock = Mock()
-
-    with patch("bonsai.tool.geometry.bpy.ops", new=bpy_ops_mock), patch.object(
-        tool.Ifc, "get_entity", return_value=_mock_element(42)
-    ), patch.object(tool.Geometry, "get_active_representation", return_value=Mock()):
-        with tool.Geometry.batch_host_recut():
-            tool.Geometry._host_update_queue[999] = dead_obj
-            tool.Geometry.update_host_representation(live_obj)
-
-    assert bpy_ops_mock.bim.update_representation.call_count == 1
-
-
 def test_exception_inside_batch_still_resets_state():
     from bonsai import tool
 

src/bonsai/test/tool/test_model.py

@@ -23,7 +23,6 @@ import bpy
 import ifcopenshell
 import ifcopenshell.api.geometry
 import ifcopenshell.api.material
-import ifcopenshell.api.pset
 import ifcopenshell.api.root
 import ifcopenshell.api.style
 import ifcopenshell.api.type
@@ -631,15 +630,15 @@ class TestUsingArrays(NewFile):
     def test_remove_array_first_to_last(self):
         self.setup_array(add_second_layer=True)
         bpy.ops.bim.remove_array(item=0)
-        assert len(self._array_objects()) == 3
+        assert len(bpy.context.selected_objects) == 3
         bpy.ops.bim.remove_array(item=0)
-        assert len(self._array_objects()) == 1
+        assert len(bpy.context.selected_objects) == 1
 
     def test_apply_array_1_layer(self):
         self.setup_array()
         bpy.ops.bim.apply_array()
 
-        objs = self._array_objects()
+        objs = bpy.context.selected_objects
         assert len(objs) == 4
         # check BBIM_Array psets are removed
         for obj in objs:
@@ -665,7 +664,7 @@ class TestUsingArrays(NewFile):
         self.setup_array(sync_children=True)
         bpy.ops.bim.apply_array()
 
-        objs = self._array_objects()
+        objs = bpy.context.selected_objects
         assert len(objs) == 4
         # check BBIM_Array psets are removed
         for obj in objs:

src/bsdd/bsdd.py

@@ -21,7 +21,6 @@ import http.server
 import time
 import urllib.parse
 import uuid
-import warnings
 import webbrowser
 from typing import TYPE_CHECKING, Any, Literal, Optional, TypedDict
 
@@ -522,17 +521,7 @@ class Client:
         headers = {"User-Agent": "IfcOpenShell.bSDD.py/0.8.0"}
         if is_auth_required:
             headers["Authorization"] = "Bearer " + self.get_access_token()
-        response = requests.get(f"{self.baseurl}{endpoint}", timeout=10, headers=headers, params=params or None)
-        try:
-            response.raise_for_status()
-        except requests.exceptions.HTTPError as e:
-            try:
-                data = response.json()
-                message = data.get("message", data.get("error", str(e)))
-            except requests.exceptions.JSONDecodeError:
-                message = response.text or str(e)
-            raise requests.exceptions.HTTPError(f"{e}: {message}", response=response) from e
-        return response.json()
+        return requests.get(f"{self.baseurl}{endpoint}", timeout=10, headers=headers, params=params or None).json()
 
     def _get_deprecated(self, endpoint, params=None, is_auth_required=False):
         headers = {"User-Agent": "IfcOpenShell.bSDD.py/0.8.0"}
@@ -780,16 +769,6 @@ class Client:
         Get Class details
         this API replaces Classification
         """
-        # Not very well documented on bsdd side,
-        # the deprecation note only occurs when you run into rate limit.
-        # See https://github.com/buildingSMART/bSDD/issues/149
-        if include_class_properties:
-            warnings.warn(
-                "include_class_properties=True is deprecated and heavily rate-limited by the bSDD API. "
-                "Use get_class_properties() instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
         endpoint = f"Class/v{version}"
         params = {
             "Uri": class_uri,

src/bsdd/tests/test_bsdd.py

@@ -31,7 +31,6 @@ def test_get_nbs_classes():
 
 def test_get_class():
     uri_light_fixture = next(l for l in get_ifc_classes()["classes"] if "IfcLightFixture" == l["code"])["uri"]
-    # TODO: fix deprecation warning.
     ifc4x3_light_fixture = client.get_class(uri_light_fixture)
     assert "Maintenance Factor" and "Light Fixture Mounting Type" in [
         l["name"] for l in ifc4x3_light_fixture["classProperties"]
@@ -40,7 +39,7 @@ def test_get_class():
 
 def test_get_class_relations():
     uri_light_fixture = next(l for l in get_ifc_classes()["classes"] if "IfcLightFixture" == l["code"])["uri"]
-    ifc4x3_light_fixture_relations = client.get_class_relations(uri_light_fixture, True)
+    ifc4x3_light_fixture_relations = client.get_class_properties(uri_light_fixture, True)
     assert "Electrical unit for light-line system" and "Tubelight system" in [
         r["className"] for r in ifc4x3_light_fixture_relations["classRelations"]
     ]

src/ifc4d/ifc4d/p62ifc.py

@@ -28,7 +28,6 @@ class P62Ifc:
         self.file = None
         self.work_plan = None
         self.project = {}
-        self.default_calendar_id = None
         self.calendars = {}
         self.wbs = {}
         self.root_activites = []
@@ -90,7 +89,6 @@ class P62Ifc:
         self.ns = {"pr": root.tag[1:].partition("}")[0]}
         project = root.find("pr:Project", self.ns)
         self.project["Name"] = project.findtext("pr:Name") or "Unnamed"
-        self.default_calendar_id = project.findtext("pr:ActivityDefaultCalendarObjectId", namespaces=self.ns)
         self.parse_calendar_xml(root)
         self.parse_calendar_xml(project)
         self.parse_wbs_xml(project)
@@ -176,9 +174,6 @@ class P62Ifc:
                 self.wbs[wbs_id]["activities"].append(activity_id)
             else:
                 self.root_activites.append(activity_id)
-            # CalendarObjectId is optional in the P6 schema: an activity without one
-            # inherits the project's ActivityDefaultCalendarObjectId.
-            calendar_id = activity.findtext("pr:CalendarObjectId", namespaces=self.ns)
             self.activities[activity_id] = {
                 "Name": activity.find("pr:Name", self.ns).text,
                 "Identification": activity.find("pr:Id", self.ns).text,
@@ -186,7 +181,7 @@ class P62Ifc:
                 "FinishDate": datetime.datetime.fromisoformat(activity.find("pr:FinishDate", self.ns).text),
                 "PlannedDuration": activity.find("pr:PlannedDuration", self.ns).text,
                 "Status": activity.find("pr:Status", self.ns).text,
-                "CalendarObjectId": calendar_id or self.default_calendar_id,
+                "CalendarObjectId": activity.find("pr:CalendarObjectId", self.ns).text,
                 "ifc": None,
             }
 

src/ifc5d/ifc5d/csv2ifc.py

@@ -57,8 +57,7 @@ class CsvHeader(TypedDict):
 
     # Formula
     Formula: NotRequired[str]
-    # QuantityClass: NotRequired[str]
-
+    #QuantityClass: NotRequired[str]
 
 # Currently we assume that if column is not part of the main header,
 # then it is a cost value category. So here we list any additional column
@@ -82,11 +81,6 @@ MAIN_CSV_HEADER_COLUMNS.extend(
 )
 
 
-class CostRate(TypedDict):
-    Schedule: str | None
-    RateID: str | None
-
-
 class CostItem(TypedDict):
     children: list[CostItem]
     ifc: NotRequired[ifcopenshell.entity_instance]
@@ -102,10 +96,8 @@ class CostItem(TypedDict):
     Property: Union[str, None]
     Query: Union[str, None]
 
-    CostRate: CostRate | None
     Formula: Union[str, None]
-    # QuantityClass: Union[str, None]
-
+    #QuantityClass: Union[str, None]
 
 class Csv2Ifc:
     # Inputs.
@@ -245,7 +237,7 @@ class Csv2Ifc:
             cost_values = float(cost_values) if cost_values else None
 
         if self.has_rates:
-            cost_rate: CostRate = {
+            cost_rate = {
                 "Schedule": row[(self.headers["RateSchedule"])] if "RateSchedule" in self.headers else None,
                 "RateID": row[(self.headers["RateID"])] if "RateID" in self.headers else None,
             }
@@ -428,7 +420,7 @@ class Csv2Ifc:
                     products=results,
                     formula=cost_item["Formula"],
                     ifc_class=ifc_quantity_class,
-                )
+                    )
 
         self.create_cost_items(cost_item["children"], cost_item["ifc"])
 

src/ifc5d/ifc5d/ifc5Dspreadsheet.py

@@ -26,8 +26,7 @@ import logging
 import os
 import time
 from collections import Counter
-from typing import Optional, Union
-from typing_extensions import TypedDict
+from typing import Optional, TypedDict, Union
 
 import ifcopenshell
 import ifcopenshell.util.cost
@@ -36,7 +35,7 @@ import ifcopenshell.util.element
 import ifcopenshell.util.unit
 
 
-class CostItem(TypedDict, extra_items=float):
+class CostItem(TypedDict):
     # Exported columns.
     Index: int
     Hierarchy: str

src/ifc5d/pyproject.toml

@@ -17,7 +17,6 @@ classifiers = [
 ]
 dependencies = [
     "ifcopenshell",
-    "typing_extensions",
 ]
 
  [project.optional-dependencies] 

src/ifcclash/ifcclash/ifcclash.py

@@ -53,8 +53,6 @@ class ClashResult(TypedDict):
     p1: list[float]
     p2: list[float]
     distance: float
-    # Added by `Clasher.smart_group_clashes`.
-    smart_group: NotRequired[int]
 
 
 class ClashSet(TypedDict):
@@ -288,8 +286,7 @@ class Clasher:
 
             positions = []
             for clash in clashes.values():
-                # Midpoint of p1/p2 as an approximation of the clash location for clustering purposes.
-                positions.append([(a + b) / 2 for a, b in zip(clash["p1"], clash["p2"])])
+                positions.append(clash["position"])
 
             data = np.array(positions)
 

src/ifcconvert/IfcConvert.cpp

@@ -252,10 +252,6 @@ int main(int argc, char** argv) {
 		("stderr-progress", "output progress to stderr stream")
 		("yes,y", "answer 'yes' automatically to possible confirmation queries (e.g. overwriting an existing output file)")
 		("no-progress", "suppress possible progress bar type of prints that use carriage return")
-		("fail-on-error", "return a non-zero exit code when one or more errors were logged during "
-			"geometry conversion (e.g. an element failed to convert). By default IfcConvert exits "
-			"successfully as long as an output file could be written, even if some elements were "
-			"silently dropped. Enable this flag so scripts and CI can detect partial conversions.")
 		("log-format", po::value<std::string>(&log_format), "log format: plain or json")
 		("log-file", new po::typed_value<path_t, char_t>(&log_file), "redirect log output to file");
 
@@ -453,7 +449,6 @@ int main(int argc, char** argv) {
 
 	const bool mmap = vmap.count("mmap") != 0;
 	const bool no_progress = vmap.count("no-progress") != 0;
-	const bool fail_on_error = vmap.count("fail-on-error") != 0;
 	const bool quiet = vmap.count("quiet") != 0;
 	const bool stderr_progress = vmap.count("stderr-progress") != 0;
 
@@ -890,7 +885,6 @@ int main(int argc, char** argv) {
 	}
 
 	if (!serializer->ready()) {
-		logger.Error("SYS", 25, "Unable to open output file '" + IfcUtil::path::to_utf8(output_filename) + "' for writing; check that the directory exists and is writable");
 		IfcUtil::path::delete_file(IfcUtil::path::to_utf8(output_temp_filename));
 		write_log(!quiet);
 		return EXIT_FAILURE;
@@ -1226,11 +1220,6 @@ int main(int argc, char** argv) {
 		successful = false;
 	}
 
-	if (fail_on_error && logger.MaxSeverity() >= Logger::LOG_ERROR) {
-		logger.Error("SYS", 26, "Errors encountered during processing, failing due to --fail-on-error.");
-		successful = false;
-	}
-
 	if (logger.Verbosity() == Logger::LOG_PERF) {
 		logger.PrintPerformanceStats();
 	}

src/ifcdiff/ifcdiff.py

@@ -51,10 +51,8 @@ class IfcDiff:
 
     :param old: IFC file object for the old model
     :param new: IFC file object for the new model
-    :param relationships: List of relationships to check. None means that
-        attributes and geometry are compared, so changes such as a modified or
-        removed PredefinedType are reported. See RELATIONSHIP_TYPE for available
-        relationships.
+    :param relationships: List of relationships to check. None means that only
+        geometry is compared. See RELATIONSHIP_TYPE for available relationships.
     :param is_shallow: True if you want only the first difference to be listed.
         False if you want all differences to be checked. Choosing False means
         that comparisons will take longer.
@@ -88,7 +86,7 @@ class IfcDiff:
         self.new = new
         self.change_register = {}
         self.representation_ids = {}
-        self.relationships = relationships or ["attributes", "geometry"]
+        self.relationships = relationships or ["geometry"]
         self.precision = 1e-4
         self.is_shallow = is_shallow
         self.filter_elements = filter_elements
@@ -437,11 +435,7 @@ if __name__ == "__main__":
         "-r",
         "--relationships",
         type=str,
-        help=(
-            'A list of space-separated relationships, chosen from "attributes", "geometry", '
-            '"type", "property", "container", "aggregate", "classification". '
-            'Defaults to "attributes geometry" when omitted.'
-        ),
+        help='A list of space-separated relationships, chosen from "type", "property", "container", "aggregate", "classification"',
         default="",
     )
     args = parser.parse_args()

src/ifcdiff/test.py

@@ -77,23 +77,6 @@ class TestIfcDiff:
         assert ifc_diff.deleted_elements == set()
         assert ifc_diff.change_register == {wall.GlobalId: {"attributes_changed": True}}
 
-    def test_changed_predefined_type_is_caught_by_default(self):
-        # Regression test for #8214: a plain diff (no relationships specified)
-        # must report a modified or removed PredefinedType. Previously the
-        # default only compared geometry, so attribute-only edits were missed.
-        ifc_file = setup_project()
-        wall = ifcopenshell.api.root.create_entity(ifc_file, ifc_class="IfcWall", name="Foo")
-        wall.PredefinedType = "SOLIDWALL"
-
-        new_file = ifc_file.from_string(ifc_file.to_string())
-        new_file.by_id(wall.id()).PredefinedType = "NOTDEFINED"
-
-        ifc_diff = ifcdiff.IfcDiff(ifc_file, new_file)
-        ifc_diff.diff()
-        assert ifc_diff.added_elements == set()
-        assert ifc_diff.deleted_elements == set()
-        assert ifc_diff.change_register == {wall.GlobalId: {"attributes_changed": True}}
-
     def test_changed_geometry(self):
         ifc_file = setup_project()
         wall = ifcopenshell.api.root.create_entity(ifc_file, ifc_class="IfcWall", name="Foo")

src/ifcedit/README.md

@@ -258,7 +258,7 @@ ifcedit quantify run model.ifc IFC4QtoBaseQuantities -o model_qto.ifc
 
 Options:
 
-- `--selector <query>` -- ifcopenshell selector to restrict elements (default: all `IfcElement` and `IfcSpace`)
+- `--selector <query>` -- ifcopenshell selector to restrict elements (default: all `IfcElement`)
 - `-o, --output <path>` -- write to a different file instead of overwriting the input
 
 Note: `quantify run` writes geometry-based measurements and requires the

src/ifcedit/ifcedit/__main__.py

@@ -244,9 +244,7 @@ def main():
     qrun_parser = quantify_sub.add_parser("run", help="Run QTO on an IFC file")
     qrun_parser.add_argument("ifc_file", help="Path to the IFC file")
     qrun_parser.add_argument("rule_name", help="QTO rule name (e.g. IFC4QtoBaseQuantities)")
-    qrun_parser.add_argument(
-        "--selector", help="ifcopenshell selector to restrict elements (default: all IfcElement and IfcSpace)"
-    )
+    qrun_parser.add_argument("--selector", help="ifcopenshell selector to restrict elements (default: all IfcElement)")
     qrun_parser.add_argument("-o", "--output", help="Output file path (default: overwrite input)")
 
     args, extra = parser.parse_known_args()