Merge branch 'v0.8.0' into doc/ifcquery-readme

.github/workflows/build_osx.yml

@@ -53,7 +53,7 @@ jobs:
           python ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.21
         with:
           key: mac-${{ matrix.arch }}
 

.github/workflows/build_pyodide.yml

@@ -29,7 +29,7 @@ jobs:
           python ../IfcOpenShell/nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.21
         with:
           key: ubuntu-22.04-${{ runner.arch }}
 

.github/workflows/build_rocky.yml

@@ -48,7 +48,7 @@ jobs:
           python3 ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.21
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 

.github/workflows/build_rocky_arm.yml

@@ -48,7 +48,7 @@ jobs:
           python3 ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.21
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 

.github/workflows/build_win.yml

@@ -52,7 +52,7 @@ jobs:
           }
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.22
+        uses: hendrikmuhs/ccache-action@v1.2.21
         with:
           key: win-${{ matrix.arch }}
           # Windows ccache needs ~1GB

.github/workflows/ci-ifcopenshell-conda-cleaner.yml

@@ -24,7 +24,7 @@ jobs:
     if: |
       github.repository == 'IfcOpenShell/IfcOpenShell'
     steps:
-      - uses: mamba-org/setup-micromamba@v3 # https://github.com/mamba-org/setup-micromamba
+      - uses: mamba-org/setup-micromamba@v2 # https://github.com/mamba-org/setup-micromamba
         with:
           environment-name: test-env
           create-args: >-

.github/workflows/ci-ifcopenshell-conda-daily.yml

@@ -84,7 +84,7 @@ jobs:
         run: |
           curl -L https://github.com/phracker/MacOSX-SDKs/releases/download/11.3/MacOSX10.13.sdk.tar.xz | tar -xvJf - -C /Users/runner/work/
 
-      - uses: mamba-org/setup-micromamba@v3 # https://github.com/mamba-org/setup-micromamba
+      - uses: mamba-org/setup-micromamba@v2 # https://github.com/mamba-org/setup-micromamba
         with:
           environment-name: test-env
           create-args: >-

.github/workflows/ci-ifcopenshell-docker.yml

@@ -35,7 +35,7 @@ jobs:
 
     -
       name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.22
+      uses: hendrikmuhs/ccache-action@v1.2.21
 
     - 
       name: Build ifcopenshell

.github/workflows/ci.yml

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

.github/workflows/publish-pyodide-demo-app.yml

@@ -31,7 +31,7 @@ jobs:
           submodules: recursive
           fetch-depth: 0
       - name: Setup Pages
-        uses: actions/configure-pages@v6
+        uses: actions/configure-pages@v5
       - name: Upload static files as artifact
         id: deployment
         uses: actions/upload-pages-artifact@v4
@@ -47,4 +47,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4

pyproject.toml

@@ -3,7 +3,7 @@ name = "IfcOpenShell"
 version = "0.0.0"
 dependencies = [
     "black==26.3.1",
-    "ruff==0.15.8",
+    "ruff==0.15.7",
     "poethepoet",
     "gersemi==0.26.1",
 ]

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

@@ -104,7 +104,6 @@ classes = (
     profile.ExtendProfile,
     profile.RecalculateProfile,
     profile.Rotate90,
-    profile.SplitProfile,
     profile.PatchNonParametricMepSegment,
     roof.GenerateHippedRoof,
     slab.DisableEditingExtrusionProfile,

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

@@ -421,7 +421,7 @@ class PolylineOperator:
                     tool.Polyline.calculate_x_y_and_z(context, self.input_ui, self.tool_state)
 
                 tool.Blender.update_viewport()
-            return {"RUNNING_MODAL"}
+                return {"RUNNING_MODAL"}
 
     def set_offset(self, context: bpy.types.Context, relating_type: ifcopenshell.entity_instance) -> None:
         props = tool.Model.get_model_props()
@@ -461,7 +461,6 @@ class PolylineOperator:
         self.tool_state.axis_method = None
         self.tool_state.plane_method = None
         self.tool_state.mode = "Mouse"
-        tool.Raycast.clear_snap_objs()
         self.visible_objs = tool.Raycast.get_visible_objects(context)
         for obj in self.visible_objs:
             if bbox_2d := tool.Raycast.get_on_screen_2d_bounding_boxes(context, obj):

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

@@ -849,57 +849,6 @@ class DumbProfileJoiner:
     def create_matrix(self, p: Vector, x: Vector, y: Vector, z: Vector) -> Matrix:
         return Matrix([x, y, z, p]).to_4x4().transposed()
 
-    def split(self, profile1: bpy.types.Object, target: Vector) -> None:
-        element1 = tool.Ifc.get_entity(profile1)
-        if not element1:
-            return
-
-        if tool.Ifc.is_moved(profile1):
-            bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=profile1)
-
-        axis1 = self.get_profile_axis(profile1)
-        intersect, cut_percentage = mathutils.geometry.intersect_point_line(target, *axis1)
-        if cut_percentage < 0 or cut_percentage > 1 or tool.Cad.is_x(cut_percentage, (0, 1)):
-            return
-
-        # Duplicate the profile element
-        profile2 = profile1.copy()
-        profile2.data = profile2.data.copy()
-        for collection in profile1.users_collection:
-            collection.objects.link(profile2)
-        bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=profile2)
-        element2 = tool.Ifc.get_entity(profile2)
-
-        # Transfer ATEND connection from element1 to element2
-        relating_element = None
-        relating_connection = None
-        description = None
-        for conn in list(element1.ConnectedTo):
-            if conn.is_a("IfcRelConnectsPathElements") and conn.RelatingConnectionType == "ATEND":
-                relating_element = conn.RelatedElement
-                relating_connection = conn.RelatedConnectionType
-                description = conn.Description
-                bonsai.core.geometry.remove_connection(tool.Geometry, connection=conn)
-        for conn in list(element1.ConnectedFrom):
-            if conn.is_a("IfcRelConnectsPathElements") and conn.RelatedConnectionType == "ATEND":
-                relating_element = conn.RelatingElement
-                relating_connection = conn.RelatingConnectionType
-                description = conn.Description
-                bonsai.core.geometry.remove_connection(tool.Geometry, connection=conn)
-        if relating_element:
-            ifcopenshell.api.geometry.connect_path(
-                tool.Ifc.get(),
-                relating_element=relating_element,
-                related_element=element2,
-                relating_connection=relating_connection,
-                related_connection="ATEND",
-                description=description,
-            )
-
-        # Recreate both profiles with split axes
-        self.recreate_profile(element1, profile1, [axis1[0], intersect], [axis1[0], intersect])
-        self.recreate_profile(element2, profile2, [intersect, axis1[1]], [intersect, axis1[1]])
-
     def get_profile_axis(self, obj: bpy.types.Object) -> list[Vector]:
         z_values = [v[2] for v in obj.bound_box]
         return [
@@ -908,29 +857,6 @@ class DumbProfileJoiner:
         ]
 
 
-class SplitProfile(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.split_profile"
-    bl_label = "Split Profile"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = (
-        "Split selected profile element into two elements at the Blender cursor location. "
-        "The cursor must be positioned on the element's axis."
-    )
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Model.has_selected_ifc_objects():
-            cls.poll_message_set("No IFC objects selected.")
-            return False
-        return True
-
-    def _execute(self, context):
-        selected_objs = tool.Model.get_selected_mesh_objects()
-        for obj in selected_objs:
-            DumbProfileJoiner().split(obj, context.scene.cursor.location)
-        return {"FINISHED"}
-
-
 class RecalculateProfile(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.recalculate_profile"
     bl_label = "Recalculate Profile"

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

@@ -937,21 +937,13 @@ class EditObjectUI:
                 row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
                 add_layout_hotkey_operator(row, "Mitre", "S_Y", "", ui_context)
                 row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
-                add_layout_hotkey_operator(
-                    row,
-                    "Split",
-                    "S_K",
-                    "Split selected Element into two Elements at the cursor location\n\nHotkey: ⇧ K",
-                    ui_context,
-                )
-                row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
                 add_layout_hotkey_operator(row, "Rotate 90", "S_R", bpy.ops.bim.rotate_90.__doc__, ui_context)
 
         else:
             if "LAYER2" in AuthoringData.data["selected_material_usages"]:
                 row = cls.layout.row(align=True) if ui_context != "TOOL_HEADER" else row
                 add_layout_hotkey_operator(
-                    cls.layout, "Extend To Underside", "S_E", bpy.ops.bim.extend_walls_to_underside.__doc__, ui_context
+                    cls.layout, "Extend To Underside", "S_E", bpy.ops.bim.extend_to_underside.__doc__, ui_context
                 )
 
         if AuthoringData.data["is_flippable_element"]:
@@ -1369,8 +1361,6 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             return
         if self.active_material_usage == "LAYER2":
             bpy.ops.bim.split_wall()
-        elif self.active_material_usage == "PROFILE":
-            bpy.ops.bim.split_profile()
 
     def hotkey_S_T(self):
         if not bpy.context.selected_objects:

src/bonsai/bonsai/tool/raycast.py

@@ -16,9 +16,6 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
-from __future__ import annotations
-
-import math
 from typing import Union
 
 import bmesh
@@ -44,7 +41,6 @@ class Raycast(bonsai.core.tool.Raycast):
         (0, -offset),
         (offset, -offset),
     )
-    snap_objs = []
 
     @classmethod
     def get_visible_objects(cls, context: bpy.types.Context):
@@ -73,14 +69,8 @@ class Raycast(bonsai.core.tool.Raycast):
         rv3d = context.region_data
         assert rv3d
         view_location = rv3d.view_matrix.inverted().translation
-        view_normal = rv3d.view_rotation @ mathutils.Vector((0.0, 0.0, -1.0))
         obj_matrix = obj.matrix_world.copy()
         bbox = [obj_matrix @ Vector(v) for v in obj.bound_box]
-        bbox_edges = [
-            (0,1),(1,2),(2,3),(3,0),
-            (4,5),(5,6),(6,7),(7,4),
-            (0,4),(1,5),(2,6),(3,7)
-        ]
 
         transposed_bbox: list[Vector] = []
         bbox_2d: list[float] = []
@@ -104,23 +94,8 @@ class Raycast(bonsai.core.tool.Raycast):
 
         for v in bbox:
             coord_2d = tool.Cad.location_3d_to_region_2d_np(context.region, context.space_data.region_3d, v)
-            transposed_bbox.append(coord_2d)
-
-        if not any(transposed_bbox):
-            transposed_bbox = []
-        # If there are None values in transposed_bbox it means that there are vertices behind the camera
-        # so we get the intersection of the edge with the region border
-        # new_bbox = []
-        if any(transposed_bbox) and not all(transposed_bbox):
-            new_bbox = transposed_bbox.copy()
-            new_bbox = [x for x in new_bbox if x is not None]
-            for edge in bbox_edges:
-                if (transposed_bbox[edge[0]] is None) ^ (transposed_bbox[edge[1]] is None):
-                    point, _ = cls.intersect_edge_region_border(context.region, context.space_data, rv3d, bbox[edge[0]], bbox[edge[1]])
-                    if point:
-                        new_bbox.append(point)
-            if new_bbox:
-                transposed_bbox = new_bbox
+            if coord_2d is not None:
+                transposed_bbox.append(coord_2d)
 
         region = context.region
         borders = (0, region.width, 0, region.height)
@@ -142,99 +117,6 @@ class Raycast(bonsai.core.tool.Raycast):
             return (obj, bbox_2d)
         return None
 
-    def intersect_edge_region_border(region, space, rv3d, v1, v2):
-        def segment_intersect_near_plane(view_matrix, clip_start, p_world_a, p_world_b):
-            a_view = view_matrix @ p_world_a
-            b_view = view_matrix @ p_world_b
-            z_near = -clip_start
-            za = a_view.z
-            zb = b_view.z
-            denom = (zb - za)
-            if denom == 0.0:
-                return None, None
-            t = (z_near - za) / denom
-            if t < 0.0 or t > 1.0:
-                return None, None
-            p_view = a_view.lerp(b_view, t)
-            cam_world = view_matrix.inverted()
-            p_world = cam_world @ p_view
-            return p_world, t
-
-        def is_inside_region(pt2d, region):
-            return 0.0 <= pt2d.x <= region.width and 0.0 <= pt2d.y <= region.height
-
-        def clamp_to_region_border(point2d, region):
-            x, y = point2d
-            x_clamped = max(0.0, min(region.width, x))
-            y_clamped = max(0.0, min(region.height, y))
-            return Vector((x_clamped, y_clamped))
-
-        def find_nearby_onscreen_point(region, rv3d, p1, p2, initial_t_on_segment, max_iters=40, step=0.05):
-            """
-            Use iterative approach: move t toward 0. Returns the first point that is inside region border
-            """
-            t = initial_t_on_segment
-            for i in range(max_iters):
-                test_3d = p1.lerp(p2, t)
-                test_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, test_3d)
-                if test_2d is not None and is_inside_region(test_2d, region):
-                    return test_3d, test_2d, t
-                # move t toward 0 by reducing it by a fraction of its current value
-                t -= step
-                # if t is already very small, break
-                if t <= 1e-6:
-                    break
-
-            return None, None, None
-
-        # Ensures that all the calculation uses the same direction based on which point is on the screen
-        if view3d_utils.location_3d_to_region_2d(region, rv3d, v1):
-            onscreen_vert = v1
-            offscreen_vert = v2
-        else:
-            onscreen_vert = v2
-            offscreen_vert = v1
-            # v2, v1 = v1, v2
-
-        clip_start = space.clip_start
-        view_mat = rv3d.view_matrix
-        inter_world, t_on_ab = segment_intersect_near_plane(view_mat, clip_start, onscreen_vert, offscreen_vert)
-
-        if inter_world is None:
-            print("No intersection with viewport near plane found for the segment.")
-            return
-
-        init_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, inter_world)
-
-        if init_2d is not None and is_inside_region(init_2d, region):
-            final_world = inter_world
-            final_2d = init_2d
-            final_t = initial_t
-        else:
-            found_world, found_2d, found_t = find_nearby_onscreen_point(
-                region, rv3d,
-                onscreen_vert, offscreen_vert,
-                t_on_ab,
-                max_iters=600, step=0.01
-            )
-            if found_world is None:
-                if init_2d is None:
-                    print("Initial projection invalid and iterative search failed.")
-                    return
-                # fallback: clamp projected point to border via manual mapping
-                final_2d = clamp_to_region_border(init_2d, region)
-                final_world = None
-                final_t = None
-                # print("Iterative search failed; using clamped 2D:", final_2d)
-            else:
-                final_world = found_world
-                final_2d = found_2d
-                final_t = found_t
-                # print(f"Found onscreen point at t={final_t:.4f}")
-
-        # print("Final 2D:", final_2d)
-        return final_2d, v2
-
     @classmethod
     def intersect_mouse_2d_bounding_box(cls, mouse_pos: tuple[int, int], bbox: list[float, float, float, float]):
         x, y = mouse_pos
