fluidcad 0.0.35 → 0.0.37

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

@@ -0,0 +1,406 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Explorer } from "./explorer.js";
+import { FaceQuery } from "./face-query.js";
+import { WireOps } from "./wire-ops.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+import { ConeDevelopment, CylinderDevelopment, } from "./wrap-development.js";
+import { interpolateBSpline2d } from "../math/bspline-interpolation.js";
+/** Sample points per curved sketch edge before fitting its UV pcurve. */
+const CURVED_EDGE_SAMPLES = 48;
+/** Margin (radians) kept free so a wrapped region never closes on itself. */
+const FULL_TURN_MARGIN = 1e-3;
+/** Walls are ruled along the surface normal, so their normals are (near) perpendicular to it. */
+const ALIGNED_NORMAL_THRESHOLD = 0.7;
+/** Tracks the u-range covered by a wrapped region to reject over-full wraps. */
+class UvSpan {
+    min = Infinity;
+    max = -Infinity;
+    add(u) {
+        if (u < this.min) {
+            this.min = u;
+        }
+        if (u > this.max) {
+            this.max = u;
+        }
+    }
+    assertWithinOneTurn() {
+        if (this.max - this.min > 2 * Math.PI - FULL_TURN_MARGIN) {
+            throw new Error("wrap(): the sketch is too wide for the target surface — it would wrap around more than a full turn");
+        }
+    }
+}
+export class WrapOps {
+    /**
+     * Wraps planar sketch region faces onto the surface of `targetFace` and
+     * thickens them by `thickness` measured along the surface normal. Positive
+     * thickness grows out of the material (emboss), negative grows into it
+     * (deboss tool). Returns the thickened solids with their faces classified.
+     *
+     * The pad base lies EXACTLY on the target surface. Downstream booleans
+     * resolve that coincident-face contact via their fuzzy tolerance and
+     * same-domain handling; do not be tempted to sink the base slightly past
+     * the surface to "help" them — the resulting wall∕target section curves
+     * are approximated by OCCT and oscillate visibly near the wall joints.
+     */
+    static wrap(regionFaces, sketchPlane, targetFace, thickness) {
+        const development = WrapOps.createDevelopment(targetFace, sketchPlane);
+        const surface = WrapOps.makeSurface(development);
+        // Positive thickness must grow out of the material. The rebuilt
+        // development surface always thickens toward the development's outward
+        // normal (away from the axis), so flip the offset when the target face's
+        // material normal points toward the axis (e.g. a bore wall).
+        const signedOffset = WrapOps.isInwardFacing(targetFace, development)
+            ? -thickness
+            : thickness;
+        const result = {
+            solids: [],
+            startFaces: [],
+            endFaces: [],
+            sideFaces: [],
+            internalFaces: [],
+        };
+        try {
+            for (const region of regionFaces) {
+                const wrappedFace = WrapOps.wrapRegion(region, sketchPlane, development, surface);
+                const thickened = WrapOps.thicken(wrappedFace, signedOffset);
+                WrapOps.classify(thickened, wrappedFace, development, result);
+            }
+        }
+        finally {
+            surface.delete();
+        }
+        return result;
+    }
+    /** Builds the development mapping for the target face's underlying surface. */
+    static createDevelopment(targetFace, sketchPlane) {
+        const surfaceType = FaceQuery.getSurfaceTypeRaw(targetFace.getShape());
+        if (surfaceType === 'cylinder') {
+            const cylinder = FaceQuery.getSurfaceAdaptorCylinderRaw(targetFace.getShape());
+            const axis = cylinder.Axis();
+            const spec = {
+                origin: Convert.toPoint(axis.Location(), true),
+                axisDir: Convert.toVector3dFromGpDir(axis.Direction(), true),
+                radius: cylinder.Radius(),
+            };
+            axis.delete();
+            cylinder.delete();
+            return new CylinderDevelopment(spec, sketchPlane);
+        }
+        if (surfaceType === 'cone') {
+            const cone = FaceQuery.getSurfaceAdaptorConeRaw(targetFace.getShape());
+            const axis = cone.Axis();
+            const spec = {
+                origin: Convert.toPoint(axis.Location(), true),
+                axisDir: Convert.toVector3dFromGpDir(axis.Direction(), true),
+                refRadius: cone.RefRadius(),
+                semiAngle: cone.SemiAngle(),
+            };
+            axis.delete();
+            cone.delete();
+            return new ConeDevelopment(spec, sketchPlane);
+        }
+        throw new Error(`wrap() requires a cylindrical or conical target face, got a ${surfaceType} face`);
+    }
+    /**
+     * Whether the target face's material-outward normal points toward the
+     * surface axis (a bore wall) rather than away from it (an outer wall).
+     * The TopAbs orientation flag alone cannot tell: prism-swept lateral
+     * faces carry a reverse-parameterized surface (intrinsic normal inward,
+     * flag REVERSED) yet still face away from the axis.
+     */
+    static isInwardFacing(targetFace, development) {
+        const probe = WrapOps.probeFace(targetFace);
+        return probe.normal.dot(development.surfaceNormalAt(probe.point)) < 0;
+    }
+    /** Builds the recentered Geom surface (sketch anchor at u = 0). */
+    static makeSurface(development) {
+        const oc = getOC();
+        const [origin, disposeOrigin] = Convert.toGpPnt(development.origin);
+        const [zDir, disposeZ] = Convert.toGpDir(development.axisDir);
+        const [xDir, disposeX] = Convert.toGpDir(development.xDir);
+        const frame = new oc.gp_Ax3(origin, zDir, xDir);
+        const surface = development.kind === 'cylinder'
+            ? new oc.Geom_CylindricalSurface(frame, development.radius)
+            : new oc.Geom_ConicalSurface(frame, development.semiAngle, development.refRadius);
+        frame.delete();
+        disposeX();
+        disposeZ();
+        disposeOrigin();
+        return surface;
+    }
+    /** Maps one planar region face onto the surface as a face with pcurve boundaries. */
+    static wrapRegion(region, sketchPlane, development, surface) {
+        const oc = getOC();
+        const regionFace = oc.TopoDS.Face(region.getShape());
+        const outerWire = oc.BRepTools.OuterWire(regionFace);
+        const span = new UvSpan();
+        let outerUv = null;
+        const holesUv = [];
+        for (const wire of region.getWires()) {
+            const isOuter = wire.getShape().IsSame(outerWire);
+            const uvWire = WrapOps.mapWire(wire, sketchPlane, development, surface, span);
+            const oriented = WrapOps.orientUvWire(uvWire, wire, sketchPlane, development, isOuter);
+            if (isOuter) {
+                outerUv = oriented;
+            }
+            else {
+                holesUv.push(oriented);
+            }
+        }
+        if (!outerUv) {
+            throw new Error("wrap(): could not identify the outer boundary of a sketch region");
+        }
+        span.assertWithinOneTurn();
+        const maker = new oc.BRepBuilderAPI_MakeFace(surface, outerUv, true);
+        for (const hole of holesUv) {
+            maker.Add(hole);
+        }
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("wrap(): failed to build the wrapped face on the target surface");
+        }
+        const rawFace = maker.Face();
+        maker.delete();
+        oc.BRepLib.BuildCurves3d(rawFace);
+        // Belt and suspenders for remaining surface-specific issues (the wire
+        // windings themselves are already enforced by orientUvWire — ShapeFix
+        // does NOT reliably fix multi-wire faces on periodic surfaces).
+        const fix = new oc.ShapeFix_Face(rawFace);
+        fix.Perform();
+        const fixedFace = fix.Face();
+        fix.delete();
+        return fixedFace;
+    }
+    /**
+     * Enforces the winding the face builder needs: the outer boundary
+     * counter-clockwise in UV (material to its left on the surface), holes
+     * clockwise. The mapped wire inherits the planar wire's winding through the
+     * development (possibly mirrored), so measure the source and reverse the UV
+     * wire when it lands the wrong way.
+     */
+    static orientUvWire(uvWire, sourceWire, sketchPlane, development, isOuter) {
+        const planarCW = WireOps.isCWRaw(sourceWire.getShape(), sketchPlane.normal);
+        const uvCW = development.isOrientationPreserving() ? planarCW : !planarCW;
+        const wantCW = !isOuter;
+        if (uvCW === wantCW) {
+            return uvWire;
+        }
+        return WireOps.reverseWireRaw(uvWire);
+    }
+    /** Maps a planar wire into a wire of edges with pcurves on the surface. */
+    static mapWire(wire, sketchPlane, development, surface, span) {
+        const uvEdges = wire.getEdges().flatMap(edge => WrapOps.mapEdge(edge, sketchPlane, development, surface, span));
+        return WireOps.makeWireFromEdgesRaw(uvEdges);
+    }
+    /**
+     * Maps one sketch edge onto the surface, following the source wire's
+     * traversal direction (reversed edges are sampled back to front) so the
+     * assembled UV wire winds the same way as the planar wire it came from.
+     * Straight edges on cylinders map to exact UV lines (the development is
+     * affine there); everything else is sampled along the curve and fitted with
+     * a 2D B-spline. Closed edges (e.g. full circles) are split into two halves
+     * so the resulting wire has topologically distinct vertices.
+     */
+    static mapEdge(edge, sketchPlane, development, surface, span) {
+        const oc = getOC();
+        const reversed = edge.getShape().Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED;
+        const adaptor = new oc.BRepAdaptor_Curve(oc.TopoDS.Edge(edge.getShape()));
+        try {
+            const first = adaptor.FirstParameter();
+            const last = adaptor.LastParameter();
+            const isLine = adaptor.GetType() === oc.GeomAbs_CurveType.GeomAbs_Line;
+            if (isLine && development.kind === 'cylinder') {
+                const start = WrapOps.mapPoint(adaptor, reversed ? last : first, sketchPlane, development, span);
+                const end = WrapOps.mapPoint(adaptor, reversed ? first : last, sketchPlane, development, span);
+                return [WrapOps.makeUvLineEdge(start, end, surface)];
+            }
+            const samples = [];
+            for (let i = 0; i <= CURVED_EDGE_SAMPLES; i++) {
+                const t = first + ((last - first) * i) / CURVED_EDGE_SAMPLES;
+                samples.push(WrapOps.mapPoint(adaptor, t, sketchPlane, development, span));
+            }
+            if (reversed) {
+                samples.reverse();
+            }
+            const start = samples[0];
+            const end = samples[samples.length - 1];
+            const isClosed = Math.hypot(end.u - start.u, end.v - start.v) < 1e-9;
+            if (isClosed) {
+                const mid = Math.floor(samples.length / 2);
+                return [
+                    WrapOps.makeFittedUvEdge(samples.slice(0, mid + 1), surface),
+                    WrapOps.makeFittedUvEdge(samples.slice(mid), surface),
+                ];
+            }
+            return [WrapOps.makeFittedUvEdge(samples, surface)];
+        }
+        finally {
+            adaptor.delete();
+        }
+    }
+    static mapPoint(adaptor, t, sketchPlane, development, span) {
+        const point = Convert.toPoint(adaptor.Value(t), true);
+        const uv = development.toUV(sketchPlane.worldToLocal(point));
+        span.add(uv.u);
+        return uv;
+    }
+    static makeFittedUvEdge(samples, surface) {
+        const oc = getOC();
+        const curve = WrapOps.fitUvCurve(samples);
+        const maker = new oc.BRepBuilderAPI_MakeEdge(curve, surface);
+        const result = maker.Edge();
+        maker.delete();
+        curve.delete();
+        return result;
+    }
+    static makeUvLineEdge(start, end, surface) {
+        const oc = getOC();
+        const du = end.u - start.u;
+        const dv = end.v - start.v;
+        const length = Math.hypot(du, dv);
+        const point = new oc.gp_Pnt2d(start.u, start.v);
+        const direction = new oc.gp_Dir2d(du, dv);
+        const line = new oc.Geom2d_Line(point, direction);
+        const maker = new oc.BRepBuilderAPI_MakeEdge(line, surface, 0, length);
+        const result = maker.Edge();
+        maker.delete();
+        line.delete();
+        direction.delete();
+        point.delete();
+        return result;
+    }
+    /**
+     * Interpolates the developed UV samples of one sketch edge with a 2D
+     * B-spline that passes exactly through every sample (so adjacent wire
+     * edges meet bit-exactly — no endpoint snapping needed).
+     *
+     * The poles/knots are computed in-house: fluidcad-ocjs currently
+     * miscompiles `Geom2dAPI_PointsToBSpline` — both its array constructors
+     * (NaN poles) and its `Init` path (the "fit" of a clean semicircle bulged
+     * 70% past the samples). `Geom2d_BSplineCurve`'s array constructor is
+     * unaffected.
+     */
+    static fitUvCurve(samples) {
+        const oc = getOC();
+        const data = interpolateBSpline2d(samples.map(s => ({ x: s.u, y: s.v })));
+        const poles = new oc.NCollection_Array1_gp_Pnt2d(1, data.poles.length);
+        for (let i = 0; i < data.poles.length; i++) {
+            const point = new oc.gp_Pnt2d(data.poles[i].x, data.poles[i].y);
+            poles.SetValue(i + 1, point);
+            point.delete();
+        }
+        const knots = new oc.NCollection_Array1_double(1, data.knots.length);
+        const multiplicities = new oc.NCollection_Array1_int(1, data.knots.length);
+        for (let i = 0; i < data.knots.length; i++) {
+            knots.SetValue(i + 1, data.knots[i]);
+            multiplicities.SetValue(i + 1, data.multiplicities[i]);
+        }
+        const curve = new oc.Geom2d_BSplineCurve(poles, knots, multiplicities, data.degree);
+        poles.delete();
+        knots.delete();
+        multiplicities.delete();
+        return curve;
+    }
+    /** Thickens the wrapped face along the surface normal into a solid. */
+    static thicken(wrappedFace, offset) {
+        const oc = getOC();
+        const maker = new oc.BRepOffsetAPI_MakeThickSolid();
+        maker.MakeThickSolidBySimple(wrappedFace, offset);
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("wrap(): thickening the wrapped face failed");
+        }
+        const shape = maker.Shape();
+        maker.delete();
+        const SOLID = oc.TopAbs_ShapeEnum.TopAbs_SOLID;
+        const solids = Explorer.findShapes(shape, SOLID);
+        if (solids.length === 0) {
+            throw new Error("wrap(): thickening the wrapped face did not produce a solid");
+        }
+        return solids.map(solid => {
+            const typedSolid = oc.TopoDS.Solid(solid);
+            oc.BRepLib.OrientClosedSolid(typedSolid);
+            return ShapeFactory.fromShape(typedSolid);
+        });
+    }
+    /**
+     * Classifies the thickened solid's faces. The wrapped base face survives
+     * thickening unchanged (start); the only other face whose normal is aligned
+     * with the surface normal is the offset face (end); the remaining walls are
+     * split into internal (sharing an edge with a sketch hole) and side.
+     */
+    static classify(solids, baseFace, development, out) {
+        const holeEdges = WrapOps.collectHoleEdges(baseFace);
+        for (const solid of solids) {
+            out.solids.push(solid);
+            for (const shape of Explorer.findFacesWrapped(solid)) {
+                const face = shape;
+                if (face.getShape().IsSame(baseFace)) {
+                    out.startFaces.push(face);
+                    continue;
+                }
+                const probe = WrapOps.probeFace(face);
+                const aligned = Math.abs(probe.normal.dot(development.surfaceNormalAt(probe.point))) > ALIGNED_NORMAL_THRESHOLD;
+                if (aligned) {
+                    out.endFaces.push(face);
+                }
+                else if (WrapOps.sharesEdgeWith(face, holeEdges)) {
+                    out.internalFaces.push(face);
+                }
+                else {
+                    out.sideFaces.push(face);
+                }
+            }
+        }
+    }
+    static collectHoleEdges(face) {
+        const oc = getOC();
+        const outerWire = oc.BRepTools.OuterWire(face);
+        const WIRE = oc.TopAbs_ShapeEnum.TopAbs_WIRE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const holeEdges = [];
+        for (const wire of Explorer.findShapes(face, WIRE)) {
+            if (wire.IsSame(outerWire)) {
+                continue;
+            }
+            for (const edge of Explorer.findShapes(wire, EDGE)) {
+                holeEdges.push(oc.TopoDS.Edge(edge));
+            }
+        }
+        return holeEdges;
+    }
+    static sharesEdgeWith(face, edges) {
+        if (edges.length === 0) {
+            return false;
+        }
+        return face.getEdges().some(faceEdge => edges.some(edge => faceEdge.getShape().IsSame(edge)));
+    }
+    /**
+     * Samples the face at the middle of its UV bounds: the surface point and
+     * the material-outward normal (oriented by the face's TopAbs flag) at that
+     * SAME parameter. Classification compares this normal against the
+     * development normal at the sampled point — sampling both at one location
+     * keeps the comparison angle-independent on periodic surfaces, where the
+     * normal rotates with u (a normal taken anywhere else drifts by the angular
+     * distance and breaks the alignment test past ~45°).
+     */
+    static probeFace(face) {
+        const oc = getOC();
+        const rawFace = oc.TopoDS.Face(face.getShape());
+        const bounds = oc.BRepTools.UVBounds(rawFace);
+        const u = (bounds.UMin + bounds.UMax) / 2;
+        const v = (bounds.VMin + bounds.VMax) / 2;
+        const surface = oc.BRep_Tool.Surface(rawFace);
+        const props = new oc.GeomLProp_SLProps(surface, u, v, 1, 1e-6);
+        let rawNormal = props.Normal();
+        if (rawFace.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
+            rawNormal = rawNormal.Reversed();
+        }
+        const normal = Convert.toVector3dFromGpDir(rawNormal);
+        const point = Convert.toPoint(props.Value(), true);
+        props.delete();
+        surface.delete();
+        return { point, normal };
+    }
+}

