fluidcad 0.0.36 → 0.0.38

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

@@ -96,9 +96,8 @@ export class EdgeOps {
     static edgeMiddlePoint(edge) {
         const oc = getOC();
         const curveAdaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge));
-        const curve = curveAdaptor.Curve();
-        const midParam = (curve.FirstParameter() + curve.LastParameter()) / 2.0;
-        const midPoint = curve.Value(midParam);
+        const midParam = (curveAdaptor.FirstParameter() + curveAdaptor.LastParameter()) / 2.0;
+        const midPoint = curveAdaptor.Value(midParam);
         const result = new oc.gp_Pnt(midPoint.X(), midPoint.Y(), midPoint.Z());
         curveAdaptor.delete();
         return result;
@@ -131,7 +130,7 @@ export class EdgeOps {
         const oc = getOC();
         const isReversed = edge.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED;
         const curveHandle = oc.BRep_Tool.Curve(edge, 0, 1);
-        const curve = curveHandle.get();
+        const curve = curveHandle.returnValue;
         const param = isReversed ? curve.FirstParameter() : curve.LastParameter();
         const edgeSign = isReversed ? -1 : 1;
         const tangentVec = new oc.gp_Vec();
@@ -143,11 +142,11 @@ export class EdgeOps {
     }
     static makeEdgeFromCurveAndVerticesRaw(curve, v1, v2) {
         const oc = getOC();
-        const handle = new oc.Handle_Geom_Curve(curve);
-        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(handle, v1, v2);
+        // Handles are unwrapped in V8: pass the Geom_Curve straight to MakeEdge
+        // (constructing the abstract oc.Geom_Curve base throws at runtime).
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(curve, v1, v2);
         const edge = edgeMaker.Edge();
         edgeMaker.delete();
-        handle.delete();
         return edge;
     }
     static splitEdges(edges) {
@@ -233,17 +232,17 @@ export class EdgeOps {
                 sourceIndex.push(srcIdx);
                 continue;
             }
-            // Get the underlying curve for creating sub-edges
-            const curveHandle = oc.BRep_Tool.Curve(edge, 0, 1);
-            const curve = curveHandle.get();
-            const handle = new oc.Handle_Geom_Curve(curve);
+            // Get the underlying curve for creating sub-edges. Handles are unwrapped in
+            // V8 — use the returned Geom_Curve directly (the abstract oc.Geom_Curve base
+            // has no constructor).
+            const geomCurve = oc.BRep_Tool.Curve(edge, 0, 1).returnValue;
             if (isClosed && interior.length >= 2) {
                 // Closed curve: N split points → N arcs (no seam split)
                 const period = last - first;
                 for (let k = 0; k < interior.length; k++) {
                     const u1 = interior[k];
                     const u2 = k < interior.length - 1 ? interior[k + 1] : interior[0] + period;
-                    const maker = new oc.BRepBuilderAPI_MakeEdge(handle, u1, u2);
+                    const maker = new oc.BRepBuilderAPI_MakeEdge(geomCurve, u1, u2);
                     if (maker.IsDone()) {
                         result.push(Edge.fromTopoDSEdge(maker.Edge()));
                         sourceIndex.push(srcIdx);
@@ -255,7 +254,7 @@ export class EdgeOps {
                 // Open curve: include edge endpoints as boundaries
                 const allParams = [first, ...interior, last];
                 for (let k = 0; k < allParams.length - 1; k++) {
-                    const maker = new oc.BRepBuilderAPI_MakeEdge(handle, allParams[k], allParams[k + 1]);
+                    const maker = new oc.BRepBuilderAPI_MakeEdge(geomCurve, allParams[k], allParams[k + 1]);
                     if (maker.IsDone()) {
                         result.push(Edge.fromTopoDSEdge(maker.Edge()));
                         sourceIndex.push(srcIdx);
@@ -268,7 +267,7 @@ export class EdgeOps {
                 result.push(Edge.fromTopoDSEdge(edge));
                 sourceIndex.push(srcIdx);
             }
-            handle.delete();
+            geomCurve.delete();
         }
         return { edges: result, sourceIndex };
     }

package/lib/dist/oc/edge-props.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 export interface EdgeProperties {
     curveType: 'line' | 'circle' | 'arc' | 'ellipse' | 'other';
     length?: number;

package/lib/dist/oc/edge-query.d.ts

@@ -1,4 +1,4 @@
-import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "occjs-wrapper";
+import type { gp_Pln, gp_Vec, TopoDS_Edge, TopoDS_Face, TopoDS_Shape } from "ocjs-fluidcad";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Plane } from "../math/plane.js";

package/lib/dist/oc/edge-query.js

@@ -148,17 +148,12 @@ export class EdgeQuery {
         const oc = getOC();
         const ocEdge = oc.TopoDS.Edge(edge);
         const adaptor = new oc.BRepAdaptor_Curve(ocEdge);
-        const curve = adaptor.Curve().Curve()?.get();
-        if (!curve) {
-            adaptor.delete();
-            return false;
-        }
-        const firstParam = curve.FirstParameter();
-        const lastParam = curve.LastParameter();
+        const firstParam = adaptor.FirstParameter();
+        const lastParam = adaptor.LastParameter();
         const midParam = (firstParam + lastParam) / 2;
         const tangent = new oc.gp_Vec();
         const tempPnt = new oc.gp_Pnt();
-        curve.D1(midParam, tempPnt, tangent);
+        adaptor.D1(midParam, tempPnt, tangent);
         const dotProduct = Math.abs(tangent.Dot(planeNormal));
         const tolerance = 1e-6;
         const result = dotProduct < tolerance;

package/lib/dist/oc/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ocjs v3 / OCCT V8 raises C++ failures as native `WebAssembly.Exception`
+ * objects. Their default stringification is the opaque
+ * `[object WebAssembly.Exception]`, so decode the OCCT failure type + message
+ * via the module's `getExceptionMessage`. Ordinary JS errors pass through with
+ * their stack/message.
+ */
+export declare function describeOcException(e: unknown): string;

package/lib/dist/oc/errors.js

@@ -0,0 +1,27 @@
+import { getOC } from "./init.js";
+/**
+ * ocjs v3 / OCCT V8 raises C++ failures as native `WebAssembly.Exception`
+ * objects. Their default stringification is the opaque
+ * `[object WebAssembly.Exception]`, so decode the OCCT failure type + message
+ * via the module's `getExceptionMessage`. Ordinary JS errors pass through with
+ * their stack/message.
+ */
+export function describeOcException(e) {
+    if (isWasmException(e)) {
+        try {
+            const [type, message] = getOC().getExceptionMessage(e);
+            return `${type}: ${message}`;
+        }
+        catch {
+            return "WebAssembly.Exception (failed to decode OCCT message)";
+        }
+    }
+    if (e instanceof Error) {
+        return e.stack ?? e.message;
+    }
+    return String(e);
+}
+function isWasmException(e) {
+    const ctor = globalThis.WebAssembly?.Exception;
+    return typeof ctor === "function" && e instanceof ctor;
+}

package/lib/dist/oc/explorer.d.ts

@@ -1,4 +1,4 @@
-import type { TopAbs_ShapeEnum, TopoDS_Compound, TopoDS_Edge, TopoDS_Face, TopoDS_Shape, TopoDS_Solid, TopoDS_Wire, TopoDS_Vertex } from "occjs-wrapper";
+import type { TopAbs_ShapeEnum, TopoDS_Compound, TopoDS_Edge, TopoDS_Face, TopoDS_Shape, TopoDS_Solid, TopoDS_Wire, TopoDS_Vertex } from "ocjs-fluidcad";
 import { Shape } from "../common/shape.js";
 import { Face } from "../common/face.js";
 import { Edge } from "../common/edge.js";
@@ -18,7 +18,7 @@ export declare class Explorer {
     static findShapes<T = TopoDS_Shape>(shape: TopoDS_Shape, lookFor: TopAbs_ShapeEnum): T[];
     static findFirstShapeOfType<T = TopoDS_Shape>(shape: TopoDS_Shape, lookFor: TopAbs_ShapeEnum): T | null;
     static findAllShapes(shape: TopoDS_Compound): any[];
-    static getOcShapeType(type: string): any;
+    static getOcShapeType(type: string): "TopAbs_SOLID" | "TopAbs_FACE" | "TopAbs_WIRE" | "TopAbs_EDGE" | "TopAbs_VERTEX";
     static toSolid(shape: TopoDS_Shape): TopoDS_Solid;
     static toFace(shape: TopoDS_Shape): TopoDS_Face;
     static toWire(shape: TopoDS_Shape): TopoDS_Wire;

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 import { Vector3d } from "../math/vector3d.js";
 import { Plane } from "../math/plane.js";
 import { Axis } from "../math/axis.js";
@@ -22,11 +22,37 @@ export interface MakeRevolResult {
 }
 export declare class ExtrudeOps {
     static makePrism(shape: Shape, direction: Vector3d, distance: number): Shape;
-    static makePrismFromVec(shape: Shape, vec: Vector3d): {
+    /**
+     * Build a prism by sweeping `shape` along `vec`. `firstFace` is the cap at the
+     * profile location, `lastFace` the cap at `profile + vec`.
+     *
+     * When `canonicalizeSweep` is set, the sweep is reoriented to a canonical
+     * direction (see below). The swept lateral surfaces (cylinders, cones from a
+     * non-drafted profile) take their axis/parametrization from the sweep
+     * direction, and OCCT 8's `ShapeUpgrade_UnifySameDomain` refuses to merge two
+     * such faces swept in opposite directions. So a symmetric extrude (one half
+     * up, one half down) otherwise fuses into a solid whose lateral surface stays
+     * split at the mid-plane. Canonicalizing makes anti-parallel extrudes share
+     * parametrization so the fused result merges cleanly.
+     *
+     * This must stay OFF for drafted extrudes: `BRepOffsetAPI_DraftAngle` tilts
+     * each side face relative to its own parametrization, so flipping the sweep
+     * would invert the draft. Drafted halves are cones of differing half-angle
+     * anyway and are not expected to merge across the mid-plane.
+     */
+    static makePrismFromVec(shape: Shape, vec: Vector3d, canonicalizeSweep?: boolean): {
         solid: Shape;
         firstFace: Shape;
         lastFace: Shape;
     };
+    /**
+     * Whether a sweep vector points into the canonical hemisphere (dominant
+     * component positive). Anti-parallel vectors map to opposite results, so a
+     * `v` / `-v` pair always agree on a single canonical sweep direction — which
+     * is what keeps their swept surfaces mergeable. `>=` ties pick the same axis
+     * for `v` and `-v`.
+     */
+    private static isCanonicalSweep;
     static makePrismInfinite(shape: Shape, direction: Vector3d): Shape;
     static makePrismSymmetric(shape: Shape, direction: Vector3d): Shape;
     static makeRevol(shape: Shape, axis: Axis, angle: number): MakeRevolResult;

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

@@ -1,5 +1,6 @@
 import { getOC } from "./init.js";
 import { Convert } from "./convert.js";
+import { Matrix4 } from "../math/matrix4.js";
 import { Explorer } from "./explorer.js";
 import { Face } from "../common/face.js";
 import { ShapeFactory } from "../common/shape-factory.js";
@@ -14,26 +15,74 @@ export class ExtrudeOps {
         disposeVec();
         return ShapeFactory.fromShape(result);
     }
-    static makePrismFromVec(shape, vec) {
+    /**
+     * Build a prism by sweeping `shape` along `vec`. `firstFace` is the cap at the
+     * profile location, `lastFace` the cap at `profile + vec`.
+     *
+     * When `canonicalizeSweep` is set, the sweep is reoriented to a canonical
+     * direction (see below). The swept lateral surfaces (cylinders, cones from a
+     * non-drafted profile) take their axis/parametrization from the sweep
+     * direction, and OCCT 8's `ShapeUpgrade_UnifySameDomain` refuses to merge two
+     * such faces swept in opposite directions. So a symmetric extrude (one half
+     * up, one half down) otherwise fuses into a solid whose lateral surface stays
+     * split at the mid-plane. Canonicalizing makes anti-parallel extrudes share
+     * parametrization so the fused result merges cleanly.
+     *
+     * This must stay OFF for drafted extrudes: `BRepOffsetAPI_DraftAngle` tilts
+     * each side face relative to its own parametrization, so flipping the sweep
+     * would invert the draft. Drafted halves are cones of differing half-angle
+     * anyway and are not expected to merge across the mid-plane.
+     */
+    static makePrismFromVec(shape, vec, canonicalizeSweep = false) {
         const oc = getOC();
-        const [gpVec, disposeVec] = Convert.toGpVec(vec);
-        const prism = new oc.BRepPrimAPI_MakePrism(shape.getShape(), gpVec, true, true);
+        // Sweep toward the hemisphere whose dominant component is positive; for a
+        // `v` / `-v` pair this resolves to the same direction. When we flip, sweep
+        // a copy of the profile translated to the far end, then swap the caps back.
+        const flip = canonicalizeSweep && !ExtrudeOps.isCanonicalSweep(vec);
+        const sweep = flip ? vec.multiply(-1) : vec;
+        const profile = flip
+            ? ShapeOps.transform(shape, Matrix4.fromTranslationVector(vec))
+            : shape;
+        const [gpVec, disposeVec] = Convert.toGpVec(sweep);
+        const prism = new oc.BRepPrimAPI_MakePrism(profile.getShape(), gpVec, true, true);
         if (!prism.IsDone()) {
             prism.delete();
             disposeVec();
             throw new Error("Extrusion failed");
         }
         const solid = prism.Shape();
-        const firstFace = prism.FirstShape();
-        const lastFace = prism.LastShape();
+        // When flipped, the swept profile is the far cap: FirstShape is the far end
+        // and LastShape sits at the original profile location — swap them back to
+        // preserve the (firstFace = profile, lastFace = far end) contract.
+        const first = prism.FirstShape();
+        const last = prism.LastShape();
         prism.delete();
         disposeVec();
         return {
             solid: ShapeFactory.fromShape(solid),
-            firstFace: ShapeFactory.fromShape(firstFace),
-            lastFace: ShapeFactory.fromShape(lastFace),
+            firstFace: ShapeFactory.fromShape(flip ? last : first),
+            lastFace: ShapeFactory.fromShape(flip ? first : last),
         };
     }
+    /**
+     * Whether a sweep vector points into the canonical hemisphere (dominant
+     * component positive). Anti-parallel vectors map to opposite results, so a
+     * `v` / `-v` pair always agree on a single canonical sweep direction — which
+     * is what keeps their swept surfaces mergeable. `>=` ties pick the same axis
+     * for `v` and `-v`.
+     */
+    static isCanonicalSweep(vec) {
+        const ax = Math.abs(vec.x);
+        const ay = Math.abs(vec.y);
+        const az = Math.abs(vec.z);
+        if (az >= ax && az >= ay) {
+            return vec.z > 0;
+        }
+        if (ay >= ax) {
+            return vec.y > 0;
+        }
+        return vec.x > 0;
+    }
     static makePrismInfinite(shape, direction) {
         const oc = getOC();
         const [vec, disposeVec] = Convert.toGpVec(direction);

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

@@ -1,4 +1,4 @@
-import type { gp_Cylinder, gp_Pln, TopoDS_Face, TopoDS_Wire } from "occjs-wrapper";
+import type { gp_Cone, gp_Cylinder, gp_Pln, TopoDS_Face, TopoDS_Wire } from "ocjs-fluidcad";
 import { Plane } from "../math/plane.js";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
@@ -28,5 +28,6 @@ export declare class FaceOps {
     }): TopoDS_Face;
     static makeFaceFromPlane(plane: gp_Pln): TopoDS_Face;
     static makeFaceFromCylinder(cylinder: gp_Cylinder): TopoDS_Face;
+    static makeFaceFromCone(cone: gp_Cone): TopoDS_Face;
     static planeToFace(plane: Plane, center?: Point): Face;
 }

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

@@ -223,6 +223,17 @@ export class FaceOps {
         faceMaker.delete();
         return face;
     }
+    static makeFaceFromCone(cone) {
+        const oc = getOC();
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(cone);
+        if (!faceMaker.IsDone()) {
+            faceMaker.delete();
+            throw new Error("Failed to create face from cone");
+        }
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        return face;
+    }
     static planeToFace(plane, center) {
         const oc = getOC();
         const size = 100;

package/lib/dist/oc/face-props.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 export interface FaceProperties {
     surfaceType: 'plane' | 'circle' | 'cylinder' | 'sphere' | 'torus' | 'cone' | 'other';
     areaMm2?: number;

package/lib/dist/oc/face-query.d.ts

@@ -1,4 +1,4 @@
-import type { gp_Pln, gp_Cylinder, TopoDS_Shape } from "occjs-wrapper";
+import type { gp_Pln, gp_Cylinder, gp_Cone, TopoDS_Shape } from "ocjs-fluidcad";
 import { Vector3d } from "../math/vector3d.js";
 import { Plane } from "../math/plane.js";
 import { Shape } from "../common/shape.js";
@@ -20,6 +20,7 @@ export declare class FaceQuery {
     static findFarthestCornerDistanceFromFace(targetFace: Shape, sourceFace: Shape): number;
     static makeInfinitePlanarFace(face: Shape, offset?: number, offsetDirection?: Vector3d): Face;
     static makeInfiniteCylindricalFace(face: Shape, offset?: number): Face;
+    static makeInfiniteConicalFace(face: Shape, offset?: number): Face;
     static isCircleFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
     static isConeFaceRaw(face: TopoDS_Shape): boolean;
     static isCylinderFaceRaw(face: TopoDS_Shape, diameter?: number): boolean;
@@ -31,6 +32,16 @@ export declare class FaceQuery {
     static getSurfaceTypeRaw(face: TopoDS_Shape): string;
     static getSurfaceAdaptorPlaneRaw(face: TopoDS_Shape): gp_Pln;
     static getSurfaceAdaptorCylinderRaw(face: TopoDS_Shape): gp_Cylinder;
+    static getSurfaceAdaptorConeRaw(face: TopoDS_Shape): gp_Cone;
+    /**
+     * Returns the parametric V-bounds of `face`'s underlying surface. For a
+     * cylindrical surface V is the axial coordinate; for a conical surface V is
+     * along the slant (caller multiplies by `cos(semiAngle)` to get axial Z).
+     */
+    static getSurfaceVBoundsRaw(face: TopoDS_Shape): {
+        vMin: number;
+        vMax: number;
+    };
     static findFarthestCornerDistanceRaw(face: TopoDS_Shape, plane: gp_Pln): number;
     static arePlanesParallelRaw(plane1: gp_Pln, plane2: gp_Pln): boolean;
     static findFaceByDistance(faces: Face[], plane: Plane, mode: 'first' | 'last'): Face | null;

package/lib/dist/oc/face-query.js

@@ -102,6 +102,23 @@ export class FaceQuery {
         cylMaker.delete();
         return Face.fromTopoDSFace(rawFace);
     }
+    static makeInfiniteConicalFace(face, offset) {
+        const cone = FaceQuery.getSurfaceAdaptorConeRaw(face.getShape());
+        if (offset) {
+            // The parallel surface at normal distance `offset` is the coaxial cone
+            // with the same semi-angle and a reference radius enlarged by
+            // offset / cos(semiAngle).
+            const radius = cone.RefRadius() + offset / Math.cos(cone.SemiAngle());
+            if (radius < 0) {
+                cone.delete();
+                throw new Error("endOffset is too large for the conical target face");
+            }
+            cone.SetRadius(radius);
+        }
+        const rawFace = FaceOps.makeFaceFromCone(cone);
+        cone.delete();
+        return Face.fromTopoDSFace(rawFace);
+    }
     // Raw methods (for oc-internal and common/ use)
     static isCircleFaceRaw(face, diameter) {
         const oc = getOC();
@@ -296,6 +313,28 @@ export class FaceQuery {
         adaptor.delete();
         return cylinder;
     }
+    static getSurfaceAdaptorConeRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const cone = adaptor.Cone();
+        adaptor.delete();
+        return cone;
+    }
+    /**
+     * Returns the parametric V-bounds of `face`'s underlying surface. For a
+     * cylindrical surface V is the axial coordinate; for a conical surface V is
+     * along the slant (caller multiplies by `cos(semiAngle)` to get axial Z).
+     */
+    static getSurfaceVBoundsRaw(face) {
+        const oc = getOC();
+        const ocFace = oc.TopoDS.Face(face);
+        const adaptor = new oc.BRepAdaptor_Surface(ocFace, true);
+        const vMin = adaptor.FirstVParameter();
+        const vMax = adaptor.LastVParameter();
+        adaptor.delete();
+        return { vMin, vMax };
+    }
     static findFarthestCornerDistanceRaw(face, plane) {
         const oc = getOC();
         const bbox = new oc.Bnd_Box();

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

@@ -1,4 +1,4 @@
-import type { gp_Pln, TopoDS_Wire } from "occjs-wrapper";
+import type { gp_Pln, TopoDS_Wire } from "ocjs-fluidcad";
 import { Shape } from "../common/shape.js";
 import { Edge } from "../common/edge.js";
 import { Face } from "../common/face.js";

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

@@ -105,7 +105,7 @@ export class FilletOps {
             const explorer = new oc.BRepTools_WireExplorer(wire);
             while (explorer.More()) {
                 const raw = oc.TopoDS.Edge(explorer.Current());
-                const isReversed = raw.Orientation().value === oc.TopAbs_Orientation.TopAbs_REVERSED.value;
+                const isReversed = raw.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED;
                 if (!isReversed) {
                     wireEdges.push(raw);
                     ownedEdges.push(raw);
@@ -116,13 +116,13 @@ export class FilletOps {
                     const edgeLast = adaptor.LastParameter();
                     adaptor.delete();
                     const curveHandle = oc.BRep_Tool.Curve(raw, 0, 1);
-                    if (!curveHandle || curveHandle.IsNull()) {
+                    if (!curveHandle) {
                         raw.delete();
                         explorer.delete();
                         ownedEdges.forEach(e => e.delete());
                         throw new Error("fillet2d: edge has no 3D curve");
                     }
-                    const curve = curveHandle.get();
+                    const curve = curveHandle.returnValue;
                     const reversedHandle = curve.Reversed();
                     const newFirst = curve.ReversedParameter(edgeLast);
                     const newLast = curve.ReversedParameter(edgeFirst);
@@ -130,7 +130,7 @@ export class FilletOps {
                     const newEdge = oc.TopoDS.Edge(maker.Edge());
                     maker.delete();
                     reversedHandle.delete();
-                    curveHandle.delete();
+                    curve.delete();
                     raw.delete();
                     wireEdges.push(newEdge);
                     ownedEdges.push(newEdge);

package/lib/dist/oc/geometry.d.ts

@@ -1,4 +1,4 @@
-import type { Geom_BezierCurve, Geom_Circle, Geom_TrimmedCurve, TopoDS_Edge } from "occjs-wrapper";
+import type { Geom_BezierCurve, Geom_Circle, Geom_TrimmedCurve, TopoDS_Edge } from "ocjs-fluidcad";
 import { Point, Point2D } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { Edge } from "../common/edge.js";

package/lib/dist/oc/geometry.js

@@ -16,7 +16,7 @@ export class Geometry {
             disposeP2();
             throw new Error("Failed to create segment: " + status);
         }
-        const geometry = segmentMaker.Value().get();
+        const geometry = segmentMaker.Value();
         segmentMaker.delete();
         disposeP1();
         disposeP2();
@@ -29,7 +29,7 @@ export class Geometry {
         const [gpP3, disposeP3] = Convert.toGpPnt(p3);
         const arcMaker = new oc.GC_MakeArcOfCircle(gpStart, gpEnd, gpP3);
         if (arcMaker.IsDone()) {
-            const curve = arcMaker.Value().get();
+            const curve = arcMaker.Value();
             arcMaker.delete();
             disposeStart();
             disposeEnd();
@@ -54,7 +54,7 @@ export class Geometry {
         const arcMaker = new oc.GC_MakeArcOfCircle(circle, s, e, true);
         let curve = null;
         if (arcMaker.IsDone()) {
-            curve = arcMaker.Value().get();
+            curve = arcMaker.Value();
         }
         disposeC();
         disposeS();
@@ -77,7 +77,7 @@ export class Geometry {
         const circle = new oc.gp_Circ(ax2, radius);
         const arcMaker = new oc.GC_MakeArcOfCircle(circle, gpStart, angle, true);
         if (arcMaker.IsDone()) {
-            const curve = arcMaker.Value().get();
+            const curve = arcMaker.Value();
             arcMaker.delete();
             ax2.delete();
             circle.delete();
@@ -102,7 +102,7 @@ export class Geometry {
         const [gpEnd, disposeEnd] = Convert.toGpPnt(end);
         const arcMaker = new oc.GC_MakeArcOfCircle(gpStart, gpTangent, gpEnd);
         if (arcMaker.IsDone()) {
-            const curve = arcMaker.Value().get();
+            const curve = arcMaker.Value();
             arcMaker.delete();
             disposeStart();
             disposeTangent();
@@ -124,7 +124,7 @@ export class Geometry {
         const gpCircle = new oc.gp_Circ(ax2, radius);
         const circleMaker = new oc.GC_MakeCircle(gpCircle);
         if (circleMaker.IsDone()) {
-            const circle = circleMaker.Value().get();
+            const circle = circleMaker.Value();
             circleMaker.delete();
             ax2.delete();
             gpCircle.delete();
@@ -185,17 +185,16 @@ export class Geometry {
     }
     static makeEdgeFromBezier(curve) {
         const oc = getOC();
-        const handle = new oc.Handle_Geom_Curve(curve);
-        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(handle, curve.StartPoint(), curve.EndPoint());
+        // Handles are unwrapped in V8: pass the Geom_Curve straight to MakeEdge
+        // (constructing the abstract oc.Geom_Curve base throws at runtime).
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(curve, curve.StartPoint(), curve.EndPoint());
         if (edgeMaker.IsDone()) {
             const edge = edgeMaker.Edge();
             edgeMaker.delete();
-            handle.delete();
             return Edge.fromTopoDSEdge(edge);
         }
         const status = edgeMaker.Error();
         edgeMaker.delete();
-        handle.delete();
         throw new Error('Failed to create edge from bezier curve: ' + status);
     }
     // ── Edge factories ─────────────────────────────────────────────────────────
@@ -223,17 +222,16 @@ export class Geometry {
     }
     static makeEdgeFromCurveRaw(curve) {
         const oc = getOC();
-        const handle = new oc.Handle_Geom_Curve(curve);
-        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(handle, curve.StartPoint(), curve.EndPoint());
+        // Handles are unwrapped in V8: pass the Geom_Curve straight to MakeEdge
+        // (constructing the abstract oc.Geom_Curve base throws at runtime).
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(curve, curve.StartPoint(), curve.EndPoint());
         if (edgeMaker.IsDone()) {
             const edge = edgeMaker.Edge();
             edgeMaker.delete();
-            handle.delete();
             return edge;
         }
         const status = edgeMaker.Error();
         edgeMaker.delete();
-        handle.delete();
         throw new Error('Failed to create edge from arc: ' + status);
     }
     static makeEdgeFromCircleRaw(circle) {

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

@@ -0,0 +1,37 @@
+import { Edge } from "../common/edge.js";
+import { CoordinateSystem } from "../math/coordinate-system.js";
+/**
+ * Builds 3D helix edges with OCCT's TKHelix package. The analytic helix
+ * (`HelixGeom_HelixCurve`) is approximated as a single B-spline via
+ * `HelixGeom_Tools.ApprCurve3D`. Cylindrical and tapered (conical) helixes come
+ * from one uniform call — the taper is driven purely by the difference between
+ * the start and end radii over the axial range.
+ *
+ * NB: we deliberately do NOT use `HelixGeom_Tools.ApprHelix`, which hardcodes a
+ * 150-segment approximation budget. That is plenty for a cylinder (~3 segments
+ * per turn) but far too few for a many-turn tapered helix (~25+ per turn): the
+ * single-B-spline fit silently saturates the budget and oscillates wildly over
+ * the final turns while still reporting success (returnValue 0, theMaxError in
+ * the tens of mm). ApprCurve3D lets us scale the segment budget with the turn
+ * count so the adaptive fit can actually reach tolerance.
+ */
+export declare class HelixOps {
+    private static readonly APPROX_TOLERANCE;
+    private static readonly MAX_DEGREE;
+    private static readonly SEGMENTS_PER_TURN;
+    private static readonly MIN_SEGMENTS;
+    private static readonly MAX_SEGMENTS;
+    /**
+     * Build a helix edge running `turns` full revolutions, climbing along
+     * `cs.mainDirection` from axial coordinate `zStart` to `zEnd` and starting at
+     * angle 0 (the `cs.xDirection` ray). `startRadius` is the radius at `zStart`;
+     * when `endRadius` differs the radius tapers linearly to it at `zEnd`, yielding
+     * a conical helix (`endRadius === startRadius` gives a constant-radius cylinder).
+     */
+    static makeHelix(cs: CoordinateSystem, startRadius: number, endRadius: number, zStart: number, zEnd: number, turns: number): Edge;
+    /**
+     * Rigidly move an edge built in the canonical frame (axis +Z through the
+     * origin) so it sits in `cs`, lifted along `cs.mainDirection` by `zStart`.
+     */
+    private static placeInFrame;
+}