@@ -350,161 +232,6 @@ class Raycast(bonsai.core.tool.Raycast):
         else:
             return None, None, None
 
-    @classmethod
-    def ray_cast_by_proximity_2d(
-        cls,
-        context: bpy.types.Context,
-        event: bpy.types.Event,
-        snap_obj: SnapObj,
-    ):
-
-        def divide_vector(start, end, n):
-            points = []
-            delta = (end - start) / n
-            for i in range(1, n):
-                point = start + i * delta
-                points.append(point)
-            return points
-
-        region = context.region
-        rv3d = context.region_data
-        mouse_pos = event.mouse_region_x, event.mouse_region_y
-        ray_origin, ray_target, ray_direction = cls.get_viewport_ray_data(context, event)
-        points = []
-
-        try:
-            loc = tool.Cad.region_2d_to_location_3d_np(region, rv3d, mouse_pos, ray_direction)
-        except:
-            loc = Vector((0, 0, 0))
-
-        verts_2d = [
-            view3d_utils.location_3d_to_region_2d(region, rv3d, v) for v in snap_obj.verts_3d
-        ]  # Numpy version is worst in performance
-
-        intersected = snap_obj.raycast_boxes(
-            context, event, snap_obj.root, intersected=[], rays=(ray_origin, ray_direction)
-        )
-        edges = []
-        for it in intersected:
-            edges.extend(it.edges)
-        edges = set(edges)
-
-        edge_verts = {}
-        for e in edges:
-            verts_idx = tuple(snap_obj.obj.data.edges[e].vertices)
-            verts = snap_obj.obj.data.vertices
-            v1 = snap_obj.obj.matrix_world @ verts[verts_idx[0]].co
-            v1_2d = verts_2d[verts_idx[0]]
-            v2 = snap_obj.obj.matrix_world @ verts[verts_idx[1]].co
-            v2_2d = verts_2d[verts_idx[1]]
-            if (v1_2d is None) ^ (v2_2d is None):
-                point, _ = cls.intersect_edge_region_border(region, context.space_data, rv3d, v1, v2)
-                if v1_2d is None:
-                    edge_verts[e] = (point, v2_2d)
-                else:
-                    edge_verts[e] = (v1_2d, point)
-            else:
-                edge_verts[e] = (v1_2d, v2_2d)
-            
-        snap_threshold = 10.0
-
-        for i, point in enumerate(verts_2d):
-            if not point:
-                continue
-            distance = (Vector(mouse_pos) - point).length
-            if distance <= snap_threshold:
-                snap_point = {
-                    "object": snap_obj.obj,
-                    "type": "Vertex",
-                    "point": snap_obj.verts_3d[i],
-                    "distance": distance / 10,
-                }
-                points.append(snap_point)
-
-        count = 0
-        selected_edges = {}
-        for e in edges:
-            p0, p1 = edge_verts[e]
-            p0x, p0y = p0
-            p1x, p1y = p1
-            px, py = mouse_pos
-
-            # segment vector = p1 - p0
-            sx = p1x - p0x
-            sy = p1y - p0y
-
-            # seg length squared
-            seg_len_sq = sx * sx + sy * sy
-
-            if seg_len_sq == 0.0:
-                # degenerate segment: return distance to p0
-                dx = px - p0x
-                dy = py - p0y
-                dist = math.hypot(dx, dy)
-                return dist, (p0x, p0y), 0.0
-
-            # project (p - p0) onto seg: t = dot(p-p0, seg) / |seg|^2
-            apx = px - p0x
-            apy = py - p0y
-            t = (apx * sx + apy * sy) / seg_len_sq
-
-            # clamp to segment
-            if t <= 0.0:
-                t_clamped = 0.0
-                cx, cy = p0x, p0y
-            elif t >= 1.0:
-                t_clamped = 1.0
-                cx, cy = p1x, p1y
-            else:
-                t_clamped = t
-                cx = p0x + sx * t_clamped
-                cy = p0y + sy * t_clamped
-
-            dx = px - cx
-            dy = py - cy
-            dist = math.hypot(dx, dy)
-            if dist <= snap_threshold:
-                selected_edges[dist] = e
-
-        if selected_edges:
-            min_dist = float("inf")
-            for key in selected_edges:
-                if key < min_dist:
-                    min_dist = key
-
-            idx = snap_obj.obj.data.edges[selected_edges[min_dist]].vertices
-            edge_verts = (snap_obj.verts_3d[idx[0]], snap_obj.verts_3d[idx[1]])
-            division_points = divide_vector(
-                edge_verts[0], edge_verts[1], 2
-            )  # TODO Make it work for different divisions
-            for division_point in division_points:
-                intersection = tool.Cad.point_on_edge(division_point, (ray_target, loc))
-                distance = (division_point - intersection).length
-                if distance < snap_threshold:
-                    snap_point = {
-                        "object": snap_obj.obj,
-                        "type": "Edge Center",
-                        "point": division_point.copy(),
-                        "distance": distance,
-                    }
-                    points.append(snap_point)
-
-            intersection = tool.Cad.intersect_edges_v2((ray_target, loc), edge_verts)
-            if intersection[0]:
-                if tool.Cad.is_point_on_edge(intersection[1], edge_verts):
-                    distance = (intersection[1] - intersection[0]).length
-                    if distance < snap_threshold:
-                        snap_point = {
-                            "object": snap_obj.obj,
-                            "type": "Edge",
-                            "point": intersection[1].copy(),
-                            "edge_verts": edge_verts,
-                            "distance": distance,
-                        }
-                        points.append(snap_point)
-
-        return points
-
     @classmethod
     def ray_cast_by_proximity(
         cls,
@@ -730,8 +457,7 @@ class Raycast(bonsai.core.tool.Raycast):
             if bbox_2d:
                 if tool.Raycast.intersect_mouse_2d_bounding_box(mouse_pos, bbox_2d):
                     if tool.Raycast.object_is_visible_in_clipping_plane(obj):
-                        snap_obj = cls.create_snap_obj(obj)
-                        objs_to_raycast.append(snap_obj)
+                        objs_to_raycast.append(obj)
 
         return objs_to_raycast
 
@@ -748,6 +474,12 @@ class Raycast(bonsai.core.tool.Raycast):
         face_index = None
         # Wireframes
         if obj.type in {"EMPTY", "CURVE"} or (hasattr(obj.data, "polygons") and len(obj.data.polygons) == 0):
+            snap_points = tool.Raycast.ray_cast_by_proximity(context, event, obj)
+            if snap_points:
+                hit = sorted(snap_points, key=lambda x: x["distance"])[0]["point"]
+                if hit:
+                    hit_world = obj.original.matrix_world @ hit
+                    return obj, hit_world, face_index
             return None, None, None
         # Meshes
         else:
@@ -782,20 +514,19 @@ class Raycast(bonsai.core.tool.Raycast):
 
         ray_origin, ray_target, ray_direction = cls.get_viewport_ray_data(context, event)
 
-        for snap_obj in objs_to_raycast:
+        for obj in objs_to_raycast:
             if not include_wireframes and (
-                snap_obj.obj.type in {"EMPTY", "CURVE"}
-                or (hasattr(snap_obj.obj.data, "polygons") and len(snap_obj.obj.data.polygons) == 0)
+                obj.type in {"EMPTY", "CURVE"} or (hasattr(obj.data, "polygons") and len(obj.data.polygons) == 0)
             ):
                 continue
 
-            hit_obj, hit, face_index = cls.cast_rays_to_single_object(context, event, snap_obj.obj)
+            snap_obj, hit, face_index = cls.cast_rays_to_single_object(context, event, obj)
 
             if hit is not None:
                 length_squared = (hit - ray_origin).length_squared
                 if best_obj is None or length_squared < best_length_squared:
                     best_length_squared = length_squared
-                    best_obj = hit_obj
+                    best_obj = snap_obj
                     best_hit = hit
                     best_face_index = face_index
 
@@ -805,81 +536,6 @@ class Raycast(bonsai.core.tool.Raycast):
         else:
             return None, None, None
 
-    @classmethod
-    def ray_cast_and_get_closest_to_camera_snaps(
-        cls,
-        context: bpy.types.Context,
-        event: bpy.types.Event,
-        objs_to_raycast: list[bpy.types.Object],
-    ) -> Union[tuple[bpy.types.Object, Vector, int], tuple[None, None, None]]:
-        closest_length_squared = 1.0
-        closest_obj = None
-        closest_hit = None
-        closest_face_index = None
-
-        ray_origin, ray_target, ray_direction = cls.get_viewport_ray_data(context, event)
-
-        closest_snaps = []
-        hit = None
-
-        for snap_obj in objs_to_raycast:
-            if (snap_obj.obj.type in {"EMPTY", "CURVE"}
-                or (hasattr(snap_obj.obj.data, "polygons") and len(snap_obj.obj.data.polygons) == 0)
-            ):
-                # For wireframe objects we have to test all the snaps to see which is closer
-                snap_points = tool.Raycast.ray_cast_by_proximity_2d(context, event, snap_obj)
-                closest_wf_hit = None
-                closest_wf_length_squared = 1.0
-                closest_wf_point = None
-                if snap_points:
-                    for point in snap_points:
-                        point["group"] = "Wireframe"
-                        closest_snaps.append(point)
-                        length = (point["point"] - ray_origin).length_squared
-                        if closest_wf_hit is None or length < closest_wf_length_squared:
-                            closest_wf_length_squared = length
-                            closest_wf_hit = point["point"]
-                            closest_wf_point = point
-
-                    if closest_wf_point:
-                        hit_obj = closest_wf_point["object"]
-                        hit = closest_wf_point["point"]
-                        face_index = None
-
-
-            else:
-                # Solid objects
-                hit_obj, hit, face_index = cls.cast_rays_to_single_object(context, event, snap_obj.obj)
-
-                if hit:
-                    snap_point = {
-                        "point": hit,
-                        "type": "Face",
-                        "group": "Object",
-                        "object": hit_obj,
-                        "face_index": face_index,
-                        "distance": 9,  # High value so it has low priority
-                    }
-                    closest_snaps.append(snap_point)
-            
-
-            # Here we test which is closer, including wireframe and solid objects
-            if hit is not None:
-                length_squared = (hit - ray_origin).length_squared
-                if closest_obj is None or length_squared < closest_length_squared:
-                    closest_length_squared = length_squared
-                    closest_obj = hit_obj
-                    closest_hit = hit
-                    closest_face_index = face_index
-
-        # Label snaps from the closest object
-        if closest_obj is not None:
-            for snap in closest_snaps:
-                if snap["object"] == closest_obj:
-                    snap["is_closest_to_camera"] = True
-
-        return closest_snaps
-
     @classmethod
     def calculate_snap_threshold(cls, view_distance):
         snap_threshold = view_distance / 100
@@ -891,260 +547,3 @@ class Raycast(bonsai.core.tool.Raycast):
         if lens < 50:
             snap_threshold *= value
         return snap_threshold
-
-    @classmethod
-    def create_snap_obj(cls, obj):
-        for snap_obj in cls.snap_objs:
-            if obj.name == snap_obj.obj.name:
-                return snap_obj
-        snap_obj = SnapObj(obj)
-        cls.snap_objs.append(snap_obj)
-        return snap_obj
-
-    @classmethod
-    def clear_snap_objs(cls):
-        TreeNode.__clear_all__()
-        SnapObj.__clear_all__()
-        cls.snap_objs.clear()
-
-
-class TreeNode:
-    all = []
-
-    def __init__(self, box: tuple):
-        self.__class__.all.append(self)
-        self.box = box
-        self.child_a = None
-        self.child_b = None
-        self.edges = []
-
-    def __clear_all__():
-        for instance in TreeNode.all:
-            del instance
-        TreeNode.all.clear()
-
-
-class SnapObj:
-    max_depth = 9
-    all = []
-
-    def __init__(self, obj: bpy.types.Object):
-        self.__class__.all.append(self)
-        self.obj = obj
-        self.root = self._create_root_node()
-        self.root.edges = [e.index for e in obj.data.edges]
-        self.split_box(self.root, 0)
-        self.verts_3d = [obj.matrix_world @ v.co for v in obj.data.vertices]
-        self.snap_points = []
-
-    def __clear_all__():
-        for instance in SnapObj.all:
-            del instance
-        SnapObj.all.clear()
-
-    def _create_root_node(self) -> TreeNode:
-        bbox = tool.Blender.get_object_bounding_box(self.obj)
-        min_point = self.obj.matrix_world @ bbox["min_point"]
-        max_point = self.obj.matrix_world @ bbox["max_point"]
-        new_bbox = self.expand_bounding_box((min_point, max_point))
-        return TreeNode(new_bbox)
-
-    def divide_bounding_box_along_longest_axis(
-        self, min_pt: Vector, max_pt: Vector
-    ) -> Union[tuple[Vector, Vector], tuple[Vector, Vector]]:
-        """
-        Divide a bounding box into two equal parts along the axis with the longest dimension.
-
-        Args:
-            min_pt: The minimum point of the bounding box.
-            max_pt: The maximum point of the bounding box.
-
-        Returns:
-            list: A list of two tuples, each containing the minimum and maximum points of the divided boxes.
-        """
-
-        # Calculate the dimensions of the box
-        dx = max_pt.x - min_pt.x
-        dy = max_pt.y - min_pt.y
-        dz = max_pt.z - min_pt.z
-
-        # Determine the axis with the longest dimension
-        if dx >= dy and dx >= dz:
-            # Divide along the x-axis
-            mid_x = min_pt.x + dx / 2
-            box1 = (min_pt, Vector((mid_x, max_pt.y, max_pt.z)))
-            box2 = (Vector((mid_x, min_pt.y, min_pt.z)), max_pt)
-        elif dy >= dx and dy >= dz:
-            # Divide along the y-axis
-            mid_y = min_pt.y + dy / 2
-            box1 = (min_pt, Vector((max_pt.x, mid_y, max_pt.z)))
-            box2 = (Vector((min_pt.x, mid_y, min_pt.z)), max_pt)
-        else:
-            # Divide along the z-axis
-            mid_z = min_pt.z + dz / 2
-            box1 = (min_pt, Vector((max_pt.x, max_pt.y, mid_z)))
-            box2 = (Vector((min_pt.x, min_pt.y, mid_z)), max_pt)
-
-        return [box1, box2]
-
-    def expand_bounding_box(self, box: tuple[Vector, Vector], offset: float = 0.1) -> tuple[Vector, Vector]:
-        """
-        Expand a 3D bounding box by a given offset.
-
-        Args:
-            min_pt: The minimum point of the bounding box.
-            max_pt: The maximum point of the bounding box.
-            offset: The offset to expand the bounding box by.
-
-        Returns:
-            tuple: A tuple containing the new minimum and maximum points of the expanded bounding box.
-        """
-
-        min_pt, max_pt = box
-        # Calculate the new minimum and maximum points
-        new_min_pt = Vector((min_pt.x - offset, min_pt.y - offset, min_pt.z - offset))
-        new_max_pt = Vector((max_pt.x + offset, max_pt.y + offset, max_pt.z + offset))
-
-        return new_min_pt, new_max_pt
-
-    def split_box(self, parent: TreeNode, depth: int):
-        """
-        Splits the bounding box creating two child nodes to compose a BVH Tree recursively.
-
-        Args:
-            parent: the TreeNode instance that represents the parent node of a BVH Tree.
-            depth: the depth of the BVH Tree no be used in recursion.
-        """
-        if depth > self.max_depth:
-            return
-        box_a, box_b = self.divide_bounding_box_along_longest_axis(parent.box[0], parent.box[1])
-        parent.child_a = TreeNode(box_a)
-        parent.child_b = TreeNode(box_b)
-        edges_a = []
-        edges_b = []
-        for e in parent.edges:
-            verts_idx = [v for v in self.obj.data.edges[e].vertices]
-            verts_coords = []
-            for idx in verts_idx:
-                if idx < len(self.obj.data.vertices):
-                    verts_coords.append(self.obj.matrix_world @ self.obj.data.vertices[idx].co)
-            if self.line_intersects_box(verts_coords[0], verts_coords[1], parent.child_a.box):
-                edges_a.append(e)
-            if self.line_intersects_box(verts_coords[0], verts_coords[1], parent.child_b.box):
-                edges_b.append(e)
-        parent.child_a.edges = edges_a
-        parent.child_b.edges = edges_b
-        self.split_box(parent.child_a, depth + 1)
-        self.split_box(parent.child_b, depth + 1)
-
-    def raycast_box(
-        self, context: bpy.types.Context, event: bpy.types.Event, node: TreeNode, rays: tuple[Vector, Vector]
-    ) -> bool:
-        """
-        Raycast bounding box.
-
-        Args:
-            context: Blender context.
-            event: Blender event.
-            node: a TreeNode instance.
-            rays: tuple containing ray origin and ray direction
-
-        Returns:
-            True if hits the box or False otherwise.
-        """
-        box = node.box
-        min_v = box[0]
-        max_v = box[1]
-        t_min = 0.0
-        t_max = float("inf")
-        ray_origin, ray_dir = rays
-        inv_dir = Vector((1.0 / r if r != 0.0 else 1e32) for r in (ray_dir.x, ray_dir.y, ray_dir.z))
-        # X
-        tx1 = (min_v.x - ray_origin.x) * inv_dir[0]
-        tx2 = (max_v.x - ray_origin.x) * inv_dir[0]
-        tmin = min(tx1, tx2)
-        tmax = max(tx1, tx2)
-        # Y
-        ty1 = (min_v.y - ray_origin.y) * inv_dir[1]
-        ty2 = (max_v.y - ray_origin.y) * inv_dir[1]
-        tmin = max(tmin, min(ty1, ty2))
-        tmax = min(tmax, max(ty1, ty2))
-        # Z
-        tz1 = (min_v.z - ray_origin.z) * inv_dir[2]
-        tz2 = (max_v.z - ray_origin.z) * inv_dir[2]
-        tmin = max(tmin, min(tz1, tz2))
-        tmax = min(tmax, max(tz1, tz2))
-        return (tmax >= max(tmin, t_min)) and (tmin <= t_max)
-
-    def line_intersects_box(self, v1: mathutils.Vector, v2: mathutils.Vector, box: tuple) -> bool:
-        """
-        Check if a line segment intersects an axis-aligned bounding box (AABB).
-
-        Args:
-            v1: The first endpoint of the line segment as a mathutils.Vector.
-            v2: The second endpoint of the line segment as a mathutils.Vector.
-            box: A tuple containing the minimum and maximum points of the AABB, where each point is a mathutils.Vector.
-
-        Returns:
-            bool: True if the segment [v1, v2] intersects the AABB; otherwise, False.
-        """
-        bmin, bmax = box
-        dir = v2 - v1
-        tmin = 0.0
-        tmax = 1.0
-
-        for i in range(3):
-            if abs(dir[i]) < 1e-12:
-                # Line is parallel to slab. If origin not within slab -> no hit.
-                if v1[i] < bmin[i] or v1[i] > bmax[i]:
-                    return False
-            else:
-                ood = 1.0 / dir[i]
-                t1 = (bmin[i] - v1[i]) * ood
-                t2 = (bmax[i] - v1[i]) * ood
-                if t1 > t2:
-                    t1, t2 = t2, t1
-                if t1 > tmin:
-                    tmin = t1
-                if t2 < tmax:
-                    tmax = t2
-                if tmin > tmax:
-                    return False
-
-        # If any overlap in [0,1] exists, there's intersection
-        return (tmax >= 0.0) and (tmin <= 1.0)
-
-    def raycast_boxes(
-        self,
-        context: bpy.types.Context,
-        event: bpy.Types.Event,
-        node: TreeNode,
-        intersected: Union[TreeNode] = [],
-        rays: tuple[Vector, Vector] = (),
-    ) -> Union[TreeNode]:
-        """
-        Raycast bounding box subdivisions recursively.
-
-        Args:
-            context: Blender context.
-            event: Blender event.
-            node: a TreeNode instance.
-            intersected: list of intersected boxes to use in recursion.
-            rays: tuple containing ray origin and ray direction
-
-        Returns:
-            tuple: a list of TreeNode instances that represent the subdivided boxes hit by the ray cast.
-        """
-        if not node.child_a:
-            intersected.append(node)
-            return intersected
-
-        intersects_a = self.raycast_box(context, event, node.child_a, rays)
-        intersects_b = self.raycast_box(context, event, node.child_b, rays)
-        if intersects_a:
-            intersected = self.raycast_boxes(context, event, node.child_a, intersected, rays)
-
-        if intersects_b:
-            intersected = self.raycast_boxes(context, event, node.child_b, intersected, rays)
-
-        return intersected

src/bonsai/bonsai/tool/snap.py

@@ -360,7 +360,6 @@ class Snap(bonsai.core.tool.Snap):
             plane_normal = tool.Polyline.use_transform_orientations(plane_normal)
             return plane_origin, plane_normal
 
-
         # Polyline
         polyline_props = tool.Model.get_polyline_props()
         try:
@@ -389,31 +388,58 @@ class Snap(bonsai.core.tool.Snap):
 
         # Objects
         objs_to_raycast = tool.Raycast.filter_objects_to_raycast(context, event, objs_2d_bbox)
-        closest_snaps = tool.Raycast.ray_cast_and_get_closest_to_camera_snaps(context, event, objs_to_raycast)
-        detected_snaps.extend(closest_snaps)
-
-        xray_mode = (space.shading.type == "SOLID" and space.shading.show_xray) or (space.shading.type == "WIREFRAME" and space.shading.show_xray_wireframe)
-
+        # Wireframes
+        # For wireframe we have to get all the objects so we can further calculate edge intersection
         for snap_obj in objs_to_raycast:
-            for snap in closest_snaps:
-                if snap_obj.obj == snap["object"]:
-                    if xray_mode:
-                        if "face_index" in snap and snap["face_index"] is not None:
-                            snap_points = tool.Raycast.ray_cast_by_proximity_2d(context, event, snap_obj)
-                            for point in snap_points:
-                                point["group"] = "Object"
-                                detected_snaps.append(point)
-                    else:
-                        # If it is a solid object that is closest to camera it ignores all the rest
-                        if "is_closest_to_camera" in snap and snap["is_closest_to_camera"] and snap["group"] == "Object":
-                            closest_snap = [snap] # discards objects that aren't the closest
-                            if "face_index" in snap and snap["face_index"] is not None:
-                                snap_points = tool.Raycast.ray_cast_by_proximity_2d(context, event, snap_obj)
-                                for point in snap_points:
-                                    point["group"] = "Object"
-                                    closest_snap.append(point)
-                            detected_snaps = closest_snap
-                        
+            if snap_obj.type in {"EMPTY", "CURVE"} or (snap_obj.type == "MESH" and len(snap_obj.data.polygons) == 0):
+                snap_points = tool.Raycast.ray_cast_by_proximity(context, event, snap_obj)
+                if snap_points:
+                    for point in snap_points:
+                        point["group"] = "Wireframe"
+                        detected_snaps.append(point)
+
+        if (space.shading.type == "SOLID" and space.shading.show_xray) or (
+            space.shading.type == "WIREFRAME" and space.shading.show_xray_wireframe
+        ):
+            results = []
+            for obj in objs_to_raycast:
+                results.append(tool.Raycast.cast_rays_to_single_object(context, event, obj))
+        else:
+            results = []
+            results.append(tool.Raycast.cast_rays_and_get_best_object(context, event, objs_to_raycast))
+
+        for result in results:
+            snap_obj = result[0]
+            hit = result[1]
+            face_index = result[2]
+            if hit is not None:
+                # Wireframes
+                if snap_obj.type in {"EMPTY", "CURVE"} or (
+                    snap_obj.type == "MESH" and len(snap_obj.data.polygons) == 0
+                ):
+                    continue
+                # Meshes
+                else:
+                    # Add face snap
+                    snap_point = {
+                        "point": hit,
+                        "type": "Face",
+                        "group": "Object",
+                        "object": snap_obj,
+                        "face_index": face_index,
+                        "distance": 9,  # High value so it has low priority
+                    }
+                    detected_snaps.append(snap_point)
+
+                    # Add vertex and edge snap
+                    snap_points = tool.Raycast.ray_cast_by_proximity(
+                        context, event, snap_obj, snap_obj.data.polygons[face_index]
+                    )
+                    if snap_points:
+                        for point in snap_points:
+                            point["group"] = "Object"
+                            detected_snaps.append(point)
+
         # snap to cut geometry (e.g. in plan view)
         if CutDecorator.installed:
             cut_snaps = []

src/bonsai/test/bim/feature/model.feature

@@ -396,44 +396,6 @@ Scenario: Add a slab
     And the object "IfcSlab/Slab" bottom left corner is at "0,0,0"
     And the object "IfcSlab/Slab" top right corner is at "1,1,0.2"
 
-Scenario: Extend walls to underside
-    Given an empty IFC project
-    And I load the demo construction library
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "element_type" is "[e for e in {ifc}.by_type('IfcWallType') if e.Name == 'WAL100'][0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{element_type}"
-    And I press "bim.add_occurrence"
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcSlabType"
-    And the variable "element_type" is "[e for e in {ifc}.by_type('IfcSlabType') if e.Name == 'FLR200'][0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{element_type}"
-    And I press "bim.add_occurrence"
-    And the object "IfcSlab/Slab" is moved to "0,0,2.5"
-    When the object "IfcWall/Wall" is selected
-    And additionally the object "IfcSlab/Slab" is selected
-    And I look at the tool header
-    And I click "Extend To Underside"
-    Then the object "IfcWall/Wall" dimensions are "1,0.1,2.5"
-
-Scenario: Extend walls to underside - extending to a tessellated gable roof
-    Given an empty IFC project
-    And I load the demo construction library
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "element_type" is "[e for e in {ifc}.by_type('IfcWallType') if e.Name == 'WAL100'][0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{element_type}"
-    And I press "bim.add_occurrence"
-    # Create gable roof: a cube turned into a prism with a ridge.
-    And I add a cube of size "1" at "0.5,0.05,3"
-    And the object "Cube" is selected
-    And I evaluate expression "obj = bpy.context.active_object; [setattr(v.co, 'y', 0) for v in obj.data.vertices if v.co.z > 0]"
-    And I set "scene.BIMRootProperties.ifc_product" to "IfcElement"
-    And I set "scene.BIMRootProperties.ifc_class" to "IfcRoof"
-    And I press "bim.assign_class"
-    When the object "IfcWall/Wall" is selected
-    And additionally the object "IfcRoof/Cube" is selected
-    And I look at the tool header
-    And I click "Extend To Underside"
-    Then the object "IfcWall/Wall" dimensions are "1,0.1,2.5"
-
 Scenario: Enable editing a slab profile
     Given an empty IFC project
     And I load the demo construction library

src/bonsai/test/bim/test_feature.py

@@ -133,11 +133,7 @@ class PanelSpy:
             self.spied_labels.append(kwargs["text"])
             return self
         elif self.spied_attr == "prop":
-            if args:
-                props, name = args
-            else:
-                props = kwargs.get("data")
-                name = kwargs.get("property")
+            props, name = args
             props: bpy.types.bpy_struct
             text = kwargs.get("text", props.bl_rna.properties[name].name)
             icon = kwargs.get("icon", None)
@@ -394,32 +390,6 @@ def i_look_at_the_panel_panel(panel: str) -> None:
     panel_spy.refresh_spy()
 
 
-@given(parsers.parse("I look at the tool header"))
-@when(parsers.parse("I look at the tool header"))
-@then(parsers.parse("I look at the tool header"))
-def i_look_at_the_tool_header() -> None:
-    from bonsai.bim.module.model.workspace import EditObjectUI
-
-    class MockRegion:
-        type = "UI"
-
-    class MockContext:
-        def __getattr__(self, name):
-            if name == "region":
-                return MockRegion()
-            return getattr(bpy.context, name)
-
-    global panel_spy
-    panel_spy = PanelSpy(EditObjectUI)
-    panel_spy.is_spy_dirty = False
-    panel_spy.spied_attr = None
-    panel_spy.spied_labels = []
-    panel_spy.spied_props = []
-    panel_spy.spied_operators = []
-    panel_spy.spied_lists = []
-    EditObjectUI.draw(MockContext(), panel_spy)
-
-
 @given(parsers.parse('I open the "{name}" menu'))
 @when(parsers.parse('I open the "{name}" menu'))
 @then(parsers.parse('I open the "{name}" menu'))

src/ifcmcp/README.md

@@ -1,401 +0,0 @@
-<!-- This file was generated with the assistance of an AI coding tool. -->
-# ifcmcp
-
-An MCP (Model Context Protocol) server that wraps `ifcquery` and `ifcedit`,
-holding the IFC model in memory across tool calls for fast interactive editing
-sessions.
-
-## Installation
-
-```bash
-pip install ifcmcp
-```
-
-Requires `ifcopenshell`, `ifcquery`, and `ifcedit`. The `mcp` package is an optional dependency needed to run the server; install it with `pip install ifcmcp[mcp]` or add `mcp` separately.
-
-## Running the server
-
-```bash
-python3 -m ifcmcp
-```
-
-This starts the server on stdio transport, suitable for use with Claude Code
-or any MCP client.
-
-### Claude Code configuration
-
-Use the `claude mcp add` command:
-
-```bash
-claude mcp add --transport stdio ifc -- python3 -m ifcmcp
-```
-
-Or create a `.mcp.json` file in your project root:
-
-```json
-{
-  "mcpServers": {
-    "ifc": {
-      "type": "stdio",
-      "command": "python3",
-      "args": ["-m", "ifcmcp"]
-    }
-  }
-}
-```
-
-After adding the server, restart Claude Code for the tools to become available.
-Then load a model by asking Claude to use `ifc_load`:
-
-```
-load model.ifc using ifc_load
-```
-
-## Tools
-
-### Session
-
-#### ifc_new
-
-Create a new empty IFC model in memory, replacing any currently loaded model.
-
-```
-ifc_new()
-ifc_new(schema="IFC4X3")
-```
-
-Default schema is `IFC4`.
-
-#### ifc_load
-
-Open an IFC file into memory.
-
-```
-ifc_load(path="/path/to/model.ifc")
--> "Loaded /path/to/model.ifc: schema IFC4, 1847 entities"
-```
-
-#### ifc_reset
-
-Unload the current model from memory, freeing all session state.
-
-```
-ifc_reset()
-```
-
-#### ifc_save
-
-Write the in-memory model to disk. Empty path overwrites the original file.
-
-```
-ifc_save()
-ifc_save(path="/path/to/output.ifc")
-```
-
-### Query tools
-
-All query tools require a model to be loaded first via `ifc_load`.
-
-#### ifc_summary
-
-Model overview: schema, entity counts, project info.
-
-```json
-{
-  "schema": "IFC4",
-  "total_entities": 1847,
-  "project": {"id": 1, "name": "Office Building"},
-  "types": {"IfcWall": 42, "IfcSlab": 12, "IfcWindow": 36}
-}
-```
-
-#### ifc_tree
-
-Full spatial hierarchy from IfcProject down through sites, buildings, storeys,
-and contained elements.
-
-```json
-{
-  "id": 1,
-  "type": "IfcProject",
-  "name": "Office Building",
-  "children": [
-    {
-      "id": 2,
-      "type": "IfcSite",
-      "children": [{"id": 3, "type": "IfcBuilding", "children": ["..."]}]
-    }
-  ]
-}
-```
-
-#### ifc_info
-
-Deep inspection of an entity by step ID: attributes, property sets, type,
-material, container, and 4x4 placement matrix.
-
-```
-ifc_info(element_id=10)
-```
-
-#### ifc_select
-
-Filter elements using ifcopenshell selector syntax.
-
-```
-ifc_select(query="IfcWall")
-ifc_select(query="IfcWindow")
-```
-
-Returns a sorted list of `{"id", "type", "name"}` references.
-
-#### ifc_relations
-
-Show all relationships for an element: hierarchy, children, type, groups,
-systems, material, connections.
-
-```
-ifc_relations(element_id=10)
-ifc_relations(element_id=10, traverse="up")
-```
-
-With `traverse="up"`, walks the hierarchy from element up to IfcProject.
-
-#### ifc_contexts
-
-List all geometric representation contexts and subcontexts in the loaded model.
-
-```
-ifc_contexts()
-```
-
-#### ifc_materials
-
-List all materials and material sets in the loaded model, with their assigned elements.
-
-```
-ifc_materials()
-```
-
-#### ifc_clash
-
-Check an element for geometric intersections and clearance violations.
-
-```
-ifc_clash(element_id=10)
-ifc_clash(element_id=10, clearance=0.5, scope="all")
-```
-
-Parameters:
-
-- `clearance` -- minimum clearance distance in meters (0.0 = no clearance check)
-- `tolerance` -- intersection tolerance in meters (default: 0.002)
-- `scope` -- `"storey"` or `"all"` (default: `"storey"`)
-
-#### ifc_validate
-
-Check the model for schema and constraint violations.
-
-```
-ifc_validate()
-ifc_validate(express_rules=True)
-```
-
-Returns `{"valid": true, "issues": []}` or `{"valid": false, "issues": [{"level": "ERROR", "message": "..."}]}`.
-
-#### ifc_schedule
-
-List all work schedules and their nested task trees.
-
-```
-ifc_schedule()
-ifc_schedule(max_depth=1)   # top-level phases only
-```
-
-`max_depth` limits subtask expansion. At the cutoff, `subtasks` is replaced
-with `{"truncated": true, "count": N}` so you know children exist without
-fetching them all. Omit for unlimited depth.
-
-#### ifc_cost
-
-List all cost schedules and their nested cost item trees.
-
-```
-ifc_cost()
-ifc_cost(max_depth=2)   # top two levels of the BoQ
-```
-
-`max_depth` limits cost item expansion, same truncation convention as
-`ifc_schedule`.
-
-#### ifc_schema
-
-Return IFC class documentation for any entity type, using the loaded model's
-schema version.
-
-```
-ifc_schema(entity_type="IfcWall")
-ifc_schema(entity_type="IfcBuildingStorey")
-```
-
-Returns description, predefined types, spec URL, and attribute descriptions.
-Returns `{"error": "Unknown entity: Foo"}` for unrecognised types.
-
-#### ifc_quantify
-
-Run quantity take-off (QTO) on the loaded model using an `ifc5d` rule.
-Computes physical measurements (volume, area, length, count, weight) and
-writes them back as `IfcElementQuantity` property sets. Modifies the model
-in-place -- call `ifc_save()` when done.
-
-```
-ifc_quantify(rule="IFC4QtoBaseQuantities")
-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`).
-
-Returns `{"ok": true, "rule": "...", "elements_quantified": 42}`.
-
-### Drawing and rendering tools
-
-#### ifc_plot
-
-Generate a 2D technical drawing of the loaded model and return it as an inline image.
-
-```
-ifc_plot()
-ifc_plot(selector="IfcWall", view="floorplan", scale=0.01, output_path="/tmp/plan.svg")
-ifc_plot(element_ids=[10, 11], view="floorplan")
-```
-
-Parameters:
-
-- `selector` -- ifcopenshell selector to restrict plotted elements
-- `element_ids` -- step IDs of elements to highlight; others are faded
-- `view` -- `"floorplan"` (default), `"elevation"`, `"section"`, or `"auto"`
-- `width_mm`, `height_mm` -- paper size in mm (default: 297 x 420)
-- `scale` -- model-to-paper ratio (default: 0.01 = 1:100)
-- `png_width`, `png_height` -- raster output size in pixels (default: 1024 x 1024)
-- `output_path` -- optional path to also save to disk (`.svg` for vector, otherwise PNG)
-
-Returns an inline PNG the LLM can inspect. Requires `ifcopenshell.draw`.
-
-#### ifc_render
-
-Render the loaded model to a 3D PNG image.
-
-```
-ifc_render()
-ifc_render(selector="IfcWall", view="iso", output_path="/tmp/model.png")
-ifc_render(element_ids=[10, 11], view="south")
-```
-
-Parameters:
-
-- `selector` -- ifcopenshell selector to restrict rendered elements
-- `element_ids` -- step IDs of elements to highlight; others are shown translucent
-- `view` -- `"iso"` (default), `"top"`, `"south"`, `"north"`, `"east"`, or `"west"`
-- `output_path` -- optional path to save the PNG to disk
-
-Returns an inline PNG. Requires `pyvista` and the IfcOpenShell C++ geometry bindings.
-
-### Shape builder tools
-
-#### ifc_shape_list
-
-List all available `ShapeBuilder` methods with brief descriptions.
-
-```
-ifc_shape_list()
-```
-
-#### ifc_shape_docs
-
-Show full documentation for a specific `ShapeBuilder` method.
-
-```
-ifc_shape_docs(method="extrude")
-ifc_shape_docs(method="create_ellipse")
-```
-
-#### ifc_shape
-
-Execute a `ShapeBuilder` method on the loaded model.
-
-```
-ifc_shape(method="extrude", params='{"profile": "42", "magnitude": 3.0}')
-```
-
-`params` is a JSON string; entity references are resolved by step ID (same coercion as `ifc_edit`).
-
-### Edit discovery tools
-
-#### ifc_list
-
-List all API modules, or functions within a specific module.
-
-```
-ifc_list()              # all modules
-ifc_list(module="root") # functions in the root module
-```
-
-#### ifc_docs
-
-Show full documentation for an API function including parameters, types,
-defaults, and descriptions.
-
-```
-ifc_docs(function_path="root.create_entity")
-```
-
-### Edit execution
-
-#### ifc_edit
-
-Execute an `ifcopenshell.api` mutation function. Parameters are passed as a
-JSON string with string values that get coerced by ifcedit's type system.
-
-```
-ifc_edit(
-    function_path="root.create_entity",
-    params='{"ifc_class": "IfcWall", "name": "My Wall"}'
-)
-```
-
-Returns `{"ok": true, "result": ...}` or `{"ok": false, "error": "..."}`.
-
-Does NOT auto-save -- call `ifc_save()` when ready to write changes to disk.
-
-**Parameter coercion:**
-
-| Type | JSON value | Python value |
-|------|------------|--------------|
-| `entity_instance` | `"42"` | resolved from model by step ID |
-| `list[entity_instance]` | `"5,6,7"` | list of resolved entities |
-| `dict` | `'{"key": "val"}'` | parsed JSON object |
-| `bool` | `"true"` | `True` |
-| `Optional[X]` | `"none"` | `None` |
-
-## Typical workflow
-
-1. **Load** a model: `ifc_load`
-2. **Inspect** with query tools: `ifc_summary`, `ifc_tree`, `ifc_select`, `ifc_info`, `ifc_relations`
-3. **Validate** if needed: `ifc_validate`
-4. **Browse schedules / costs**: `ifc_schedule`, `ifc_cost` (use `max_depth=1` first on large projects)
-5. **Look up IFC classes**: `ifc_schema`
-6. **Find** the right API function: `ifc_list`, `ifc_docs`
-7. **Edit** the model: `ifc_edit`
-8. **Quantify** elements: `ifc_quantify` (writes QTO psets in-place)
-9. **Verify** changes with query tools
-10. **Save** when satisfied: `ifc_save`
-
-The model stays in memory across all calls, so multi-step editing sessions
-are fast -- no file I/O between operations.
-
-## License
-
-LGPLv3+ -- see the IfcOpenShell project license.

