fluidcad 0.0.2

package/lib/dist/math/vector3d.test.js

@@ -0,0 +1,276 @@
+import { describe, it, expect } from "vitest";
+import { Vector3d, normalizeVector } from "./vector3d.js";
+describe("Vector3d", () => {
+    describe("constructor", () => {
+        it("creates a vector with x, y, z components", () => {
+            const v = new Vector3d(1, 2, 3);
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(2);
+            expect(v.z).toBe(3);
+        });
+    });
+    describe("equals", () => {
+        it("returns true for identical vectors", () => {
+            const v1 = new Vector3d(1, 2, 3);
+            const v2 = new Vector3d(1, 2, 3);
+            expect(v1.equals(v2)).toBe(true);
+        });
+        it("returns false for different vectors", () => {
+            const v1 = new Vector3d(1, 2, 3);
+            const v2 = new Vector3d(1, 2, 4);
+            expect(v1.equals(v2)).toBe(false);
+        });
+        it("supports tolerance", () => {
+            const v1 = new Vector3d(1, 2, 3);
+            const v2 = new Vector3d(1.001, 2.001, 3.001);
+            expect(v1.equals(v2, 0.01)).toBe(true);
+            expect(v1.equals(v2, 0.0001)).toBe(false);
+        });
+    });
+    describe("dot", () => {
+        it("computes dot product correctly", () => {
+            const v1 = new Vector3d(1, 2, 3);
+            const v2 = new Vector3d(4, 5, 6);
+            expect(v1.dot(v2)).toBe(32); // 1*4 + 2*5 + 3*6
+        });
+        it("returns 0 for perpendicular vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(0, 1, 0);
+            expect(v1.dot(v2)).toBe(0);
+        });
+    });
+    describe("cross", () => {
+        it("computes cross product correctly", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(0, 1, 0);
+            const result = v1.cross(v2);
+            expect(result.x).toBe(0);
+            expect(result.y).toBe(0);
+            expect(result.z).toBe(1);
+        });
+        it("returns zero vector for parallel vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(2, 0, 0);
+            const result = v1.cross(v2);
+            expect(result.isZero()).toBe(true);
+        });
+    });
+    describe("length", () => {
+        it("computes length correctly", () => {
+            const v = new Vector3d(3, 4, 0);
+            expect(v.length()).toBe(5);
+        });
+        it("returns 0 for zero vector", () => {
+            const v = new Vector3d(0, 0, 0);
+            expect(v.length()).toBe(0);
+        });
+    });
+    describe("normalize", () => {
+        it("returns unit vector", () => {
+            const v = new Vector3d(3, 4, 0);
+            const normalized = v.normalize();
+            expect(normalized.length()).toBeCloseTo(1);
+            expect(normalized.x).toBeCloseTo(0.6);
+            expect(normalized.y).toBeCloseTo(0.8);
+            expect(normalized.z).toBe(0);
+        });
+        it("throws for zero vector", () => {
+            const v = new Vector3d(0, 0, 0);
+            expect(() => v.normalize()).toThrow();
+        });
+    });
+    describe("add", () => {
+        it("adds vectors correctly", () => {
+            const v1 = new Vector3d(1, 2, 3);
+            const v2 = new Vector3d(4, 5, 6);
+            const result = v1.add(v2);
+            expect(result.x).toBe(5);
+            expect(result.y).toBe(7);
+            expect(result.z).toBe(9);
+        });
+        it("is immutable", () => {
+            const v1 = new Vector3d(1, 2, 3);
+            const v2 = new Vector3d(4, 5, 6);
+            v1.add(v2);
+            expect(v1.x).toBe(1);
+        });
+    });
+    describe("subtract", () => {
+        it("subtracts vectors correctly", () => {
+            const v1 = new Vector3d(4, 5, 6);
+            const v2 = new Vector3d(1, 2, 3);
+            const result = v1.subtract(v2);
+            expect(result.x).toBe(3);
+            expect(result.y).toBe(3);
+            expect(result.z).toBe(3);
+        });
+    });
+    describe("multiply", () => {
+        it("multiplies by scalar correctly", () => {
+            const v = new Vector3d(1, 2, 3);
+            const result = v.multiply(2);
+            expect(result.x).toBe(2);
+            expect(result.y).toBe(4);
+            expect(result.z).toBe(6);
+        });
+    });
+    describe("negate", () => {
+        it("negates vector correctly", () => {
+            const v = new Vector3d(1, -2, 3);
+            const result = v.negate();
+            expect(result.x).toBe(-1);
+            expect(result.y).toBe(2);
+            expect(result.z).toBe(-3);
+        });
+    });
+    describe("isZero", () => {
+        it("returns true for zero vector", () => {
+            const v = new Vector3d(0, 0, 0);
+            expect(v.isZero()).toBe(true);
+        });
+        it("returns false for non-zero vector", () => {
+            const v = new Vector3d(0.001, 0, 0);
+            expect(v.isZero()).toBe(false);
+        });
+        it("supports tolerance", () => {
+            const v = new Vector3d(0.001, 0.001, 0.001);
+            expect(v.isZero(0.01)).toBe(true);
+        });
+    });
+    describe("angleTo", () => {
+        it("returns 0 for same direction", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(2, 0, 0);
+            expect(v1.angleTo(v2)).toBeCloseTo(0);
+        });
+        it("returns PI/2 for perpendicular vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(0, 1, 0);
+            expect(v1.angleTo(v2)).toBeCloseTo(Math.PI / 2);
+        });
+        it("returns PI for opposite directions", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(-1, 0, 0);
+            expect(v1.angleTo(v2)).toBeCloseTo(Math.PI);
+        });
+    });
+    describe("projectOnto", () => {
+        it("projects vector correctly", () => {
+            const v = new Vector3d(3, 4, 0);
+            const onto = new Vector3d(1, 0, 0);
+            const result = v.projectOnto(onto);
+            expect(result.x).toBeCloseTo(3);
+            expect(result.y).toBeCloseTo(0);
+            expect(result.z).toBeCloseTo(0);
+        });
+    });
+    describe("reflect", () => {
+        it("reflects vector correctly", () => {
+            const v = new Vector3d(1, -1, 0);
+            const normal = new Vector3d(0, 1, 0);
+            const result = v.reflect(normal);
+            expect(result.x).toBeCloseTo(1);
+            expect(result.y).toBeCloseTo(1);
+            expect(result.z).toBeCloseTo(0);
+        });
+    });
+    describe("lerp", () => {
+        it("interpolates at t=0", () => {
+            const v1 = new Vector3d(0, 0, 0);
+            const v2 = new Vector3d(10, 10, 10);
+            const result = v1.lerp(v2, 0);
+            expect(result.equals(v1)).toBe(true);
+        });
+        it("interpolates at t=1", () => {
+            const v1 = new Vector3d(0, 0, 0);
+            const v2 = new Vector3d(10, 10, 10);
+            const result = v1.lerp(v2, 1);
+            expect(result.equals(v2)).toBe(true);
+        });
+        it("interpolates at t=0.5", () => {
+            const v1 = new Vector3d(0, 0, 0);
+            const v2 = new Vector3d(10, 10, 10);
+            const result = v1.lerp(v2, 0.5);
+            expect(result.x).toBe(5);
+            expect(result.y).toBe(5);
+            expect(result.z).toBe(5);
+        });
+    });
+    describe("isParallelTo", () => {
+        it("returns true for parallel vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(5, 0, 0);
+            expect(v1.isParallelTo(v2)).toBe(true);
+        });
+        it("returns true for anti-parallel vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(-5, 0, 0);
+            expect(v1.isParallelTo(v2)).toBe(true);
+        });
+        it("returns false for non-parallel vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(1, 1, 0);
+            expect(v1.isParallelTo(v2)).toBe(false);
+        });
+    });
+    describe("isPerpendicularTo", () => {
+        it("returns true for perpendicular vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(0, 1, 0);
+            expect(v1.isPerpendicularTo(v2)).toBe(true);
+        });
+        it("returns false for non-perpendicular vectors", () => {
+            const v1 = new Vector3d(1, 0, 0);
+            const v2 = new Vector3d(1, 1, 0);
+            expect(v1.isPerpendicularTo(v2)).toBe(false);
+        });
+    });
+    describe("static methods", () => {
+        it("unitX returns (1,0,0)", () => {
+            const v = Vector3d.unitX();
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(0);
+            expect(v.z).toBe(0);
+        });
+        it("unitY returns (0,1,0)", () => {
+            const v = Vector3d.unitY();
+            expect(v.x).toBe(0);
+            expect(v.y).toBe(1);
+            expect(v.z).toBe(0);
+        });
+        it("unitZ returns (0,0,1)", () => {
+            const v = Vector3d.unitZ();
+            expect(v.x).toBe(0);
+            expect(v.y).toBe(0);
+            expect(v.z).toBe(1);
+        });
+        it("zero returns (0,0,0)", () => {
+            const v = Vector3d.zero();
+            expect(v.isZero()).toBe(true);
+        });
+        it("fromArray creates vector from array", () => {
+            const v = Vector3d.fromArray([1, 2, 3]);
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(2);
+            expect(v.z).toBe(3);
+        });
+    });
+    describe("toVector3d helper", () => {
+        it("returns same instance for Vector3d", () => {
+            const v = new Vector3d(1, 2, 3);
+            expect(normalizeVector(v)).toBe(v);
+        });
+        it("converts array to Vector3d", () => {
+            const v = normalizeVector([1, 2, 3]);
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(2);
+            expect(v.z).toBe(3);
+        });
+        it("converts object to Vector3d", () => {
+            const v = normalizeVector({ x: 1, y: 2, z: 3 });
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(2);
+            expect(v.z).toBe(3);
+        });
+    });
+});

