fluidcad 0.0.2

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

@@ -0,0 +1,5 @@
+import { Shape } from "../common/shape.js";
+import { Face } from "../common/face.js";
+export declare class ShellOps {
+    static makeThickSolid(solid: Shape, faces: Face[], thickness: number): Shape;
+}

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

@@ -0,0 +1,25 @@
+import { getOC } from "./init.js";
+import { ShapeOps } from "./shape-ops.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+export class ShellOps {
+    static makeThickSolid(solid, faces, thickness) {
+        const oc = getOC();
+        const listOfFaces = new oc.TopTools_ListOfShape();
+        for (const f of faces) {
+            listOfFaces.Append(f.getShape());
+        }
+        const maker = new oc.BRepOffsetAPI_MakeThickSolid();
+        const progress = new oc.Message_ProgressRange();
+        maker.MakeThickSolidByJoin(oc.TopoDS.Solid(solid.getShape()), listOfFaces, thickness, oc.Precision.Confusion(), oc.BRepOffset_Mode.BRepOffset_Skin, false, false, oc.GeomAbs_JoinType.GeomAbs_Arc, false, progress);
+        progress.delete();
+        if (!maker.IsDone()) {
+            maker.delete();
+            listOfFaces.delete();
+            throw new Error("Failed to create thick solid.");
+        }
+        const newShape = maker.Shape();
+        maker.delete();
+        listOfFaces.delete();
+        return ShapeFactory.fromShape(ShapeOps.cleanShapeRaw(newShape));
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+import { Solid } from "../common/solid.js";
+import { Wire } from "../common/wire.js";
+import { Face } from "../common/face.js";
+export interface SweepResult {
+    solids: Solid[];
+    firstShape: TopoDS_Shape;
+    lastShape: TopoDS_Shape;
+}
+export declare class SweepOps {
+    static makeSweep(spineWire: Wire, profileFaces: Face[]): SweepResult;
+}

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

@@ -0,0 +1,39 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+import { Solid } from "../common/solid.js";
+export class SweepOps {
+    static makeSweep(spineWire, profileFaces) {
+        const oc = getOC();
+        const allSolids = [];
+        let firstShape = null;
+        let lastShape = null;
+        for (const face of profileFaces) {
+            const pipe = new oc.BRepOffsetAPI_MakePipe(spineWire.getShape(), face.getShape());
+            const progress = new oc.Message_ProgressRange();
+            pipe.Build(progress);
+            progress.delete();
+            if (!pipe.IsDone()) {
+                pipe.delete();
+                throw new Error("Sweep operation failed.");
+            }
+            if (!firstShape) {
+                firstShape = pipe.FirstShape();
+                lastShape = pipe.LastShape();
+            }
+            const result = pipe.Shape();
+            pipe.delete();
+            const solids = Explorer.findShapes(result, Explorer.getOcShapeType("solid"));
+            for (const s of solids) {
+                allSolids.push(Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+            }
+        }
+        if (allSolids.length === 0) {
+            throw new Error("Sweep produced no solids.");
+        }
+        return {
+            solids: allSolids,
+            firstShape: firstShape,
+            lastShape: lastShape,
+        };
+    }
+}

package/lib/dist/oc/tangent-circle-solver.d.ts

@@ -0,0 +1,17 @@
+import { Edge } from "../common/edge.js";
+import { ConstraintQualifier } from "../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../math/plane.js";
+import { Shape } from "../common/shape.js";
+export declare class TangentCircleSolver {
+    static getTangentLines(plane: Plane, shape1: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }, shape2: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }): Edge[];
+    private static getPointCircleTangent;
+    private static getCircleCircleTangent;
+    private static collectSolverEdges;
+    private static getShapeGeometry;
+}

package/lib/dist/oc/tangent-circle-solver.js