src/ifcmcp/ifcmcp/__init__.py

@@ -1,20 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-# IfcMCP - MCP server for IFC building models
-# Copyright (C) 2026 Bruno Postle <bruno@postle.net>
-#
-# This file is part of IfcMCP.
-#
-# IfcMCP is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# IfcMCP 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 Lesser General Public License
-# along with IfcMCP.  If not, see <http://www.gnu.org/licenses/>.
-
-__version__ = version = "0.0.0"

src/ifcmcp/ifcmcp/__main__.py

@@ -1,48 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-import argparse
-
-from ifcmcp import __version__
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        prog="python3 -m ifcmcp",
-        description=(
-            "ifcmcp — MCP server for IFC building models.\n\n"
-            "Runs a Model Context Protocol server over stdio so that MCP clients\n"
-            "can query and edit IFC files without writing them to disk between\n"
-            "operations.\n\n"
-            "Add to .mcp.json to configure:\n"
-            '  {"mcpServers": {"ifc": {"type": "stdio", "command": "python3", "args": ["-m", "ifcmcp"]}}}'
-        ),
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--version", action="version", version=f"ifcmcp {__version__}")
-    parser.add_argument(
-        "--transport",
-        choices=["stdio", "sse", "streamable-http"],
-        default="stdio",
-        help="MCP transport to use (default: stdio)",
-    )
-
-    args = parser.parse_args()
-
-    try:
-        from mcp.server.fastmcp import FastMCP  # noqa: F401
-    except ImportError:
-        import sys
-        print(
-            "error: the 'mcp' package is required to run the server.\n"
-            "Install it with:  pip install mcp",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    from ifcmcp.server import build_server
-
-    server = build_server()
-    server.run(transport=args.transport)
-
-
-if __name__ == "__main__":
-    main()

src/ifcmcp/ifcmcp/core.py

@@ -1,731 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-from __future__ import annotations
-
-# inside ifcmcp/core.py
-import json
-from collections.abc import Callable  # noqa: F401 — Callable used in helpers below
-from dataclasses import dataclass
-from typing import Any
-
-import ifcopenshell
-from ifcedit.discover import function_docs, list_functions, list_modules
-from ifcedit.quantify import run_quantify
-from ifcedit.run import run_api
-from ifcquery import clash as clash_mod
-from ifcquery import contexts as contexts_mod
-from ifcquery import cost as cost_mod
-from ifcquery import (
-    info,
-    relations,
-    schedule,
-    schema,
-    select,
-    summary,
-    tree,
-)
-from ifcquery import (
-    materials as materials_mod,
-)
-from ifcquery import (
-    plot as plot_mod,
-)
-from ifcquery import (
-    render as render_mod,
-)
-from ifcquery import validate as validate_mod
-
-
-def _jsonify(x: Any) -> Any:
-    """Convert IfcOpenShell objects / iterables into JSON-safe primitives."""
-    if x is None or isinstance(x, (str, int, float, bool)):
-        return x
-
-    # numpy arrays (and any array-like with tolist)
-    if hasattr(x, "tolist"):
-        return x.tolist()
-
-    # IfcOpenShell entity instances: normalize
-    if isinstance(x, ifcopenshell.entity_instance):
-        return {
-            "id": int(x.id()),
-            "type": x.is_a(),
-            "repr": str(x),
-            "name": getattr(x, "Name", None),
-        }
-
-    if isinstance(x, dict):
-        return {str(k): _jsonify(v) for k, v in x.items()}
-
-    if isinstance(x, (list, tuple, set)):
-        return [_jsonify(v) for v in x]
-
-    # Try JSON as-is, else fallback to string
-    try:
-        json.dumps(x)
-        return x
-    except Exception:
-        return str(x)
-
-
-# ---------------------------------------------------------------------------
-# Shape builder helpers
-# ---------------------------------------------------------------------------
-
-
-def _list_shape_methods() -> list[dict]:
-    """Introspect ShapeBuilder and return a summary of all public methods."""
-    import inspect
-
-    from ifcedit.discover import _extract_params
-    from ifcopenshell.util.shape_builder import ShapeBuilder
-
-    results = []
-    for name, fn in inspect.getmembers(ShapeBuilder, predicate=inspect.isfunction):
-        if name.startswith("_"):
-            continue
-        doc = fn.__doc__ or ""
-        description = doc.strip().split("\n")[0] if doc.strip() else ""
-        results.append({"method": name, "description": description, "params": _extract_params(fn)})
-    return results
-
-
-def _shape_method_docs(method_name: str) -> dict:
-    """Return full documentation for a single ShapeBuilder method."""
-    import typing
-
-    from ifcedit.discover import (
-        _extract_params,
-        _format_type_hint,
-        _parse_docstring_body,
-        _parse_param_docs,
-        _parse_return_doc,
-    )
-    from ifcopenshell.util.shape_builder import ShapeBuilder
-
-    if method_name.startswith("_"):
-        raise ValueError(f"ShapeBuilder has no method '{method_name}'")
-    fn = getattr(ShapeBuilder, method_name, None)
-    if fn is None:
-        raise ValueError(f"ShapeBuilder has no method '{method_name}'")
-
-    doc = fn.__doc__ or ""
-    description, long_description = _parse_docstring_body(doc)
-    params = _extract_params(fn)
-    for param in params:
-        param_desc = _parse_param_docs(doc)
-        if param["name"] in param_desc:
-            param["description"] = param_desc[param["name"]]
-
-    try:
-        hints = typing.get_type_hints(fn)
-    except Exception:
-        hints = {}
-
-    result: dict[str, Any] = {
-        "method": method_name,
-        "description": description,
-        "long_description": long_description,
-        "params": params,
-    }
-    return_type = _format_type_hint(hints.get("return"))
-    if return_type:
-        result["return_type"] = return_type
-    return_description = _parse_return_doc(doc)
-    if return_description:
-        result["return_description"] = return_description
-    return result
-
-
-def _coerce_shape_params(fn: Callable, raw_kwargs: dict, model: ifcopenshell.file) -> dict:
-    """Coerce JSON-parsed kwargs to proper Python types for a ShapeBuilder method."""
-    import inspect
-    import typing
-
-    sig = inspect.signature(fn)
-    try:
-        hints = typing.get_type_hints(fn)
-    except Exception:
-        hints = {}
-
-    return {
-        key: _coerce_shape_value(value, hints.get(key), model)
-        for key, value in raw_kwargs.items()
-        if key in sig.parameters and key != "self"
-    }
-
-
-def _coerce_shape_value(value: Any, hint: Any, model: ifcopenshell.file) -> Any:
-    """Convert a single JSON-parsed value to the correct Python type."""
-    import typing
-
-    if hint is None or value is None:
-        return value
-
-    origin = typing.get_origin(hint)
-    args = typing.get_args(hint)
-
-    # Optional[X] / Union — try each non-None branch in order
-    if origin is typing.Union:
-        if value is None:
-            return None
-        for t in (a for a in args if a is not type(None)):
-            try:
-                return _coerce_shape_value(value, t, model)
-            except (ValueError, TypeError):
-                continue
-        return value
-
-    # entity_instance: resolve integer or "#N" string step ID
-    if hint is ifcopenshell.entity_instance or (
-        isinstance(hint, type) and issubclass(hint, ifcopenshell.entity_instance)
-    ):
-        entity_id = int(str(value).lstrip("#"))
-        entity = model.by_id(entity_id)
-        if entity is None:
-            raise ValueError(f"Entity #{entity_id} not found in model")
-        return entity
-
-    # Sequence[entity_instance]: resolve each element in the list
-    import collections.abc
-
-    if origin is not None and issubclass(origin, collections.abc.Sequence) and not isinstance(value, str):
-        if args and (
-            args[0] is ifcopenshell.entity_instance
-            or (isinstance(args[0], type) and issubclass(args[0], ifcopenshell.entity_instance))
-        ):
-            if isinstance(value, (list, tuple)):
-                return [_coerce_shape_value(v, args[0], model) for v in value]
-
-    # bool: JSON gives actual bools; also accept string representations
-    if hint is bool:
-        if isinstance(value, bool):
-            return value
-        return str(value).lower() in ("true", "1", "yes")
-
-    # Everything else (float, int, VectorType lists, dicts, Literals) passes through
-    return value
-
-
-class IfcSessionError(RuntimeError):
-    pass
-
-
-@dataclass
-class IfcSession:
-    """In-memory IFC session (no FastMCP dependency).
-
-    Designed to work in:
-      - FastMCP server (single global session)
-      - Embedded runtimes like Pyodide (one session per browser tab/worker)
-    """
-
-    model: ifcopenshell.file | None = None
-    model_path: str | None = None
-
-    # -----------------
-    # Session lifecycle
-    # -----------------
-    def _require_model(self) -> ifcopenshell.file:
-        if self.model is None:
-            raise IfcSessionError("No model loaded. Call ifc_load() or ifc_new() first.")
-        return self.model
-
-    def ifc_new(self, schema: str = "IFC4") -> dict[str, Any]:
-        """Create a new empty IFC model in memory."""
-        self.model = ifcopenshell.file(schema=schema)
-        self.model_path = None
-        return {"ok": True, "schema": self.model.schema, "entities": sum(1 for _ in self.model)}
-
-    def ifc_load(self, path: str) -> str:
-        """Open an IFC file into memory. Returns confirmation string."""
-        self.model = ifcopenshell.open(path)
-        self.model_path = path
-        count = sum(1 for _ in self.model)
-        return f"Loaded {path}: schema {self.model.schema}, {count} entities"
-
-    def ifc_save(self, path: str = "") -> str:
-        """Write the in-memory model to disk. Empty path overwrites the original file."""
-        model = self._require_model()
-        target = path if path else self.model_path
-        if not target:
-            raise IfcSessionError("No path specified and no original path available.")
-        model.write(target)
-        return f"Saved to {target}"
-
-    def ifc_reset(self) -> dict[str, Any]:
-        """Drop the in-memory model."""
-        self.model = None
-        self.model_path = None
-        return {"ok": True}
-
-    # -------------
-    # Query tools
-    # -------------
-    def ifc_summary(self) -> dict[str, Any]:
-        """Model overview: schema, entity counts, project info."""
-        return summary.summary(self._require_model())
-
-    def ifc_tree(self) -> dict[str, Any] | list[dict[str, Any]]:
-        """Full spatial hierarchy tree (Project -> Site -> Building -> Storeys -> Elements)."""
-        return tree.tree(self._require_model())
-
-    def ifc_info(self, element_id: int) -> dict[str, Any]:
-        """Deep inspection of an entity by step ID (attributes, psets, placement, type, material)."""
-        model = self._require_model()
-        element = model.by_id(element_id)
-        if element is None:
-            raise IfcSessionError(f"Element #{element_id} not found.")
-        return info.info(model, element)
-
-    def ifc_select(self, query: str) -> list[dict[str, Any]]:
-        """Filter elements using ifcopenshell selector syntax (e.g. 'IfcWall', 'IfcWindow')."""
-        return select.select(self._require_model(), query)
-
-    def ifc_relations(self, element_id: int, traverse: str = "") -> dict[str, Any] | list[dict[str, Any]]:
-        """Show relationships for an element. Set traverse='up' to walk hierarchy to IfcProject."""
-        model = self._require_model()
-        element = model.by_id(element_id)
-        if element is None:
-            raise IfcSessionError(f"Element #{element_id} not found.")
-        return relations.relations(model, element, traverse=traverse if traverse else None)
-
-    def ifc_clash(
-        self,
-        element_id: int,
-        clearance: float = 0.0,
-        tolerance: float = 0.002,
-        scope: str = "storey",
-    ) -> dict[str, Any]:
-        """Check element for geometric clashes. clearance=0.0 means no clearance check."""
-        model = self._require_model()
-        element = model.by_id(element_id)
-        if element is None:
-            raise IfcSessionError(f"Element #{element_id} not found.")
-        return clash_mod.clash(
-            model,
-            element,
-            clearance=clearance if clearance and clearance > 0.0 else None,
-            tolerance=tolerance,
-            scope=scope,
-        )
-
-    def ifc_contexts(self) -> list[dict[str, Any]]:
-        """List all geometric representation contexts and subcontexts with their step IDs."""
-        return contexts_mod.contexts(self._require_model())
-
-    def ifc_materials(self) -> list[dict[str, Any]]:
-        """List all materials and material sets (layers, constituents, profiles)."""
-        return materials_mod.materials(self._require_model())
-
-    # ------------------------
-    # Edit discovery + execute
-    # ------------------------
-    def ifc_list(self, module: str = "") -> list[dict]:
-        """List all API modules, or functions within a module. Empty module = all modules."""
-        return list_functions(module) if module else list_modules()
-
-    def ifc_docs(self, function_path: str) -> dict:
-        """Show full documentation for an API function. Input format: 'module.function'."""
-        module, function = function_path.split(".", 1)
-        return function_docs(module, function)
-
-    def ifc_edit(self, function_path: str, params: Any = "{}") -> dict:
-        """Execute an ifcopenshell.api mutation.
-
-        params may be:
-        - JSON string
-        - dict (from tool calling / JS)
-        - JsProxy (handled upstream in embedded.py)
-        """
-        model = self._require_model()
-        module, function = function_path.split(".", 1)
-
-        if isinstance(params, str):
-            raw_kwargs = json.loads(params) if params.strip() else {}
-        elif isinstance(params, dict):
-            raw_kwargs = params
-        else:
-            # e.g. list/None/etc
-            raw_kwargs = dict(params) if params is not None else {}
-
-        res = run_api(model, module, function, raw_kwargs)
-        return _jsonify(res)
-
-    # ------------------------
-    # Extended query + edit tools
-    # ------------------------
-    def ifc_validate(self, express_rules: bool = False) -> dict[str, Any]:
-        """Validate the loaded model. Returns {'valid': bool, 'issues': [...]}."""
-        return validate_mod.validate(self._require_model(), express_rules=express_rules)
-
-    def ifc_schedule(self, max_depth: int | None = None) -> list[dict[str, Any]]:
-        """List work schedules and nested tasks from the model.
-
-        max_depth limits subtask expansion (None = unlimited). At the cutoff,
-        subtasks is replaced with {"truncated": True, "count": N}.
-        """
-        return schedule.schedule(self._require_model(), max_depth=max_depth)
-
-    def ifc_cost(self, max_depth: int | None = None) -> list[dict[str, Any]]:
-        """List cost schedules and nested cost items from the model.
-
-        max_depth limits cost item expansion (None = unlimited). At the cutoff,
-        subitems is replaced with {"truncated": True, "count": N}.
-        """
-        return cost_mod.cost(self._require_model(), max_depth=max_depth)
-
-    def ifc_schema(self, entity_type: str) -> dict[str, Any]:
-        """Return IFC class documentation for entity_type using the model's schema version."""
-        return schema.schema(self._require_model(), entity_type)
-
-    def ifc_plot(
-        self,
-        selector: str = "",
-        element_ids: list[int] | None = None,
-        view: str = "floorplan",
-        width_mm: float = 297.0,
-        height_mm: float = 420.0,
-        scale: float = 1.0 / 100.0,
-        png_width: int = 1024,
-        png_height: int = 1024,
-        output_format: str = "png",
-    ) -> bytes:
-        """Generate a 2D technical drawing (floor plan, elevation, or section) and return image bytes.
-
-        Uses ifcopenshell.draw to produce SVG output which is rasterised to PNG via CairoSVG
-        when output_format is 'png'.
-
-        :param selector: ifcopenshell selector to restrict plotted elements
-            (e.g. ``'IfcWall'``). Omit to plot the whole model.
-        :param element_ids: Step IDs of elements to highlight. Other elements
-            are faded to 10% opacity so the subject stands out.
-        :param view: Drawing view — ``floorplan`` (default), ``elevation``,
-            ``section``, or ``auto``.
-        :param width_mm: Paper width in mm (default 297 = A4).
-        :param height_mm: Paper height in mm (default 420 = A4).
-        :param scale: Model-to-paper scale ratio (default 0.01 = 1:100).
-        :param png_width: Raster output width in pixels (default 1024).
-        :param png_height: Raster output height in pixels (default 1024).
-        :param output_format: ``'svg'`` or ``'png'`` (default ``'png'``).
-        :return: SVG or PNG bytes depending on output_format.
-        """
-        model = self._require_model()
-        return plot_mod.plot(
-            model,
-            output_format=output_format,
-            selector=selector if selector else None,
-            element_ids=element_ids,
-            view=view,
-            width_mm=width_mm,
-            height_mm=height_mm,
-            scale=scale,
-            png_width=png_width,
-            png_height=png_height,
-        )
-
-    def ifc_render(
-        self,
-        selector: str = "",
-        element_ids: list[int] | None = None,
-        view: str = "iso",
-    ) -> bytes:
-        """Render the loaded model to a PNG image and return raw bytes.
-
-        :param selector: ifcopenshell selector to restrict rendered elements
-            (e.g. ``'IfcWall'``). Omit to render the whole model.
-        :param element_ids: Step IDs of elements to highlight. Other elements
-            are rendered in translucent grey.
-        :param view: Camera angle: ``iso``, ``top``, ``south``, ``north``,
-            ``east``, or ``west``.
-        :return: PNG image as raw bytes.
-        """
-        model = self._require_model()
-        return render_mod.render(
-            model,
-            selector=selector if selector else None,
-            element_ids=element_ids,
-            view=view,
-        )
-
-    # ------------------------
-    # Shape builder tools
-    # ------------------------
-    def ifc_shape_list(self) -> list[dict]:
-        """List all ShapeBuilder geometry methods with one-line descriptions and parameter names."""
-        return _list_shape_methods()
-
-    def ifc_shape_docs(self, method: str) -> dict:
-        """Full documentation for a ShapeBuilder method: params, types, return value."""
-        return _shape_method_docs(method)
-
-    def ifc_shape(self, method: str, params: Any = "{}") -> dict:
-        """Call a ShapeBuilder method by name. Returns the created entity's step ID.
-
-        params is a JSON string of keyword arguments. Pass entity references as integer
-        step IDs; vectors as JSON arrays (e.g. [1.0, 0.0, 0.0]).
-        """
-        model = self._require_model()
-
-        from ifcopenshell.util.shape_builder import ShapeBuilder
-
-        if method.startswith("_"):
-            raise IfcSessionError(f"Private method '{method}' is not accessible")
-        fn = getattr(ShapeBuilder, method, None)
-        if fn is None:
-            return {"ok": False, "error": f"ShapeBuilder has no method '{method}'"}
-
-        if isinstance(params, str):
-            raw_kwargs = json.loads(params) if params.strip() else {}
-        elif isinstance(params, dict):
-            raw_kwargs = params
-        else:
-            raw_kwargs = {}
-
-        try:
-            coerced = _coerce_shape_params(fn, raw_kwargs, model)
-            result = fn(ShapeBuilder(model), **coerced)
-            return {"ok": True, "result": _jsonify(result)}
-        except Exception as e:
-            return {"ok": False, "error": f"{type(e).__name__}: {e}"}
-
-    def ifc_quantify(self, rule: str, selector: str = "") -> dict[str, Any]:
-        """Run quantity take-off on the model using the named rule.
-
-        Modifies the model in-place; call ifc_save() after.
-        """
-        model = self._require_model()
-        return run_quantify(model, rule, selector=selector if selector else None)
-
-    # ------------------------
-    # Generic dispatcher + tool specs for LLMs
-    # ------------------------
-    def dispatch(self, name: str, args: dict[str, Any] | None = None) -> Any:
-        args = args or {}
-        fn = getattr(self, name, None)
-        if not callable(fn):
-            raise IfcSessionError(f"Unknown tool: {name}")
-        return _jsonify(fn(**args))
-
-    def openai_tools(self) -> list[dict[str, Any]]:
-        """Tool schemas in the OpenAI 'Responses API' format (type=function)."""
-        # Keep schemas tight so the model calls tools correctly.
-        return [
-            {
-                "type": "function",
-                "name": "ifc_new",
-                "description": "Create a new empty IFC model in memory.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"schema": {"type": "string", "description": "IFC schema, e.g. IFC4"}},
-                    "required": [],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_summary",
-                "description": "Get a concise overview of the loaded IFC model.",
-                "parameters": {"type": "object", "properties": {}, "required": [], "additionalProperties": False},
-            },
-            {
-                "type": "function",
-                "name": "ifc_tree",
-                "description": "Get the full spatial hierarchy tree.",
-                "parameters": {"type": "object", "properties": {}, "required": [], "additionalProperties": False},
-            },
-            {
-                "type": "function",
-                "name": "ifc_select",
-                "description": "Select elements using ifcopenshell selector syntax (e.g. 'IfcWall').",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"query": {"type": "string"}},
-                    "required": ["query"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_info",
-                "description": "Inspect an entity by STEP id.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"element_id": {"type": "integer"}},
-                    "required": ["element_id"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_relations",
-                "description": "Get relationships for an element. traverse='up' walks to IfcProject.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"element_id": {"type": "integer"}, "traverse": {"type": "string"}},
-                    "required": ["element_id"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_clash",
-                "description": "Run clash/clearance checks for an element.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "element_id": {"type": "integer"},
-                        "clearance": {"type": "number"},
-                        "tolerance": {"type": "number"},
-                        "scope": {"type": "string", "description": "storey or all"},
-                    },
-                    "required": ["element_id"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_contexts",
-                "description": "List all geometric representation contexts and subcontexts with their step IDs, context type, identifier, and target view. Use this to find the context ID required for geometry-creation API calls.",
-                "parameters": {"type": "object", "properties": {}, "required": [], "additionalProperties": False},
-            },
-            {
-                "type": "function",
-                "name": "ifc_materials",
-                "description": "List all materials and material sets (IfcMaterial, IfcMaterialLayerSet, IfcMaterialConstituentSet, IfcMaterialProfileSet) with their layers, constituents, or profiles.",
-                "parameters": {"type": "object", "properties": {}, "required": [], "additionalProperties": False},
-            },
-            {
-                "type": "function",
-                "name": "ifc_list",
-                "description": "List ifcopenshell.api modules or functions within a module.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"module": {"type": "string"}},
-                    "required": [],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_docs",
-                "description": "Get documentation for an ifcopenshell.api function, 'module.function'.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"function_path": {"type": "string"}},
-                    "required": ["function_path"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_edit",
-                "description": "Execute an ifcopenshell.api mutation; params is a JSON string of stringly-typed kwargs.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"function_path": {"type": "string"}, "params": {"type": "string"}},
-                    "required": ["function_path"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_validate",
-                "description": "Validate the loaded model. Returns valid bool and list of issues.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "express_rules": {"type": "boolean", "description": "Also check EXPRESS rules (slower)"}
-                    },
-                    "required": [],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_schedule",
-                "description": "List work schedules and nested tasks. Use max_depth=1 for top-level phases only on large projects.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "max_depth": {
-                            "type": "integer",
-                            "description": "Max levels of subtask expansion (omit for unlimited)",
-                        }
-                    },
-                    "required": [],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_cost",
-                "description": "List cost schedules and nested cost items. Use max_depth=1 for top-level sections only on large BoQs.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "max_depth": {
-                            "type": "integer",
-                            "description": "Max levels of cost item expansion (omit for unlimited)",
-                        }
-                    },
-                    "required": [],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_schema",
-                "description": "Return IFC class documentation for an entity type.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {"entity_type": {"type": "string", "description": "IFC entity type, e.g. IfcWall"}},
-                    "required": ["entity_type"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_quantify",
-                "description": "Run quantity take-off (QTO) on the model. Modifies model in-place; call ifc_save() after.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "rule": {"type": "string", "description": "QTO rule name, e.g. IFC4QtoBaseQuantities"},
-                        "selector": {
-                            "type": "string",
-                            "description": "ifcopenshell selector to restrict elements (default: all IfcElement)",
-                        },
-                    },
-                    "required": ["rule"],
-                    "additionalProperties": False,
-                },
-            },
-            {
-                "type": "function",
-                "name": "ifc_render",
-                "description": (
-                    "Render the loaded IFC model to a PNG image for visual inspection. "
-                    "Use selector to restrict which elements are rendered (e.g. a single storey). "
-                    "Use element_ids to highlight elements against a greyed-out background. "
-                    "Returns base64-encoded PNG bytes."
-                ),
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "selector": {"type": "string", "description": "ifcopenshell selector (default: whole model)"},
-                        "element_ids": {
-                            "type": "array",
-                            "items": {"type": "integer"},
-                            "description": "Step IDs of elements to highlight",
-                        },
-                        "view": {
-                            "type": "string",
-                            "enum": ["iso", "top", "south", "north", "east", "west"],
-                            "description": "Camera angle (default: iso)",
-                        },
-                    },
-                    "required": [],
-                    "additionalProperties": False,
-                },
-            },
-        ]