package/lib/dist/oc/boolean-ops.d.ts

@@ -0,0 +1,36 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { Shape } from "../common/shape.js";
+import { Solid } from "../common/solid.js";
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { Plane } from "../math/plane.js";
+export declare class BooleanOps {
+    static cutShapes(shape: Shape, tool: Shape): Shape;
+    static cutShapesRaw(shape: TopoDS_Shape, tool: TopoDS_Shape): TopoDS_Shape;
+    static cutMultiShape(stocks: Shape[], tools: Shape[], plane?: Plane, cutDistance?: number): {
+        result: Solid | Edge | Face | import("../common/wire.js").Wire;
+        modified: (shape: Shape) => (Solid | Edge | Face | import("../common/wire.js").Wire)[];
+        sectionEdges: Edge[];
+        startEdges: Edge[];
+        endEdges: Edge[];
+        internalEdges: Edge[];
+        internalFaces: Face[];
+    };
+    static fuse(args: Shape[]): {
+        result: Shape[];
+        modifiedShapes: Shape[];
+        newShapes: Shape[];
+    };
+    static fuseFaces(args: Shape[]): {
+        result: Shape[];
+        modifiedShapes: Shape[];
+        newShapes: Shape[];
+    };
+    static splitShape(shape: Shape, tool: Shape): Shape[];
+    static common(args: Shape[]): {
+        result: Shape[];
+        modifiedShapes: Shape[];
+        newShapes: Shape[];
+    };
+    static doShapesIntersect(shape1: Shape, shape2: Shape): boolean;
+}