@@ -0,0 +1,72 @@
+import { Convert } from "./convert.js";
+import { Geometry } from "./geometry.js";
+import { getOC } from "./init.js";
+import { ConstraintResolver } from "./constraint-resolver.js";
+export class TangentCircleSolver {
+    static getTangentLines(plane, shape1, shape2) {
+        return [];
+    }
+    static getPointCircleTangent(plane, vertex, circleShape) {
+        const oc = getOC();
+        // new oc.GccAna_Circ2d2TanRad()
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const geometry = this.getShapeGeometry(circleShape.shape);
+        const qualifiedGeometry = ConstraintResolver.getQualified(pln, geometry, circleShape.qualifier);
+        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry, pnt, tolerance);
+        disposePnt();
+        const edges = this.collectSolverEdges(solver, plane);
+        disposePln();
+        return edges;
+    }
+    static getCircleCircleTangent(plane, shape1, shape2) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const geometry1 = this.getShapeGeometry(shape1.shape);
+        const geometry2 = this.getShapeGeometry(shape2.shape);
+        const qualifiedGeometry1 = ConstraintResolver.getQualified(pln, geometry1, shape1.qualifier);
+        const qualifiedGeometry2 = ConstraintResolver.getQualified(pln, geometry2, shape2.qualifier);
+        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry1, qualifiedGeometry2, tolerance);
+        const edges = this.collectSolverEdges(solver, plane);
+        disposePln();
+        return edges;
+    }
+    static collectSolverEdges(solver, plane) {
+        const oc = getOC();
+        const edges = [];
+        if (solver.IsDone()) {
+            const nSolutions = solver.NbSolutions();
+            for (let i = 1; i <= nSolutions; i++) {
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, true));
+                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, true));
+                const line = Geometry.makeSegment(worldPnt1, worldPnt2);
+                edges.push(Geometry.makeEdge(line));
+            }
+        }
+        return edges;
+    }
+    static getShapeGeometry(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        let geometry;
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            geometry = adaptor.Line();
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle && adaptor.IsClosed()) {
+            geometry = adaptor.Circle();
+        }
+        else {
+            adaptor.delete();
+            throw new Error('Unsupported shape type for tangent line solver');
+        }
+        adaptor.delete();
+        return geometry;
+    }
+}

package/lib/dist/oc/tangent-line-solver.d.ts

@@ -0,0 +1,17 @@
+import { Edge } from "../common/edge.js";
+import { ConstraintQualifier } from "../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../math/plane.js";
+import { Shape } from "../common/shape.js";
+export declare class TangentLineSolver {
+    static getTangentLines(plane: Plane, shape1: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }, shape2: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }): Edge[];
+    private static getPointCircleTangent;
+    private static getCircleCircleTangent;
+    private static collectSolverEdges;
+    private static getShapeGeometry;
+}

package/lib/dist/oc/tangent-line-solver.js

