Add tests for IfcGridAxis fixes

- Add test_create_axis_curve.py with three unit tests: basic
  polyline creation, safe removal of an unshared existing curve,
  and preservation of a shared curve when only one referencing
  axis is updated (regression for the shallow-copy duplication bug)
- Add feature scenario "Export IFC - with duplicate-of-duplicate
  grid axis locations preserved" to project.feature, reproducing
  the case where duplicates of duplicates lost their positions on
  save/reload

.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*
 

cmake/CMakeLists.txt

@@ -314,12 +314,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 +559,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 +571,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
     )

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

@@ -1,28 +0,0 @@
-<!-- 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/profile-length-per-instance.md

@@ -1,154 +0,0 @@
-<!-- This file was generated with the assistance of an AI coding tool. -->
-
-# Profile length per-instance — typed vs per-instance length for profile types
-
-> **Living dev note** for the `profile-length-per-instance` 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.
->
-> Tracks feature **#8657**; depends on bug fixes **#8655** (`change_data` None) and
-> **#8656** (mapped-profile assign cascade).
-
-## Problem
-
-Revit-exported profile members (e.g. curtain-wall mullions) come in **typed-length**:
-the extrusion — including its **length** — lives on the `IfcMemberType` as an
-`IfcRepresentationMap`, and every occurrence shares it via an `IfcMappedItem`. Bonsai's
-profile tools assume each occurrence owns an editable extrusion (`IfcMemberStandardCase`
-style), so on these mapped occurrences the length UI never appears, editing/joining
-crashes, changing the type-material bleeds across all instances, and `extend_profile`
-flips the origin.
-
-Goal: make **Length** a typed-vs-per-instance property of a profile type, toggle-able in
-both directions, without corrupting the shared geometry.
-
-- **Typed length** = geometry (incl. length) on the type's `RepresentationMap`;
-  occurrences `IfcMappedItem` it. One length for all instances.
-- **Per-instance length** = occurrence has its **own** `SweptSolid` body + its **own**
-  `IfcMaterialProfileSetUsage`. Each instance edits its own length (`IfcMemberStandardCase`).
-
-## Key facts established
-
-- **`tool.Model.get_usage_type(el)` returns `"PROFILE"` iff `el` carries an
-  `IfcMaterialProfileSet(Usage)`** (checked with `should_inherit=False`). Bonsai gates the
-  per-instance profile UI (Length control) on this. A mapped occurrence that only
-  *inherits* the type's profile set reports `None` → no Length UI. This is why un-mapping
-  must also give the occurrence its **own** `IfcMaterialProfileSetUsage`.
-- **The mapped representation is shared.** `bonsai.core.geometry.remove_representation`,
-  when handed a mapped rep, resolves it and loops `get_elements_of_type` →
-  `switch_from_representation`, i.e. it **cascades to every sibling instance of the type**,
-  leaving them empty. Any code that removes an occurrence's mapped body triggers this. This
-  is the single biggest hazard and the root of most crashes we saw.
-- **Typed length is spec-valid.** A plain `IfcMember` with a mapped body + a profile-set
-  usage is valid IFC (just not the `IfcMemberStandardCase` subtype). `IfcMaterialProfileSet`
-  has **no length**; length is always in the geometry. So offering typed length is a
-  legitimate mode, not a workaround (verified against local IFC4 ADD2 TC1).
-- **Two origins, on opposite ends.** Revit places the object's `ObjectPlacement` origin at
-  one end of the mullion and the extrusion's own `Position` origin at the other, with the
-  object's local **+Z pointing away** from the sweep (local Z runs `-depth → 0`).
-  `get_profile_axis` (object bound-box local-Z range) + `DumbProfileJoiner.recreate_profile`
-  (which plants the new origin at `body[0]` = min-local-Z) then relocate the origin to the
-  far end on extend/join — the "flip". Natively-authored profiles run local Z `0 → depth`,
-  so `body[0]` is already the origin and nothing moves.
-- **`create_profile` double-bodies mapped types.** `assign_type` (default
-  `should_map_representations=True`) maps the type's shared body onto a new occurrence, then
-  `DumbProfileGenerator.create_profile` adds a per-instance extrusion on top → two Body reps
-  / typed-by-default.
-- The wrapper/core were **not** the cause of the crashes we chased for a while — a
-  `git reset --hard v0.8.0` reproduced clean, our applied changes reproduced the crash. The
-  installed environment is now matched (repo source + release wrapper `3e7b739`, via
-  `dev_environment.py`).
-
-## Design
-
-Two explicit operators + a Type-panel toggle, plus defaults/guards so the mapped hazard is
-never hit implicitly.
-
-- **`bim.make_profile_length_per_instance`** (un-map; `MakeProfileLengthPerInstance`):
-  1. Copy the mapped extrusion items into a new per-instance `SweptSolid` body, **keeping
-     the shared `IfcProfileDef`** (`copy_deep(..., exclude=["IfcProfileDef"])`).
-  2. **Orphan** the old mapped body (retarget the product shape, do **not** delete it) —
-     deleting cascades to siblings, and the raw delete dangles Bonsai's Blender-side links.
-  3. Give the occurrence its **own** `IfcMaterialProfileSetUsage` (else no Length UI).
-  4. **Normalize placement**: if the object's local +Z points away from the sweep (origin at
-     the max-local-Z end), flip 180° about local X and rebuild the extrusion via
-     `add_profile_representation` so local Z runs `0 → depth` from the (unchanged) origin.
-     This is what stops `extend_profile` flipping the origin.
-  - Idempotent / repair-capable: re-running adds a missing usage to an already-un-mapped
-    occurrence. Only identity mapping transforms are handled (others are skipped).
-- **`bim.make_profile_length_type_driven`** (re-map; `MakeProfileLengthTypeDriven`):
-  drop the occurrence's own usage, then `ifcopenshell.api.type.map_type_representations` to
-  map the type's shared geometry back on. If the type has **no** `RepresentationMap`
-  (Bonsai-authored profile type), first **promote** a copy of the occurrence's body onto the
-  type as a `RepresentationMap` (so the first toggled occurrence defines the type's length;
-  siblings snap to it).
-- **UI toggle** (`type/ui.py` `draw_product_ui`, `type/data.py`, `type/prop.py`): a single
-  **Per-instance Length** checkbox. Backed by a `get`/`set` `BoolProperty`
-  (`length_per_instance`) — `get` reads the current mode from cached `TypeData` flags
-  (`is_typed_length_profile` / `can_make_length_type_driven`), `set` runs the matching
-  operator. No stored state to desync.
-- **New occurrences default to per-instance** (`DumbProfileGenerator.create_profile`): after
-  `assign_type`, drop the inherited mapped reps so only the per-instance extrusion remains.
-  No-op for types without a `RepresentationMap`.
-- **`recreate_profile` mapped guard** (`DumbProfileJoiner.recreate_profile`): if the body is
-  mapped, **skip** the per-instance rebuild (leaving typed geometry alone — a length-driven
-  type should stay typed) **but `switch_representation` to reload** so the Blender mesh
-  reflects a just-mapped type's geometry. This kills the "assign a length-driven type ⇒
-  Failed to set value + sibling turns empty" cascade *and* keeps the typed display fresh.
-  Fixes issue **#8656**.
-- **`assign_type` preserves per-instance** (`core/type.py`): if the occurrence is already
-  per-instance (own non-mapped body + own profile usage), pass
-  `should_map_representations=False` so reassigning a type keeps its own geometry/length
-  instead of converting it to typed.
-- **…but that flag gates the material usage too** (`core/type.py`): in `api type.assign_type`
-  the `map_material_usages` call sits *inside* the same `if should_map_representations:`
-  block. Suppressing the mapping therefore also suppressed the step that re-points the
-  occurrence's `IfcMaterialProfileSetUsage` at the new type's set, leaving a usage whose
-  `ForProfileSet` still referenced the **old** type. `get_material(should_skip_usage=True)`
-  follows that pointer, so the material panel showed — and edited — the old type's profile:
-  duplicate a profile type, change the copy's profile, and the *original's* profile was
-  rewritten instead, taking every other occurrence of the original with it. This is the
-  "revisit if reassigning across different profiles" caveat that used to sit here, and it
-  bit in the wild.
-  Fixed by re-pointing the usage in `core/type.py` immediately after the `ifc.run`. Reuse
-  `material.assign_material` rather than setting `ForProfileSet` by hand: its
-  `update_representation_profile` rewrites `SweptArea` to the new type's profile but never
-  touches the extrusion depth, so the per-instance length this whole branch exists to
-  protect still survives. `restore_material_usage_attributes` runs after it and lands on the
-  new usage. Covered by `test/bim/module/type/test_assign_type_material_usage.py`.
-
-## Supporting bug fixes (separate from the feature)
-
-- **`tool/geometry.py` `change_data`** — guard `has_data_users`/`delete_data` against a
-  `None` `old_data` (empty→mesh reload path). Real Bonsai bug, exposed by the re-map reload;
-  filed as **#8655** — worth its own commit.
-- **`ifcopenshell/util/placement.py` `get_axis2placement`** — numpy-2.x `x.resize(3)` fix
-  for 2D `RefDirection`. **Duplicate of open PRs #8307 / #8586** — kept locally only so
-  profile editing works during testing; **do not commit**, drop when #8307 merges.
-
-## Dead ends (ruled out)
-
-- Auto-un-mapping during `type.assign_type`/`regenerate_profile` → sibling cascade. Un-map
-  is an **explicit** action only.
-- Deriving depth from `obj.bound_box` for un-map → unreliable when several instances share a
-  Blender mesh; use the copied extrusion / native rebuild instead.
-- Blaming the compiled wrapper / core (`3e7b739`) for the profile crashes — it was our code.
-
-## Test checklist / what's left before merge
-
-- [ ] **Strip debug prints**: `make_length_per_instance` / `make_length_type_driven`,
-      `DumbProfileJoiner.recreate_profile` + `get_profile_axis`, and `core/type.py`
-      `assign_type`.
-- [ ] Un-map a mullion → own length, Length UI, geometry unchanged, siblings untouched.
-- [ ] `extend_profile('T')` on an un-mapped mullion → origin **stays** (no flip).
-- [ ] Toggle checkbox both ways → round-trips; typed snaps to type length.
-- [ ] New occurrence of a mapped type → defaults to per-instance.
-- [ ] Assign a length-driven type to a **typed** occurrence → adopts type length, no cascade.
-- [ ] Assign another type to a **per-instance** occurrence → stays per-instance, keeps length.
-- [x] Reassigning across types with **different** profiles — was broken (the occurrence's
-      usage kept the old type's profile set, so editing it mutated the old type). Fixed in
-      `core/type.py`; covered by `test_assign_type_material_usage.py`.
-- [ ] Edge cases untested: non-identity mapping transforms; non-centroid cardinal point vs
-      the 180° flip.
-- [ ] Commit layout: feature on `1c421d0`; separate `change_data` fix; exclude `placement.py`.

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/export_ifc.py

@@ -120,10 +120,10 @@ class IfcExporter:
                 # updata_representation will run edit_object_placement if object is scaled
                 # and had no openings.
                 return element
-        if not tool.Ifc.is_moved(obj):
-            return
         if element.is_a("IfcGridAxis"):
             return self.sync_grid_axis_object_placement(obj, element)
+        if not tool.Ifc.is_moved(obj):
+            return
         if not hasattr(element, "ObjectPlacement"):
             return
         bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
@@ -134,7 +134,8 @@ class IfcExporter:
         grid_obj = tool.Ifc.get_object(grid)
         if grid_obj:
             self.sync_object_placement(grid_obj)
-            if grid_obj.matrix_world != obj.matrix_world:
+            matrices_differ = grid_obj.matrix_world != obj.matrix_world
+            if matrices_differ:
                 bpy.ops.bim.update_representation(obj=obj.name)
         tool.Geometry.record_object_position(obj)
 

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/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

@@ -1706,12 +1706,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 +2343,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 +2365,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 +2389,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 +2486,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 +3548,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/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

@@ -151,8 +151,6 @@ classes = (
     profile.EditExtrusionAxis,
     profile.EnableEditingExtrusionAxis,
     profile.ExtendProfile,
-    profile.MakeProfileLengthPerInstance,
-    profile.MakeProfileLengthTypeDriven,
     profile.RecalculateProfile,
     profile.Rotate90,
     profile.PatchNonParametricMepSegment,

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

@@ -21,10 +21,8 @@ from math import atan2, degrees, pi, radians
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 import bpy
-import numpy as np
 import ifcopenshell
 import ifcopenshell.api.geometry
-import ifcopenshell.api.material
 import ifcopenshell.api.pset
 import ifcopenshell.api.type
 import ifcopenshell.util.element
@@ -144,17 +142,6 @@ class DumbProfileGenerator:
         material = ifcopenshell.util.element.get_material(element)
         material.CardinalPoint = self.cardinal_point
 
-        # assign_type maps the type's shared geometry onto the occurrence when the type has a
-        # RepresentationMap (e.g. Revit-exported profiles). We build a per-instance extrusion below,
-        # so drop those inherited mapped representations first -- new occurrences then default to
-        # per-instance (editable) length. The IfcMaterialProfileSetUsage assign_type created is kept.
-        if element.Representation:
-            for representation in list(element.Representation.Representations):
-                ifcopenshell.api.geometry.unassign_representation(
-                    tool.Ifc.get(), product=element, representation=representation
-                )
-                ifcopenshell.api.geometry.remove_representation(tool.Ifc.get(), representation=representation)
-
         obj.matrix_world = matrix_world
         bpy.context.view_layer.update()
         bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
@@ -456,21 +443,6 @@ class DumbProfileJoiner:
         self.recreate_profile(element2, profile2, axis2, axis2)
 
     def recreate_profile(self, element: ifcopenshell.entity_instance, obj: bpy.types.Object, axis=None, body=None):
-        _body_rep = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        _mapped = bool(_body_rep and any(i.is_a("IfcMappedItem") for i in (_body_rep.Items or [])))
-        # A mapped/shared body means this occurrence is typed-length (its geometry is driven by the
-        # type's RepresentationMap). Regenerating a per-instance profile here would remove the shared
-        # mapped body, which cascades to every sibling instance of the type (leaving them empty) and
-        # surfaces as a generic "Failed to set value". Leave typed geometry alone; converting to
-        # per-instance is an explicit action (bim.make_profile_length_per_instance).
-        if _mapped:
-            # The mapped body may have just changed (e.g. assign_type mapped a new type's geometry),
-            # but the Blender mesh is stale. Reload it so the display matches the typed geometry
-            # instead of skipping silently.
-            bonsai.core.geometry.switch_representation(
-                tool.Ifc, tool.Geometry, obj=obj, representation=_body_rep, apply_openings=True
-            )
-            return
         if axis is None or body is None:
             axis = body = self.get_profile_axis(obj)
         self.axis = copy.deepcopy(axis)
@@ -879,11 +851,10 @@ class DumbProfileJoiner:
 
     def get_profile_axis(self, obj: bpy.types.Object) -> list[Vector]:
         z_values = [v[2] for v in obj.bound_box]
-        axis = [
+        return [
             (obj.matrix_world @ Vector((0.0, 0.0, min(z_values)))),
             (obj.matrix_world @ Vector((0.0, 0.0, max(z_values)))),
         ]
-        return axis
 
 
 class RecalculateProfile(bpy.types.Operator, tool.Ifc.Operator):
@@ -900,196 +871,6 @@ class RecalculateProfile(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class MakeProfileLengthPerInstance(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.make_profile_length_per_instance"
-    bl_label = "Make Profile Length Per Instance"
-    bl_description = (
-        "Un-map typed/shared profile geometry so each selected occurrence gets its own body "
-        "(the extrusion length lives on the instance instead of being typed/shared via a "
-        "RepresentationMap). Geometry is preserved exactly and sibling instances are left untouched"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        return bool(context.selected_objects)
-
-    def _execute(self, context):
-        ifc_file = tool.Ifc.get()
-        unmapped = 0
-        for obj in context.selected_objects:
-            element = tool.Ifc.get_entity(obj)
-            if not element:
-                continue
-            if self.unmap_element_body(ifc_file, element, obj):
-                unmapped += 1
-        self.report({"INFO"}, f"Length made per-instance for {unmapped} object(s)")
-        return {"FINISHED"}
-
-    def unmap_element_body(
-        self, ifc_file: ifcopenshell.file, element: ifcopenshell.entity_instance, obj: bpy.types.Object
-    ) -> bool:
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        if not body:
-            return False
-
-        changed = False
-
-        # (1) Un-map the body if it is a shared/mapped representation.
-        mapped_items = [i for i in (body.Items or []) if i.is_a("IfcMappedItem")]
-        if mapped_items:
-            # Only identity mapping transforms are handled; refuse rather than move geometry.
-            for mi in mapped_items:
-                if not np.allclose(ifcopenshell.util.placement.get_mappeditem_transformation(mi), np.eye(4)):
-                    return False
-
-            # Give this object its own mesh so sibling instances (sharing the mapped mesh) are not disturbed.
-            if obj.data is not None and obj.data.users > 1:
-                obj.data = obj.data.copy()
-
-            # Per-instance copy of the mapped geometry items, keeping the shared IfcProfileDef.
-            new_items = []
-            for mi in mapped_items:
-                for src_item in (mi.MappingSource.MappedRepresentation.Items or []):
-                    new_items.append(ifcopenshell.util.element.copy_deep(ifc_file, src_item, exclude=["IfcProfileDef"]))
-
-            # New per-instance SweptSolid body replacing the mapped wrapper; retarget the product shape to it.
-            # The old mapped IfcShapeRepresentation is left as a harmless orphan (purgeable later) rather than
-            # deleted -- deleting it would either cascade to siblings (via the shared RepresentationMap) or
-            # leave Bonsai's Blender-side links dangling.
-            new_body = ifcopenshell.util.element.copy(ifc_file, body)
-            new_body.Items = new_items
-            new_body.RepresentationType = "SweptSolid"
-            for inverse in ifc_file.get_inverse(body):
-                ifcopenshell.util.element.replace_attribute(inverse, body, new_body)
-            bonsai.core.geometry.switch_representation(
-                tool.Ifc, tool.Geometry, obj=obj, representation=new_body, apply_openings=True
-            )
-            changed = True
-
-        # (2) Give the occurrence its OWN IfcMaterialProfileSetUsage if it only inherits one. Bonsai gates the
-        # per-instance profile-editing UI on get_usage_type(should_inherit=False) == "PROFILE", so an occurrence
-        # that merely inherits the type's IfcMaterialProfileSet never shows the Length control. This runs even
-        # when the body was already un-mapped, so re-running repairs earlier partial conversions.
-        if not ifcopenshell.util.element.get_material(element, should_inherit=False):
-            profile_set = ifcopenshell.util.element.get_material(element, should_inherit=True)
-            if profile_set and profile_set.is_a("IfcMaterialProfileSet"):
-                usage = ifcopenshell.api.material.assign_material(
-                    ifc_file, products=[element], type="IfcMaterialProfileSetUsage", material=profile_set
-                )
-                usage = usage[0] if isinstance(usage, (list, tuple)) else usage
-                if usage is not None and usage.is_a("IfcMaterialProfileSetUsage"):
-                    usage.CardinalPoint = 5  # geometric centroid (Bonsai default)
-                changed = True
-
-        # (3) Normalize a freshly un-mapped body to Bonsai's native profile convention. The copied Revit
-        # extrusion can leave the object's local +Z pointing AWAY from the extrusion (geometry in local
-        # -Z, origin at the far end). get_profile_axis/recreate_profile then plant the origin at the
-        # min-local-Z end, so extend/join relocate ("flip") the origin. Detect that case, flip the
-        # object 180deg about local X so local +Z runs along the axis (origin unchanged), and rebuild a
-        # native 0 -> depth extrusion. Only touches the just-un-mapped (per-instance, non-cascading) body.
-        if mapped_items:
-            z_vals = [v[2] for v in obj.bound_box]
-            length = (max(z_vals) - min(z_vals)) if z_vals else 0.0
-            if length > 1e-6 and abs(max(z_vals)) <= abs(min(z_vals)):
-                usage = ifcopenshell.util.element.get_material(element, should_inherit=False)
-                profile_set = usage.ForProfileSet if usage and usage.is_a("IfcMaterialProfileSetUsage") else None
-                profile = (profile_set.CompositeProfile or profile_set.MaterialProfiles[0].Profile) if profile_set else None
-                body_context = ifcopenshell.util.representation.get_context(ifc_file, "Model", "Body", "MODEL_VIEW")
-                if profile and body_context:
-                    obj.matrix_world = obj.matrix_world @ Matrix.Rotation(pi, 4, "X")
-                    bpy.context.view_layer.update()
-                    bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
-                    native_body = ifcopenshell.api.geometry.add_profile_representation(
-                        ifc_file,
-                        context=body_context,
-                        profile=profile,
-                        depth=length,
-                        cardinal_point=(usage.CardinalPoint or 5),
-                    )
-                    old_body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-                    for inverse in ifc_file.get_inverse(old_body):
-                        ifcopenshell.util.element.replace_attribute(inverse, old_body, native_body)
-                    ifcopenshell.api.geometry.remove_representation(ifc_file, old_body)
-                    bonsai.core.geometry.switch_representation(
-                        tool.Ifc, tool.Geometry, obj=obj, representation=native_body, apply_openings=True
-                    )
-
-        return changed
-
-
-class MakeProfileLengthTypeDriven(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.make_profile_length_type_driven"
-    bl_label = "Make Profile Length Type Driven"
-    bl_description = (
-        "Re-map selected profile occurrences onto their type's shared representation so the extrusion "
-        "length is driven by the type again (typed length). The per-instance length is discarded and "
-        "the occurrence snaps to the type's length. This is the inverse of 'Make Length Per-Instance'"
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        return bool(context.selected_objects)
-
-    def _execute(self, context):
-        ifc_file = tool.Ifc.get()
-        remapped = 0
-        for obj in context.selected_objects:
-            element = tool.Ifc.get_entity(obj)
-            if not element:
-                continue
-            if self.remap_element_body(ifc_file, element, obj):
-                remapped += 1
-        self.report({"INFO"}, f"Length made type-driven for {remapped} object(s)")
-        return {"FINISHED"}
-
-    def remap_element_body(
-        self, ifc_file: ifcopenshell.file, element: ifcopenshell.entity_instance, obj: bpy.types.Object
-    ) -> bool:
-        element_type = ifcopenshell.util.element.get_type(element)
-        if not element_type:
-            return False
-
-        # Ensure the type carries a body representation to drive the length. If it has none (e.g. a
-        # Bonsai-authored profile type, where occurrences carry their own geometry), promote a copy of
-        # this occurrence's current body onto the type. Siblings toggled later snap to this length.
-        if not getattr(element_type, "RepresentationMaps", None):
-            body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-            if not body:
-                return False
-            template = ifcopenshell.util.element.copy_deep(
-                ifc_file, body, exclude=["IfcProfileDef", "IfcGeometricRepresentationContext"]
-            )
-            origin = ifc_file.create_entity(
-                "IfcAxis2Placement3D",
-                Location=ifc_file.create_entity("IfcCartesianPoint", Coordinates=(0.0, 0.0, 0.0)),
-            )
-            rep_map = ifc_file.create_entity(
-                "IfcRepresentationMap", MappingOrigin=origin, MappedRepresentation=template
-            )
-            element_type.RepresentationMaps = list(element_type.RepresentationMaps or []) + [rep_map]
-
-
-        # Drop the occurrence's own material association so it inherits the type's IfcMaterialProfileSet again.
-        if ifcopenshell.util.element.get_material(element, should_inherit=False):
-            ifcopenshell.api.material.unassign_material(ifc_file, products=[element])
-
-        # Replace the occurrence's per-instance representation(s) with mapped items pointing at the type's
-        # RepresentationMaps (this removes the per-instance body and maps the shared/typed geometry).
-        ifcopenshell.api.type.map_type_representations(
-            ifc_file, related_object=element, relating_type=element_type
-        )
-
-        # Reload the object's geometry from the (now mapped) body representation.
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        if body:
-            bonsai.core.geometry.switch_representation(
-                tool.Ifc, tool.Geometry, obj=obj, representation=body, apply_openings=True
-            )
-        return True
-
-
 class DumbProfileRecalculator:
     def recalculate(self, profiles):
         "`profiles` is a list of blender profile objects"

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

@@ -985,10 +985,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 +995,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 +1041,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 +1136,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 +1149,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)
 
@@ -1980,7 +1947,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 +2007,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 +2069,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 +2103,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 +2111,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/spatial/prop.py

@@ -128,7 +128,7 @@ def update_grid_is_locked(self: "BIMGridProperties", context: bpy.types.Context)
     if tool.Ifc.get().schema in ("IFC2X3", "IFC4"):
         elements = tool.Ifc.get().by_type("IfcGrid") + tool.Ifc.get().by_type("IfcGridAxis")
     else:
-        elements = tool.Ifc.get().by_type("IfcPositioningElement")
+        elements = tool.Ifc.get().by_type("IfcPositioningElement") + tool.Ifc.get().by_type("IfcGridAxis")
     for element in elements:
         if obj := tool.Ifc.get_object(element):
             if self.is_locked:

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/data.py

@@ -18,7 +18,6 @@
 
 import bpy
 import ifcopenshell.util.element
-import ifcopenshell.util.representation
 import ifcopenshell.util.type
 from ifcopenshell.util.doc import get_entity_doc
 
@@ -45,47 +44,9 @@ class TypeData:
                 "total_instances": cls.total_instances(),
                 "relating_type": cls.relating_type(),
                 "relating_type_attributes": cls.relating_type_attributes(),
-                "is_typed_length_profile": cls.is_typed_length_profile(),
-                "can_make_length_type_driven": cls.can_make_length_type_driven(),
             }
         )
 
-    @classmethod
-    def can_make_length_type_driven(cls):
-        """True if the active occurrence is a per-instance profile (its own body + usage) that has a
-        type, so its length can be re-driven by the type. If the type has no shared representation
-        yet, the conversion promotes this occurrence's body onto the type."""
-        if not (obj := bpy.context.active_object):
-            return False
-        element = tool.Ifc.get_entity(obj)
-        if not element or not element.is_a("IfcProduct"):
-            return False
-        own_material = ifcopenshell.util.element.get_material(element, should_inherit=False)
-        if not (own_material and "Profile" in own_material.is_a()):
-            return False
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        if body and any(i.is_a("IfcMappedItem") for i in (body.Items or [])):
-            return False  # already mapped/typed
-        return bool(ifcopenshell.util.element.get_type(element))
-
-    @classmethod
-    def is_typed_length_profile(cls):
-        """True if the active occurrence is a profile-based element whose length is 'typed'/shared
-        (its body is a mapped/shared representation and/or it only inherits the type's material
-        profile set), so it could be converted to per-instance editable length."""
-        if not (obj := bpy.context.active_object):
-            return False
-        element = tool.Ifc.get_entity(obj)
-        if not element or not element.is_a("IfcProduct"):
-            return False
-        material = ifcopenshell.util.element.get_material(element, should_inherit=True)
-        if not (material and "Profile" in material.is_a()):  # IfcMaterialProfileSet(Usage)
-            return False
-        has_own_usage = bool(ifcopenshell.util.element.get_material(element, should_inherit=False))
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        body_is_mapped = bool(body and any(i.is_a("IfcMappedItem") for i in (body.Items or [])))
-        return (not has_own_usage) or body_is_mapped
-
     @classmethod
     def relating_type_classes(cls):
         results = []

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

@@ -45,22 +45,6 @@ def get_relating_type(self: "BIMTypeProperties", context: bpy.types.Context) ->
     return TypeData.data["relating_types"]
 
 
-def get_length_per_instance(self: "BIMTypeProperties") -> bool:
-    # Reflect the current IFC state (per-instance vs typed length) so the checkbox has no stored
-    # state to keep in sync. TypeData caches the flag; the panel loads it before drawing.
-    if not TypeData.is_loaded:
-        TypeData.load()
-    return bool(TypeData.data.get("can_make_length_type_driven"))
-
-
-def set_length_per_instance(self: "BIMTypeProperties", value: bool) -> None:
-    # Ticking the box makes the length per-instance; unticking re-maps it back to the type.
-    if value:
-        bpy.ops.bim.make_profile_length_per_instance()
-    else:
-        bpy.ops.bim.make_profile_length_type_driven()
-
-
 def update_relating_type_class(self: "BIMTypeProperties", context: bpy.types.Context) -> None:
     TypeData.is_loaded = False
 
@@ -106,15 +90,6 @@ class BIMTypeProperties(PropertyGroup):
     )
     is_editing_type_attributes: BoolProperty(name="Is Editing Type Attributes")
     type_attributes: CollectionProperty(type=Attribute, name="Type Attributes")
-    length_per_instance: BoolProperty(
-        name="Per-instance Length",
-        description=(
-            "Ticked: this profile occurrence has its own editable extrusion length. "
-            "Unticked: the length is typed/shared (driven by the type's representation)"
-        ),
-        get=get_length_per_instance,
-        set=set_length_per_instance,
-    )
 
     if TYPE_CHECKING:
         is_editing_type: bool
@@ -123,4 +98,3 @@ class BIMTypeProperties(PropertyGroup):
         relating_type_object: Union[bpy.types.Object, None]
         is_editing_type_attributes: bool
         type_attributes: bpy.types.bpy_prop_collection_idprop[Attribute]
-        length_per_instance: bool

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

@@ -107,11 +107,6 @@ class BIM_PT_type(Panel):
                 row.label(text="No Relating Type")
                 row.operator("bim.enable_editing_type", icon="GREASEPENCIL", text="")
 
-        # Length checkbox: ticked = per-instance editable length, unticked = typed/shared length.
-        # The checkbox state is read from the IFC (get/set property); ticking runs the conversion.
-        if TypeData.data.get("is_typed_length_profile") or TypeData.data.get("can_make_length_type_driven"):
-            layout.row(align=True).prop(props, "length_per_instance", text="Per-instance Length")
-
 
 class BIM_PT_type_attributes(Panel):
     bl_label = "Type Attributes"

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

@@ -303,7 +303,17 @@ def add_drawing(
         ifc_representation_class=None,
     )
 
-    drawings_parent_group = drawing.ensure_drawings_parent_group()
+    drawings_parent_group = None
+    for group in ifc.get().by_type("IfcGroup"):
+        if group.Name == "DRAWINGS" and group.ObjectType == "DRAWINGS":
+            drawings_parent_group = group
+            break
+
+    if not drawings_parent_group:
+        drawings_parent_group = ifc.run("group.add_group")
+        ifc.run(
+            "group.edit_group", group=drawings_parent_group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"}
+        )
 
     group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
@@ -342,7 +352,19 @@ def add_drawing(
     )
     drawing.setup_shading_styles_path(shading_styles_path)
 
-    drawings_parent_document = drawing.ensure_drawings_parent_document()
+    drawings_parent_document = None
+    for document in ifc.get().by_type("IfcDocumentInformation"):
+        if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
+            drawings_parent_document = document
+            break
+
+    if not drawings_parent_document:
+        drawings_parent_document = ifc.run("document.add_information")
+        if ifc.get_schema() == "IFC2X3":
+            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
+        else:
+            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
+        ifc.run("document.edit_information", information=drawings_parent_document, attributes=attributes)
 
     information = ifc.run("document.add_information", parent=drawings_parent_document)
     uri = drawing.get_default_drawing_path(drawing_name)
@@ -373,7 +395,17 @@ def duplicate_drawing(
     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()
+    drawings_parent_group = None
+    for parent_group in ifc.get().by_type("IfcGroup"):
+        if parent_group.Name == "DRAWINGS" and parent_group.ObjectType == "DRAWINGS":
+            drawings_parent_group = parent_group
+            break
+
+    if not drawings_parent_group:
+        drawings_parent_group = ifc.run("group.add_group")
+        ifc.run(
+            "group.edit_group", group=drawings_parent_group, attributes={"Name": "DRAWINGS", "ObjectType": "DRAWINGS"}
+        )
 
     new_group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=new_group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
@@ -394,7 +426,19 @@ 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()
+    drawings_parent_document = None
+    for document in ifc.get().by_type("IfcDocumentInformation"):
+        if document.Name == "DRAWINGS" and document.Scope == "DRAWINGS":
+            drawings_parent_document = document
+            break
+
+    if not drawings_parent_document:
+        drawings_parent_document = ifc.run("document.add_information")
+        if ifc.get_schema() == "IFC2X3":
+            attributes = {"DocumentId": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
+        else:
+            attributes = {"Identification": "DRAWINGS", "Name": "DRAWINGS", "Scope": "DRAWINGS"}
+        ifc.run("document.edit_information", information=drawings_parent_document, attributes=attributes)
 
     information = ifc.run("document.add_information", parent=drawings_parent_document)
     uri = drawing_tool.get_default_drawing_path(drawing_name)
@@ -582,7 +626,8 @@ def sync_references(
 
     for reference_element in potential_reference_elements:
         if not drawing_tool.get_drawing_reference_annotation(drawing, reference_element):
-            if annotation := drawing_tool.generate_reference_annotation(drawing, reference_element, context):
+            annotation = drawing_tool.generate_reference_annotation(drawing, reference_element, context)
+            if annotation:
                 ifc.run("drawing.assign_product", relating_product=reference_element, related_object=annotation)
                 ifc.run("group.assign_group", group=group, products=[annotation])
                 collector.assign(ifc.get_object(annotation))

src/bonsai/bonsai/core/product.py

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

src/bonsai/bonsai/core/tool.py

@@ -254,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
@@ -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/core/type.py

@@ -33,41 +33,8 @@ def assign_type(
     element: ifcopenshell.entity_instance,
     type: ifcopenshell.entity_instance,
 ) -> None:
-    import ifcopenshell.util.element
-    import ifcopenshell.util.representation
-
-    # A per-instance profile occurrence (its own non-mapped body + own profile usage) should keep its
-    # own geometry/length when reassigned to another type. Mapping the new type's shared representation
-    # over it (the default) would convert it to typed/length-driven. Detect this and skip the mapping.
-    def _is_per_instance_profile(el: ifcopenshell.entity_instance) -> bool:
-        mat = ifcopenshell.util.element.get_material(el, should_inherit=False)
-        if not (mat and "Profile" in mat.is_a()):
-            return False
-        body = ifcopenshell.util.representation.get_representation(el, "Model", "Body", "MODEL_VIEW")
-        return bool(body) and not any(i.is_a("IfcMappedItem") for i in (body.Items or []))
-
-    should_map = not _is_per_instance_profile(element)
     usage_attributes = type_tool.record_material_usage_attributes(element)
-    ifc.run(
-        "type.assign_type",
-        related_objects=[element],
-        relating_type=type,
-        should_map_representations=should_map,
-    )
-    if not should_map:
-        # should_map_representations=False also suppresses api type.assign_type's
-        # map_material_usages, which is what re-points an occurrence's usage at the new type's
-        # material set. Skipping it leaves the occurrence's IfcMaterialProfileSetUsage pointing
-        # at the OLD type's set, so the material panel then edits the old type's profile and
-        # every other occurrence of that type moves with it. Re-point it here instead: this
-        # rewrites SweptArea to the new type's profile but leaves the extrusion depth alone,
-        # so the per-instance length this branch exists to protect still survives.
-        type_material = ifcopenshell.util.element.get_material(type)
-        if type_material and (material_class := type_material.is_a()) in (
-            "IfcMaterialLayerSet",
-            "IfcMaterialProfileSet",
-        ):
-            ifc.run("material.assign_material", products=[element], type=f"{material_class}Usage")
+    ifc.run("type.assign_type", related_objects=[element], relating_type=type)
     obj = ifc.get_object(element)
     if (usage := model.get_usage_type(type)) and usage_attributes:
         type_tool.restore_material_usage_attributes(element, usage_attributes)

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/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/collector.py

@@ -120,7 +120,8 @@ class Collector(bonsai.core.tool.Collector):
                 project_obj = tool.Ifc.get_object(tool.Ifc.get().by_type("IfcProject")[0])
                 cls.link_collection_child_safe(tool.Blender.get_object_bim_props(project_obj).collection, collection)
         elif element.is_a("IfcAnnotation") and (drawing_obj := cls.get_annotation_drawing_obj(element)):
-            cls.link_collection_object_safe(tool.Blender.get_object_bim_props(drawing_obj).collection, obj)
+            target_collection = tool.Blender.get_object_bim_props(drawing_obj).collection
+            cls.link_collection_object_safe(target_collection, obj)
         elif container := ifcopenshell.util.element.get_container(element):
             while container.is_a("IfcSpace"):
                 container = ifcopenshell.util.element.get_aggregate(container)

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
@@ -1974,19 +1953,29 @@ class Drawing(bonsai.core.tool.Drawing):
         if camera.data.type != "ORTHO":
             return
 
-        settings = ifcopenshell.geom.settings()
-        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
-        geometry = ifcopenshell.geom.create_shape(settings, axis.AxisCurve)
-        verts = ifcopenshell.util.shape.get_vertices(geometry)
         grid = (axis.PartOfU or axis.PartOfV or axis.PartOfW)[0]
-        m = ifcopenshell.util.placement.get_local_placement(grid.ObjectPlacement)
+        axis_obj = tool.Ifc.get_object(axis)
+        if axis_obj and axis_obj.data and len(axis_obj.data.vertices) >= 2:
+            m = np.array(axis_obj.matrix_world)
+            verts = [np.array(v.co) for v in axis_obj.data.vertices[:2]]
+        else:
+            settings = ifcopenshell.geom.settings()
+            settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
+            geometry = ifcopenshell.geom.create_shape(settings, axis.AxisCurve)
+            verts = list(ifcopenshell.util.shape.get_vertices(geometry)[:2])
+            grid_obj = tool.Ifc.get_object(grid)
+            if grid_obj:
+                m = np.array(grid_obj.matrix_world)
+            else:
+                m = ifcopenshell.util.placement.get_local_placement(grid.ObjectPlacement)
         im = camera.matrix_world.inverted()
-        v1, v2 = [im @ Vector((m @ np.append(v, 1.0))[:3]) for v in verts[:2]]
+        v1, v2 = [im @ Vector((m @ np.append(v[:3], 1.0))[:3]) for v in verts]
 
         target_view = tool.Drawing.get_drawing_target_view(drawing)
         if target_view in ("PLAN_VIEW", "REFLECTED_PLAN_VIEW"):
             bounds = helper.ortho_view_frame(camera.data)
-            if not (points := helper.clip_segment(bounds, [v1, v2])):
+            points = helper.clip_segment(bounds, [v1, v2])
+            if not points:
                 return
         elif target_view in ("ELEVATION_VIEW", "SECTION_VIEW"):
             bounds = helper.ortho_view_frame(camera.data)
@@ -2204,6 +2193,7 @@ class Drawing(bonsai.core.tool.Drawing):
     def sync_object_placement(cls, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
         blender_matrix = np.array(obj.matrix_world)
         element = tool.Ifc.get_entity(obj)
+        is_moved = tool.Ifc.is_moved(obj)
         if tool.Geometry.is_scaled(obj):
             bpy.ops.bim.update_representation(obj=obj.name)
             return element
@@ -2220,7 +2210,8 @@ class Drawing(bonsai.core.tool.Drawing):
         grid_obj = tool.Ifc.get_object(grid)
         if grid_obj:
             cls.sync_object_placement(grid_obj)
-            if grid_obj.matrix_world != obj.matrix_world:
+            matrices_differ = grid_obj.matrix_world != obj.matrix_world
+            if matrices_differ:
                 bpy.ops.bim.update_representation(obj=obj.name)
         tool.Geometry.record_object_position(obj)
 
@@ -2444,8 +2435,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/geometry.py

@@ -33,6 +33,7 @@ from typing import (
     Optional,
     TypeGuard,
     Union,
+    cast,
     get_args,
 )
 
@@ -1094,10 +1095,7 @@ class Geometry(bonsai.core.tool.Geometry):
             else:
                 obj = cls.recreate_object_with_data(obj, data, is_global=False)
             cls.record_object_materials(obj)
-            # old_data is None when the object had no mesh (e.g. an EMPTY being given geometry);
-            # recreate_object_with_data already handled that transition above, so there is nothing to
-            # clean up. Guard has_data_users/delete_data, which both assume a non-None datablock.
-            if old_data is not None and not cls.has_data_users(old_data):
+            if not cls.has_data_users(old_data):
                 cls.delete_data(old_data)
             cls.clear_modifiers(obj)
             cls.clear_cache(element)
@@ -2189,7 +2187,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 == "-":
@@ -2672,6 +2670,11 @@ class Geometry(bonsai.core.tool.Geometry):
         # copy the actual class
         new = bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
 
+        # Give each duplicated IfcGridAxis its own AxisCurve so it doesn't
+        # share geometry with the source axis.
+        if new and new.is_a("IfcGridAxis"):
+            tool.Model.create_axis_curve(new_obj, new)
+
         # 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"):

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/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/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/project.feature

@@ -920,6 +920,21 @@ Scenario: Export IFC - with moved grid axis location synchronised
     And I load previously saved IFC project
     Then the object "IfcGridAxis/01" bottom left corner is at "1,-2,0"
 
+Scenario: Export IFC - with duplicate-of-duplicate grid axis locations preserved
+    Given an empty IFC project
+    And I press "bim.add_grid"
+    And I set "scene.BIMGridProperties.is_locked" to "False"
+    And the object "IfcGridAxis/01" is selected
+    And I duplicate the selected objects
+    And the object "IfcGridAxis/01.001" is moved to "1,0,0"
+    And the object "IfcGridAxis/01.001" is selected
+    And I duplicate the selected objects
+    And the object "IfcGridAxis/01.002" is moved to "2,0,0"
+    When I save IFC project
+    And I load previously saved IFC project
+    Then the object "IfcGridAxis/01.001" bottom left corner is at "1,-2,0"
+    And the object "IfcGridAxis/01.002" bottom left corner is at "2,-2,0"
+
 Scenario: Export IFC - with changed object scale ignored
     Given an empty IFC project
     And I add a cube

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/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/module/type/test_assign_type_material_usage.py

@@ -1,236 +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 Lesser 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.
-
-"""Regression test: retyping a per-instance profile occurrence must move its
-material usage to the new type.
-
-``core.assign_type`` passes ``should_map_representations=False`` for an
-occurrence that owns its body, so the new type's shared representation is not
-mapped over it. That flag also gates ``map_material_usages`` inside
-``api type.assign_type``, which is the step that re-points the occurrence's
-``IfcMaterialProfileSetUsage`` at the new type's material set.
-
-Left unhandled, the occurrence kept a usage whose ``ForProfileSet`` still
-referenced the OLD type's set. ``get_material(should_skip_usage=True)`` follows
-that pointer, so the material panel showed — and edited — the old type's
-profile: duplicating a profile-based type and changing the copy's profile
-silently rewrote the original's, and every other occurrence of the original
-moved with it.
-
-The fix must re-point the usage without undoing what the flag exists for, so
-the occurrence's own extrusion (and its length) has to survive intact.
-
-These live here rather than in ``test/core``, even though the subject is
-``bonsai.core.type``. The Prophecy harness ``test/core`` uses cannot reach this
-branch: ``_is_per_instance_profile`` calls ``ifcopenshell.util`` directly on the
-element, so a real entity is needed, and Prophecy serialises call arguments to
-JSON. Driving a real IFC file in turn imports ``ifcopenshell.api.material`` and
-so ``mathutils``, which ``make test-core`` (``pytest -p no:pytest-blender
-test/core``) deliberately runs without. Nothing here touches ``bpy`` itself.
-"""
-
-from unittest import mock
-
-import pytest
-
-pytestmark = pytest.mark.type
-
-DEPTH = 3.0
-
-
-class _IfcStub:
-    """Stand-in for ``tool.Ifc``. ``core.assign_type`` only reaches for ``run``
-    and ``get_object``; ``run`` dispatches to the real API so the assertions are
-    made against genuine IFC state rather than recorded calls."""
-
-    def __init__(self, ifc_file):
-        self._file = ifc_file
-
-    def run(self, usecase, **kwargs):
-        import ifcopenshell.api
-
-        return ifcopenshell.api.run(usecase, self._file, **kwargs)
-
-    def get_object(self, element):
-        return None
-
-
-def _add_profile_type(ifc_file, body_context, name, profile_name):
-    """An element type carrying its own IfcMaterialProfileSet."""
-    import ifcopenshell.api.material
-    import ifcopenshell.api.root
-
-    element_type = ifcopenshell.api.root.create_entity(ifc_file, ifc_class="IfcColumnType", name=name)
-    material = ifcopenshell.api.material.add_material(ifc_file, name="STEEL")
-    profile_set = ifcopenshell.api.material.add_material_set(
-        ifc_file, name=f"{name} set", set_type="IfcMaterialProfileSet"
-    )
-    profile = ifc_file.create_entity(
-        "IfcRectangleProfileDef", ProfileType="AREA", ProfileName=profile_name, XDim=0.1, YDim=0.2
-    )
-    ifcopenshell.api.material.add_profile(ifc_file, profile_set=profile_set, material=material, profile=profile)
-    ifcopenshell.api.material.assign_material(ifc_file, products=[element_type], material=profile_set)
-    return element_type, profile_set, profile
-
-
-@pytest.fixture
-def model():
-    """Two profile types, and one occurrence of the first that owns its body:
-    its own non-mapped extrusion plus its own usage pointing at type A's set.
-    That is what makes ``_is_per_instance_profile`` true."""
-    import ifcopenshell
-    import ifcopenshell.api.material
-    import ifcopenshell.api.root
-    import ifcopenshell.api.type
-
-    ifc_file = ifcopenshell.file(schema="IFC4")
-    ifcopenshell.api.root.create_entity(ifc_file, ifc_class="IfcProject")
-    context = ifc_file.create_entity(
-        "IfcGeometricRepresentationContext",
-        ContextType="Model",
-        CoordinateSpaceDimension=3,
-        WorldCoordinateSystem=ifc_file.create_entity(
-            "IfcAxis2Placement3D", Location=ifc_file.create_entity("IfcCartesianPoint", Coordinates=(0.0, 0.0, 0.0))
-        ),
-    )
-    body_context = ifc_file.create_entity(
-        "IfcGeometricRepresentationSubContext",
-        ContextIdentifier="Body",
-        ContextType="Model",
-        ParentContext=context,
-        TargetView="MODEL_VIEW",
-    )
-
-    type_a, profile_set_a, profile_a = _add_profile_type(ifc_file, body_context, "Type A", "RECT_A")
-    type_b, profile_set_b, profile_b = _add_profile_type(ifc_file, body_context, "Type B", "RECT_B")
-
-    occurrence = ifcopenshell.api.root.create_entity(ifc_file, ifc_class="IfcColumn", name="Column")
-    ifcopenshell.api.type.assign_type(
-        ifc_file, related_objects=[occurrence], relating_type=type_a, should_map_representations=False
-    )
-    ifcopenshell.api.material.assign_material(
-        ifc_file, products=[occurrence], type="IfcMaterialProfileSetUsage", material=profile_set_a
-    )
-
-    solid = ifc_file.create_entity(
-        "IfcExtrudedAreaSolid",
-        SweptArea=profile_a,
-        Position=ifc_file.create_entity(
-            "IfcAxis2Placement3D", Location=ifc_file.create_entity("IfcCartesianPoint", Coordinates=(0.0, 0.0, 0.0))
-        ),
-        ExtrudedDirection=ifc_file.create_entity("IfcDirection", DirectionRatios=(0.0, 0.0, 1.0)),
-        Depth=DEPTH,
-    )
-    representation = ifc_file.create_entity(
-        "IfcShapeRepresentation",
-        ContextOfItems=body_context,
-        RepresentationIdentifier="Body",
-        RepresentationType="SweptSolid",
-        Items=[solid],
-    )
-    occurrence.Representation = ifc_file.create_entity(
-        "IfcProductDefinitionShape", Representations=[representation]
-    )
-
-    return {
-        "file": ifc_file,
-        "occurrence": occurrence,
-        "type_a": type_a,
-        "type_b": type_b,
-        "profile_set_a": profile_set_a,
-        "profile_set_b": profile_set_b,
-        "profile_b": profile_b,
-        "solid": solid,
-    }
-
-
-def _retype(model, new_type):
-    """Drive ``core.assign_type`` with the real IFC file behind ``ifc.run``.
-    ``model``/``type_tool`` are mocked: they only drive Blender-side refresh,
-    which has no bearing on the IFC state under test."""
-    import bonsai.core.type as subject
-
-    model_tool = mock.Mock()
-    model_tool.get_usage_type.return_value = None
-    type_tool = mock.Mock()
-    type_tool.record_material_usage_attributes.return_value = None
-    type_tool.get_object_data.return_value = None
-
-    subject.assign_type(
-        _IfcStub(model["file"]),
-        model_tool,
-        type_tool,
-        element=model["occurrence"],
-        type=new_type,
-    )
-
-
-def test_usage_follows_the_new_type(model):
-    """The occurrence's own usage must point at the new type's profile set.
-
-    Before the fix it still referenced type A's set, so the material panel
-    edited type A's profile while the user believed they were editing type B's."""
-    import ifcopenshell.util.element
-
-    _retype(model, model["type_b"])
-
-    usage = ifcopenshell.util.element.get_material(model["occurrence"], should_inherit=False)
-    assert usage is not None, "occurrence must keep a material usage of its own"
-    assert usage.is_a("IfcMaterialProfileSetUsage")
-    assert usage.ForProfileSet == model["profile_set_b"], (
-        "usage must follow the new type; still pointing at the old type's set means editing "
-        "the occurrence's profile would mutate the old type"
-    )
-
-    resolved = ifcopenshell.util.element.get_material(model["occurrence"], should_skip_usage=True)
-    assert resolved == model["profile_set_b"], "the set the material panel resolves to must be the new type's"
-
-
-def test_per_instance_geometry_survives_the_retype(model):
-    """Re-pointing the usage must not undo what should_map_representations=False
-    exists for: the occurrence keeps its own non-mapped body at its own length,
-    picking up only the new type's profile."""
-    import ifcopenshell.util.element
-    import ifcopenshell.util.representation
-
-    _retype(model, model["type_b"])
-
-    body = ifcopenshell.util.representation.get_representation(
-        model["occurrence"], "Model", "Body", "MODEL_VIEW"
-    )
-    assert body is not None
-    assert not any(
-        item.is_a("IfcMappedItem") for item in body.Items
-    ), "occurrence must keep its own body, not be mapped onto the type's shared representation"
-    assert model["solid"].Depth == DEPTH, "per-instance extrusion length must be preserved"
-    assert model["solid"].SweptArea == model["profile_b"], "body must pick up the new type's profile"
-
-
-def test_old_type_is_left_alone(model):
-    """The type the occurrence came from must not be touched by the retype."""
-    import ifcopenshell.util.element
-
-    profile_set_a = model["profile_set_a"]
-    profile_a = profile_set_a.MaterialProfiles[0].Profile
-
-    _retype(model, model["type_b"])
-
-    assert ifcopenshell.util.element.get_material(model["type_a"], should_skip_usage=True) == profile_set_a
-    assert profile_set_a.MaterialProfiles[0].Profile == profile_a, "old type's profile must be untouched"

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/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/core/test_type.py

@@ -23,12 +23,7 @@ from test.core.bootstrap import geometry, ifc, model, type
 class TestAssignType:
     def test_assigning_and_switching_to_an_existing_type_data(self, ifc, model, type):
         type.record_material_usage_attributes("element").should_be_called().will_return(None)
-        ifc.run(
-            "type.assign_type",
-            related_objects=["element"],
-            relating_type="type",
-            should_map_representations=True,
-        ).should_be_called()
+        ifc.run("type.assign_type", related_objects=["element"], relating_type="type").should_be_called()
         model.get_usage_type("type").should_be_called(2).will_return(None)
         ifc.get_object("type").should_be_called().will_return("type_obj")
         type.get_object_data("type_obj").should_be_called().will_return("type_obj_data")
@@ -39,12 +34,7 @@ class TestAssignType:
 
     def test_assigning_and_not_changing_data_if_the_type_has_no_data(self, ifc, model, type):
         type.record_material_usage_attributes("element").should_be_called().will_return(None)
-        ifc.run(
-            "type.assign_type",
-            related_objects=["element"],
-            relating_type="type",
-            should_map_representations=True,
-        ).should_be_called()
+        ifc.run("type.assign_type", related_objects=["element"], relating_type="type").should_be_called()
         model.get_usage_type("type").should_be_called(2).will_return(None)
         ifc.get_object("type").should_be_called().will_return("type_obj")
         type.get_object_data("type_obj").should_be_called().will_return(None)

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/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

@@ -82,11 +82,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,7 +97,6 @@ class CostItem(TypedDict):
     Property: Union[str, None]
     Query: Union[str, None]
 
-    CostRate: CostRate | None
     Formula: Union[str, None]
     # QuantityClass: Union[str, None]
 
@@ -245,7 +239,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,
             }

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

src/ifcedit/ifcedit/coerce.py

@@ -60,11 +60,9 @@ def coerce_value(
     # Union / Optional
     if origin is typing.Union:
         non_none_types = [a for a in args if a is not type(None)]
-        if isinstance(value_str, str) and value_str.lower() == "none":
+        if value_str.lower() == "none":
             if type(None) in args:
                 return None
-        if value_str is None and type(None) in args:
-            return None
         # Try each non-None type in order
         for t in non_none_types:
             try:

src/ifcedit/ifcedit/quantify.py

@@ -30,7 +30,7 @@ def run_quantify(model: ifcopenshell.file, rule: str, selector: str | None = Non
     if selector:
         elements = set(ifcopenshell.util.selector.filter_elements(model, selector))
     else:
-        elements = set(model.by_type("IfcElement")) | set(model.by_type("IfcSpace"))
+        elements = set(model.by_type("IfcElement"))
 
     results = quantify(model, elements, rule_sets[rule])
     edit_qtos(model, results)

src/ifcedit/tests/test_coerce.py

@@ -57,16 +57,6 @@ class TestOptionalCoercion:
     def test_optional_int(self):
         assert coerce_value("42", Optional[int]) == 42
 
-    def test_optional_entity_native_int(self, model):
-        # MCP callers pass JSON-decoded native types (int), not CLI strings.
-        wall = model.by_type("IfcWall")[0]
-        result = coerce_value(wall.id(), Optional[ifcopenshell.entity_instance], model)
-        assert result == wall
-
-    def test_optional_entity_native_none(self, model):
-        # JSON null decodes to Python None, not the string "none".
-        assert coerce_value(None, Optional[ifcopenshell.entity_instance], model) is None
-
 
 class TestUnionCoercion:
     def test_union_str_int(self):

src/ifcedit/tests/test_quantify.py

@@ -85,20 +85,3 @@ class TestRunQuantify:
     def test_empty_selector_runs_on_all(self, quantify_model):
         result = run_quantify(quantify_model, "IFC4QtoBaseQuantities", selector=None)
         assert result["ok"] is True
-
-    def test_default_selector_includes_spaces(self, quantify_model, monkeypatch):
-        """IfcSpace is not a subtype of IfcElement, so the default scope must add it explicitly."""
-        import ifc5d.qto
-
-        seen_elements = {}
-
-        def fake_quantify(ifc_file, elements, rules):
-            seen_elements["elements"] = elements
-            return {}
-
-        monkeypatch.setattr(ifc5d.qto, "quantify", fake_quantify)
-
-        space = ifcopenshell.api.root.create_entity(quantify_model, ifc_class="IfcSpace", name="TestSpace")
-        run_quantify(quantify_model, "IFC4QtoBaseQuantities")
-
-        assert space in seen_elements["elements"]

src/ifcfm/ifcfm/cobie24.py

@@ -28,7 +28,6 @@ import ifcopenshell.util.fm
 import ifcopenshell.util.placement
 import ifcopenshell.util.shape
 import ifcopenshell.util.system
-import ifcopenshell.util.unit
 from ifcopenshell.util.shape_builder import np_matrix_to_euler
 
 # The original BIMServer plugin has a function called ifcToCOBie:
@@ -921,11 +920,6 @@ def get_coordinate_data_(element: ifcopenshell.entity_instance) -> Generator[dic
     verts = ifcopenshell.util.shape.get_shape_vertices(shape, shape.geometry)
     categories = ("box-lowerleft", "box-upperright")
     bbox = ifcopenshell.util.shape.get_bbox(verts)
-    # Geometry vertices are in SI metres, but Floor rows use the raw placement in
-    # project length units. Convert space points to project units so the whole
-    # Coordinate sheet is consistent with the Facility LinearUnits.
-    unit_scale = ifcopenshell.util.unit.calculate_unit_scale(element.file)
-    bbox = [point / unit_scale for point in bbox]
     base_data = base_data | {
         "Category": "point",
         "SheetName": "Space",

src/ifcgeom/ConversionSettings.h

@@ -361,8 +361,8 @@ namespace ifcopenshell {
 
 			struct CircleSegments : public SettingBase<CircleSegments, int> {
 				static constexpr const char* const name = "circle-segments";
-				static constexpr const char* const description = "Number of segments to approximate full circles in the CGAL kernel. When 0 (the default) the segment count is derived from mesher-linear-deflection instead, so curves stay within the deflection tolerance regardless of radius.";
-				static constexpr int defaultvalue = 0;
+				static constexpr const char* const description = "Number of segments to approximate full circles in CGAL kernel.";
+				static constexpr int defaultvalue = 16;
 			};
 
 			struct CgalSmoothAngleDegrees : public SettingBase<CgalSmoothAngleDegrees, double> {

src/ifcgeom/kernels/cgal/CgalKernel.cpp

@@ -391,11 +391,6 @@ namespace {
 		}
 	};
 
-	// Representative radius used to size the polygonal approximation of a conic.
-	// For an ellipse the larger semi-axis is the conservative choice.
-	inline double conic_radius(const taxonomy::circle::ptr& c) { return c->radius; }
-	inline double conic_radius(const taxonomy::ellipse::ptr& e) { return e->radius > e->radius2 ? e->radius : e->radius2; }
-
 	struct cgal_curve_creation_visitor {
 		Settings& settings_;
 		parameter_range param;
@@ -430,36 +425,7 @@ namespace {
 			if (b <= a) {
 				b += 2 * M_PI;
 			}
-			const double span = std::fabs(a - b);
-			// CircleSegments controls how conics (circles, ellipses, arcs) are approximated
-			// in the CGAL kernel. Two modes, one or the other:
-			//  - CircleSegments == 0 (the default): the segment count is derived from
-			//    MesherLinearDeflection, so the chord deviation stays within the mesher's
-			//    linear deflection regardless of radius. This matches the deflection based
-			//    meshing the OpenCascade kernel already does and fixes issue #8051, where
-			//    large radius arcs (curved curtain wall mullions) collapsed to straight chords
-			//    because a fixed segment count is radius agnostic.
-			//  - CircleSegments > 0: it is used directly as the number of segments for a full
-			//    circle, giving deterministic, radius independent output.
-			int num_segments;
-			const int circle_segments = settings_.get<settings::CircleSegments>().get();
-			if (circle_segments > 0) {
-				num_segments = (int)std::ceil(span / (2 * M_PI) * circle_segments);
-			} else {
-				const double radius = conic_radius(t);
-				const double deflection = settings_.get<settings::MesherLinearDeflection>().get();
-				if (deflection > 0. && radius > deflection) {
-					const double max_segment_angle = 2.0 * std::acos(1.0 - deflection / radius);
-					num_segments = (int)std::ceil(span / max_segment_angle);
-				} else {
-					// Radius within the deflection tolerance (or no deflection set): a chord per
-					// quarter turn already keeps the deviation within tolerance.
-					num_segments = (int)std::ceil(span / (M_PI / 2.));
-				}
-			}
-			if (num_segments < 1) {
-				num_segments = 1;
-			}
+			int num_segments = (int)std::ceil(std::fabs(a - b) / (2 * M_PI) * settings_.get<settings::CircleSegments>().get());
 			double du = (b - a) / num_segments;
 			taxonomy::point3 P;
 			// @nb for loop is not inclusive of the both end points

src/ifcgeom/kernels/opencascade/face.cpp

@@ -31,7 +31,6 @@
 #include <ShapeFix_Shape.hxx>
 #include <ShapeFix_ShapeTolerance.hxx>
 #include <BRep_Tool.hxx>
-#include <BRepExtrema_DistShapeShape.hxx>
 
 #include <Standard_Macro.hxx>
 #include <TopoDS_Shape.hxx>
@@ -357,27 +356,6 @@ bool OpenCascadeKernel::convert(const taxonomy::face::ptr face, TopoDS_Shape& re
 		return false;
 	}
 
-	// #527: A face whose inner boundary intersects the outer boundary (or
-	// another inner boundary) is invalid per the schema. Open Cascade heals or
-	// drops such a face silently, so the intended hole is lost with no
-	// diagnostic. The distance between two non-intersecting loops is strictly
-	// positive; a distance at (or below) the modelling precision means the
-	// boundaries touch or cross. Emit a clear warning so the invalid input is
-	// not silently lost. wires() is ordered outer-first, inner-bounds after.
-	if (fd.wires().size() > 1) {
-		const auto& fwires = fd.wires();
-		bool reported = false;
-		for (size_t i = 1; i < fwires.size() && !reported; ++i) {
-			for (size_t j = 0; j < i && !reported; ++j) {
-				BRepExtrema_DistShapeShape dss(fwires[i], fwires[j]);
-				if (dss.IsDone() && dss.Value() < precision_) {
-					logger().Warning("GEO", 402, "Face inner boundary intersects another face boundary", face->instance);
-					reported = true;
-				}
-			}
-		}
-	}
-
 	if (fd.surface().IsNull()) {
 		// Use the first wire to find a plane manually for polygonal wires
 		const TopoDS_Wire& wire = fd.wires().front();

src/ifcgeom/mapping/IfcAsymmetricIShapeProfileDef.cpp

@@ -1,93 +0,0 @@
-// This file was generated with the assistance of an AI coding tool.
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
-
-#include "mapping.h"
-#define mapping POSTFIX_SCHEMA(mapping)
-using namespace ifcopenshell::geometry;
-
-#include "../profile_helper.h"
-
-// In IFC2X3 IfcAsymmetricIShapeProfileDef is a subtype of IfcIShapeProfileDef and is
-// therefore dispatched (and handled) by the IfcIShapeProfileDef mapping. From IFC4
-// onwards it is a standalone subtype of IfcParameterizedProfileDef with its own
-// Bottom*/Top* attributes, so nothing mapped it and the extrusion came out empty.
-// The presence of the standalone BottomFlangeWidth attribute is the discriminator:
-// it is only defined in the schemas where the type is standalone (IFC4 / IFC4X3).
-#ifdef SCHEMA_IfcAsymmetricIShapeProfileDef_HAS_BottomFlangeWidth
-
-taxonomy::ptr mapping::map_impl(const IfcSchema::IfcAsymmetricIShapeProfileDef* inst) {
-	// Bottom flange (half width), overall depth (half), web (half thickness).
-	const double xb = inst->BottomFlangeWidth() / 2.0 * length_unit_;
-	const double xt = inst->TopFlangeWidth() / 2.0 * length_unit_;
-	const double y = inst->OverallDepth() / 2.0 * length_unit_;
-	const double d1 = inst->WebThickness() / 2.0 * length_unit_;
-
-	// Bottom flange thickness; top flange thickness defaults to the bottom one.
-	const double ftb = inst->BottomFlangeThickness() * length_unit_;
-	const double ftt = inst->TopFlangeThickness().get_value_or(inst->BottomFlangeThickness()) * length_unit_;
-
-	// Optional fillet radii (web/flange transition) and flange edge radii.
-	const double fb = inst->BottomFlangeFilletRadius().get_value_or(0.) * length_unit_;
-	const double ft_top = inst->TopFlangeFilletRadius().get_value_or(0.) * length_unit_;
-	const double feb = inst->BottomFlangeEdgeRadius().get_value_or(0.) * length_unit_;
-	const double fet = inst->TopFlangeEdgeRadius().get_value_or(0.) * length_unit_;
-
-	// Optional flange slopes: the inner edge of the flange rises towards the web.
-	const double bottomSlope = inst->BottomFlangeSlope().get_value_or(0.) * angle_unit_;
-	const double topSlope = inst->TopFlangeSlope().get_value_or(0.) * angle_unit_;
-	const double dyb = (xb - d1) * tan(bottomSlope);
-	const double dyt = (xt - d1) * tan(topSlope);
-
-	const double tol = settings_.get<settings::Precision>().get();
-
-	if (xb < tol || xt < tol || y < tol || d1 < tol || ftb < tol || ftt < tol) {
-		logger_.Message(Logger::LOG_NOTICE, "GEO", 264, "Skipping zero sized profile:", inst);
-		return nullptr;
-	}
-
-	taxonomy::matrix4::ptr m4;
-	bool has_position = true;
-#ifdef SCHEMA_IfcParameterizedProfileDef_Position_IS_OPTIONAL
-	has_position = !!inst->Position();
-#endif
-	if (has_position) {
-		m4 = taxonomy::cast<taxonomy::matrix4>(map(inst->Position()));
-	}
-
-	// Twelve corner points, running counter-clockwise from the bottom-left, with the
-	// bottom flange (xb) possibly wider than the top flange (xt). Fillet/edge radii are
-	// attached to the corner they round, matching the symmetric IfcIShapeProfileDef.
-	return profile_helper(m4, {
-		{{-xb,-y}},
-		{{xb,-y}},
-		{{xb,-y + ftb}, {feb}},
-		{{d1,-y + ftb + dyb},{fb} },
-		{{d1,y - ftt - dyt},{ft_top} },
-		{{xt,y - ftt}, {fet}},
-		{{xt,y}},
-		{{-xt,y}},
-		{{-xt,y - ftt}, {fet}},
-		{{-d1,y - ftt - dyt},{ft_top} },
-		{{-d1,-y + ftb + dyb},{fb} },
-		{{-xb,-y + ftb}, {feb}}
-	});
-}
-
-#endif

src/ifcgeom/mapping/IfcPolygonalFaceSet.cpp

@@ -39,25 +39,8 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcPolygonalFaceSet* inst) {
 
 	int max_index = (int)points.size();
 
-	// When the optional PnIndex is present, CoordIndex values do not index into
-	// CoordList directly but into PnIndex, which in turn remaps to CoordList.
-	// Both index levels are 1-based per the IFC specification.
-	auto pn_index = inst->PnIndex();
-	auto resolve = [&](int idx) -> const taxonomy::point3::ptr& {
-		if (pn_index) {
-			if (idx < 1 || idx > (int)pn_index->size()) {
-				throw IfcParse::IfcException("IfcPolygonalFaceSet PnIndex out of bounds for index " + boost::lexical_cast<std::string>(idx));
-			}
-			idx = (*pn_index)[idx - 1];
-		}
-		if (idx < 1 || idx > max_index) {
-			throw IfcParse::IfcException("IfcPolygonalFaceSet index out of bounds for index " + boost::lexical_cast<std::string>(idx));
-		}
-		return points[idx - 1];
-	};
-
 	auto shell = taxonomy::make<taxonomy::shell>();
-
+	
 	for (auto& f : *polygonal_faces) {
 		auto fa = taxonomy::make<taxonomy::face>();
 		shell->children.push_back(fa);
@@ -69,14 +52,17 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcPolygonalFaceSet* inst) {
 			auto indices = f->CoordIndex();
 			taxonomy::point3::ptr previous;
 			for (std::vector<int>::const_iterator jt = indices.begin(); jt != indices.end(); ++jt) {
-				auto current = resolve(*jt);
+				if (*jt < 1 || *jt > max_index) {
+					throw IfcParse::IfcException("IfcPolygonalFaceSet index out of bounds for index " + boost::lexical_cast<std::string>(*jt));
+				}
+				auto current = points[(*jt) - 1];
 				if (jt != indices.begin()) {
 					loop->children.push_back(taxonomy::make<taxonomy::edge>(previous, current));
 				}
 				previous = current;
 			}
 			if (!indices.empty()) {
-				auto current = resolve(indices.front());
+				auto current = points[indices.front() - 1];
 				loop->children.push_back(taxonomy::make<taxonomy::edge>(previous, current));
 			}
 		}
@@ -91,14 +77,17 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcPolygonalFaceSet* inst) {
 					loop->external = false;
 
 					for (std::vector<int>::const_iterator jt = li.begin(); jt != li.end(); ++jt) {
-						auto current = resolve(*jt);
+						if (*jt < 1 || *jt > max_index) {
+							throw IfcParse::IfcException("IfcPolygonalFaceSet index out of bounds for index " + boost::lexical_cast<std::string>(*jt));
+						}
+						auto current = points[(*jt) - 1];
 						if (jt != li.begin()) {
 							loop->children.push_back(taxonomy::make<taxonomy::edge>(previous, current));
 						}
 						previous = current;
 					}
 					if (!li.empty()) {
-						auto current = resolve(li.front());
+						auto current = points[li.front() - 1];
 						loop->children.push_back(taxonomy::make<taxonomy::edge>(previous, current));
 					}
 				}

src/ifcgeom/mapping/IfcTriangulatedFaceSet.cpp

@@ -39,23 +39,6 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTriangulatedFaceSet* inst) {
 
 	int max_index = (int)points.size();
 
-	// When the optional PnIndex is present, CoordIndex values do not index into
-	// CoordList directly but into PnIndex, which in turn remaps to CoordList.
-	// Both index levels are 1-based per the IFC specification.
-	auto pn_index = inst->PnIndex();
-	auto resolve = [&](int idx) -> const taxonomy::point3::ptr& {
-		if (pn_index) {
-			if (idx < 1 || idx > (int)pn_index->size()) {
-				throw IfcParse::IfcException("IfcTriangulatedFaceSet PnIndex out of bounds for index " + boost::lexical_cast<std::string>(idx));
-			}
-			idx = (*pn_index)[idx - 1];
-		}
-		if (idx < 1 || idx > max_index) {
-			throw IfcParse::IfcException("IfcTriangulatedFaceSet index out of bounds for index " + boost::lexical_cast<std::string>(idx));
-		}
-		return points[idx - 1];
-	};
-
 	auto shell = taxonomy::make<taxonomy::shell>();
 
 	for (auto& indices : indices_list) {
@@ -68,7 +51,10 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTriangulatedFaceSet* inst) {
 			loop->external = true;
 			taxonomy::point3::ptr first, previous;
 			for (std::vector<int>::const_iterator jt = indices.begin(); jt != indices.end(); ++jt) {
-				const taxonomy::point3::ptr& current = resolve(*jt);
+				if (*jt < 1 || *jt > max_index) {
+					throw IfcParse::IfcException("IfcTriangulatedFaceSet index out of bounds for index " + boost::lexical_cast<std::string>(*jt));
+				}
+				const taxonomy::point3::ptr& current = points[(*jt) - 1];
 				if (jt == indices.begin()) {
 					first = current;
 				} else {

src/ifcgeom/mapping/mapping.i

@@ -89,11 +89,7 @@ BIND(IfcRectangleHollowProfileDef);
 BIND(IfcRectangleProfileDef);
 BIND(IfcTrapeziumProfileDef);
 BIND(IfcCShapeProfileDef);
-// In IFC2X3 IfcAsymmetricIShapeProfileDef is a subtype of IfcIShapeProfileDef and is
-// mapped by it; from IFC4 onwards it is a standalone type and needs its own binding.
-#ifdef SCHEMA_IfcAsymmetricIShapeProfileDef_HAS_BottomFlangeWidth
-BIND(IfcAsymmetricIShapeProfileDef);
-#endif
+// IfcAsymmetricIShapeProfileDef included
 BIND(IfcIShapeProfileDef);
 BIND(IfcLShapeProfileDef);
 BIND(IfcTShapeProfileDef);

src/ifcmcp/README.md

@@ -255,7 +255,7 @@ ifc_quantify(rule="IFC4QtoBaseQuantities", selector="IfcWall")
 Available rules: `IFC4QtoBaseQuantities`, `IFC4X3QtoBaseQuantities`.
 
 `selector` is an optional ifcopenshell selector to restrict which elements
-are quantified (default: all `IfcElement` and `IfcSpace`).
+are quantified (default: all `IfcElement`).
 
 Returns `{"ok": true, "rule": "...", "elements_quantified": 42}`.
 

src/ifcmcp/ifcmcp/core.py

@@ -703,7 +703,7 @@ class IfcSession:
                         "rule": {"type": "string", "description": "QTO rule name, e.g. IFC4QtoBaseQuantities"},
                         "selector": {
                             "type": "string",
-                            "description": "ifcopenshell selector to restrict elements (default: all IfcElement and IfcSpace)",
+                            "description": "ifcopenshell selector to restrict elements (default: all IfcElement)",
                         },
                     },
                     "required": ["rule"],

src/ifcopenshell-python/docs/ifcconvert/usage.rst

@@ -311,12 +311,8 @@ CLI Manual
                                             output.
       --force-space-transparency arg        Overrides transparency of spaces in 
                                             geometry output.
-      --circle-segments arg (= 0)           Number of segments to approximate full
-                                            circles in the CGAL kernel. When 0 (the
-                                            default) the segment count is derived from
-                                            mesher-linear-deflection instead, so curves
-                                            stay within the deflection tolerance
-                                            regardless of radius.
+      --circle-segments arg (= 16)          Number of segments to approximate full 
+                                            circles in CGAL kernel.
       --cgal-smooth-angle-degrees arg (= -1)
                                             Angle in degrees under which adjacent 
                                             facets will have averaged vertex