package/lib/dist/rendering/render-solid.js

@@ -47,8 +47,16 @@ function getFacesMesh(shapeObj) {
             for (let t = 0; t < triangleCount; t++) {
                 group.faceMapping.push(faceIdx);
             }
-            group.vertices.push(...faceResult.vertices);
-            group.normals.push(...faceResult.normals);
+            // Avoid spread on potentially huge arrays — JS argument count is
+            // capped (~65K) and would throw "Maximum call stack size exceeded".
+            const verts = faceResult.vertices;
+            for (let i = 0; i < verts.length; i++) {
+                group.vertices.push(verts[i]);
+            }
+            const norms = faceResult.normals;
+            for (let i = 0; i < norms.length; i++) {
+                group.normals.push(norms[i]);
+            }
             for (const idx of faceResult.indices) {
                 group.indices.push(group.vertexOffset + idx);
             }

package/lib/dist/scene-manager.d.ts

@@ -7,6 +7,7 @@ import type { ShapeProperties } from "./oc/props.js";
 import type { FaceProperties } from "./oc/face-props.js";
 import type { EdgeProperties } from "./oc/edge-props.js";
 import type { HitTestResult } from "./oc/hit-test.js";
+import type { MeasureEntityRef, MeasureResult } from "./oc/measure/measure-types.js";
 declare class SceneManager {
     rootPath: string;
     currentScene: Scene;
@@ -22,6 +23,7 @@ declare class SceneManager {
     getShapeProperties(scene: Scene, shapeId: string): ShapeProperties | null;
     getFaceProperties(scene: Scene, shapeId: string, faceIndex: number): FaceProperties | null;
     getEdgeProperties(scene: Scene, shapeId: string, edgeIndex: number): EdgeProperties | null;
+    measure(scene: Scene, refs: MeasureEntityRef[]): MeasureResult | null;
     exportShapes(scene: Scene, shapeIds: string[], options: ExportOptions): {
         data: string | Uint8Array;
         fileName: string;

package/lib/dist/scene-manager.js

@@ -9,6 +9,7 @@ import { FaceProps } from "./oc/face-props.js";
 import { EdgeProps } from "./oc/edge-props.js";
 import { Explorer } from "./oc/explorer.js";
 import { OccHitTest } from "./oc/hit-test.js";
+import { MeasureOps } from "./oc/measure/measure-ops.js";
 class SceneManager {
     rootPath;
     currentScene = new Scene();
@@ -76,6 +77,24 @@ class SceneManager {
         }
         return null;
     }
+    measure(scene, refs) {
+        const inputs = [];
+        for (const ref of refs) {
+            const shape = findShapeById(scene, ref.shapeId);
+            if (!shape) {
+                return null;
+            }
+            const subShapes = ref.kind === 'face' ? Explorer.findFacesWrapped(shape) : Explorer.findEdgesWrapped(shape);
+            if (ref.index < 0 || ref.index >= subShapes.length) {
+                return null;
+            }
+            inputs.push({ ref, shape: subShapes[ref.index].getShape() });
+        }
+        if (inputs.length === 0) {
+            return null;
+        }
+        return MeasureOps.measure(inputs);
+    }
     exportShapes(scene, shapeIds, options) {
         const solids = [];
         for (const obj of scene.getAllSceneObjects()) {
@@ -101,6 +120,16 @@ class SceneManager {
         return null;
     }
 }
+function findShapeById(scene, shapeId) {
+    for (const obj of scene.getAllSceneObjects()) {
+        for (const shape of obj.getAddedShapes()) {
+            if (shape.id === shapeId) {
+                return shape;
+            }
+        }
+    }
+    return null;
+}
 let currentManager = null;
 function resolveMeshConfig(options) {
     return {

package/lib/dist/tests/features/cylinder-curve-filter.test.js

@@ -50,8 +50,8 @@ describe("cylinderCurve filter on fillet faces", () => {
                 const curveTypeNames = {};
                 for (const k of Object.keys(oc.GeomAbs_CurveType)) {
                     const v = oc.GeomAbs_CurveType[k];
-                    if (v && typeof v.value === "number") {
-                        curveTypeNames[v.value] = k;
+                    if (v && typeof v === "number") {
+                        curveTypeNames[v] = k;
                     }
                 }
                 const edgeInfo = edges.map(e => {
@@ -59,7 +59,7 @@ describe("cylinderCurve filter on fillet faces", () => {
                     const t = adaptor.GetType();
                     const closed = adaptor.IsClosed();
                     adaptor.delete();
-                    return { type: curveTypeNames[t.value] ?? t.value, closed };
+                    return { type: curveTypeNames[(t)] ?? t, closed };
                 });
                 console.log("Cylinder face missed by cylinderCurve:", JSON.stringify(edgeInfo));
             }

package/lib/dist/tests/features/extrude-to-face.test.js

@@ -4,7 +4,10 @@ import sketch from "../../core/sketch.js";
 import extrude from "../../core/extrude.js";
 import select from "../../core/select.js";
 import rotate from "../../core/rotate.js";
-import { circle, move, rect } from "../../core/2d/index.js";
+import { circle, move, rect, slot } from "../../core/2d/index.js";
+import plane from "../../core/plane.js";
+import { ShapeProps } from "../../oc/props.js";
+import { getSceneManager } from "../../scene-manager.js";
 import cylinder from "../../core/cylinder.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
 import { face } from "../../filters/index.js";
@@ -206,6 +209,40 @@ describe("extrude to face", () => {
             expect(shapes[0].getType()).toBe("solid");
         });
     });
+    describe("conical face", () => {
+        function buildDraftedScenario(endOffset) {
+            getSceneManager().startScene();
+            sketch("top", () => {
+                circle(50);
+            });
+            const base = extrude(50).draft(-8);
+            sketch(plane("front", 50), () => {
+                slot([0, 10], [0, 30], 5);
+            });
+            let e = extrude(base.sideFaces());
+            if (endOffset !== undefined) {
+                e = e.endOffset(endOffset);
+            }
+            render();
+            let volume = 0;
+            for (const s of e.getShapes()) {
+                volume += ShapeProps.getProperties(s.getShape()).volumeMm3;
+            }
+            return volume;
+        }
+        it("should extrude up to a drafted (conical) side face", () => {
+            const volume = buildDraftedScenario();
+            expect(volume).toBeGreaterThan(0);
+        });
+        it("should respect endOffset against a conical target face", () => {
+            const without = buildDraftedScenario();
+            const withOffset = buildDraftedScenario(2);
+            // endOffset(2) stops the extrusion short of the cone, so the result
+            // stays a separate, smaller solid instead of fusing with the base.
+            expect(withOffset).not.toBeCloseTo(without, 1);
+            expect(withOffset).toBeLessThan(without);
+        });
+    });
     describe("inclined cylindrical face", () => {
         it("should extrude up to a rotated cylindrical face", () => {
             const cyl = cylinder(50, 80);

package/lib/dist/tests/features/helix.test.d.ts

@@ -0,0 +1 @@
+export {};