@@ -0,0 +1,83 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Geometry } from "./geometry.js";
+import { ConstraintResolver } from "./constraint-resolver.js";
+import { Vertex } from "../common/vertex.js";
+export class TangentLineSolver {
+    static getTangentLines(plane, shape1, shape2) {
+        if (shape1.shape instanceof Vertex || shape2.shape instanceof Vertex) {
+            const [vertex] = [shape1, shape2].filter(s => s.shape instanceof Vertex);
+            const [otherShape] = [shape1, shape2].filter(s => s !== vertex);
+            if (otherShape instanceof Vertex) {
+                // todo: create a line between the two points and return it as the single tangent solution
+                return [];
+            }
+            return this.getPointCircleTangent(plane, vertex.shape, otherShape);
+        }
+        else {
+            return this.getCircleCircleTangent(plane, shape1, shape2);
+        }
+    }
+    static getPointCircleTangent(plane, vertex, circleShape) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const geometry = this.getShapeGeometry(circleShape.shape);
+        const qualifiedGeometry = ConstraintResolver.getQualified(pln, geometry, circleShape.qualifier);
+        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry, pnt, tolerance);
+        disposePnt();
+        const edges = this.collectSolverEdges(solver, plane);
+        disposePln();
+        return edges;
+    }
+    static getCircleCircleTangent(plane, shape1, shape2) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const geometry1 = this.getShapeGeometry(shape1.shape);
+        const geometry2 = this.getShapeGeometry(shape2.shape);
+        const qualifiedGeometry1 = ConstraintResolver.getQualified(pln, geometry1, shape1.qualifier);
+        const qualifiedGeometry2 = ConstraintResolver.getQualified(pln, geometry2, shape2.qualifier);
+        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry1, qualifiedGeometry2, tolerance);
+        const edges = this.collectSolverEdges(solver, plane);
+        disposePln();
+        return edges;
+    }
+    static collectSolverEdges(solver, plane) {
+        const oc = getOC();
+        const edges = [];
+        if (solver.IsDone()) {
+            const nSolutions = solver.NbSolutions();
+            for (let i = 1; i <= nSolutions; i++) {
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, true));
+                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, true));
+                const line = Geometry.makeSegment(worldPnt1, worldPnt2);
+                edges.push(Geometry.makeEdge(line));
+            }
+        }
+        return edges;
+    }
+    static getShapeGeometry(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        let geometry;
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            geometry = adaptor.Line();
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle && adaptor.IsClosed()) {
+            geometry = adaptor.Circle();
+        }
+        else {
+            adaptor.delete();
+            throw new Error('Unsupported shape type for tangent line solver');
+        }
+        adaptor.delete();
+        return geometry;
+    }
+}

package/lib/dist/oc/tangent-solver.d.ts

@@ -0,0 +1,14 @@
+import { Point2D } from "../math/point.js";
+import { Edge } from "../common/edge.js";
+import { QualifiedGeometry } from "../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../math/plane.js";
+export declare class TangentSolver {
+    static getTangentLines(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry): Edge[];
+    static getTangentCircles(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry, radius: number): Edge[];
+    static getTangentArcs(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry, radius: number): {
+        edge: Edge;
+        endTangent: Point2D;
+    }[];
+    static getTangentCircles3Tan(plane: Plane, qualifiedC1: QualifiedGeometry, qualifiedC2: QualifiedGeometry, qualifiedC3: QualifiedGeometry): Edge[];
+    private static buildCirc2TanSolver;
+}

package/lib/dist/oc/tangent-solver.js