src/ifcmcp/ifcmcp/embedded.py

@@ -1,60 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any
-
-from ifcmcp.core import IfcSession
-
-session = IfcSession()
-
-# Optional imports only available under Pyodide
-try:
-    from pyodide.ffi import JsProxy, to_py  # type: ignore
-except Exception:  # pragma: no cover
-    JsProxy = None  # type: ignore
-    to_py = None  # type: ignore
-
-
-def _coerce_args(args: Any) -> dict[str, Any]:
-    """Convert JS objects / JsProxy / mappings into a real Python dict."""
-    if args is None:
-        return {}
-
-    # Pyodide: JS object arrives as JsProxy; convert recursively to Python.
-    if JsProxy is not None and isinstance(args, JsProxy):
-        # dict_converter=dict ensures JS object -> Python dict (not Map)
-        return to_py(args, dict_converter=dict)
-
-    # Already a Python dict
-    if isinstance(args, dict):
-        return args
-
-    # Any Mapping-like object
-    if isinstance(args, Mapping):
-        return dict(args)
-
-    # Last resort: try dict() coercion
-    try:
-        return dict(args)
-    except Exception as e:
-        raise TypeError(f"Tool args must be a mapping/dict; got {type(args)}") from e
-
-
-def tools_openai() -> list[dict[str, Any]]:
-    return session.openai_tools()
-
-
-def call_tool(name: str, args: Any = None) -> dict[str, Any]:
-    """
-    Non-throwing tool dispatcher.
-    Always returns: {"ok": bool, "data": ...} or {"ok": false, "error": "...", "error_type": "...", ...}
-    """
-    try:
-        py_args = _coerce_args(args)
-        data = session.dispatch(name, py_args)
-        return {"ok": True, "data": data}
-
-    except Exception as e:
-        # Keep it short; avoid full tracebacks in tool output unless debugging.
-        return {"ok": False, "error_type": type(e).__name__, "error": str(e)}

