fluidcad 0.0.28 → 0.0.30

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

@@ -0,0 +1,75 @@
+import { Geometry } from "../../oc/geometry.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+export class Ellipse extends ExtrudableGeometryBase {
+    rx;
+    ry;
+    centerOverride;
+    constructor(rx, ry, targetPlane = null, centerOverride = null) {
+        super(targetPlane);
+        this.rx = rx;
+        this.ry = ry;
+        this.centerOverride = centerOverride;
+    }
+    getType() {
+        return 'ellipse';
+    }
+    build() {
+        if (this.rx <= 0 || this.ry <= 0) {
+            throw new Error(`Ellipse radii must be positive (rx=${this.rx}, ry=${this.ry})`);
+        }
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const center = this.centerOverride
+            ?? (this.targetPlane
+                ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+                : this.getCurrentPosition());
+        // OCC requires majorRadius >= minorRadius. Pick which plane axis carries the major.
+        const rxIsMajor = this.rx >= this.ry;
+        const major = rxIsMajor ? this.rx : this.ry;
+        const minor = rxIsMajor ? this.ry : this.rx;
+        const majorAxisDir = rxIsMajor ? plane.xDirection : plane.yDirection;
+        const edge = Geometry.makeEllipseEdge(plane.localToWorld(center), major, minor, plane.normal, majorAxisDir);
+        this.addShape(edge);
+        if (this.sketch) {
+            this.setCurrentPosition(center);
+        }
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        return this.targetPlane ? [this.targetPlane] : [];
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        return new Ellipse(this.rx, this.ry, targetPlane, this.centerOverride);
+    }
+    compareTo(other) {
+        if (!(other instanceof Ellipse)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        if (this.rx !== other.rx || this.ry !== other.ry) {
+            return false;
+        }
+        if (this.centerOverride && other.centerOverride) {
+            return this.centerOverride.x === other.centerOverride.x
+                && this.centerOverride.y === other.centerOverride.y;
+        }
+        return this.centerOverride === other.centerOverride;
+    }
+    serialize() {
+        return {
+            rx: this.rx,
+            ry: this.ry,
+            ...(this.centerOverride ? { center: { x: this.centerOverride.x, y: this.centerOverride.y } } : {}),
+        };
+    }
+}

package/lib/dist/features/2d/hline.d.ts