package/lib/dist/oc/boolean-ops.js

@@ -0,0 +1,337 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+import { ShapeOps } from "./shape-ops.js";
+import { Solid } from "../common/solid.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { EdgeOps } from "./edge-ops.js";
+export class BooleanOps {
+    static cutShapes(shape, tool) {
+        const result = BooleanOps.cutShapesRaw(shape.getShape(), tool.getShape());
+        return ShapeFactory.fromShape(result);
+    }
+    static cutShapesRaw(shape, tool) {
+        const oc = getOC();
+        const progress = new oc.Message_ProgressRange();
+        const cutter = new oc.BRepAlgoAPI_Cut(shape, tool, progress);
+        cutter.Build(progress);
+        if (!cutter.IsDone()) {
+            cutter.delete();
+            progress.delete();
+            throw new Error("Cut operation failed");
+        }
+        const result = cutter.Shape();
+        cutter.delete();
+        progress.delete();
+        return result;
+    }
+    static cutMultiShape(stocks, tools, plane, cutDistance = 0) {
+        const oc = getOC();
+        const stockList = new oc.TopTools_ListOfShape();
+        for (const s of stocks) {
+            stockList.Append(s.getShape());
+        }
+        const toolList = new oc.TopTools_ListOfShape();
+        for (const t of tools) {
+            toolList.Append(t.getShape());
+        }
+        const progress = new oc.Message_ProgressRange();
+        const cutMaker = new oc.BRepAlgoAPI_Cut();
+        cutMaker.SetArguments(stockList);
+        cutMaker.SetTools(toolList);
+        cutMaker.SetNonDestructive(true);
+        cutMaker.SetRunParallel(true);
+        cutMaker.Build(progress);
+        const result = cutMaker.Shape();
+        const resultSolids = Explorer.findShapes(result, Explorer.getOcShapeType("solid"));
+        const wrappedResult = resultSolids.length > 0
+            ? Solid.fromTopoDSSolid(Explorer.toSolid(resultSolids[0]))
+            : ShapeFactory.fromShape(result);
+        const modified = (shape) => ShapeOps.shapeListToArray(cutMaker.Modified(shape.getShape()))
+            .map(s => ShapeFactory.fromShape(s));
+        // Build maps of all edges and faces that came from the original stocks (unchanged or modified).
+        // Any result edge/face not in these maps is new, created by the cut.
+        const stockEdgeMap = new oc.TopTools_MapOfShape();
+        const stockFaceMap = new oc.TopTools_MapOfShape();
+        for (const stock of stocks) {
+            const rawEdges = Explorer.findShapes(stock.getShape(), Explorer.getOcShapeType("edge"));
+            for (const rawEdge of rawEdges) {
+                stockEdgeMap.Add(rawEdge);
+                // Also track modified versions of this edge so we don't misidentify them as new.
+                const modifiedList = cutMaker.Modified(rawEdge);
+                while (modifiedList.Size() > 0) {
+                    stockEdgeMap.Add(modifiedList.First());
+                    modifiedList.RemoveFirst();
+                }
+                modifiedList.delete();
+            }
+            const rawFaces = Explorer.findShapes(stock.getShape(), Explorer.getOcShapeType("face"));
+            for (const rawFace of rawFaces) {
+                stockFaceMap.Add(rawFace);
+                const modifiedList = cutMaker.Modified(rawFace);
+                while (modifiedList.Size() > 0) {
+                    stockFaceMap.Add(modifiedList.First());
+                    modifiedList.RemoveFirst();
+                }
+                modifiedList.delete();
+            }
+        }
+        const resultRawEdges = Explorer.findShapes(result, Explorer.getOcShapeType("edge"));
+        const sectionEdges = resultRawEdges
+            .filter(re => !stockEdgeMap.Contains(re))
+            .map(re => Edge.fromTopoDSEdge(Explorer.toEdge(re)));
+        // Classify section edges into start, end, and internal groups using signed
+        // distance from the cut plane. Through-all cuts use min/max projection.
+        const startEdges = [];
+        const endEdges = [];
+        const internalEdges = [];
+        if (plane && sectionEdges.length > 0) {
+            const tolerance = oc.Precision.Confusion();
+            const isThroughAll = cutDistance === 0;
+            const dists = sectionEdges.map(edge => ({
+                edge,
+                d: plane.signedDistanceToPoint(EdgeOps.getEdgeMidPoint(edge))
+            }));
+            const startDist = isThroughAll ? Math.max(...dists.map(e => e.d)) : 0;
+            const endDist = isThroughAll ? Math.min(...dists.map(e => e.d)) : -cutDistance;
+            for (const { edge, d } of dists) {
+                if (Math.abs(d - startDist) < tolerance) {
+                    startEdges.push(edge);
+                }
+                else if (Math.abs(d - endDist) < tolerance) {
+                    endEdges.push(edge);
+                }
+                else {
+                    internalEdges.push(edge);
+                }
+            }
+        }
+        const resultRawFaces = Explorer.findShapes(result, Explorer.getOcShapeType("face"));
+        const internalFaces = resultRawFaces
+            .filter(rf => !stockFaceMap.Contains(rf))
+            .map(rf => Face.fromTopoDSFace(Explorer.toFace(rf)));
+        stockEdgeMap.delete();
+        stockFaceMap.delete();
+        progress.delete();
+        stockList.delete();
+        toolList.delete();
+        return { result: wrappedResult, modified, sectionEdges, startEdges, endEdges, internalEdges, internalFaces };
+    }
+    static fuse(args) {
+        const oc = getOC();
+        const builder = new oc.BRepAlgoAPI_Fuse();
+        builder.SetNonDestructive(true);
+        builder.SetCheckInverted(true);
+        builder.SetRunParallel(true);
+        const argsList = new oc.TopTools_ListOfShape();
+        for (const arg of args) {
+            argsList.Append(arg.getShape());
+        }
+        const empty = ShapeOps.makeCompoundRaw([]);
+        const list = new oc.TopTools_ListOfShape();
+        list.Append(empty);
+        builder.SetArguments(list);
+        builder.SetTools(argsList);
+        const progress = new oc.Message_ProgressRange();
+        builder.Build(progress);
+        builder.SimplifyResult(false, true, oc.Precision.Angular());
+        const resultShape = builder.Shape();
+        console.log('FuseMultiShape: Result shape type:', Explorer.getShapeType(resultShape));
+        const rawShapes = Explorer.findAllShapes(resultShape);
+        console.log('FuseMultiShape: Result shapes count:', rawShapes.length);
+        const result = rawShapes.map(s => ShapeFactory.fromShape(s));
+        const modifiedShapes = [];
+        for (const shape of args) {
+            if (builder.IsDeleted(shape.getShape())) {
+                modifiedShapes.push(shape);
+            }
+        }
+        builder.delete();
+        progress.delete();
+        const newShapes = [];
+        for (const s of result) {
+            const existsInArgs = args.some(arg => arg.getShape().IsPartner(s.getShape()));
+            if (!existsInArgs) {
+                newShapes.push(s);
+            }
+        }
+        return { result, newShapes, modifiedShapes };
+    }
+    static fuseFaces(args) {
+        const oc = getOC();
+        const builder = new oc.BRepAlgoAPI_Fuse();
+        builder.SetNonDestructive(true);
+        builder.SetRunParallel(true);
+        const argsList = new oc.TopTools_ListOfShape();
+        for (const arg of args) {
+            argsList.Append(arg.getShape());
+        }
+        const empty = ShapeOps.makeCompoundRaw([]);
+        const list = new oc.TopTools_ListOfShape();
+        list.Append(empty);
+        builder.SetArguments(list);
+        builder.SetTools(argsList);
+        const progress = new oc.Message_ProgressRange();
+        builder.Build(progress);
+        const resultShape = builder.Shape();
+        console.log('FuseMultiShape: Result shape type:', Explorer.getShapeType(resultShape));
+        const unify = new oc.ShapeUpgrade_UnifySameDomain(resultShape, true, true, false);
+        unify.Build();
+        const mergedShape = unify.Shape();
+        const rawShapes = Explorer.findAllShapes(mergedShape);
+        if (rawShapes.length === args.length || rawShapes.length === 0) {
+            return {
+                result: args,
+                newShapes: [],
+                modifiedShapes: []
+            };
+        }
+        console.log('FuseMultiShape: Result shapes count:', rawShapes.length);
+        const result = rawShapes.map(s => ShapeFactory.fromShape(s));
+        const modifiedShapes = [];
+        for (const shape of args) {
+            if (builder.IsDeleted(shape.getShape())) {
+                console.log('=======', 'Shape was deleted in fuse:', shape);
+                modifiedShapes.push(shape);
+            }
+        }
+        builder.delete();
+        progress.delete();
+        const newShapes = [];
+        for (const s of result) {
+            const existsInArgs = args.some(arg => arg.getShape().IsPartner(s.getShape()));
+            if (!existsInArgs) {
+                newShapes.push(s);
+            }
+        }
+        const cleanResult = result.map(s => ShapeOps.cleanShape(s));
+        const cleanNewShapes = newShapes.map(s => ShapeOps.cleanShape(s));
+        return { result: cleanResult, newShapes: cleanNewShapes, modifiedShapes };
+    }
+    static splitShape(shape, tool) {
+        const oc = getOC();
+        const splitter = new oc.BOPAlgo_Splitter();
+        splitter.SetRunParallel(true);
+        splitter.SetNonDestructive(true);
+        splitter.AddTool(tool.getShape());
+        splitter.AddArgument(shape.getShape());
+        const progress = new oc.Message_ProgressRange();
+        splitter.Perform(progress);
+        progress.delete();
+        if (splitter.HasErrors()) {
+            splitter.delete();
+            throw new Error("Splitter failed");
+        }
+        const resultShape = splitter.Shape();
+        splitter.delete();
+        if (Explorer.isSolid(resultShape)) {
+            return [ShapeFactory.fromShape(resultShape)];
+        }
+        return Explorer.findShapes(resultShape, Explorer.getOcShapeType("solid"))
+            .map(s => ShapeFactory.fromShape(s));
+    }
+    static common(args) {
+        const oc = getOC();
+        const argsList = new oc.TopTools_ListOfShape();
+        for (const arg of args) {
+            argsList.Append(arg.getShape());
+        }
+        const empty = ShapeOps.makeCompoundRaw([]);
+        const list = new oc.TopTools_ListOfShape();
+        list.Append(empty);
+        const progress = new oc.Message_ProgressRange();
+        const builder = new oc.BOPAlgo_CellsBuilder();
+        builder.SetArguments(argsList);
+        builder.SetNonDestructive(true);
+        builder.SetCheckInverted(true);
+        builder.SetRunParallel(true);
+        builder.Perform(progress);
+        if (builder.HasErrors()) {
+            builder.delete();
+            progress.delete();
+            list.delete();
+            throw new Error('Common operation failed');
+        }
+        builder.RemoveAllFromResult();
+        const inside = new oc.TopTools_ListOfShape();
+        for (const arg of args) {
+            inside.Append(arg.getShape());
+        }
+        const outside = new oc.TopTools_ListOfShape();
+        builder.AddToResult(inside, outside, 0, false);
+        builder.MakeContainers();
+        const resultShape = builder.Shape();
+        const rawShapes = Explorer.findAllShapes(resultShape);
+        const result = rawShapes.map(s => ShapeFactory.fromShape(s));
+        console.log('Common operation: result shape type:', rawShapes.length);
+        const modifiedShapes = [];
+        for (const shape of args) {
+            if (builder.IsDeleted(shape.getShape())) {
+                modifiedShapes.push(shape);
+            }
+            else {
+                const modified = builder.Modified(shape.getShape());
+                if (modified.Size() > 0) {
+                    modifiedShapes.push(shape);
+                }
+            }
+        }
+        builder.delete();
+        progress.delete();
+        const newShapes = [];
+        for (const s of result) {
+            const existsInArgs = args.some(arg => arg.getShape().IsPartner(s.getShape()));
+            if (!existsInArgs) {
+                newShapes.push(s);
+            }
+        }
+        const cleanResult = result.map(s => ShapeOps.cleanShape(s));
+        const cleanNewShapes = newShapes.map(s => ShapeOps.cleanShape(s));
+        console.log('Common operation: result shapes count:', cleanResult.length);
+        console.log('Common operation: new shapes count:', cleanNewShapes.length);
+        console.log('Common operation: modified shapes count:', modifiedShapes.length);
+        return { result: cleanResult, newShapes: cleanNewShapes, modifiedShapes };
+    }
+    static doShapesIntersect(shape1, shape2) {
+        const oc = getOC();
+        const raw1 = shape1.getShape();
+        const raw2 = shape2.getShape();
+        const bbox1 = new oc.Bnd_Box();
+        const bbox2 = new oc.Bnd_Box();
+        oc.BRepBndLib.Add(raw1, bbox1, false);
+        oc.BRepBndLib.Add(raw2, bbox2, false);
+        if (bbox1.IsOut(bbox2)) {
+            bbox1.delete();
+            bbox2.delete();
+            console.log(`Intersection test: Bounding boxes do not intersect.`);
+            return false;
+        }
+        bbox1.delete();
+        bbox2.delete();
+        const progress = new oc.Message_ProgressRange();
+        const distCalc = new oc.BRepExtrema_DistShapeShape(raw1, raw2, oc.Extrema_ExtFlag.Extrema_ExtFlag_MIN, oc.Extrema_ExtAlgo.Extrema_ExtAlgo_Grad, progress);
+        distCalc.SetMultiThread(true);
+        const distance = distCalc.IsDone() ? distCalc.Value() : Infinity;
+        distCalc.delete();
+        console.log(`Intersection test: Minimum distance between shapes is ${distance}.`);
+        if (distance <= 0) {
+            console.log(`Intersection test: Shapes are separated by distance ${distance}.`);
+            return true;
+        }
+        const common = new oc.BRepAlgoAPI_Common(raw1, raw2, progress);
+        common.SetRunParallel(true);
+        common.Build(new oc.Message_ProgressRange());
+        if (!common.IsDone()) {
+            common.delete();
+            console.log(`Intersection test: Boolean common operation failed.`);
+            return false;
+        }
+        const props = new oc.GProp_GProps();
+        oc.BRepGProp.VolumeProperties(common.Shape(), props, false, false, false);
+        const volume = props.Mass();
+        props.delete();
+        common.delete();
+        return volume > 1e-9;
+    }
+}