src/ifcmcp/ifcmcp/server.py

@@ -1,231 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-from __future__ import annotations
-
-import base64
-from typing import Any
-
-from ifcmcp.core import IfcSession
-
-try:
-    from mcp.server.fastmcp import FastMCP  # type: ignore
-    from mcp.types import ImageContent  # type: ignore
-except Exception:  # pragma: no cover
-    FastMCP = None  # type: ignore
-    ImageContent = None  # type: ignore
-
-
-def build_server() -> Any:
-    """Create the FastMCP server if the dependency is available."""
-    if FastMCP is None:
-        raise ImportError(
-            "FastMCP is not installed. Install with: pip install ifcmcp[mcp] " "(or add 'mcp' to your environment)."
-        )
-
-    session = IfcSession()
-
-    server = FastMCP(
-        name="ifc-mcp",
-        instructions=(
-            "MCP server for querying and editing IFC building models. "
-            "Load a file first with ifc_load, then use query/edit tools. "
-            "Save changes with ifc_save."
-        ),
-    )
-
-    # ---- Lifecycle ----
-    @server.tool()
-    def ifc_new(schema: str = "IFC4") -> dict[str, Any]:
-        return session.ifc_new(schema=schema)
-
-    @server.tool()
-    def ifc_load(path: str) -> str:
-        return session.ifc_load(path)
-
-    @server.tool()
-    def ifc_save(path: str = "") -> str:
-        return session.ifc_save(path)
-
-    @server.tool()
-    def ifc_reset() -> dict[str, Any]:
-        return session.ifc_reset()
-
-    # ---- Query ----
-    @server.tool()
-    def ifc_summary() -> dict[str, Any]:
-        return session.ifc_summary()
-
-    @server.tool()
-    def ifc_tree() -> dict[str, Any] | list[dict[str, Any]]:
-        return session.ifc_tree()
-
-    @server.tool()
-    def ifc_info(element_id: int) -> dict[str, Any]:
-        return session.ifc_info(element_id)
-
-    @server.tool()
-    def ifc_select(query: str) -> list[dict[str, Any]]:
-        return session.ifc_select(query)
-
-    @server.tool()
-    def ifc_relations(element_id: int, traverse: str = "") -> dict[str, Any] | list[dict[str, Any]]:
-        return session.ifc_relations(element_id, traverse=traverse)
-
-    @server.tool()
-    def ifc_clash(
-        element_id: int,
-        clearance: float = 0.0,
-        tolerance: float = 0.002,
-        scope: str = "storey",
-    ) -> dict[str, Any]:
-        return session.ifc_clash(
-            element_id=element_id,
-            clearance=clearance,
-            tolerance=tolerance,
-            scope=scope,
-        )
-
-    @server.tool()
-    def ifc_contexts() -> list[dict[str, Any]]:
-        return session.ifc_contexts()
-
-    @server.tool()
-    def ifc_materials() -> list[dict[str, Any]]:
-        return session.ifc_materials()
-
-    # ---- Edit ----
-    @server.tool()
-    def ifc_list(module: str = "") -> list[dict]:
-        return session.ifc_list(module=module)
-
-    @server.tool()
-    def ifc_docs(function_path: str) -> dict:
-        return session.ifc_docs(function_path=function_path)
-
-    @server.tool()
-    def ifc_edit(function_path: str, params: str = "{}") -> dict:
-        return session.ifc_edit(function_path=function_path, params=params)
-
-    # ---- Extended query + edit ----
-    @server.tool()
-    def ifc_validate(express_rules: bool = False) -> dict[str, Any]:
-        return session.ifc_validate(express_rules=express_rules)
-
-    @server.tool()
-    def ifc_schedule(max_depth: int | None = None) -> list[dict[str, Any]]:
-        return session.ifc_schedule(max_depth=max_depth)
-
-    @server.tool()
-    def ifc_cost(max_depth: int | None = None) -> list[dict[str, Any]]:
-        return session.ifc_cost(max_depth=max_depth)
-
-    @server.tool()
-    def ifc_schema(entity_type: str) -> dict[str, Any]:
-        return session.ifc_schema(entity_type=entity_type)
-
-    @server.tool()
-    def ifc_quantify(rule: str, selector: str = "") -> dict[str, Any]:
-        return session.ifc_quantify(rule=rule, selector=selector)
-
-    # ---- Shape builder ----
-    @server.tool()
-    def ifc_shape_list() -> list[dict]:
-        return session.ifc_shape_list()
-
-    @server.tool()
-    def ifc_shape_docs(method: str) -> dict:
-        return session.ifc_shape_docs(method=method)
-
-    @server.tool()
-    def ifc_shape(method: str, params: str = "{}") -> dict:
-        return session.ifc_shape(method=method, params=params)
-
-    @server.tool(structured_output=False)
-    def ifc_plot(
-        selector: str = "",
-        element_ids: list[int] | None = None,
-        view: str = "floorplan",
-        width_mm: float = 297.0,
-        height_mm: float = 420.0,
-        scale: float = 1.0 / 100.0,
-        png_width: int = 1024,
-        png_height: int = 1024,
-        output_path: str = "",
-    ) -> list[ImageContent]:
-        """Generate a 2D technical drawing of the loaded IFC model.
-
-        Returns an inline PNG image (floor plan, elevation, or section) that the
-        LLM can inspect to understand the 2D layout of the model.  If
-        ``output_path`` is provided the drawing is also saved to disk — as SVG
-        when the path ends in ``.svg``, otherwise as PNG.
-
-        :param selector: ifcopenshell selector to restrict plotted elements
-            (e.g. ``'IfcWall'``). Omit to plot the whole model.
-        :param element_ids: Step IDs of elements to highlight. Other elements
-            are faded so the subject stands out.
-        :param view: Drawing view — ``floorplan`` (default), ``elevation``,
-            ``section``, or ``auto``.
-        :param width_mm: Paper width in mm (default 297 = A4 landscape width).
-        :param height_mm: Paper height in mm (default 420 = A4 landscape height).
-        :param scale: Model-to-paper scale ratio (default 0.01 = 1:100).
-        :param png_width: Raster output width in pixels (default 1024).
-        :param png_height: Raster output height in pixels (default 1024).
-        :param output_path: Optional file path to save the drawing to disk.
-        """
-        png_bytes = session.ifc_plot(
-            selector=selector,
-            element_ids=element_ids,
-            view=view,
-            width_mm=width_mm,
-            height_mm=height_mm,
-            scale=scale,
-            png_width=png_width,
-            png_height=png_height,
-            output_format="png",
-        )
-        if output_path:
-            if output_path.endswith(".svg"):
-                svg_bytes = session.ifc_plot(
-                    selector=selector,
-                    element_ids=element_ids,
-                    view=view,
-                    width_mm=width_mm,
-                    height_mm=height_mm,
-                    scale=scale,
-                    output_format="svg",
-                )
-                with open(output_path, "wb") as f:
-                    f.write(svg_bytes)
-            else:
-                with open(output_path, "wb") as f:
-                    f.write(png_bytes)
-        return [ImageContent(type="image", data=base64.b64encode(png_bytes).decode(), mimeType="image/png")]
-
-    @server.tool(structured_output=False)
-    def ifc_render(
-        selector: str = "",
-        element_ids: list[int] | None = None,
-        view: str = "iso",
-        output_path: str = "",
-    ) -> list[ImageContent]:
-        """Render the loaded IFC model to a PNG image.
-
-        Returns an inline image the LLM can inspect to understand the spatial
-        layout of the model or a specific element in context.  If
-        ``output_path`` is provided the PNG is also saved to that file path.
-
-        :param selector: ifcopenshell selector to restrict rendered elements
-            (e.g. ``'IfcWall'``, ``'IfcBuildingStorey[Name="0"]'``).
-            Omit to render the whole model.
-        :param element_ids: Step IDs of elements to highlight. Other elements
-            are rendered in translucent grey so the subject stands out.
-        :param view: Camera angle — ``iso`` (default), ``top``, ``south``,
-            ``north``, ``east``, or ``west``.
-        :param output_path: Optional file path to save the PNG to disk.
-        """
-        png_bytes = session.ifc_render(selector=selector, element_ids=element_ids, view=view)
-        if output_path:
-            with open(output_path, "wb") as f:
-                f.write(png_bytes)
-        return [ImageContent(type="image", data=base64.b64encode(png_bytes).decode(), mimeType="image/png")]
-
-    return server