@@ -0,0 +1,199 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Point2D } from "../math/point.js";
+import { Geometry } from "./geometry.js";
+import { ConstraintResolver } from "./constraint-resolver.js";
+import { Wire } from "../common/wire.js";
+import { Vertex } from "../common/vertex.js";
+export class TangentSolver {
+    static getTangentLines(plane, qualifiedC1, qualifiedC2) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        let shape1 = qualifiedC1.object.getShapes({ excludeMeta: false })[0];
+        let shape2 = qualifiedC2.object.getShapes({ excludeMeta: false })[0];
+        if (shape1 instanceof Wire) {
+            shape1 = shape1.getEdges()[0];
+        }
+        if (shape2 instanceof Wire) {
+            shape2 = shape2.getEdges()[0];
+        }
+        let qc1;
+        let qc2;
+        if (shape1 instanceof Vertex || shape2 instanceof Vertex) {
+            // const oc = getOC();
+            // const vertex = shape.getShape() as TopoDS_Vertex;
+            // const pnt = oc.BRep_Tool.Pnt(vertex);
+            //       const localPoint = plane.worldToLocal(Convert.toPoint(c2.qualified as gp_Pnt));
+            // const [gpPnt, disposeGpPnt] = Convert.toGpPnt2d(localPoint);
+            // solver = new oc.GccAna_Lin2d2Tan(c1.qualified as any, gpPnt, tolerance);
+            // disposeGpPnt();
+            throw new Error('TODO');
+        }
+        const adaptor1 = new oc.BRepAdaptor_Curve(shape1.getShape());
+        const adaptor2 = new oc.BRepAdaptor_Curve(shape2.getShape());
+        const type1 = adaptor1.GetType();
+        const type2 = adaptor2.GetType();
+        let solver;
+        if (type1 === oc.GeomAbs_CurveType.GeomAbs_Circle && type2 === oc.GeomAbs_CurveType.GeomAbs_Circle && adaptor1.IsClosed() && adaptor2.IsClosed()) {
+            const c1 = ConstraintResolver.getQualified(pln, qualifiedC1);
+            const c2 = ConstraintResolver.getQualified(pln, qualifiedC2);
+            solver = new oc.GccAna_Lin2d2Tan(c1.qualified, c2.qualified, tolerance);
+        }
+        else {
+            const c1 = ConstraintResolver.getQualifiedAsCurve(pln, adaptor1, ConstraintResolver.getQualifier(qualifiedC1.qualifier));
+            const c2 = ConstraintResolver.getQualifiedAsCurve(pln, adaptor2, ConstraintResolver.getQualifier(qualifiedC2.qualifier));
+            solver = new oc.Geom2dGcc_Lin2d2Tan(c1, c2, tolerance);
+        }
+        disposePln();
+        const edges = [];
+        if (solver.IsDone()) {
+            const nSolutions = solver.NbSolutions();
+            for (let i = 1; i <= nSolutions; i++) {
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, true));
+                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, true));
+                const line = Geometry.makeSegment(worldPnt1, worldPnt2);
+                edges.push(Geometry.makeEdge(line));
+            }
+        }
+        return edges;
+    }
+    static getTangentCircles(plane, qualifiedC1, qualifiedC2, radius) {
+        const solver = TangentSolver.buildCirc2TanSolver(plane, qualifiedC1, qualifiedC2, radius);
+        const edges = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const circ2d = solver.ThisSolution(i);
+                const center2d = Convert.toPoint2D(circ2d.Location());
+                const worldCenter = plane.localToWorld(center2d);
+                const r = circ2d.Radius();
+                const circle = Geometry.makeCircle(worldCenter, r, plane.normal);
+                edges.push(Geometry.makeEdgeFromCircle(circle));
+            }
+        }
+        return edges;
+    }
+    static getTangentArcs(plane, qualifiedC1, qualifiedC2, radius) {
+        const oc = getOC();
+        const solver = TangentSolver.buildCirc2TanSolver(plane, qualifiedC1, qualifiedC2, radius);
+        const results = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const circ2d = solver.ThisSolution(i);
+                const center2d = Convert.toPoint2D(circ2d.Location());
+                const worldCenter = plane.localToWorld(center2d);
+                const r = circ2d.Radius();
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                const worldPnt1 = plane.localToWorld(Convert.toPoint2D(pnt1, false));
+                const worldPnt2 = plane.localToWorld(Convert.toPoint2D(pnt2, false));
+                const angle1 = Math.atan2(pnt1.Y() - center2d.y, pnt1.X() - center2d.x);
+                const angle2 = Math.atan2(pnt2.Y() - center2d.y, pnt2.X() - center2d.x);
+                pnt1.delete();
+                pnt2.delete();
+                let diff = angle2 - angle1;
+                if (diff > Math.PI) {
+                    diff -= 2 * Math.PI;
+                }
+                if (diff < -Math.PI) {
+                    diff += 2 * Math.PI;
+                }
+                const midAngle = angle1 + diff / 2;
+                const worldMid = plane.localToWorld(new Point2D(center2d.x + r * Math.cos(midAngle), center2d.y + r * Math.sin(midAngle)));
+                const arc = Geometry.makeArcThreePoints(worldPnt1, worldMid, worldPnt2);
+                const edge = Geometry.makeEdgeFromCurve(arc);
+                const sign = diff > 0 ? 1 : -1;
+                const endTangent = new Point2D(sign * (-Math.sin(angle2)), sign * Math.cos(angle2));
+                results.push({ edge, endTangent });
+            }
+        }
+        return results;
+    }
+    static getTangentCircles3Tan(plane, qualifiedC1, qualifiedC2, qualifiedC3) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Confusion();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const inputs = [
+            { q: qualifiedC1, r: ConstraintResolver.getQualified(pln, qualifiedC1) },
+            { q: qualifiedC2, r: ConstraintResolver.getQualified(pln, qualifiedC2) },
+            { q: qualifiedC3, r: ConstraintResolver.getQualified(pln, qualifiedC3) },
+        ];
+        const circles = inputs.filter(i => i.r.type === 'circle');
+        const lines = inputs.filter(i => i.r.type === 'line');
+        const curves = inputs.filter(i => i.r.type === 'curve');
+        let solver;
+        if (curves.length > 0) {
+            const qc1 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC1);
+            const qc2 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC2);
+            const qc3 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC3);
+            solver = new oc.Geom2dGcc_Circ2d3Tan(qc1, qc2, qc3, tolerance, 0, 0, 0);
+        }
+        else if (circles.length === 3) {
+            solver = new oc.GccAna_Circ2d3Tan(circles[0].r.qualified, circles[1].r.qualified, circles[2].r.qualified, tolerance);
+        }
+        else if (circles.length === 2 && lines.length === 1) {
+            solver = new oc.GccAna_Circ2d3Tan(circles[0].r.qualified, circles[1].r.qualified, lines[0].r.qualified, tolerance);
+        }
+        else if (circles.length === 1 && lines.length === 2) {
+            solver = new oc.GccAna_Circ2d3Tan(circles[0].r.qualified, lines[0].r.qualified, lines[1].r.qualified, tolerance);
+        }
+        else {
+            solver = new oc.GccAna_Circ2d3Tan(lines[0].r.qualified, lines[1].r.qualified, lines[2].r.qualified, tolerance);
+        }
+        disposePln();
+        const edges = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const circ2d = solver.ThisSolution(i);
+                const center2d = Convert.toPoint2D(circ2d.Location());
+                const worldCenter = plane.localToWorld(center2d);
+                const r = circ2d.Radius();
+                const circle = Geometry.makeCircle(worldCenter, r, plane.normal);
+                edges.push(Geometry.makeEdgeFromCircle(circle));
+            }
+        }
+        return edges;
+    }
+    static buildCirc2TanSolver(plane, qualifiedC1, qualifiedC2, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Confusion();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const c1 = ConstraintResolver.getQualified(pln, qualifiedC1);
+        const c2 = ConstraintResolver.getQualified(pln, qualifiedC2);
+        let solver;
+        if (c1.type === 'circle' && c2.type === 'circle') {
+            solver = new oc.GccAna_Circ2d2TanRad(c1.qualified, c2.qualified, radius, tolerance);
+        }
+        else if (c1.type === 'circle' && c2.type === 'line') {
+            solver = new oc.GccAna_Circ2d2TanRad(c1.qualified, c2.qualified, radius, tolerance);
+        }
+        else if (c1.type === 'line' && c2.type === 'circle') {
+            solver = new oc.GccAna_Circ2d2TanRad(c2.qualified, c1.qualified, radius, tolerance);
+        }
+        else if (c1.type === 'line' && c2.type === 'line') {
+            solver = new oc.GccAna_Circ2d2TanRad(c1.qualified, c2.qualified, radius, tolerance);
+        }
+        else if (c1.type === 'point' && c2.type === 'point') {
+            const localPoint1 = plane.worldToLocal(Convert.toPoint(c1.qualified));
+            const localPoint2 = plane.worldToLocal(Convert.toPoint(c2.qualified));
+            const [gpPnt1, disposeGpPnt1] = Convert.toGpPnt2d(localPoint1);
+            const [gpPnt2, disposeGpPnt2] = Convert.toGpPnt2d(localPoint2);
+            solver = new oc.GccAna_Circ2d2TanRad(gpPnt1, gpPnt2, radius, tolerance);
+            disposeGpPnt1();
+            disposeGpPnt2();
+        }
+        else {
+            const qc1 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC1);
+            const qc2 = ConstraintResolver.getQualifiedAsCurve(pln, qualifiedC2);
+            solver = new oc.Geom2dGcc_Circ2d2TanRad(qc1, qc2, radius, tolerance);
+        }
+        disposePln();
+        return solver;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { TopoDS_Vertex } from "occjs-wrapper";
+import { Point } from "../math/point.js";
+import { Vertex } from "../common/vertex.js";
+export declare class VertexOps {
+    static toPoint(vertex: Vertex): Point;
+    static fromPoint(point: Point): Vertex;
+    static reverse(vertex: Vertex): Vertex;
+    static reverseRaw(vertex: TopoDS_Vertex): TopoDS_Vertex;
+    static toPointRaw(vertex: TopoDS_Vertex): Point;
+    static fromPointRaw(point: Point): TopoDS_Vertex;
+}

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

