fluidcad 0.0.35 → 0.0.37

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

@@ -139,6 +139,9 @@ export class ExtrudeToFace extends ExtrudeBase {
             if (surfaceType === 'cylinder') {
                 splitTargetFace = this.resizeCylindricalFace(targetFace);
             }
+            else if (surfaceType === 'cone') {
+                splitTargetFace = this.resizeConicalFace(targetFace);
+            }
             else {
                 splitTargetFace = targetFace;
             }
@@ -157,6 +160,9 @@ export class ExtrudeToFace extends ExtrudeBase {
     resizeCylindricalFace(targetFace) {
         return FaceQuery.makeInfiniteCylindricalFace(targetFace, this.getEndOffset());
     }
+    resizeConicalFace(targetFace) {
+        return FaceQuery.makeInfiniteConicalFace(targetFace, this.getEndOffset());
+    }
     /**
      * Computes the signed distance from the sketch plane to the farthest
      * bounding-box corner of the target face, measured along the sketch

package/lib/dist/features/fillet.d.ts

@@ -8,7 +8,7 @@ export declare class Fillet extends SceneObject {
     validate(): void;
     build(context: BuildSceneObjectContext): void;
     doBuild(sceneObjectsMap: Map<SceneObject, Shape[]>, selections: SceneObject[]): {
-        addedShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];
+        addedShapes: Shape<import("ocjs-fluidcad").TopoDS_Shape>[];
         removedShapes: {
             shape: Shape;
             owner: SceneObject;

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

@@ -0,0 +1,41 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { IHelix } from "../core/interfaces.js";
+export declare class Helix extends SceneObject implements IHelix {
+    source: AxisObjectBase | SceneObject;
+    private _pitch?;
+    private _turns?;
+    private _startOffset;
+    private _endOffset;
+    private _height?;
+    private _radius?;
+    private _endRadius?;
+    constructor(source: AxisObjectBase | SceneObject);
+    pitch(value: number): this;
+    turns(value: number): this;
+    startOffset(value: number): this;
+    endOffset(value: number): this;
+    height(value: number): this;
+    radius(value: number): this;
+    endRadius(value: number): this;
+    validate(): void;
+    build(_context?: BuildSceneObjectContext): void;
+    private deriveTurnsFromHeight;
+    private resolveSource;
+    private resolveFace;
+    private resolveEdge;
+    getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: SceneObject): boolean;
+    serialize(): {
+        source: any;
+        pitch: number;
+        turns: number;
+        startOffset: number;
+        endOffset: number;
+        height: number;
+        radius: number;
+        endRadius: number;
+    };
+}

package/lib/dist/features/helix.js

@@ -0,0 +1,337 @@
+import { SceneObject } from "../common/scene-object.js";
+import { BuildError } from "../common/build-error.js";
+import { requireShapes } from "../common/operand-check.js";
+import { AxisObjectBase } from "./axis-renderable-base.js";
+import { HelixOps } from "../oc/helix-ops.js";
+import { FaceQuery } from "../oc/face-query.js";
+import { EdgeQuery } from "../oc/edge-query.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+import { Convert } from "../oc/convert.js";
+import { CoordinateSystem } from "../math/coordinate-system.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Axis } from "../math/axis.js";
+const DEFAULT_RADIUS = 20;
+const DEFAULT_HEIGHT = 50;
+const DEFAULT_TURNS = 1;
+const EPS = 1e-7;
+const TANGENCY_BREAK_EPSILON = 1e-6;
+export class Helix extends SceneObject {
+    source;
+    _pitch;
+    _turns;
+    _startOffset = 0;
+    _endOffset = 0;
+    _height;
+    _radius;
+    _endRadius;
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    pitch(value) {
+        this._pitch = value;
+        return this;
+    }
+    turns(value) {
+        this._turns = value;
+        return this;
+    }
+    startOffset(value) {
+        this._startOffset = value;
+        return this;
+    }
+    endOffset(value) {
+        this._endOffset = value;
+        return this;
+    }
+    height(value) {
+        this._height = value;
+        return this;
+    }
+    radius(value) {
+        this._radius = value;
+        return this;
+    }
+    endRadius(value) {
+        this._endRadius = value;
+        return this;
+    }
+    validate() {
+        if (this.source instanceof AxisObjectBase) {
+            return;
+        }
+        requireShapes(this.source, "source", "helix");
+    }
+    build(_context) {
+        const resolved = this.resolveSource();
+        let startRadius;
+        let endRadius;
+        let cs;
+        let zStart;
+        let zEnd;
+        let offsetsAlreadyApplied = false;
+        switch (resolved.kind) {
+            case 'axis': {
+                cs = HelixOps_csFromAxis(resolved.axis);
+                startRadius = this._radius ?? DEFAULT_RADIUS;
+                endRadius = this._endRadius ?? startRadius;
+                const { height } = resolveAxisHeightAndPitch(this._height, this._pitch, this._turns);
+                zStart = 0;
+                zEnd = height;
+                break;
+            }
+            case 'cylinder-face': {
+                if (this._endRadius !== undefined && this._endRadius !== (this._radius ?? resolved.radius)) {
+                    console.warn("helix: .endRadius() is ignored when source is a cylindrical face — for a tapered helix, use a conical face or axis input.");
+                }
+                cs = resolved.cs;
+                // Nudge inward by TANGENCY_BREAK_EPSILON when falling back to the
+                // face's natural radius. A helix exactly on the cylinder's surface
+                // produces a swept tube that's tangent to the cylinder along helical
+                // curves, and OCC's BOPAlgo (BRepAlgoAPI_Fuse/Cut) silently fails on
+                // tangent contact along curves — fuse returns the inputs as a
+                // compound, cut is a no-op. The 1e-6mm nudge is sub-nanometer
+                // (visually identical) but produces transversal intersections that
+                // BOPAlgo handles cleanly. Sweep also passes skipSimplify=true to
+                // avoid SimplifyResult/UnifySameDomain hanging on the resulting
+                // tangent-curve topology.
+                startRadius = this._radius ?? (resolved.radius - TANGENCY_BREAK_EPSILON);
+                endRadius = startRadius;
+                if (this._height !== undefined) {
+                    zStart = 0;
+                    zEnd = this._height;
+                }
+                else {
+                    zStart = resolved.vMin;
+                    zEnd = resolved.vMax;
+                }
+                break;
+            }
+            case 'cone-face': {
+                if (this._radius !== undefined || this._endRadius !== undefined) {
+                    console.warn("helix: .radius()/.endRadius() are ignored when source is a conical face — radii are derived from the face geometry.");
+                }
+                cs = resolved.cs;
+                const cosA = Math.cos(resolved.semiAngle);
+                const sinA = Math.sin(resolved.semiAngle);
+                const zMinFace = resolved.vMin * cosA;
+                const zMaxFace = resolved.vMax * cosA;
+                const zLow = Math.min(zMinFace, zMaxFace);
+                const zHigh = Math.max(zMinFace, zMaxFace);
+                if (this._height !== undefined) {
+                    zStart = zLow;
+                    zEnd = zLow + this._height;
+                }
+                else {
+                    zStart = zLow;
+                    zEnd = zHigh;
+                }
+                // Apply offsets here so the radii follow the cone's surface at the
+                // extended positions (offsets extend along the cone's natural taper,
+                // not as a cylindrical extension).
+                zStart += this._startOffset;
+                zEnd += this._endOffset;
+                startRadius = resolved.refRadius + (zStart / cosA) * sinA;
+                endRadius = resolved.refRadius + (zEnd / cosA) * sinA;
+                offsetsAlreadyApplied = true;
+                break;
+            }
+            case 'line-edge': {
+                cs = HelixOps_csFromAxis(resolved.axis);
+                startRadius = this._radius ?? DEFAULT_RADIUS;
+                endRadius = this._endRadius ?? startRadius;
+                zStart = 0;
+                zEnd = this._height ?? resolved.length;
+                break;
+            }
+            case 'circle-edge': {
+                if (this._endRadius !== undefined) {
+                    console.warn("helix: .endRadius() is ignored when source is a circular edge — both radii equal the circle radius.");
+                }
+                cs = resolved.cs;
+                startRadius = this._radius ?? resolved.radius;
+                endRadius = startRadius;
+                zStart = 0;
+                zEnd = this._height ?? DEFAULT_HEIGHT;
+                break;
+            }
+        }
+        if (!offsetsAlreadyApplied) {
+            zStart += this._startOffset;
+            zEnd += this._endOffset;
+        }
+        if (this._pitch !== undefined && Math.abs(this._pitch) < EPS) {
+            throw new BuildError(`helix: .pitch() must be non-zero.`);
+        }
+        if (this._turns !== undefined && this._turns <= 0) {
+            throw new BuildError(`helix: .turns() must be > 0, got ${this._turns}.`, `Pass a positive number to .turns().`);
+        }
+        const turns = this._turns ?? this.deriveTurnsFromHeight(zEnd - zStart);
+        if (!Number.isFinite(turns) || turns <= 0) {
+            throw new BuildError(`helix: turns must be > 0, got ${turns}.`, `Pass a positive number to .turns() or .pitch().`);
+        }
+        if (Math.abs(zEnd - zStart) < EPS) {
+            throw new BuildError(`helix: resulting axial height is zero (zStart=${zStart}, zEnd=${zEnd}).`, `Check .startOffset()/.endOffset()/.height() values.`);
+        }
+        if (startRadius <= 0) {
+            throw new BuildError(`helix: start radius must be > 0, got ${startRadius}.`);
+        }
+        if (endRadius <= 0) {
+            throw new BuildError(`helix: end radius would be ≤ 0 (got ${endRadius}). For a conical helix, the end radius must stay positive.`, `Reduce .endOffset() or use a smaller turns/height combination.`);
+        }
+        const edge = HelixOps.makeHelix(cs, startRadius, endRadius, zStart, zEnd, turns);
+        this.addShape(edge);
+        this.source.removeShapes(this);
+    }
+    deriveTurnsFromHeight(height) {
+        if (this._pitch === undefined) {
+            return DEFAULT_TURNS;
+        }
+        if (Math.abs(this._pitch) < EPS) {
+            throw new BuildError(`helix: .pitch() must be non-zero.`);
+        }
+        return Math.abs(height / this._pitch);
+    }
+    resolveSource() {
+        if (this.source instanceof AxisObjectBase) {
+            return { kind: 'axis', axis: this.source.getAxis() };
+        }
+        const shapes = this.source.getShapes({ excludeGuide: false });
+        if (shapes.length !== 1) {
+            throw new BuildError(`helix: source must contain exactly one shape (got ${shapes.length}).`, `Wrap multi-shape sources in select(...) to pick a single face or edge.`);
+        }
+        const shape = shapes[0];
+        if (shape.isFace()) {
+            return this.resolveFace(shape);
+        }
+        if (shape.isEdge()) {
+            return this.resolveEdge(shape);
+        }
+        throw new BuildError(`helix: source shape must be a face or edge, got '${shape.getType()}'.`);
+    }
+    resolveFace(face) {
+        const surfaceType = FaceQuery.getSurfaceType(face);
+        if (surfaceType === 'cylinder') {
+            const cylinder = FaceQuery.getSurfaceAdaptorCylinderRaw(face.getShape());
+            const ax3 = cylinder.Position();
+            const cs = Convert.toCoordinateSystemFromGpAx3(ax3, true);
+            const radius = cylinder.Radius();
+            cylinder.delete();
+            const { vMin, vMax } = FaceQuery.getSurfaceVBoundsRaw(face.getShape());
+            const canon = canonicalizeAxialBounds(cs, vMin, vMax);
+            return { kind: 'cylinder-face', cs: canon.cs, radius, vMin: canon.vMin, vMax: canon.vMax };
+        }
+        if (surfaceType === 'cone') {
+            const cone = FaceQuery.getSurfaceAdaptorConeRaw(face.getShape());
+            const ax3 = cone.Position();
+            const cs = Convert.toCoordinateSystemFromGpAx3(ax3, true);
+            const semiAngle = cone.SemiAngle();
+            const refRadius = cone.RefRadius();
+            cone.delete();
+            const { vMin, vMax } = FaceQuery.getSurfaceVBoundsRaw(face.getShape());
+            // For a cone, the V-axis lies along the slant; canonicalizing the
+            // CS direction here doesn't simplify the math the same way it does for
+            // a cylinder, so leave the cone's frame alone.
+            return { kind: 'cone-face', cs, semiAngle, refRadius, vMin, vMax };
+        }
+        throw new BuildError(`helix: face must be cylindrical or conical (got '${surfaceType}').`);
+    }
+    resolveEdge(edge) {
+        const curveType = EdgeQuery.getEdgeCurveType(edge);
+        if (curveType === 'line') {
+            const axis = EdgeOps.edgeToAxis(edge);
+            const params = EdgeQuery.getEdgeCurveParams(edge);
+            const length = Math.abs(params.last - params.first);
+            return { kind: 'line-edge', axis, length };
+        }
+        if (curveType === 'circle') {
+            const data = EdgeQuery.getCircleDataFromEdge(edge);
+            const axis = new Axis(data.center, data.axisDirection);
+            const cs = HelixOps_csFromAxis(axis);
+            return { kind: 'circle-edge', cs, radius: data.radius };
+        }
+        throw new BuildError(`helix: edge must be a line or circle (got '${curveType}').`);
+    }
+    getType() {
+        return 'helix';
+    }
+    getDependencies() {
+        return [this.source];
+    }
+    createCopy(remap) {
+        const newSource = (remap.get(this.source) ?? this.source);
+        const copy = new Helix(newSource);
+        copy._pitch = this._pitch;
+        copy._turns = this._turns;
+        copy._startOffset = this._startOffset;
+        copy._endOffset = this._endOffset;
+        copy._height = this._height;
+        copy._radius = this._radius;
+        copy._endRadius = this._endRadius;
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof Helix)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.source.compareTo(other.source)) {
+            return false;
+        }
+        return this._pitch === other._pitch
+            && this._turns === other._turns
+            && this._startOffset === other._startOffset
+            && this._endOffset === other._endOffset
+            && this._height === other._height
+            && this._radius === other._radius
+            && this._endRadius === other._endRadius;
+    }
+    serialize() {
+        return {
+            source: this.source.serialize(),
+            pitch: this._pitch,
+            turns: this._turns,
+            startOffset: this._startOffset,
+            endOffset: this._endOffset,
+            height: this._height,
+            radius: this._radius,
+            endRadius: this._endRadius,
+        };
+    }
+}
+function resolveAxisHeightAndPitch(height, pitch, turns) {
+    if (height !== undefined) {
+        return { height };
+    }
+    if (pitch !== undefined && turns !== undefined) {
+        return { height: Math.abs(pitch * turns) };
+    }
+    if (pitch !== undefined) {
+        return { height: Math.abs(pitch * DEFAULT_TURNS) };
+    }
+    return { height: DEFAULT_HEIGHT };
+}
+function HelixOps_csFromAxis(axis) {
+    const dir = axis.direction.normalize();
+    const seed = Math.abs(dir.z) < 0.9 ? Vector3d.unitZ() : Vector3d.unitX();
+    const xDir = seed.cross(dir).normalize();
+    return new CoordinateSystem(axis.origin, dir, xDir);
+}
+/**
+ * A cylindrical face's `Position()` Ax3 may have its main direction pointing
+ * "into" the face's V-extent rather than "out of it" (e.g. an extruded cylinder
+ * built from a sketch on z=0 yields mainDir = (0,0,-1) with V-bounds [-50, 0]).
+ * Pass through unchanged when V naturally extends in the +mainDir direction;
+ * otherwise flip mainDir and negate V-bounds so that V grows along the body's
+ * axial extent. This keeps `.startOffset()`/`.endOffset()` semantics intuitive
+ * (positive end-offset extends past the cylinder's "top").
+ */
+function canonicalizeAxialBounds(cs, vMin, vMax) {
+    if (Math.abs(vMin) <= Math.abs(vMax)) {
+        return { cs, vMin, vMax };
+    }
+    const flipped = new CoordinateSystem(cs.origin, cs.mainDirection.negate(), cs.xDirection);
+    return { cs: flipped, vMin: -vMax, vMax: -vMin };
+}

package/lib/dist/features/select.js

@@ -4,6 +4,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { BelongsToFaceFilter, NotBelongsToFaceFilter } from "../filters/edge/belongs-to-face.js";
 import { FromSceneObjectFilter } from "../filters/from-object.js";
 import { TopologyIndex } from "../oc/topology-index.js";
+import { ShapeHasher } from "../oc/shape-hash.js";
 export class SelectSceneObject extends SceneObject {
     filters;
     constraintObject;
@@ -26,12 +27,20 @@ export class SelectSceneObject extends SceneObject {
         let filters = this.filters;
         let sceneObjects = context.getSceneObjects();
         let excludedObjects = [];
+        let narrowedToCloneGroup = false;
         if (transform) {
             filters = filters.map(f => f.transform(transform));
             if (!this.constraintObject && parent) {
                 const snapshot = parent.getSnapshot();
                 excludedObjects = snapshot ? Array.from(snapshot.values()).flat() : [];
-                sceneObjects = context.getSceneObjectsFromTo(parent, this);
+                // Restrict to this clone instance's own siblings. Other instances of
+                // the same repeat share the parent container but carry a different
+                // clone transform, and the container itself would re-expose their
+                // shapes through getChildShapes.
+                const transformRef = this.getTransformRef();
+                sceneObjects = context.getSceneObjectsFromTo(parent, this)
+                    .filter(o => o.getTransformRef() === transformRef);
+                narrowedToCloneGroup = true;
             }
         }
         // Objects passed explicitly via `from(...)` bypass the part scope so that
@@ -48,12 +57,23 @@ export class SelectSceneObject extends SceneObject {
             }
         }
         const allShapes = this.constraintObject ? this.constraintObject.getShapes() : this.getAllShapes(sceneObjects, excludedObjects);
+        let scopeHasher = null;
         if (this.type === "edge") {
-            this.injectScopeFaces(filters, sceneObjects);
+            scopeHasher = this.injectScopeFaces(filters, sceneObjects);
         }
         const fromFilters = this.injectFromMembershipSets(filters);
         try {
-            const filteredShapes = this.applyFilters(allShapes, filters);
+            let filteredShapes = this.applyFilters(allShapes, filters);
+            if (filteredShapes.length === 0 && narrowedToCloneGroup) {
+                // Nothing matched within the cloned group: the original selection
+                // resolved to geometry outside the repeated objects (e.g. a wrap
+                // target face on a base solid). Reuse that resolution — re-running
+                // the transformed filters against base geometry cannot match.
+                const source = this.getCloneSource();
+                if (source instanceof SelectSceneObject) {
+                    filteredShapes = source.getAddedShapes();
+                }
+            }
             this.addShapes(filteredShapes);
         }
         finally {
@@ -61,6 +81,7 @@ export class SelectSceneObject extends SceneObject {
                 filter.setMembershipSet(null);
                 set.delete();
             }
+            scopeHasher?.delete();
         }
     }
     injectFromMembershipSets(filters) {
@@ -141,6 +162,7 @@ export class SelectSceneObject extends SceneObject {
         let scopeSolids = null;
         let extraFaces = null;
         let faceByHash = null;
+        let hasher = null;
         for (const builder of filters) {
             for (const filter of builder.getFilters()) {
                 if (filter instanceof BelongsToFaceFilter || filter instanceof NotBelongsToFaceFilter) {
@@ -159,19 +181,21 @@ export class SelectSceneObject extends SceneObject {
                             extraFaces = [];
                         }
                         faceByHash = new Map();
+                        hasher = new ShapeHasher();
                         for (const solid of scopeSolids) {
                             for (const face of solid.getFaces()) {
-                                addToBucket(faceByHash, face);
+                                addToBucket(faceByHash, face, hasher);
                             }
                         }
                         for (const face of extraFaces) {
-                            addToBucket(faceByHash, face);
+                            addToBucket(faceByHash, face, hasher);
                         }
                     }
-                    filter.setScopeIndex(scopeSolids, extraFaces, faceByHash);
+                    filter.setScopeIndex(scopeSolids, extraFaces, faceByHash, hasher);
                 }
             }
         }
+        return hasher;
     }
     applyFilters(shapes, filters) {
         const shapeFilter = new ShapeFilter(shapes, ...filters);
@@ -220,8 +244,8 @@ export class SelectSceneObject extends SceneObject {
         };
     }
 }
-function addToBucket(faceByHash, face) {
-    const hash = face.getShape().HashCode(2147483647);
+function addToBucket(faceByHash, face, hasher) {
+    const hash = hasher.key(face.getShape());
     let bucket = faceByHash.get(hash);
     if (!bucket) {
         bucket = [];

package/lib/dist/features/simple-extruder.d.ts

@@ -18,7 +18,7 @@ export declare class Extruder {
     getEndFaces(): Face[];
     getSideFaces(): Face[];
     getInternalFaces(): Face[];
-    extrude(): Shape<import("occjs-wrapper").TopoDS_Shape>[];
+    extrude(): Shape<import("ocjs-fluidcad").TopoDS_Shape>[];
     private isInternalFace;
     private applyDraft;
 }

package/lib/dist/features/simple-extruder.js

@@ -49,9 +49,14 @@ export class Extruder {
             ? p.record('Fuse profile faces', () => BooleanOps.fuseFaces(this.faces))
             : BooleanOps.fuseFaces(this.faces);
         for (const face of fusedFaces.result) {
+            // Canonicalize the sweep direction (so anti-parallel halves of a
+            // symmetric / two-distance extrude fuse with a single merged lateral
+            // face) only when undrafted — drafting is sensitive to the sweep
+            // parametrization and must keep the literal direction.
+            const canonicalizeSweep = !this.draft;
             let { solid, firstFace, lastFace } = p
-                ? p.record('Make prism from face', () => ExtrudeOps.makePrismFromVec(face, vec))
-                : ExtrudeOps.makePrismFromVec(face, vec);
+                ? p.record('Make prism from face', () => ExtrudeOps.makePrismFromVec(face, vec, canonicalizeSweep))
+                : ExtrudeOps.makePrismFromVec(face, vec, canonicalizeSweep);
             if (this.draft) {
                 const draftResult = p
                     ? p.record('Apply draft', () => this.applyDraft(solid, firstFace, lastFace, this.plane))

package/lib/dist/features/sphere.d.ts

@@ -1,9 +1,11 @@
 import { TransformablePrimitive } from "../common/transformable-primitive.js";
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 export declare class Sphere extends TransformablePrimitive {
     radius: number;
     angle: number;
     constructor(radius: number, angle: number);
-    build(): void;
+    build(context?: BuildSceneObjectContext): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Sphere): boolean;
     getType(): string;
     serialize(): {

package/lib/dist/features/sphere.js

@@ -8,9 +8,12 @@ export class Sphere extends TransformablePrimitive {
         this.radius = radius;
         this.angle = angle;
     }
-    build() {
+    build(context) {
         const sphere = Primitives.makeSphere(this.radius, this.angle);
-        this.addShapes([sphere]);
+        this.addPrimitiveShape(sphere, context);
+    }
+    createCopy(remap) {
+        return new Sphere(this.radius, this.angle).syncPrimitiveWith(this);
     }
     compareTo(other) {
         if (!(other instanceof Sphere)) {

package/lib/dist/features/sweep.js

@@ -141,10 +141,15 @@ export class Sweep extends ExtrudeBase {
             this.setState('side-faces', classified.sideFaces);
             this.setState('internal-faces', classified.internalFaces);
             this.setState('cap-faces', classified.capFaces);
-            cutWithSceneObjects(scope, solids, plane, 0, this, { recordHistoryFor: this });
+            cutWithSceneObjects(scope, solids, plane, 0, this, { recordHistoryFor: this, skipSimplify: true });
             return;
         }
-        this.finalizeAndFuse(solids, classified, context);
+        // Sweep paths can produce tangent contact between the swept tube and
+        // existing scene shapes (e.g., a helix sweep along a cylinder face).
+        // SimplifyResult's face unification can iterate forever on the resulting
+        // topology — skip it for sweep ops; downstream classification doesn't
+        // need same-domain face merging.
+        this.finalizeAndFuse(solids, classified, context, { skipSimplify: true });
     }
     getSpineWire(pathObj) {
         const shapes = pathObj.getShapes({ excludeMeta: false });

package/lib/dist/features/wrap.d.ts

@@ -0,0 +1,39 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { Extrudable } from "../helpers/types.js";
+import { IWrap } from "../core/interfaces.js";
+/**
+ * Wraps a sketch onto a curved face (cylindrical or conical) and thickens it
+ * along the surface normal — emboss with `.add()` (default), deboss with
+ * `.remove()`, standalone pad with `.new()`. The sketch is developed onto the
+ * surface preserving lengths (a true wrap, not a projection).
+ */
+export declare class Wrap extends ExtrudeBase implements IWrap {
+    thickness: number;
+    face: SceneObject;
+    constructor(thickness: number, face: SceneObject, source?: Extrudable | SceneObject);
+    build(context: BuildSceneObjectContext): void;
+    /** Resolve the planar sketch regions to wrap (same source rules as extrude). */
+    private resolveSourceFaces;
+    private getTargetFace;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Wrap): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        picking: true;
+        pickPoints: number[][];
+        trigger: "region-picking";
+        pickPlane: {
+            origin: import("../math/point.js").Point;
+            xDirection: import("../math/vector3d.js").Vector3d;
+            yDirection: import("../math/vector3d.js").Vector3d;
+            normal: import("../math/vector3d.js").Vector3d;
+        };
+        extrudable: any;
+        thickness: number;
+        face: string;
+        operationMode: "new" | "remove";
+    };
+}