src/ifcmcp/pyproject.toml

@@ -1,36 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "ifcmcp"
-version = "0.0.0"
-authors = [
-  { name="Bruno Postle", email="bruno@postle.net" },
-]
-description = "MCP server for querying and editing IFC building models"
-readme = "README.md"
-keywords = ["IFC", "BIM", "MCP"]
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)",
-]
-dependencies = ["ifcopenshell", "ifcquery", "ifcedit"]
-
-[project.optional-dependencies]
-mcp = ["mcp"]
-
-[project.scripts]
-ifcmcp = "ifcmcp.__main__:main"
-
-[project.urls]
-Homepage = "http://ifcopenshell.org"
-Documentation = "https://docs.ifcopenshell.org"
-Issues = "https://github.com/IfcOpenShell/IfcOpenShell/issues"
-
-[tool.setuptools.packages.find]
-include = ["ifcmcp*"]
-exclude = ["test*"]
-
-[tool.ruff]
-extend = "../../pyproject.toml"

src/ifcmcp/tests/__init__.py

@@ -1 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.

src/ifcmcp/tests/conftest.py

@@ -1,59 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-import ifcopenshell
-import ifcopenshell.api.aggregate
-import ifcopenshell.api.owner.settings
-import ifcopenshell.api.project
-import ifcopenshell.api.root
-import ifcopenshell.api.spatial
-import ifcopenshell.api.unit
-import pytest
-
-from ifcmcp.core import IfcSession
-
-
-@pytest.fixture
-def session():
-    return IfcSession()
-
-
-@pytest.fixture
-def model():
-    """IFC4 model with a spatial hierarchy, a wall, and a slab."""
-    f = ifcopenshell.api.project.create_file()
-    ifcopenshell.api.owner.settings.get_user = lambda ifc: (ifc.by_type("IfcPersonAndOrganization") or [None])[0]
-    ifcopenshell.api.owner.settings.get_application = lambda ifc: (ifc.by_type("IfcApplication") or [None])[0]
-
-    project = ifcopenshell.api.root.create_entity(f, ifc_class="IfcProject", name="TestProject")
-    ifcopenshell.api.unit.assign_unit(f)
-
-    site = ifcopenshell.api.root.create_entity(f, ifc_class="IfcSite", name="TestSite")
-    building = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBuilding", name="TestBuilding")
-    storey = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBuildingStorey", name="Ground Floor")
-
-    ifcopenshell.api.aggregate.assign_object(f, products=[site], relating_object=project)
-    ifcopenshell.api.aggregate.assign_object(f, products=[building], relating_object=site)
-    ifcopenshell.api.aggregate.assign_object(f, products=[storey], relating_object=building)
-
-    wall = ifcopenshell.api.root.create_entity(f, ifc_class="IfcWall", name="Wall001")
-    ifcopenshell.api.spatial.assign_container(f, products=[wall], relating_structure=storey)
-
-    slab = ifcopenshell.api.root.create_entity(f, ifc_class="IfcSlab", name="Slab001")
-    ifcopenshell.api.spatial.assign_container(f, products=[slab], relating_structure=storey)
-
-    return f
-
-
-@pytest.fixture
-def model_file(model, tmp_path):
-    """Write the model fixture to a temp file and return the path."""
-    path = tmp_path / "test.ifc"
-    model.write(str(path))
-    return str(path)
-
-
-@pytest.fixture
-def loaded_session(model):
-    """An IfcSession with an in-memory model already loaded (no file path)."""
-    s = IfcSession()
-    s.model = model
-    return s

