fluidcad 0.0.36 → 0.0.38

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/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/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))