@@ -0,0 +1,39 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Vertex } from "../common/vertex.js";
+export class VertexOps {
+    // Wrapper methods (public API for external callers)
+    static toPoint(vertex) {
+        return VertexOps.toPointRaw(vertex.getShape());
+    }
+    static fromPoint(point) {
+        return Vertex.fromTopoDSVertex(VertexOps.fromPointRaw(point));
+    }
+    static reverse(vertex) {
+        const reversedVertex = VertexOps.reverseRaw(vertex.getShape());
+        return Vertex.fromTopoDSVertex(reversedVertex);
+    }
+    static reverseRaw(vertex) {
+        const oc = getOC();
+        const reversed = oc.TopoDS.Vertex(vertex.Reversed());
+        vertex.delete();
+        return reversed;
+    }
+    // Raw methods (for oc-internal and common/ use)
+    static toPointRaw(vertex) {
+        const oc = getOC();
+        const pnt = oc.BRep_Tool.Pnt(vertex);
+        const r = Convert.toPoint(pnt);
+        pnt.delete();
+        return r;
+    }
+    static fromPointRaw(point) {
+        const oc = getOC();
+        console.log("Creating vertex from point:", point);
+        const [pnt, disposePnt] = Convert.toGpPnt(point);
+        const vertexMaker = new oc.BRepBuilderAPI_MakeVertex(pnt);
+        const vertex = vertexMaker.Vertex();
+        disposePnt();
+        return vertex;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { TopoDS_Edge, TopoDS_Wire, TopoDS_Face } from "occjs-wrapper";
+import { Vector3d } from "../math/vector3d.js";
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+import { Plane } from "../math/plane.js";
+export declare class WireOps {
+    static isCW(wire: Wire, normal: Vector3d): boolean;
+    static makeWireFromEdges(edges: Edge[]): Wire;
+    static reverseWire(wire: Wire): Wire;
+    static buildWire(edges: Edge[]): Wire;
+    static offsetWire(shape: Wire | Edge, distance: number, isOpen: boolean): Wire;
+    static isCWRaw(wire: TopoDS_Wire, normal: Vector3d): boolean;
+    static makeWireFromEdgesRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
+    static reverseWireRaw(wire: TopoDS_Wire): TopoDS_Wire;
+    static buildWireRaw(edges: TopoDS_Edge[]): TopoDS_Wire;
+    static fixWire(wire: Wire, plane: Plane): Wire;
+    static fixWireRaw(wire: TopoDS_Wire, face: TopoDS_Face): TopoDS_Wire;
+    static groupConnectedEdges(edges: Edge[]): Edge[][];
+    private static verticesMatch;
+    static offsetWireRaw(wire: TopoDS_Wire, distance: number, isOpen: boolean): TopoDS_Wire;
+}