src/ifcmcp/tests/test_edit.py

@@ -1,96 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-import json
-
-import ifcopenshell
-import pytest
-
-from ifcmcp.core import IfcSession, IfcSessionError
-
-
-class TestNoModel:
-    def test_edit_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_edit("root.create_entity")
-
-
-class TestList:
-    def test_list_all_modules(self, loaded_session):
-        result = loaded_session.ifc_list()
-        assert isinstance(result, list)
-        assert len(result) > 0
-        modules = [m["module"] for m in result]
-        assert "root" in modules
-        assert "spatial" in modules
-
-    def test_list_module_functions(self, loaded_session):
-        result = loaded_session.ifc_list(module="root")
-        assert isinstance(result, list)
-        names = [f["name"] for f in result]
-        assert "create_entity" in names
-
-    def test_list_empty_string_returns_modules(self, loaded_session):
-        result = loaded_session.ifc_list(module="")
-        assert isinstance(result, list)
-        assert any(m["module"] == "root" for m in result)
-
-
-class TestDocs:
-    def test_docs_create_entity(self, loaded_session):
-        result = loaded_session.ifc_docs("root.create_entity")
-        assert result["module"] == "root"
-        assert result["function"] == "create_entity"
-        assert "params" in result
-
-    def test_docs_bad_format(self, loaded_session):
-        with pytest.raises(ValueError):
-            loaded_session.ifc_docs("no_dot_here")
-
-
-class TestEdit:
-    def test_create_entity(self, loaded_session):
-        result = loaded_session.ifc_edit("root.create_entity", json.dumps({"ifc_class": "IfcWall", "name": "NewWall"}))
-        assert result["ok"] is True
-        assert result["result"]["type"] == "IfcWall"
-        assert result["result"]["name"] == "NewWall"
-
-    def test_create_entity_default_params(self, loaded_session):
-        result = loaded_session.ifc_edit("root.create_entity", "{}")
-        assert result["ok"] is True
-
-    def test_unknown_function(self, loaded_session):
-        result = loaded_session.ifc_edit("root.nonexistent", "{}")
-        assert result["ok"] is False
-        assert "Cannot find" in result["error"]
-
-    def test_unknown_parameter(self, loaded_session):
-        result = loaded_session.ifc_edit("root.create_entity", json.dumps({"bogus": "value"}))
-        assert result["ok"] is False
-        assert "Unknown parameter" in result["error"]
-
-    def test_bad_json(self, loaded_session):
-        with pytest.raises(json.JSONDecodeError):
-            loaded_session.ifc_edit("root.create_entity", "not json")
-
-    def test_edit_does_not_save(self, loaded_session, tmp_path):
-        """Verify that ifc_edit mutates the in-memory model but does not write to disk."""
-        path = str(tmp_path / "test.ifc")
-        loaded_session.model.write(path)
-        loaded_session.model_path = path
-
-        before_count = sum(1 for _ in loaded_session.model)
-        loaded_session.ifc_edit("root.create_entity", json.dumps({"ifc_class": "IfcWall", "name": "Unsaved"}))
-        after_count = sum(1 for _ in loaded_session.model)
-        assert after_count == before_count + 1
-
-        on_disk = ifcopenshell.open(path)
-        disk_count = sum(1 for _ in on_disk)
-        assert disk_count == before_count
-
-    def test_assign_container(self, loaded_session):
-        wall = loaded_session.model.by_type("IfcWall")[0]
-        storey = loaded_session.model.by_type("IfcBuildingStorey")[0]
-        result = loaded_session.ifc_edit(
-            "spatial.assign_container",
-            json.dumps({"products": str(wall.id()), "relating_structure": str(storey.id())}),
-        )
-        assert result["ok"] is True

src/ifcmcp/tests/test_query.py

@@ -1,113 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-import pytest
-
-from ifcmcp.core import IfcSessionError
-
-
-class TestNoModel:
-    """All query tools should fail when no model is loaded."""
-
-    def test_summary_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_summary()
-
-    def test_tree_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_tree()
-
-    def test_info_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_info(1)
-
-    def test_select_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_select("IfcWall")
-
-    def test_relations_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_relations(1)
-
-
-class TestSummary:
-    def test_schema(self, loaded_session):
-        result = loaded_session.ifc_summary()
-        assert result["schema"] == "IFC4"
-
-    def test_total_entities(self, loaded_session):
-        result = loaded_session.ifc_summary()
-        assert result["total_entities"] > 0
-
-    def test_project_name(self, loaded_session):
-        result = loaded_session.ifc_summary()
-        assert result["project"]["name"] == "TestProject"
-
-    def test_type_counts(self, loaded_session):
-        result = loaded_session.ifc_summary()
-        assert result["types"]["IfcWall"] == 1
-        assert result["types"]["IfcSlab"] == 1
-
-
-class TestTree:
-    def test_root_is_project(self, loaded_session):
-        result = loaded_session.ifc_tree()
-        assert result["type"] == "IfcProject"
-        assert result["name"] == "TestProject"
-
-    def test_hierarchy_depth(self, loaded_session):
-        result = loaded_session.ifc_tree()
-        site = result["children"][0]
-        assert site["type"] == "IfcSite"
-        building = site["children"][0]
-        assert building["type"] == "IfcBuilding"
-        storey = building["children"][0]
-        assert storey["type"] == "IfcBuildingStorey"
-
-
-class TestInfo:
-    def test_wall_info(self, loaded_session):
-        wall = loaded_session.model.by_type("IfcWall")[0]
-        result = loaded_session.ifc_info(wall.id())
-        assert result["id"] == wall.id()
-        assert result["type"] == "IfcWall"
-
-    def test_invalid_id(self, loaded_session):
-        with pytest.raises(Exception):
-            loaded_session.ifc_info(999999)
-
-
-class TestSelect:
-    def test_select_walls(self, loaded_session):
-        result = loaded_session.ifc_select("IfcWall")
-        assert len(result) == 1
-        assert result[0]["type"] == "IfcWall"
-        assert result[0]["name"] == "Wall001"
-
-    def test_select_slabs(self, loaded_session):
-        result = loaded_session.ifc_select("IfcSlab")
-        assert len(result) == 1
-        assert result[0]["name"] == "Slab001"
-
-    def test_select_no_match(self, loaded_session):
-        result = loaded_session.ifc_select("IfcWindow")
-        assert result == []
-
-
-class TestRelations:
-    def test_wall_relations(self, loaded_session):
-        wall = loaded_session.model.by_type("IfcWall")[0]
-        result = loaded_session.ifc_relations(wall.id())
-        assert result["id"] == wall.id()
-        assert result["type"] == "IfcWall"
-        assert "hierarchy" in result
-
-    def test_traverse_up(self, loaded_session):
-        wall = loaded_session.model.by_type("IfcWall")[0]
-        result = loaded_session.ifc_relations(wall.id(), traverse="up")
-        assert isinstance(result, list)
-        assert result[0]["type"] == "IfcWall"
-        assert result[-1]["type"] == "IfcProject"
-
-    def test_traverse_empty_string_means_no_traverse(self, loaded_session):
-        wall = loaded_session.model.by_type("IfcWall")[0]
-        result = loaded_session.ifc_relations(wall.id(), traverse="")
-        assert isinstance(result, dict)

src/ifcmcp/tests/test_server.py

