fluidcad 0.0.37 → 0.0.38

package/lib/dist/core/plane.d.ts

@@ -1,6 +1,11 @@
 import { PlaneLike, PlaneTransformOptions } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
 export type PlaneRenderableOptions = PlaneTransformOptions;
+/**
+ * Where to place a plane along an edge: a named position, or a normalized
+ * distance from the edge start (`0`) to its end (`1`). `0.5` is the midpoint.
+ */
+export type EdgePlanePosition = 'start' | 'middle' | 'end' | number;
 interface PlaneFunction {
     /**
      * Creates a plane from a standard plane or normal vector.
@@ -20,8 +25,10 @@ interface PlaneFunction {
      */
     (plane: PlaneLike, offset: number): IPlane;
     /**
-     * Creates a plane from a face selection.
-     * @param selection - The selected face to create a plane from
+     * Creates a plane from a selection. A selected face yields that face's
+     * plane; a selected edge yields a plane at the edge start, oriented normal
+     * to the edge and facing outward (away from the edge body), like a start cap.
+     * @param selection - The selected face or edge to create a plane from
      */
     (selection: ISceneObject): IPlane;
     /**
@@ -31,11 +38,24 @@ interface PlaneFunction {
      */
     (selection: ISceneObject, options: PlaneRenderableOptions): IPlane;
     /**
-     * Creates a plane from a face selection with an offset.
-     * @param selection - The selected face to create a plane from
-     * @param offset - The offset distance
+     * Creates a plane from a selection with a numeric second argument. For a
+     * face, the number is the offset distance along the face normal. For an
+     * edge, it is a normalized position from `0` (start) to `1` (end), and the
+     * plane is created at that point oriented normal to the edge. The normal
+     * follows the edge's forward direction, except at the start (`0`) where it
+     * faces outward (away from the edge body), so both ends read like caps.
+     * @param selection - The selected face or edge
+     * @param offsetOrPosition - Face: offset distance. Edge: normalized 0–1 position.
+     */
+    (selection: ISceneObject, offsetOrPosition: number): IPlane;
+    /**
+     * Creates a plane at a named position along an edge, oriented normal to the
+     * edge. At `'start'` the normal faces outward (away from the edge body);
+     * `'middle'` and `'end'` follow the edge's forward direction.
+     * @param edge - The selected edge
+     * @param position - `'start'`, `'middle'`, or `'end'`
      */
-    (selection: ISceneObject, offset: number): IPlane;
+    (edge: ISceneObject, position: 'start' | 'middle' | 'end'): IPlane;
     /**
      * Transforms an existing plane with options.
      * @param plane - The existing plane to transform

package/lib/dist/core/plane.js

@@ -23,56 +23,33 @@ function build(context) {
             }
         }
         if (arguments.length === 2) {
-            if (typeof arguments[1] === 'number') {
-                const options = { offset: arguments[1] };
-                if (arguments[0] instanceof SceneObject) {
-                    context.addSceneObject(arguments[0]);
-                    const pln = new PlaneFromObject(arguments[0], options);
-                    context.addSceneObject(pln);
-                    return pln;
-                }
-                else if (isPlaneLike(arguments[0])) {
-                    const axis = normalizePlane(arguments[0]);
-                    const pln = new PlaneObject(axis, options);
-                    context.addSceneObject(pln);
-                    return pln;
-                }
-            }
-            if ((arguments[0] instanceof PlaneObjectBase || isPlaneLike(arguments[0])) &&
-                (arguments[1] instanceof PlaneObjectBase || isPlaneLike(arguments[1]))) {
-                // axis between two others
-                let a1;
-                let a2;
-                if (arguments[0] instanceof PlaneObjectBase) {
-                    a1 = arguments[0];
-                }
-                else {
-                    const axis = normalizePlane(arguments[0]);
-                    a1 = new PlaneObject(axis);
-                }
-                if (arguments[1] instanceof PlaneObjectBase) {
-                    a2 = arguments[1];
-                }
-                else {
-                    const axis = normalizePlane(arguments[1]);
-                    a2 = new PlaneObject(axis);
-                }
-                context.addSceneObject(a1);
-                context.addSceneObject(a2);
-                const pln = new PlaneMiddleRenderable(a1, a2);
+            const a0 = arguments[0];
+            const a1 = arguments[1];
+            // Plane midway between two planes / plane-likes.
+            if ((a0 instanceof PlaneObjectBase || isPlaneLike(a0)) &&
+                (a1 instanceof PlaneObjectBase || isPlaneLike(a1))) {
+                const p1 = a0 instanceof PlaneObjectBase ? a0 : new PlaneObject(normalizePlane(a0));
+                const p2 = a1 instanceof PlaneObjectBase ? a1 : new PlaneObject(normalizePlane(a1));
+                context.addSceneObject(p1);
+                context.addSceneObject(p2);
+                const pln = new PlaneMiddleRenderable(p1, p2);
                 context.addSceneObject(pln);
                 return pln;
             }
-            else if (arguments[0] instanceof SceneObject) {
-                context.addSceneObject(arguments[0]);
-                const pln = new PlaneFromObject(arguments[0], arguments[1]);
+            // From a scene object. A face reads the second argument as an offset
+            // distance / transform options; an edge reads it as a normalized 0–1
+            // position (or 'start'/'middle'/'end'). The face-vs-edge decision is
+            // deferred to PlaneFromObject.build(), where the source shape is known.
+            if (a0 instanceof SceneObject) {
+                context.addSceneObject(a0);
+                const pln = new PlaneFromObject(a0, a1);
                 context.addSceneObject(pln);
                 return pln;
             }
-            else if (isPlaneLike(arguments[0])) {
-                const axis1 = normalizePlane(arguments[0]);
-                const options = arguments[1];
-                const pln = new PlaneObject(axis1, options);
+            // From a plane-like: number → offset, object → transform options.
+            if (isPlaneLike(a0)) {
+                const options = typeof a1 === 'number' ? { offset: a1 } : a1;
+                const pln = new PlaneObject(normalizePlane(a0), options);
                 context.addSceneObject(pln);
                 return pln;
             }

package/lib/dist/features/2d/offset.js

@@ -55,9 +55,9 @@ export class Offset extends ExtrudableGeometryBase {
             });
         }
         let lastOffsetWire = null;
+        const plane = this.getPlane();
         for (const wireInfo of wires) {
-            const isOpen = !wireInfo.wire.isClosed();
-            const offsetWire = WireOps.offsetWire(wireInfo.wire, this.distance, isOpen);
+            const offsetWire = WireOps.offsetWireOnPlane(wireInfo.wire, this.distance, wireInfo.wire.isClosed(), plane);
             lastOffsetWire = offsetWire;
             const edges = offsetWire.getEdges();
             for (const edge of edges) {

package/lib/dist/features/plane-from-object.d.ts

@@ -1,15 +1,27 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { PlaneRenderableOptions } from "../core/plane.js";
+import { EdgePlanePosition, PlaneRenderableOptions } from "../core/plane.js";
 import { PlaneObjectBase } from "./plane-renderable-base.js";
 import { Face } from "../common/face.js";
 import { Point } from "../math/point.js";
 import { Plane } from "../math/plane.js";
 export declare class PlaneFromObject extends PlaneObjectBase {
     sourceObject: SceneObject;
-    options?: PlaneRenderableOptions;
-    constructor(sourceObject: SceneObject, options?: PlaneRenderableOptions);
+    optionsOrPosition?: PlaneRenderableOptions | EdgePlanePosition;
+    constructor(sourceObject: SceneObject, optionsOrPosition?: PlaneRenderableOptions | EdgePlanePosition);
     validate(): void;
     build(context?: BuildSceneObjectContext): void;
+    /**
+     * Builds a plane normal to `edge` at the configured position. The edge
+     * tangent at that point becomes the plane normal; the in-plane axes are
+     * an arbitrary (but deterministic) basis around it.
+     */
+    private buildFromEdge;
+    /**
+     * Resolves the second argument for a face/plane source. A bare number is a
+     * normal-offset distance; a string position is only meaningful for edges
+     * and is rejected here.
+     */
+    private faceOptions;
     getFromSceneObject(sceneObject: SceneObject): {
         plane: Plane;
         sourceFace: Face;
@@ -24,7 +36,7 @@ export declare class PlaneFromObject extends PlaneObjectBase {
         xDirection: import("../math/vector3d.js").Vector3d;
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
-        options: import("../math/plane.js").PlaneTransformOptions;
+        options: import("../math/plane.js").PlaneTransformOptions | EdgePlanePosition;
         center: any;
     };
 }

package/lib/dist/features/plane-from-object.js

@@ -1,15 +1,18 @@
 import { PlaneObjectBase } from "./plane-renderable-base.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { WireOps } from "../oc/wire-ops.js";
+import { PathSampler } from "../oc/path-sampler.js";
 import { Point } from "../math/point.js";
+import { Plane } from "../math/plane.js";
 import { requireShapes } from "../common/operand-check.js";
 export class PlaneFromObject extends PlaneObjectBase {
     sourceObject;
-    options;
-    constructor(sourceObject, options) {
+    optionsOrPosition;
+    constructor(sourceObject, optionsOrPosition) {
         super();
         this.sourceObject = sourceObject;
-        this.options = options;
+        this.optionsOrPosition = optionsOrPosition;
     }
     validate() {
         // PlaneObjectBase sources expose the plane directly — no shapes required.
@@ -19,6 +22,17 @@ export class PlaneFromObject extends PlaneObjectBase {
         requireShapes(this.sourceObject, "source", "plane");
     }
     build(context) {
+        // An edge source produces a plane normal to the edge at a position along
+        // it. The face-vs-edge decision is deferred to here (rather than the
+        // plane() builder) because the source shape type is only known once the
+        // selection has been resolved.
+        if (!(this.sourceObject instanceof PlaneObjectBase)) {
+            const shapes = this.sourceObject.getShapes({ excludeGuide: false });
+            if (shapes.length === 1 && shapes[0].isEdge()) {
+                this.buildFromEdge(context, shapes[0]);
+                return;
+            }
+        }
         let plane;
         let sourceFace;
         let center;
@@ -36,10 +50,11 @@ export class PlaneFromObject extends PlaneObjectBase {
             const bbox = ShapeOps.getBoundingBox(sourceFace.getShape());
             center = new Point(bbox.centerX, bbox.centerY, bbox.centerZ);
         }
-        if (this.options) {
+        const options = this.faceOptions();
+        if (options) {
             // Apply the same transform to the center so the preview face stays on
             // the rotated plane instead of floating at its pre-rotation position.
-            const matrix = plane.getTransformMatrix(this.options);
+            const matrix = plane.getTransformMatrix(options);
             plane = plane.applyMatrix(matrix);
             if (center) {
                 center = center.transform(matrix);
@@ -60,6 +75,53 @@ export class PlaneFromObject extends PlaneObjectBase {
         face.markAsMetaShape();
         this.addShape(face);
     }
+    /**
+     * Builds a plane normal to `edge` at the configured position. The edge
+     * tangent at that point becomes the plane normal; the in-plane axes are
+     * an arbitrary (but deterministic) basis around it.
+     */
+    buildFromEdge(context, edge) {
+        const t = normalizeEdgePosition(this.optionsOrPosition);
+        const frame = sampleEdgeFrame(edge, t);
+        // The forward tangent points *into* the edge at the start, so the plane
+        // would face inward there. Flip it at the start endpoint so it faces
+        // outward — like an extrude's start cap (the end already faces outward via
+        // the forward tangent). Interior/end positions keep the forward tangent.
+        const normal = t <= 0 ? frame.tangent.negate() : frame.tangent;
+        let plane = Plane.fromPointAndNormal(frame.point, normal);
+        let center = frame.point;
+        // Unlike the face path, an edge is only *referenced* to derive the plane —
+        // it is not consumed, so it stays available to its owning solid and to
+        // other features.
+        const transform = context?.getTransform() ?? null;
+        if (transform) {
+            plane = plane.applyMatrix(transform);
+            center = center.transform(transform);
+        }
+        this.setState('plane-center', center);
+        this.setState('plane', plane);
+        const face = FaceOps.planeToFace(plane, center);
+        face.markAsMetaShape();
+        this.addShape(face);
+    }
+    /**
+     * Resolves the second argument for a face/plane source. A bare number is a
+     * normal-offset distance; a string position is only meaningful for edges
+     * and is rejected here.
+     */
+    faceOptions() {
+        const value = this.optionsOrPosition;
+        if (value == null) {
+            return undefined;
+        }
+        if (typeof value === 'number') {
+            return { offset: value };
+        }
+        if (typeof value === 'string') {
+            throw new Error(`Plane: position '${value}' is only valid for an edge source`);
+        }
+        return value;
+    }
     getFromSceneObject(sceneObject) {
         const shapes = sceneObject.getShapes();
         console.log(`Plane: Retrieved ${shapes.length} shapes from selection`, shapes);
@@ -82,7 +144,7 @@ export class PlaneFromObject extends PlaneObjectBase {
         return [];
     }
     createCopy(remap) {
-        return new PlaneFromObject(this, this.options);
+        return new PlaneFromObject(this, this.optionsOrPosition);
     }
     compareTo(other) {
         if (!(other instanceof PlaneFromObject)) {
@@ -94,7 +156,7 @@ export class PlaneFromObject extends PlaneObjectBase {
         if (!this.sourceObject.compareTo(other.sourceObject)) {
             return false;
         }
-        if (JSON.stringify(this.options) !== JSON.stringify(other.options)) {
+        if (JSON.stringify(this.optionsOrPosition) !== JSON.stringify(other.optionsOrPosition)) {
             return false;
         }
         return true;
@@ -109,8 +171,39 @@ export class PlaneFromObject extends PlaneObjectBase {
             xDirection: plane.xDirection,
             yDirection: plane.yDirection,
             normal: plane.normal,
-            options: this.options,
+            options: this.optionsOrPosition,
             center: this.getState('plane-center') || plane.origin,
         };
     }
 }
+/**
+ * Evaluates the point and unit (forward) tangent on `edge` at a normalized
+ * position `t` (`0` = start, `1` = end), measured by arc length.
+ */
+function sampleEdgeFrame(edge, t) {
+    const wire = WireOps.makeWireFromEdges([edge]);
+    const sampler = new PathSampler(wire);
+    try {
+        return sampler.evalAt(t * sampler.length);
+    }
+    finally {
+        sampler.dispose();
+    }
+}
+function normalizeEdgePosition(position) {
+    if (position === undefined) {
+        return 0;
+    }
+    if (typeof position === 'number') {
+        return position;
+    }
+    switch (position) {
+        case 'start':
+            return 0;
+        case 'middle':
+            return 0.5;
+        case 'end':
+            return 1;
+    }
+    throw new Error("Plane: an edge plane takes a 0–1 position or 'start'/'middle'/'end', not transform options");
+}

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

@@ -12,22 +12,13 @@ export declare class SweepOps {
     static makeSweep(spineWire: Wire, profileFaces: Face[]): SweepResult;
     /** Sweep a single wire along the spine with a fixed binormal. */
     private static sweepWire;
-    /** Unit tangent of the spine wire at its first parameter. */
-    private static getSpineTangent;
-    /** World-space centroid of a planar face (uses surface-area properties). */
-    private static getFaceCentroid;
     /**
-     * Build a world-to-world trsf that lays a planar face flat in world XY
-     * with its centroid at the world origin.
-     *
-     * `gp_Trsf::SetTransformation(A, B)` builds the transformation that maps
-     * frame A onto frame B (i.e., A's origin → B's origin, A's axes → B's
-     * axes). To move the profile *from* its current frame *to* the canonical
-     * frame, we pass the canonical frame as A and the profile's frame as B —
-     * counterintuitive but matches OCC's convention as verified empirically.
-     *
-     * The canonical frame is what OCC's MakePipeShell expects when
-     * WithContact/WithCorrection are both false: `Saxe = gp_Ax3(0, +Z, +X)`.
+     * The axis the spine's tangent rotates around, = normalize(Σ Tᵢ × Tᵢ₊₁) over
+     * tangents sampled along the spine. For a planar spine this is the plane
+     * normal; for a helix it is the coil axis. For a straight spine the tangent
+     * is constant, every cross product vanishes, and it returns null.
      */
-    private static profileToCanonicalFrameTrsf;
+    private static tangentRotationAxis;
+    /** Unit tangent of the spine wire at its first parameter. */
+    private static getSpineTangent;
 }

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

@@ -17,58 +17,40 @@ export class SweepOps {
         let firstShape = null;
         let lastShape = null;
         const profilePlane = profileFaces[0].getPlane();
-        // Fixed binormal: profile plane's "up" direction (perpendicular to xDir
-        // and to the face normal). Locking it via SetMode stops the swept profile
-        // from twisting along helical spines (clean spring instead of a wobbling
-        // ribbon). The binormal stays in WORLD coords — it's the user's intended
-        // "up" direction even when we pre-canonicalize the profile below.
-        const binormalVec = profilePlane.yDirection;
-        const [binormalDir, disposeBinormal] = Convert.toGpDir(binormalVec);
-        // Decide whether to pre-canonicalize the profile.
-        //
-        // OCC's `MakePipeShell.Add(_, false, true)` (no contact, with correction)
-        // works for most profile orientations: it rotates the profile to align
-        // its plane normal with the spine tangent, around an axis given by
-        // `profile.normal × spine.tangent`. That axis is well-defined unless
-        // the two are *anti-parallel* — in which case the cross product is
-        // zero, the rotation axis is undefined, and OCC produces a degenerate
-        // sweep.
+        // Fixed binormal for MakePipeShell's `SetMode`: it locks the section's
+        // "up", so the profile keeps a constant angle to it instead of twisting
+        // along the spine. The correct direction is the axis the spine's tangent
+        // rotates around — the plane normal for a planar spine, the coil axis for a
+        // helix. The tangent keeps a constant, non-zero angle to that axis, so the
+        // section never flips and the result is a clean coil.
         //
-        // For the well-behaved case we keep the user's drawn position (so the
-        // swept solid lands where the user expects). For the antiparallel case
-        // we manually canonicalize to (origin, XY plane), then call
-        // `Add(_, false, false)`. The canonicalization is necessary because
-        // `GeomFill_SectionPlacement::Transformation` builds its trsf as
-        // `Tf.SetTransformation(Saxe = gp_Ax3(0, +Z, +X), Paxe = trihedron)` —
-        // it implicitly assumes the section is at the world origin in XY and
-        // produces offset placements otherwise.
+        // The profile plane's own "up" (used previously) only works when it happens
+        // to equal that axis — true for a profile sketched on a world plane, but
+        // NOT for a plane built off a helix, whose in-plane axes are arbitrary.
+        // A wrong (e.g. roughly horizontal) binormal lets the helix tangent rotate
+        // into it, collapsing `Normal = BiNormal × Tangent` ~twice per turn and
+        // shredding the section into a self-intersecting ribbon. A straight spine
+        // has no rotation axis (the cross products vanish); there the profile's up
+        // is well-defined and never aligns with the constant tangent, so use it.
+        const spineAxis = SweepOps.tangentRotationAxis(spineWire.getShape());
+        const binormalVec = spineAxis ?? profilePlane.yDirection;
+        const [binormalDir, disposeBinormal] = Convert.toGpDir(binormalVec);
+        // `Add(_, false, true)` (no contact, with correction) rotates the profile
+        // to sit perpendicular to the spine tangent, about an axis given by
+        // `profile.normal × spine.tangent`. That axis is undefined when the two are
+        // anti-parallel — but then the profile plane is *already* perpendicular to
+        // the spine (its normal is ∥ -tangent), so no correction is needed: skip it
+        // and keep the profile's drawn position.
         const spineTangent = SweepOps.getSpineTangent(spineWire.getShape());
         const isAntiParallel = profilePlane.normal.dot(spineTangent) < -0.999;
-        let trsf = null;
-        let withCorrection = true;
-        if (isAntiParallel) {
-            const profileCentroid = SweepOps.getFaceCentroid(profileFaces[0].getShape());
-            trsf = SweepOps.profileToCanonicalFrameTrsf(profileCentroid, profilePlane.normal, profilePlane.xDirection);
-            withCorrection = false;
-        }
+        const withCorrection = !isAntiParallel;
         try {
             for (const face of profileFaces) {
-                let workingFace;
-                let transformer = null;
-                if (trsf) {
-                    transformer = new oc.BRepBuilderAPI_Transform(trsf);
-                    transformer.Perform(face.getShape(), true);
-                    workingFace = transformer.Shape();
-                }
-                else {
-                    workingFace = face.getShape();
-                }
-                const ocFace = oc.TopoDS.Face(workingFace);
+                const ocFace = oc.TopoDS.Face(face.getShape());
                 const outerWire = oc.BRepTools.OuterWire(ocFace);
-                const innerWires = trsf
-                    ? Explorer.findShapes(workingFace, Explorer.getOcShapeType("wire"))
-                        .filter(w => !w.IsSame(outerWire))
-                    : face.getWires().map(w => w.getShape()).filter(w => !w.IsSame(outerWire));
+                const innerWires = face.getWires()
+                    .map(w => w.getShape())
+                    .filter(w => !w.IsSame(outerWire));
                 const outer = SweepOps.sweepWire(spineWire.getShape(), outerWire, binormalDir, withCorrection);
                 let resultSolid = outer.solid;
                 let resultFirst = outer.firstFace;
@@ -115,11 +97,9 @@ export class SweepOps {
                 for (const s of solids) {
                     allSolids.push(Solid.fromTopoDSSolid(Explorer.toSolid(s)));
                 }
-                transformer?.delete();
             }
         }
         finally {
-            trsf?.delete();
             disposeBinormal();
         }
         if (allSolids.length === 0) {
@@ -135,10 +115,10 @@ export class SweepOps {
     static sweepWire(spine, profile, binormalDir, withCorrection) {
         const oc = getOC();
         const pipe = new oc.BRepOffsetAPI_MakePipeShell(spine);
-        // Fixed binormal (the profile plane's "up"): keeps the swept profile from
-        // twisting along the spine — a clean spring rather than a wobbling ribbon —
-        // and is well-defined on straight spines, where Frenet is not (zero
-        // curvature ⇒ undefined normal).
+        // Fixed binormal (the spine's tangent-rotation axis; see makeSweep): keeps
+        // the swept section from twisting — a clean coil rather than a wobbling
+        // ribbon — and is well-defined on straight spines, where Frenet is not
+        // (zero curvature ⇒ undefined normal).
         pipe.SetMode(binormalDir);
         // Give the swept-surface approximation enough spans for tapered/tight
         // helical spines (see MAX_PIPE_SEGMENTS) — at OCCT's default budget the
@@ -162,6 +142,41 @@ export class SweepOps {
         pipe.delete();
         return { solid, firstFace, lastFace };
     }
+    /**
+     * The axis the spine's tangent rotates around, = normalize(Σ Tᵢ × Tᵢ₊₁) over
+     * tangents sampled along the spine. For a planar spine this is the plane
+     * normal; for a helix it is the coil axis. For a straight spine the tangent
+     * is constant, every cross product vanishes, and it returns null.
+     */
+    static tangentRotationAxis(spine) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_CompCurve(spine, false);
+        const u0 = adaptor.FirstParameter();
+        const u1 = adaptor.LastParameter();
+        const SAMPLES = 64;
+        const tangents = [];
+        const pnt = new oc.gp_Pnt();
+        const vec = new oc.gp_Vec();
+        for (let i = 0; i <= SAMPLES; i++) {
+            const u = u0 + ((u1 - u0) * i) / SAMPLES;
+            adaptor.D1(u, pnt, vec);
+            const t = new Vector3d(vec.X(), vec.Y(), vec.Z());
+            if (t.length() > 1e-9) {
+                tangents.push(t.normalize());
+            }
+        }
+        pnt.delete();
+        vec.delete();
+        adaptor.delete();
+        let axis = new Vector3d(0, 0, 0);
+        for (let i = 0; i + 1 < tangents.length; i++) {
+            axis = axis.add(tangents[i].cross(tangents[i + 1]));
+        }
+        if (axis.length() < 1e-6) {
+            return null;
+        }
+        return axis.normalize();
+    }
     /** Unit tangent of the spine wire at its first parameter. */
     static getSpineTangent(spine) {
         const oc = getOC();
@@ -177,51 +192,4 @@ export class SweepOps {
         adaptor.delete();
         return tangent;
     }
-    /** World-space centroid of a planar face (uses surface-area properties). */
-    static getFaceCentroid(face) {
-        const oc = getOC();
-        const ocFace = oc.TopoDS.Face(face);
-        const props = new oc.GProp_GProps();
-        oc.BRepGProp.SurfaceProperties(ocFace, props, false, false);
-        const c = props.CentreOfMass();
-        const out = new Vector3d(c.X(), c.Y(), c.Z());
-        c.delete();
-        props.delete();
-        return out;
-    }
-    /**
-     * Build a world-to-world trsf that lays a planar face flat in world XY
-     * with its centroid at the world origin.
-     *
-     * `gp_Trsf::SetTransformation(A, B)` builds the transformation that maps
-     * frame A onto frame B (i.e., A's origin → B's origin, A's axes → B's
-     * axes). To move the profile *from* its current frame *to* the canonical
-     * frame, we pass the canonical frame as A and the profile's frame as B —
-     * counterintuitive but matches OCC's convention as verified empirically.
-     *
-     * The canonical frame is what OCC's MakePipeShell expects when
-     * WithContact/WithCorrection are both false: `Saxe = gp_Ax3(0, +Z, +X)`.
-     */
-    static profileToCanonicalFrameTrsf(centroid, normal, xDir) {
-        const oc = getOC();
-        const [originPnt, disposeOriginPnt] = Convert.toGpPnt(centroid);
-        const [normalDirGp, disposeNormalDir] = Convert.toGpDir(normal);
-        const [xDirGp, disposeXDirGp] = Convert.toGpDir(xDir);
-        const profileAx3 = new oc.gp_Ax3(originPnt, normalDirGp, xDirGp);
-        const zeroPnt = new oc.gp_Pnt(0, 0, 0);
-        const zDir = new oc.gp_Dir(0, 0, 1);
-        const xDirWorld = new oc.gp_Dir(1, 0, 0);
-        const canonicalAx3 = new oc.gp_Ax3(zeroPnt, zDir, xDirWorld);
-        const trsf = new oc.gp_Trsf();
-        trsf.SetTransformation(canonicalAx3, profileAx3);
-        profileAx3.delete();
-        canonicalAx3.delete();
-        zeroPnt.delete();
-        zDir.delete();
-        xDirWorld.delete();
-        disposeOriginPnt();
-        disposeNormalDir();
-        disposeXDirGp();
-        return trsf;
-    }
 }

package/lib/dist/oc/thin-face-maker.d.ts

@@ -11,19 +11,6 @@ export declare class ThinFaceMaker {
     static make(edges: (Wire | Edge)[], plane: Plane, offset1: number, offset2?: number): ThinFaceResult;
     private static makeSingleOffsetFace;
     private static makeDualOffsetFace;
-    /**
-     * Offsets a wire by the given distance, handling both closed and open wires.
-     * For closed wires, WireOps.offsetWire handles negative distances natively.
-     * For open wires, negative distances are handled by reversing the wire,
-     * offsetting with the absolute value, then reversing back.
-     *
-     * If the wire-only offset throws (e.g. "Offset wire is not closed." on
-     * wires whose corners are GeomAbs_OffsetCurve segments from `offset()` over
-     * a drafted body's filleted bottom), retries with a planar face as the
-     * offset spine — that path supplies an explicit normal which keeps the
-     * algorithm stable on the same input.
-     */
-    private static doOffset;
     /**
      * Merges adjacent edges that share the same underlying curve into a single
      * edge (e.g. two conic-arc segments at a filleted corner produced by
@@ -33,12 +20,6 @@ export declare class ThinFaceMaker {
      * upgrader produces no usable result.
      */
     private static unifyWireEdges;
-    /**
-     * Offsets an open wire on a given plane, using a planar face as reference
-     * so that BRepOffsetAPI_MakeOffset knows the offset direction.
-     * Only handles positive distances — use doOffset for sign handling.
-     */
-    private static offsetWireOnPlane;
     /**
      * Finds face edges that geometrically match the given wire edges by comparing midpoints.
      * This is needed because wire reversal (ShapeExtend_WireData.Reverse) creates new TShapes,