@@ -1,11 +1,16 @@
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class HorizontalLine extends GeometrySceneObject {
-    distance: number;
-    centered: boolean;
+import { IHLine } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class HorizontalLine extends GeometrySceneObject implements IHLine {
+    distanceOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(distance: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: HorizontalLine): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -2,25 +2,45 @@ import { Vertex } from "../../common/vertex.js";
 import { Geometry } from "../../oc/geometry.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class HorizontalLine extends GeometrySceneObject {
-    distance;
-    centered;
+    distanceOrTarget;
     targetPlane;
-    constructor(distance, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(distanceOrTarget, targetPlane = null) {
         super();
-        this.distance = distance;
-        this.centered = centered;
+        this.distanceOrTarget = distanceOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
-        const startPoint = this.centered
-            ? currentPos.translate(-this.distance / 2, 0)
-            : currentPos;
-        const endPoint = startPoint.translate(this.distance, 0);
+        let startPoint;
+        let endPoint;
+        let signedLength;
+        if (typeof this.distanceOrTarget === 'number') {
+            const distance = this.distanceOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(-distance / 2, 0)
+                : currentPos;
+            endPoint = startPoint.translate(distance, 0);
+            signedLength = distance;
+        }
+        else {
+            if (this._centered) {
+                throw new Error('hLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            endPoint = findNearestRayIntersection(plane, startPoint, new Point2D(1, 0), this.distanceOrTarget);
+            signedLength = endPoint.x - startPoint.x;
+        }
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(endPoint);
         let segment = Geometry.makeSegment(start, end);
@@ -28,13 +48,33 @@ export class HorizontalLine extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
-        const sign = Math.sign(this.distance) || 1;
+        const sign = Math.sign(signedLength) || 1;
         this.setTangent(new Point2D(sign, 0));
         if (this.sketch) {
             this.setCurrentPosition(endPoint);
         }
-        if (this.targetPlane)
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.distanceOrTarget instanceof SceneObject) {
+            deps.push(this.distanceOrTarget);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const distanceOrTarget = this.distanceOrTarget instanceof SceneObject
+            ? (remap.get(this.distanceOrTarget) || this.distanceOrTarget)
+            : this.distanceOrTarget;
+        const copy = new HorizontalLine(distanceOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof HorizontalLine)) {
@@ -49,7 +89,18 @@ export class HorizontalLine extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.distance === other.distance && this.centered === other.centered;
+        if (typeof this.distanceOrTarget !== typeof other.distanceOrTarget) {
+            return false;
+        }
+        if (this.distanceOrTarget instanceof SceneObject && other.distanceOrTarget instanceof SceneObject) {
+            if (!this.distanceOrTarget.compareTo(other.distanceOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.distanceOrTarget !== other.distanceOrTarget) {
+            return false;
+        }
+        return this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -59,8 +110,8 @@ export class HorizontalLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            distance: this.distance,
-            centered: this.centered
+            distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
+            centered: this._centered
         };
     }
 }

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

@@ -5,7 +5,9 @@ export declare class Offset extends ExtrudableGeometryBase {
     private distance;
     private removeOriginal;
     private sourceGeometries;
+    private _close;
     constructor(distance: number, removeOriginal?: boolean, sourceGeometries?: SceneObject[], targetPlane?: PlaneObjectBase);
+    close(): this;
     build(): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -14,5 +16,6 @@ export declare class Offset extends ExtrudableGeometryBase {
     serialize(): {
         distance: number;
         removeOriginal: boolean;
+        close: boolean;
     };
 }

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

@@ -1,4 +1,5 @@
 import { WireOps } from "../../oc/wire-ops.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
 import { Edge } from "../../common/edge.js";
 import { Vertex } from "../../common/vertex.js";
 import { Wire } from "../../common/wire.js";
@@ -7,13 +8,21 @@ export class Offset extends ExtrudableGeometryBase {
     distance;
     removeOriginal;
     sourceGeometries;
+    _close = false;
     constructor(distance, removeOriginal = false, sourceGeometries = null, targetPlane = null) {
         super(targetPlane);
         this.distance = distance;
         this.removeOriginal = removeOriginal;
         this.sourceGeometries = sourceGeometries;
     }
+    close() {
+        this._close = true;
+        return this;
+    }
     build() {
+        if (this._close && this.removeOriginal) {
+            throw new Error("Offset.close() cannot be used with removeOriginal");
+        }
         let sourceObjects;
         if (this.sketch) {
             sourceObjects = this.sketch.getEdgesWithOwner();
@@ -54,6 +63,14 @@ export class Offset extends ExtrudableGeometryBase {
             for (const edge of edges) {
                 this.addShape(edge);
             }
+            if (this._close && !offsetWire.isClosed()) {
+                const originalStart = wireInfo.wire.getFirstVertex().toPoint();
+                const originalEnd = wireInfo.wire.getLastVertex().toPoint();
+                const offsetStart = offsetWire.getFirstVertex().toPoint();
+                const offsetEnd = offsetWire.getLastVertex().toPoint();
+                this.addShape(EdgeOps.makeLineEdge(originalEnd, offsetEnd));
+                this.addShape(EdgeOps.makeLineEdge(offsetStart, originalStart));
+            }
             if (this.removeOriginal) {
                 for (const [edge, owner] of wireInfo.edges) {
                     owner.removeShape(edge, this);
@@ -83,7 +100,11 @@ export class Offset extends ExtrudableGeometryBase {
         const geometriesClone = this.sourceGeometries
             ? this.sourceGeometries.map(obj => remap.get(obj) || obj)
             : null;
-        return new Offset(this.distance, this.removeOriginal, geometriesClone, targetPlane);
+        const copy = new Offset(this.distance, this.removeOriginal, geometriesClone, targetPlane);
+        if (this._close) {
+            copy._close = true;
+        }
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof Offset)) {
@@ -113,7 +134,9 @@ export class Offset extends ExtrudableGeometryBase {
                 }
             }
         }
-        return this.distance === other.distance && this.removeOriginal === other.removeOriginal;
+        return this.distance === other.distance
+            && this.removeOriginal === other.removeOriginal
+            && this._close === other._close;
     }
     getType() {
         return 'offset';
@@ -121,7 +144,8 @@ export class Offset extends ExtrudableGeometryBase {
     serialize() {
         return {
             distance: this.distance,
-            removeOriginal: this.removeOriginal
+            removeOriginal: this.removeOriginal,
+            close: this._close
         };
     }
 }

package/lib/dist/features/2d/sketch.d.ts

@@ -14,6 +14,7 @@ export declare class Sketch extends SceneObject implements Extrudable {
     getStartPoint(): Point2D;
     getTangentAt(currentObj: GeometrySceneObject): Point2D | null;
     getPositionAt(currentObj: GeometrySceneObject): Point2D;
+    getPreviousPosition(currentObj: GeometrySceneObject, count?: number): Point2D;
     getLastPosition(scope?: Set<SceneObject>): Point2D;
     build(context?: BuildSceneObjectContext): void;
     getEdges(): Edge[];

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

@@ -58,6 +58,21 @@ export class Sketch extends SceneObject {
         }
         return this.getStartPoint();
     }
+    getPreviousPosition(currentObj, count = 1) {
+        const children = this.getChildren();
+        const previous = children.slice(0, children.indexOf(currentObj));
+        let remaining = count;
+        for (let i = previous.length - 1; i >= 0; i--) {
+            const pos = previous[i].getState('current-position');
+            if (pos) {
+                if (remaining === 0) {
+                    return pos;
+                }
+                remaining--;
+            }
+        }
+        return this.getStartPoint();
+    }
     getLastPosition(scope) {
         let children = this.getChildren().slice();
         if (scope) {

package/lib/dist/features/2d/vline.d.ts

@@ -1,11 +1,16 @@
 import { PlaneObjectBase } from "../plane-renderable-base.js";
 import { GeometrySceneObject } from "./geometry.js";
-export declare class VerticalLine extends GeometrySceneObject {
-    distance: number;
-    centered: boolean;
+import { IVLine } from "../../core/interfaces.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class VerticalLine extends GeometrySceneObject implements IVLine {
+    distanceOrTarget: number | SceneObject;
     private targetPlane;
-    constructor(distance: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    private _centered;
+    constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
+    centered(value?: boolean): this;
     build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: VerticalLine): boolean;
     getType(): string;
     getUniqueType(): string;

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

@@ -2,25 +2,45 @@ import { Vertex } from "../../common/vertex.js";
 import { Geometry } from "../../oc/geometry.js";
 import { Point2D } from "../../math/point.js";
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { findNearestRayIntersection } from "../../oc/ray-intersect.js";
 export class VerticalLine extends GeometrySceneObject {
-    distance;
-    centered;
+    distanceOrTarget;
     targetPlane;
-    constructor(distance, centered = false, targetPlane = null) {
+    _centered = false;
+    constructor(distanceOrTarget, targetPlane = null) {
         super();
-        this.distance = distance;
-        this.centered = centered;
+        this.distanceOrTarget = distanceOrTarget;
         this.targetPlane = targetPlane;
     }
+    centered(value = true) {
+        this._centered = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
             ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
             : this.getCurrentPosition();
-        const startPoint = this.centered
-            ? currentPos.translate(0, -this.distance / 2)
-            : currentPos;
-        const endPoint = startPoint.translate(0, this.distance);
+        let startPoint;
+        let endPoint;
+        let signedLength;
+        if (typeof this.distanceOrTarget === 'number') {
+            const distance = this.distanceOrTarget;
+            startPoint = this._centered
+                ? currentPos.translate(0, -distance / 2)
+                : currentPos;
+            endPoint = startPoint.translate(0, distance);
+            signedLength = distance;
+        }
+        else {
+            if (this._centered) {
+                throw new Error('vLine: .centered() cannot be combined with a target geometry');
+            }
+            startPoint = currentPos;
+            endPoint = findNearestRayIntersection(plane, startPoint, new Point2D(0, 1), this.distanceOrTarget);
+            signedLength = endPoint.y - startPoint.y;
+        }
         const start = plane.localToWorld(startPoint);
         const end = plane.localToWorld(endPoint);
         let segment = Geometry.makeSegment(start, end);
@@ -28,12 +48,33 @@ export class VerticalLine extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(endPoint));
         this.addShape(edge);
-        const sign = Math.sign(this.distance) || 1;
+        const sign = Math.sign(signedLength) || 1;
         this.setTangent(new Point2D(0, sign));
-        if (this.sketch)
+        if (this.sketch) {
             this.setCurrentPosition(endPoint);
-        if (this.targetPlane)
+        }
+        if (this.targetPlane) {
             this.targetPlane.removeShapes(this);
+        }
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.distanceOrTarget instanceof SceneObject) {
+            deps.push(this.distanceOrTarget);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane ? (remap.get(this.targetPlane) || this.targetPlane) : null;
+        const distanceOrTarget = this.distanceOrTarget instanceof SceneObject
+            ? (remap.get(this.distanceOrTarget) || this.distanceOrTarget)
+            : this.distanceOrTarget;
+        const copy = new VerticalLine(distanceOrTarget, targetPlane);
+        copy.centered(this._centered);
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof VerticalLine)) {
@@ -48,7 +89,18 @@ export class VerticalLine extends GeometrySceneObject {
         if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
             return false;
         }
-        return this.distance === other.distance && this.centered === other.centered;
+        if (typeof this.distanceOrTarget !== typeof other.distanceOrTarget) {
+            return false;
+        }
+        if (this.distanceOrTarget instanceof SceneObject && other.distanceOrTarget instanceof SceneObject) {
+            if (!this.distanceOrTarget.compareTo(other.distanceOrTarget)) {
+                return false;
+            }
+        }
+        else if (this.distanceOrTarget !== other.distanceOrTarget) {
+            return false;
+        }
+        return this._centered === other._centered;
     }
     getType() {
         return 'line';
@@ -58,8 +110,8 @@ export class VerticalLine extends GeometrySceneObject {
     }
     serialize() {
         return {
-            distance: this.distance,
-            centered: this.centered
+            distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
+            centered: this._centered
         };
     }
 }

package/lib/dist/features/common.js

@@ -15,6 +15,7 @@ export class Common extends SceneObject {
         return this._sceneObjects;
     }
     build(context) {
+        const p = context.getProfiler();
         let sceneObjects = this.sceneObjects;
         if (sceneObjects?.length === 0) {
             sceneObjects = context.getSceneObjects();
@@ -29,7 +30,7 @@ export class Common extends SceneObject {
         if (allShapes.length < 2) {
             return;
         }
-        const { newShapes, modifiedShapes, result } = BooleanOps.common(allShapes);
+        const { newShapes, modifiedShapes, result } = p.record('Common solids', () => BooleanOps.common(allShapes));
         if (!modifiedShapes.length && newShapes.length === 0) {
             return;
         }

package/lib/dist/features/extrude-base.d.ts

@@ -1,7 +1,7 @@
 import { Face } from "../common/face.js";
 import { Edge } from "../common/edge.js";
 import { Shape } from "../common/shape.js";
-import { SceneObject } from "../common/scene-object.js";
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Extrudable } from "../helpers/types.js";
 import { IExtrude } from "../core/interfaces.js";
 import { LazyVertex } from "./lazy-vertex.js";
@@ -10,6 +10,14 @@ import { Plane } from "../math/plane.js";
 import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ShapeHistory } from "../common/shape-history-tracker.js";
+/** A 3D op's classified face buckets. Each is empty if the op doesn't produce that category. */
+export type ClassifiedFaces = {
+    startFaces: Face[];
+    endFaces: Face[];
+    sideFaces: Face[];
+    internalFaces: Face[];
+    capFaces: Face[];
+};
 export declare abstract class ExtrudeBase extends SceneObject implements IExtrude {
     protected _extrudable: Extrudable | null;
     protected _faceSource: SceneObject | null;
@@ -60,6 +68,16 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
      * unchanged in the scene, every face/edge is brand new from this op's POV.
      */
     protected recordShapeFacesAndEdgesAsAdditions(shapes: Shape[]): void;
+    /**
+     * Shared post-extrude bookkeeping: store classified face state, fuse with
+     * the scene (recording history + remapping classification), and finalize
+     * with edge classification. Caller is responsible for removing source
+     * shapes (they vary across ops — Revolve also removes the axis, etc.)
+     * BEFORE calling this.
+     */
+    protected finalizeAndFuse(shapes: Shape[], classified: ClassifiedFaces, context: BuildSceneObjectContext, fuseOpts?: {
+        glue?: 'full' | 'shift';
+    }): void;
     /**
      * One-shot edge classification: derive start/end/side/internal/cap edges
      * from the already-classified face arrays in state and store them as

package/lib/dist/features/extrude-base.js

@@ -12,13 +12,41 @@ import { EdgeOps } from "../oc/edge-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { getOC } from "../oc/init.js";
 import { ShapeHistoryTracker } from "../common/shape-history-tracker.js";
-function dedupEdgesByIsSame(edges) {
+import { fuseWithSceneObjects } from "../helpers/scene-helpers.js";
+function dedupEdgesByMap(edges) {
+    if (edges.length === 0) {
+        return [];
+    }
+    const oc = getOC();
+    const seen = new oc.TopTools_MapOfShape();
+    const result = [];
+    for (const edge of edges) {
+        if (seen.Add(edge.getShape())) {
+            result.push(edge);
+        }
+    }
+    seen.delete();
+    return result;
+}
+// Dedup `edges` by TShape pointer while also excluding any edge that shares a
+// TShape with one in `excluded`. Single TopTools_MapOfShape pre-seeded with the
+// excluded set; Add returns false for duplicates and for already-excluded edges.
+function dedupEdgesByMapExcluding(edges, excluded) {
+    if (edges.length === 0) {
+        return [];
+    }
+    const oc = getOC();
+    const map = new oc.TopTools_MapOfShape();
+    for (const e of excluded) {
+        map.Add(e.getShape());
+    }
     const result = [];
     for (const edge of edges) {
-        if (!result.some(r => r.getShape().IsSame(edge.getShape()))) {
+        if (map.Add(edge.getShape())) {
             result.push(edge);
         }
     }
+    map.delete();
     return result;
 }
 export class ExtrudeBase extends SceneObject {
@@ -135,8 +163,7 @@ export class ExtrudeBase extends SceneObject {
             const startFaces = parent.getState('start-faces') || [];
             const endFaces = parent.getState('end-faces') || [];
             const excludedEdges = [...startFaces, ...endFaces].flatMap(f => f.getEdges());
-            const edges = dedupEdgesByIsSame(sideFaces.flatMap(f => f.getEdges())
-                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape()))));
+            const edges = dedupEdgesByMapExcluding(sideFaces.flatMap(f => f.getEdges()), excludedEdges);
             return this.resolveEdges(edges, args);
         }, this);
     }
@@ -202,7 +229,7 @@ export class ExtrudeBase extends SceneObject {
             return classified;
         }
         const faces = source.getState(faceKey) || [];
-        return dedupEdgesByIsSame(faces.flatMap(f => f.getEdges()));
+        return dedupEdgesByMap(faces.flatMap(f => f.getEdges()));
     }
     /**
      * Remap the state-stored face category arrays through a fusion's tool-side
@@ -236,6 +263,44 @@ export class ExtrudeBase extends SceneObject {
             }
         }
     }
+    /**
+     * Shared post-extrude bookkeeping: store classified face state, fuse with
+     * the scene (recording history + remapping classification), and finalize
+     * with edge classification. Caller is responsible for removing source
+     * shapes (they vary across ops — Revolve also removes the axis, etc.)
+     * BEFORE calling this.
+     */
+    finalizeAndFuse(shapes, classified, context, fuseOpts) {
+        const p = context.getProfiler();
+        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        this.setState('start-faces', classified.startFaces);
+        this.setState('end-faces', classified.endFaces);
+        this.setState('side-faces', classified.sideFaces);
+        this.setState('internal-faces', classified.internalFaces);
+        this.setState('cap-faces', classified.capFaces);
+        if (shapes.length === 0 || sceneObjects.length === 0) {
+            this.addShapes(shapes);
+            p.record('Record additions', () => this.recordShapeFacesAndEdgesAsAdditions(shapes));
+            p.record('Classify edges', () => this.classifyExtrudeEdges());
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, shapes, {
+            ...fuseOpts,
+            recordHistoryFor: this,
+            profiler: p,
+        });
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (!modifiedShape.object) {
+                continue;
+            }
+            modifiedShape.object.removeShape(modifiedShape.shape, this);
+        }
+        this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            p.record('Remap classified faces', () => this.remapClassifiedFaces(fusionResult.toolHistory));
+        }
+        p.record('Classify edges', () => this.classifyExtrudeEdges());
+    }
     /**
      * One-shot edge classification: derive start/end/side/internal/cap edges
      * from the already-classified face arrays in state and store them as
@@ -256,13 +321,11 @@ export class ExtrudeBase extends SceneObject {
         const sideFaces = this.getState('side-faces') || [];
         const internalFaces = this.getState('internal-faces') || [];
         const capFaces = this.getState('cap-faces') || [];
-        const startEdges = dedupEdgesByIsSame(startFaces.flatMap(f => f.getEdges()));
-        const endEdges = dedupEdgesByIsSame(endFaces.flatMap(f => f.getEdges()));
-        const excludedForSide = [...startEdges, ...endEdges];
-        const sideEdges = dedupEdgesByIsSame(sideFaces.flatMap(f => f.getEdges())
-            .filter(e => !excludedForSide.some(ex => ex.getShape().IsSame(e.getShape()))));
-        const internalEdges = dedupEdgesByIsSame(internalFaces.flatMap(f => f.getEdges()));
-        const capEdges = dedupEdgesByIsSame(capFaces.flatMap(f => f.getEdges()));
+        const startEdges = dedupEdgesByMap(startFaces.flatMap(f => f.getEdges()));
+        const endEdges = dedupEdgesByMap(endFaces.flatMap(f => f.getEdges()));
+        const sideEdges = dedupEdgesByMapExcluding(sideFaces.flatMap(f => f.getEdges()), [...startEdges, ...endEdges]);
+        const internalEdges = dedupEdgesByMap(internalFaces.flatMap(f => f.getEdges()));
+        const capEdges = dedupEdgesByMap(capFaces.flatMap(f => f.getEdges()));
         this.setState('start-edges', startEdges);
         this.setState('end-edges', endEdges);
         this.setState('side-edges', sideEdges);