@@ -1,106 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-from unittest.mock import patch
-
-import pytest
-
-from ifcmcp.server import build_server
-
-
-class TestServerRegistration:
-    def test_server_name(self):
-        server = build_server()
-        assert server.name == "ifc-mcp"
-
-    def test_all_tools_registered(self):
-        server = build_server()
-        tools = [t.name for t in server._tool_manager.list_tools()]
-        expected = [
-            "ifc_load",
-            "ifc_save",
-            "ifc_summary",
-            "ifc_tree",
-            "ifc_info",
-            "ifc_select",
-            "ifc_relations",
-            "ifc_clash",
-            "ifc_list",
-            "ifc_docs",
-            "ifc_edit",
-        ]
-        for name in expected:
-            assert name in tools, f"Tool {name} not registered"
-
-
-@pytest.fixture
-def tool_fns():
-    """Return a dict of tool name → raw function from a freshly built server."""
-    server = build_server()
-    return {t.name: t.fn for t in server._tool_manager.list_tools()}
-
-
-PNG_FAKE = b"\x89PNG\r\n\x1a\nFAKE"
-SVG_FAKE = b"<svg>FAKE</svg>"
-
-
-class TestRenderOutputPath:
-    def test_no_output_path_no_file_written(self, tool_fns, tmp_path):
-        with patch("ifcmcp.core.IfcSession.ifc_render", return_value=PNG_FAKE):
-            tool_fns["ifc_render"](selector="", element_ids=None, view="iso", output_path="")
-        assert list(tmp_path.iterdir()) == []
-
-    def test_png_output_path_writes_file(self, tool_fns, tmp_path):
-        out = str(tmp_path / "render.png")
-        with patch("ifcmcp.core.IfcSession.ifc_render", return_value=PNG_FAKE):
-            tool_fns["ifc_render"](selector="", element_ids=None, view="iso", output_path=out)
-        assert open(out, "rb").read() == PNG_FAKE
-
-
-class TestPlotOutputPath:
-    def test_no_output_path_no_file_written(self, tool_fns, tmp_path):
-        with patch("ifcmcp.core.IfcSession.ifc_plot", return_value=PNG_FAKE):
-            tool_fns["ifc_plot"](
-                selector="",
-                element_ids=None,
-                view="floorplan",
-                width_mm=297.0,
-                height_mm=420.0,
-                scale=0.01,
-                png_width=1024,
-                png_height=1024,
-                output_path="",
-            )
-        assert list(tmp_path.iterdir()) == []
-
-    def test_png_output_path_writes_png(self, tool_fns, tmp_path):
-        out = str(tmp_path / "plot.png")
-        with patch("ifcmcp.core.IfcSession.ifc_plot", return_value=PNG_FAKE):
-            tool_fns["ifc_plot"](
-                selector="",
-                element_ids=None,
-                view="floorplan",
-                width_mm=297.0,
-                height_mm=420.0,
-                scale=0.01,
-                png_width=1024,
-                png_height=1024,
-                output_path=out,
-            )
-        assert open(out, "rb").read() == PNG_FAKE
-
-    def test_svg_output_path_writes_svg(self, tool_fns, tmp_path):
-        out = str(tmp_path / "plot.svg")
-        # ifc_plot is called twice: once with "png" for the inline image,
-        # once with "svg" for the file.
-        with patch("ifcmcp.core.IfcSession.ifc_plot", side_effect=[PNG_FAKE, SVG_FAKE]):
-            tool_fns["ifc_plot"](
-                selector="",
-                element_ids=None,
-                view="floorplan",
-                width_mm=297.0,
-                height_mm=420.0,
-                scale=0.01,
-                png_width=1024,
-                png_height=1024,
-                output_path=out,
-            )
-        assert open(out, "rb").read() == SVG_FAKE

src/ifcmcp/tests/test_session.py

@@ -1,62 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-from unittest.mock import patch
-
-import ifcopenshell
-import pytest
-
-from ifcmcp.core import IfcSession, IfcSessionError
-
-
-class TestLoad:
-    def test_load_file(self, session, model_file):
-        result = session.ifc_load(model_file)
-        assert "IFC4" in result
-        assert session.model is not None
-        assert session.model_path == model_file
-
-    def test_load_sets_entity_count(self, session, model_file):
-        result = session.ifc_load(model_file)
-        assert "entities" in result
-
-    def test_load_nonexistent_file(self, session):
-        with pytest.raises(Exception):
-            session.ifc_load("/nonexistent/path/model.ifc")
-
-
-class TestSave:
-    def test_save_no_model(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_save()
-
-    def test_save_overwrites_original(self, session, model_file):
-        session.ifc_load(model_file)
-        result = session.ifc_save()
-        assert model_file in result
-
-    def test_save_to_new_path(self, session, model_file, tmp_path):
-        session.ifc_load(model_file)
-        new_path = str(tmp_path / "output.ifc")
-        result = session.ifc_save(new_path)
-        assert new_path in result
-        reloaded = ifcopenshell.open(new_path)
-        assert reloaded.schema == "IFC4"
-
-    def test_save_no_path_no_original(self, loaded_session):
-        with pytest.raises(IfcSessionError, match="No path specified"):
-            loaded_session.ifc_save()
-
-
-class TestIfcPlotOutputFormat:
-    """ifc_plot should pass output_format through to the underlying plot function."""
-
-    def test_default_output_format_is_png(self, loaded_session):
-        with patch("ifcmcp.core.plot_mod.plot", return_value=b"PNG_FAKE") as mock_plot:
-            loaded_session.ifc_plot()
-            mock_plot.assert_called_once()
-            assert mock_plot.call_args.kwargs["output_format"] == "png"
-
-    def test_svg_output_format(self, loaded_session):
-        with patch("ifcmcp.core.plot_mod.plot", return_value=b"SVG_FAKE") as mock_plot:
-            result = loaded_session.ifc_plot(output_format="svg")
-            assert result == b"SVG_FAKE"
-            assert mock_plot.call_args.kwargs["output_format"] == "svg"

src/ifcmcp/tests/test_shape.py

@@ -1,141 +0,0 @@
-# This file was generated with the assistance of an AI coding tool.
-import json
-
-import pytest
-
-from ifcmcp.core import IfcSessionError
-
-
-class TestShapeList:
-    def test_returns_list(self, loaded_session):
-        result = loaded_session.ifc_shape_list()
-        assert isinstance(result, list)
-        assert len(result) > 0
-
-    def test_has_expected_methods(self, loaded_session):
-        result = loaded_session.ifc_shape_list()
-        names = [m["method"] for m in result]
-        assert "polyline" in names
-        assert "rectangle" in names
-        assert "extrude" in names
-        assert "profile" in names
-        assert "get_representation" in names
-
-    def test_well_documented_methods_have_descriptions(self, loaded_session):
-        result = loaded_session.ifc_shape_list()
-        by_name = {m["method"]: m for m in result}
-        # These methods have detailed docstrings
-        for name in ("polyline", "extrude", "rectangle", "profile", "get_representation"):
-            assert by_name[name]["description"], f"'{name}' has no description"
-
-    def test_no_private_methods(self, loaded_session):
-        result = loaded_session.ifc_shape_list()
-        assert not any(m["method"].startswith("_") for m in result)
-
-    def test_does_not_require_model(self, session):
-        # ifc_shape_list is pure introspection — no model needed
-        result = session.ifc_shape_list()
-        assert isinstance(result, list)
-
-
-class TestShapeDocs:
-    def test_extrude_docs(self, loaded_session):
-        result = loaded_session.ifc_shape_docs("extrude")
-        assert result["method"] == "extrude"
-        assert result["description"]
-        assert "params" in result
-        param_names = [p["name"] for p in result["params"]]
-        assert "profile_or_curve" in param_names
-        assert "magnitude" in param_names
-
-    def test_has_return_type(self, loaded_session):
-        result = loaded_session.ifc_shape_docs("rectangle")
-        assert "return_type" in result
-
-    def test_has_param_descriptions(self, loaded_session):
-        result = loaded_session.ifc_shape_docs("polyline")
-        params_with_desc = [p for p in result["params"] if "description" in p]
-        assert len(params_with_desc) > 0
-
-    def test_unknown_method(self, loaded_session):
-        with pytest.raises(ValueError, match="no method"):
-            loaded_session.ifc_shape_docs("nonexistent_method")
-
-    def test_private_method_rejected(self, loaded_session):
-        with pytest.raises(ValueError):
-            loaded_session.ifc_shape_docs("__init__")
-
-    def test_does_not_require_model(self, session):
-        result = session.ifc_shape_docs("circle")
-        assert result["method"] == "circle"
-
-
-class TestShapeExecute:
-    def test_rectangle(self, loaded_session):
-        result = loaded_session.ifc_shape("rectangle", json.dumps({"size": [4.0, 0.2]}))
-        assert result["ok"] is True
-        assert result["result"]["type"] == "IfcIndexedPolyCurve"
-
-    def test_circle(self, loaded_session):
-        result = loaded_session.ifc_shape("circle", json.dumps({"center": [0.0, 0.0], "radius": 0.5}))
-        assert result["ok"] is True
-        assert result["result"]["type"] == "IfcCircle"
-
-    def test_extrude_chained_from_rectangle(self, loaded_session):
-        rect = loaded_session.ifc_shape("rectangle", json.dumps({"size": [4.0, 0.2]}))
-        rect_id = rect["result"]["id"]
-        result = loaded_session.ifc_shape("extrude", json.dumps({"profile_or_curve": rect_id, "magnitude": 3.0}))
-        assert result["ok"] is True
-        assert result["result"]["type"] == "IfcExtrudedAreaSolid"
-
-    def test_entity_id_as_integer(self, loaded_session):
-        """Entity IDs should be accepted as plain integers (from JSON)."""
-        rect = loaded_session.ifc_shape("rectangle", json.dumps({"size": [1.0, 1.0]}))
-        rect_id = rect["result"]["id"]
-        # Pass as int, not string
-        result = loaded_session.ifc_shape("extrude", json.dumps({"profile_or_curve": rect_id, "magnitude": 1.0}))
-        assert result["ok"] is True
-
-    def test_rotate_2d_point_returns_list(self, loaded_session):
-        """Methods returning numpy arrays should give back plain lists."""
-        result = loaded_session.ifc_shape(
-            "rotate_2d_point", json.dumps({"point_2d": [1.0, 0.0], "angle": 90.0, "counter_clockwise": True})
-        )
-        assert result["ok"] is True
-        assert isinstance(result["result"], list)
-        assert len(result["result"]) == 2
-
-    def test_set_polyline_coords_returns_none(self, loaded_session):
-        """In-place methods that return None should give ok=True, result=None."""
-        rect = loaded_session.ifc_shape("rectangle", json.dumps({"size": [2.0, 2.0]}))
-        rect_id = rect["result"]["id"]
-        result = loaded_session.ifc_shape(
-            "set_polyline_coords",
-            json.dumps({"polyline": rect_id, "coords": [[0.0, 0.0], [3.0, 0.0], [3.0, 3.0], [0.0, 3.0]]}),
-        )
-        assert result["ok"] is True
-        assert result["result"] is None
-
-    def test_unknown_method(self, loaded_session):
-        result = loaded_session.ifc_shape("nonexistent_method", "{}")
-        assert result["ok"] is False
-        assert "error" in result
-
-    def test_private_method_rejected(self, loaded_session):
-        with pytest.raises(IfcSessionError):
-            loaded_session.ifc_shape("__init__", "{}")
-
-    def test_no_model_raises(self, session):
-        with pytest.raises(IfcSessionError, match="No model loaded"):
-            session.ifc_shape("rectangle", "{}")
-
-    def test_params_as_dict(self, loaded_session):
-        """params can be passed as a dict (not just a JSON string)."""
-        result = loaded_session.ifc_shape("rectangle", {"size": [2.0, 1.0]})
-        assert result["ok"] is True
-
-    def test_error_on_bad_params(self, loaded_session):
-        """Bad parameters should give ok=False with an error message."""
-        result = loaded_session.ifc_shape("extrude", json.dumps({"profile_or_curve": 999999, "magnitude": 1.0}))
-        assert result["ok"] is False
-        assert "error" in result

src/ifcopenshell-python/ifcopenshell/api/georeference/add_georeferencing.py

@@ -17,7 +17,6 @@
 # along with IfcOpenShell.  If not, see <http://www.gnu.org/licenses/>.
 
 import ifcopenshell
-import ifcopenshell.api.georeference
 import ifcopenshell.api.pset
 import ifcopenshell.util.element
 
@@ -64,13 +63,8 @@ def add_georeferencing(file: ifcopenshell.file, ifc_class: str = "IfcMapConversi
             },
         )
         return
-    has_crs = bool(file.by_type("IfcProjectedCRS"))
-    has_conversion = bool(file.by_type("IfcCoordinateOperation"))
-    if has_crs and has_conversion:
+    if file.by_type("IfcProjectedCRS"):
         return
-    if has_crs or has_conversion:
-        # This is technically invalid, but we shall forgive the industry here if they are wrong ...
-        ifcopenshell.api.georeference.remove_georeferencing(file)
     source_crs = None
     for context in file.by_type("IfcGeometricRepresentationContext", include_subtypes=False):
         if context.ContextType == "Model":

src/ifcopenshell-python/test/api/georeference/test_add_georeferencing.py

@@ -51,30 +51,6 @@ class TestAddGeoreferencing(test.bootstrap.IFC4):
         assert len(self.file.by_type("IfcMapConversion")) == 1
         assert len(self.file.by_type("IfcProjectedCRS")) == 1
 
-    def test_recovering_from_orphan_projected_crs(self):
-        ifcopenshell.api.root.create_entity(self.file, ifc_class="IfcProject")
-        ifcopenshell.api.context.add_context(self.file, "Model")
-        self.file.create_entity("IfcProjectedCRS", Name="EPSG:1234")
-        assert len(self.file.by_type("IfcProjectedCRS")) == 1
-        assert len(self.file.by_type("IfcCoordinateOperation")) == 0
-        ifcopenshell.api.georeference.add_georeferencing(self.file)
-        assert len(self.file.by_type("IfcMapConversion")) == 1
-        assert len(self.file.by_type("IfcProjectedCRS")) == 1
-
-    def test_recovering_from_orphan_coordinate_operation(self):
-        ifcopenshell.api.root.create_entity(self.file, ifc_class="IfcProject")
-        context = ifcopenshell.api.context.add_context(self.file, "Model")
-        self.file.create_entity("IfcMapConversion", SourceCRS=context, TargetCRS=self.file.create_entity("IfcProjectedCRS", Name="EPSG:1234"))
-        ifcopenshell.api.georeference.remove_georeferencing(self.file)
-        # Simulate orphan by re-adding just a conversion without CRS
-        self.file.create_entity("IfcMapConversion", SourceCRS=context, TargetCRS=self.file.create_entity("IfcProjectedCRS", Name="EPSG:1234"))
-        self.file.remove(self.file.by_type("IfcProjectedCRS")[0])
-        assert len(self.file.by_type("IfcProjectedCRS")) == 0
-        assert len(self.file.by_type("IfcCoordinateOperation")) == 1
-        ifcopenshell.api.georeference.add_georeferencing(self.file)
-        assert len(self.file.by_type("IfcMapConversion")) == 1
-        assert len(self.file.by_type("IfcProjectedCRS")) == 1
-
 
 class TestAddGeoreferencingIFC2X3(test.bootstrap.IFC2X3):
     def test_adding_georeferencing(self):

src/ifctester/webapp/package-lock.json

@@ -2352,9 +2352,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
+      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
       "dev": true,
       "license": "MIT",
       "engines": {