package/lib/dist/oc/constraint-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { GccEnt_Position, GccEnt_QualifiedCirc, GccEnt_QualifiedLin, gp_Circ, gp_Circ2d, gp_Lin, gp_Lin2d, gp_Pln, gp_Pnt, gp_Pnt2d } from "occjs-wrapper";
+import { ConstraintQualifier } from "../features/2d/constraints/qualified-geometry.js";
+export declare class ConstraintResolver {
+    static get2dGeometry<T extends gp_Circ | gp_Lin | gp_Pnt>(plane: gp_Pln, geometry: T): gp_Lin2d | gp_Circ2d | gp_Pnt2d;
+    static getQualifier(qualifier: ConstraintQualifier): GccEnt_Position;
+    static getQualified(plane: gp_Pln, geometry: gp_Circ | gp_Lin, qualifier: ConstraintQualifier): GccEnt_QualifiedCirc | GccEnt_QualifiedLin;
+}

package/lib/dist/oc/constraint-resolver.js

@@ -0,0 +1,31 @@
+import { getOC } from "./init.js";
+export class ConstraintResolver {
+    static get2dGeometry(plane, geometry) {
+        const oc = getOC();
+        return oc.ProjLib.Project(plane, geometry);
+    }
+    static getQualifier(qualifier) {
+        const oc = getOC();
+        switch (qualifier) {
+            case 'unqualified':
+                return oc.GccEnt_Position.GccEnt_unqualified;
+            case 'enclosed':
+                return oc.GccEnt_Position.GccEnt_enclosed;
+            case 'enclosing':
+                return oc.GccEnt_Position.GccEnt_enclosing;
+            case 'outside':
+                return oc.GccEnt_Position.GccEnt_outside;
+        }
+    }
+    static getQualified(plane, geometry, qualifier) {
+        const oc = getOC();
+        const geom = this.get2dGeometry(plane, geometry);
+        if (geom instanceof oc.gp_Circ2d) {
+            return new oc.GccEnt_QualifiedCirc(geom, this.getQualifier(qualifier));
+        }
+        else if (geom instanceof oc.gp_Lin2d) {
+            return new oc.GccEnt_QualifiedLin(geom, this.getQualifier(qualifier));
+        }
+        throw new Error('Unsupported geometry type');
+    }
+}