fluidcad 0.0.26 → 0.0.28

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

@@ -1,5 +1,6 @@
 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 { Extrudable } from "../helpers/types.js";
 import { IExtrude } from "../core/interfaces.js";
@@ -8,16 +9,23 @@ import { Point2DLike } from "../math/point.js";
 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";
 export declare abstract class ExtrudeBase extends SceneObject implements IExtrude {
     protected _extrudable: Extrudable | null;
+    protected _faceSource: SceneObject | null;
     protected _draft?: number | [number, number];
     protected _endOffset?: number;
     protected _drill?: boolean;
     protected _picking: boolean;
     protected _pickPoints: LazyVertex[];
     protected _thin?: [number] | [number, number];
-    constructor(extrudable?: Extrudable);
+    constructor(source?: Extrudable | SceneObject);
     get extrudable(): Extrudable;
+    get faceSource(): SceneObject | null;
+    isFaceSourced(): boolean;
+    getSource(): SceneObject | null;
+    getSourcePlane(): Plane | null;
+    getSourceFaces(): Face[];
     startFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
     endFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
     startEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
@@ -33,6 +41,40 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     internalEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
     capFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
     capEdges(...args: number[] | EdgeFilterBuilder[]): SceneObject;
+    /**
+     * Read edges for a classification category, preferring the pre-computed
+     * state key (set by `classifyExtrudeEdges` during build) and falling back
+     * to deriving from the corresponding face-category state (for peer ops that
+     * haven't opted into the unified classification step yet).
+     */
+    private getClassifiedEdges;
+    /**
+     * Remap the state-stored face category arrays through a fusion's tool-side
+     * history so each face reference points at the actual post-fusion face in
+     * the final solid. Call after `fuseWithSceneObjects` returns a `toolHistory`.
+     */
+    protected remapClassifiedFaces(history: ShapeHistory): void;
+    /**
+     * Record every face/edge of the given shapes as additions on this operation.
+     * Used by 3D ops in the "no scene fusion" path — when the tools land
+     * unchanged in the scene, every face/edge is brand new from this op's POV.
+     */
+    protected recordShapeFacesAndEdgesAsAdditions(shapes: Shape[]): void;
+    /**
+     * One-shot edge classification: derive start/end/side/internal/cap edges
+     * from the already-classified face arrays in state and store them as
+     * `start-edges`, `end-edges`, `side-edges`, `internal-edges`, `cap-edges`.
+     *
+     * Call this once after face classification (and after any post-fusion
+     * face remapping) so that the selection accessors can just read the
+     * pre-computed arrays instead of re-deriving on every access. Matches
+     * the classification step from the spec: "Classify the new edges and
+     * faces created by the operation".
+     *
+     * Side edges are the edges of side faces minus any edge that's also on
+     * a start/end face (those already belong to start-edges / end-edges).
+     */
+    protected classifyExtrudeEdges(): void;
     private buildSuffix;
     private resolveFaces;
     private resolveEdges;

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

@@ -1,3 +1,5 @@
+import { Face } from "../common/face.js";
+import { Edge } from "../common/edge.js";
 import { SceneObject } from "../common/scene-object.js";
 import { LazySelectionSceneObject } from "./lazy-scene-object.js";
 import { normalizePoint2D } from "../helpers/normalize.js";
@@ -7,21 +9,65 @@ import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
 import { ShapeFilter } from "../filters/filter.js";
 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) {
+    const result = [];
+    for (const edge of edges) {
+        if (!result.some(r => r.getShape().IsSame(edge.getShape()))) {
+            result.push(edge);
+        }
+    }
+    return result;
+}
 export class ExtrudeBase extends SceneObject {
     _extrudable = null;
+    _faceSource = null;
     _draft;
     _endOffset;
     _drill = true;
     _picking = false;
     _pickPoints = [];
     _thin;
-    constructor(extrudable) {
+    constructor(source) {
         super();
-        this._extrudable = extrudable ?? null;
+        if (source) {
+            if (source.isExtrudable()) {
+                this._extrudable = source;
+            }
+            else {
+                this._faceSource = source;
+            }
+        }
     }
     get extrudable() {
         return this._extrudable;
     }
+    get faceSource() {
+        return this._faceSource;
+    }
+    isFaceSourced() {
+        return this._faceSource !== null;
+    }
+    getSource() {
+        return this._extrudable ?? this._faceSource;
+    }
+    getSourcePlane() {
+        if (this._extrudable) {
+            return this._extrudable.getPlane();
+        }
+        const faces = this.getSourceFaces();
+        return faces.length > 0 ? faces[0].getPlane() : null;
+    }
+    getSourceFaces() {
+        if (!this._faceSource) {
+            return [];
+        }
+        return this._faceSource.getShapes()
+            .flatMap(s => s.getSubShapes('face'))
+            .filter((f) => f instanceof Face);
+    }
     startFaces(...args) {
         const suffix = this.buildSuffix('start-faces', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
@@ -47,19 +93,10 @@ export class ExtrudeBase extends SceneObject {
     startEdges(...args) {
         const suffix = this.buildSuffix('start-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            if (this._operationMode === 'remove') {
-                const edges = parent.getState('start-edges') || [];
-                const transform = parent.getTransform();
-                const originalEdges = transform
-                    ? (this.getState('start-edges') || [])
-                    : null;
-                return this.resolveEdges(edges, args, transform, originalEdges);
-            }
-            const faces = parent.getState('start-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'start-edges', 'start-faces');
             const transform = parent.getTransform();
             const originalEdges = transform
-                ? (this.getState('start-faces') || []).flatMap(f => f.getEdges())
+                ? this.getClassifiedEdges(this, 'start-edges', 'start-faces')
                 : null;
             return this.resolveEdges(edges, args, transform, originalEdges);
         }, this);
@@ -67,19 +104,10 @@ export class ExtrudeBase extends SceneObject {
     endEdges(...args) {
         const suffix = this.buildSuffix('end-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            if (this._operationMode === 'remove') {
-                const edges = parent.getState('end-edges') || [];
-                const transform = parent.getTransform();
-                const originalEdges = transform
-                    ? (this.getState('end-edges') || [])
-                    : null;
-                return this.resolveEdges(edges, args, transform, originalEdges);
-            }
-            const faces = parent.getState('end-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'end-edges', 'end-faces');
             const transform = parent.getTransform();
             const originalEdges = transform
-                ? (this.getState('end-faces') || []).flatMap(f => f.getEdges())
+                ? this.getClassifiedEdges(this, 'end-edges', 'end-faces')
                 : null;
             return this.resolveEdges(edges, args, transform, originalEdges);
         }, this);
@@ -98,13 +126,17 @@ export class ExtrudeBase extends SceneObject {
     sideEdges(...args) {
         const suffix = this.buildSuffix('side-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const classified = parent.getState('side-edges');
+            if (classified !== undefined) {
+                return this.resolveEdges(classified, args);
+            }
+            // Fallback for peer ops that haven't called classifyExtrudeEdges: derive on the fly.
             const sideFaces = parent.getState('side-faces') || [];
             const startFaces = parent.getState('start-faces') || [];
             const endFaces = parent.getState('end-faces') || [];
             const excludedEdges = [...startFaces, ...endFaces].flatMap(f => f.getEdges());
-            const edges = sideFaces.flatMap(f => f.getEdges())
-                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape())))
-                .filter((e, i, arr) => arr.findIndex(o => o.getShape().IsSame(e.getShape())) === i);
+            const edges = dedupEdgesByIsSame(sideFaces.flatMap(f => f.getEdges())
+                .filter(e => !excludedEdges.some(ex => e.getShape().IsSame(ex.getShape()))));
             return this.resolveEdges(edges, args);
         }, this);
     }
@@ -136,12 +168,7 @@ export class ExtrudeBase extends SceneObject {
     internalEdges(...args) {
         const suffix = this.buildSuffix('internal-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            if (this._operationMode === 'remove') {
-                const edges = parent.getState('internal-edges') || [];
-                return this.resolveEdges(edges, args);
-            }
-            const faces = parent.getState('internal-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'internal-edges', 'internal-faces');
             return this.resolveEdges(edges, args);
         }, this);
     }
@@ -159,11 +186,89 @@ export class ExtrudeBase extends SceneObject {
     capEdges(...args) {
         const suffix = this.buildSuffix('cap-edges', args);
         return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
-            const faces = parent.getState('cap-faces') || [];
-            const edges = faces.flatMap(f => f.getEdges());
+            const edges = this.getClassifiedEdges(parent, 'cap-edges', 'cap-faces');
             return this.resolveEdges(edges, args);
         }, this);
     }
+    /**
+     * Read edges for a classification category, preferring the pre-computed
+     * state key (set by `classifyExtrudeEdges` during build) and falling back
+     * to deriving from the corresponding face-category state (for peer ops that
+     * haven't opted into the unified classification step yet).
+     */
+    getClassifiedEdges(source, edgeKey, faceKey) {
+        const classified = source.getState(edgeKey);
+        if (classified !== undefined) {
+            return classified;
+        }
+        const faces = source.getState(faceKey) || [];
+        return dedupEdgesByIsSame(faces.flatMap(f => f.getEdges()));
+    }
+    /**
+     * Remap the state-stored face category arrays through a fusion's tool-side
+     * history so each face reference points at the actual post-fusion face in
+     * the final solid. Call after `fuseWithSceneObjects` returns a `toolHistory`.
+     */
+    remapClassifiedFaces(history) {
+        const keys = ['start-faces', 'end-faces', 'side-faces', 'internal-faces', 'cap-faces'];
+        for (const key of keys) {
+            const faces = this.getState(key);
+            if (faces && faces.length > 0) {
+                this.setState(key, ShapeHistoryTracker.remapFaces(faces, history));
+            }
+        }
+    }
+    /**
+     * Record every face/edge of the given shapes as additions on this operation.
+     * Used by 3D ops in the "no scene fusion" path — when the tools land
+     * unchanged in the scene, every face/edge is brand new from this op's POV.
+     */
+    recordShapeFacesAndEdgesAsAdditions(shapes) {
+        const oc = getOC();
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        for (const shape of shapes) {
+            for (const raw of Explorer.findShapes(shape.getShape(), FACE)) {
+                this.recordAddedFace(Face.fromTopoDSFace(Explorer.toFace(raw)), this);
+            }
+            for (const raw of Explorer.findShapes(shape.getShape(), EDGE)) {
+                this.recordAddedEdge(Edge.fromTopoDSEdge(Explorer.toEdge(raw)), this);
+            }
+        }
+    }
+    /**
+     * One-shot edge classification: derive start/end/side/internal/cap edges
+     * from the already-classified face arrays in state and store them as
+     * `start-edges`, `end-edges`, `side-edges`, `internal-edges`, `cap-edges`.
+     *
+     * Call this once after face classification (and after any post-fusion
+     * face remapping) so that the selection accessors can just read the
+     * pre-computed arrays instead of re-deriving on every access. Matches
+     * the classification step from the spec: "Classify the new edges and
+     * faces created by the operation".
+     *
+     * Side edges are the edges of side faces minus any edge that's also on
+     * a start/end face (those already belong to start-edges / end-edges).
+     */
+    classifyExtrudeEdges() {
+        const startFaces = this.getState('start-faces') || [];
+        const endFaces = this.getState('end-faces') || [];
+        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()));
+        this.setState('start-edges', startEdges);
+        this.setState('end-edges', endEdges);
+        this.setState('side-edges', sideEdges);
+        this.setState('internal-edges', internalEdges);
+        this.setState('cap-edges', capEdges);
+    }
     buildSuffix(prefix, args) {
         if (args.length === 0) {
             return prefix;
@@ -230,7 +335,7 @@ export class ExtrudeBase extends SceneObject {
         return this._thin;
     }
     serializePickFields() {
-        const plane = this._extrudable?.getPlane();
+        const plane = this.getSourcePlane();
         return {
             picking: this.isPicking() || undefined,
             pickPoints: this.isPicking()

package/lib/dist/features/extrude-to-face.d.ts

@@ -4,7 +4,7 @@ import { Extrudable } from "../helpers/types.js";
 import { Point } from "../math/point.js";
 export declare class ExtrudeToFace extends ExtrudeBase {
     face: SceneObject | 'first-face' | 'last-face';
-    constructor(face: SceneObject | 'first-face' | 'last-face', extrudable?: Extrudable);
+    constructor(face: SceneObject | 'first-face' | 'last-face', source?: Extrudable | SceneObject);
     build(context: BuildSceneObjectContext): void;
     private createAdvancedExtrude;
     private resizePlanarFace;

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

@@ -13,14 +13,14 @@ import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { Point } from "../math/point.js";
 export class ExtrudeToFace extends ExtrudeBase {
     face;
-    constructor(face, extrudable) {
-        super(extrudable);
+    constructor(face, source) {
+        super(source);
         this.face = face;
     }
     build(context) {
         const allSceneObjects = context.getSceneObjects();
         const sceneObjects = this.resolveFusionScope(allSceneObjects);
-        const plane = this.extrudable.getPlane();
+        const plane = this.getSourcePlane();
         const pickedFaces = this.resolvePickedFaces(plane);
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
@@ -35,7 +35,13 @@ export class ExtrudeToFace extends ExtrudeBase {
         let faces;
         let inwardEdges;
         let outwardEdges;
-        if (this.isThin()) {
+        if (this.isFaceSourced()) {
+            if (this.isThin()) {
+                throw new Error("thin() is not supported with a face-sourced extrude");
+            }
+            faces = pickedFaces ?? this.getSourceFaces();
+        }
+        else if (this.isThin()) {
             const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
             faces = thinResult.faces;
             inwardEdges = thinResult.inwardEdges;
@@ -79,26 +85,37 @@ export class ExtrudeToFace extends ExtrudeBase {
         this.setState('side-faces', allSideFaces);
         this.setState('internal-faces', allInternalFaces);
         this.setState('cap-faces', allCapFaces);
-        this.extrudable.removeShapes(this);
+        this.getSource()?.removeShapes(this);
         if (this.face instanceof SceneObject) {
             this.face.removeShapes(this);
         }
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(allSceneObjects);
-            cutWithSceneObjects(scope, solids, plane, 0, this);
+            cutWithSceneObjects(scope, solids, plane, 0, this, { recordHistoryFor: this });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         if (sceneObjects.length === 0) {
             this.addShapes(solids);
+            this.recordShapeFacesAndEdgesAsAdditions(solids);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, solids);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, solids, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (modifiedShape.object) {
                 modifiedShape.object.removeShape(modifiedShape.shape, this);
             }
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     createAdvancedExtrude(sourceFace, targetFace, isPlanar, sketchPlane) {
         const targetDistance = this.computeSignedDistanceToFace(targetFace, sketchPlane);
@@ -128,7 +145,7 @@ export class ExtrudeToFace extends ExtrudeBase {
     resizePlanarFace(targetFace) {
         const endOffset = this.getEndOffset();
         if (endOffset) {
-            const dir = this.extrudable.getPlane().normal.reverse();
+            const dir = this.getSourcePlane().normal.reverse();
             return FaceQuery.makeInfinitePlanarFace(targetFace, endOffset, dir);
         }
         return FaceQuery.makeInfinitePlanarFace(targetFace);
@@ -165,7 +182,7 @@ export class ExtrudeToFace extends ExtrudeBase {
     }
     splitShapesByFace(extrusions, targetFace) {
         const result = [];
-        const sourcePlane = this.extrudable.getPlane();
+        const sourcePlane = this.getSourcePlane();
         for (const shape of extrusions) {
             const solids = BooleanOps.splitShape(shape, targetFace);
             if (solids.length === 1) {
@@ -221,10 +238,11 @@ export class ExtrudeToFace extends ExtrudeBase {
         }
     }
     getFirstOrLastFace(sceneObjects, mode) {
-        const plane = this.extrudable.getPlane();
+        const plane = this.getSourcePlane();
+        const source = this.getSource();
         const allFaces = [];
         for (const obj of sceneObjects) {
-            if (obj === this.extrudable) {
+            if (obj === source) {
                 continue;
             }
             for (const shape of obj.getShapes()) {
@@ -242,8 +260,9 @@ export class ExtrudeToFace extends ExtrudeBase {
     }
     getDependencies() {
         const deps = [];
-        if (this.extrudable) {
-            deps.push(this.extrudable);
+        const source = this.getSource();
+        if (source) {
+            deps.push(source);
         }
         if (this.face instanceof SceneObject) {
             deps.push(this.face);
@@ -254,10 +273,9 @@ export class ExtrudeToFace extends ExtrudeBase {
         const newFace = this.face instanceof SceneObject
             ? (remap.get(this.face) || this.face)
             : this.face;
-        const extrudable = this.extrudable
-            ? (remap.get(this.extrudable) || this.extrudable)
-            : undefined;
-        return new ExtrudeToFace(newFace, extrudable).syncWith(this);
+        const source = this.getSource();
+        const remapped = source ? (remap.get(source) || source) : undefined;
+        return new ExtrudeToFace(newFace, remapped).syncWith(this);
     }
     compareTo(other) {
         if (!(other instanceof ExtrudeToFace)) {
@@ -266,7 +284,12 @@ export class ExtrudeToFace extends ExtrudeBase {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (!this.extrudable.compareTo(other.extrudable)) {
+        const thisSource = this.getSource();
+        const otherSource = other.getSource();
+        if (!thisSource !== !otherSource) {
+            return false;
+        }
+        if (thisSource && otherSource && !thisSource.compareTo(otherSource)) {
             return false;
         }
         if (typeof (this.face) !== typeof (other.face)) {
@@ -289,7 +312,7 @@ export class ExtrudeToFace extends ExtrudeBase {
     serialize() {
         return {
             sheptType: 'wire',
-            extrudable: this.extrudable.serialize(),
+            extrudable: this.getSource()?.serialize(),
             draft: this.getDraft(),
             endOffset: this.getEndOffset(),
             face: typeof (this.face) === 'string' ? this.face : 'selection',

package/lib/dist/features/extrude-two-distances.d.ts

@@ -4,7 +4,7 @@ import { Extrudable } from "../helpers/types.js";
 export declare class ExtrudeTwoDistances extends ExtrudeBase {
     distance1: number;
     distance2: number;
-    constructor(distance1: number, distance2: number, extrudable?: Extrudable);
+    constructor(distance1: number, distance2: number, source?: Extrudable | SceneObject);
     build(context: BuildSceneObjectContext): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;

package/lib/dist/features/extrude-two-distances.js

@@ -9,14 +9,14 @@ import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class ExtrudeTwoDistances extends ExtrudeBase {
     distance1;
     distance2;
-    constructor(distance1, distance2, extrudable) {
-        super(extrudable);
+    constructor(distance1, distance2, source) {
+        super(source);
         this.distance1 = distance1;
         this.distance2 = distance2;
     }
     build(context) {
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
-        const plane = this.extrudable.getPlane();
+        const plane = this.getSourcePlane();
         const pickedFaces = this.resolvePickedFaces(plane);
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
@@ -24,7 +24,13 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         let faces;
         let inwardEdges;
         let outwardEdges;
-        if (this.isThin()) {
+        if (this.isFaceSourced()) {
+            if (this.isThin()) {
+                throw new Error("thin() is not supported with a face-sourced extrude");
+            }
+            faces = pickedFaces ?? this.getSourceFaces();
+        }
+        else if (this.isThin()) {
             const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
             faces = thinResult.faces;
             inwardEdges = thinResult.inwardEdges;
@@ -43,7 +49,9 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         const extrusions2 = extruder2.extrude();
         const endFaces = extruder2.getEndFaces();
         const all = [...extrusions1, ...extrusions2];
-        const { result: extrusions } = BooleanOps.fuse(all);
+        const halvesFuse = BooleanOps.fuse(all);
+        const extrusions = halvesFuse.result;
+        halvesFuse.dispose();
         const remainingFaces = [];
         const fusedStartFaces = [];
         const fusedEndFaces = [];
@@ -112,17 +120,25 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.setState('side-faces', sideFaces);
         this.setState('internal-faces', internalFaces);
         this.setState('cap-faces', capFaces);
-        this.extrudable.removeShapes(this);
+        this.getSource()?.removeShapes(this);
         if (this._operationMode === 'remove') {
             const scope = this.resolveFusionScope(context.getSceneObjects());
-            cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this);
+            cutWithSceneObjects(scope, extrusions, plane, this.distance1 + this.distance2, this, {
+                recordHistoryFor: this,
+            });
+            this.setFinalShapes(this.getShapes());
             return;
         }
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
+            this.recordShapeFacesAndEdgesAsAdditions(extrusions);
+            this.classifyExtrudeEdges();
+            this.setFinalShapes(this.getShapes());
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, {
+            recordHistoryFor: this,
+        });
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (!modifiedShape.object) {
                 continue;
@@ -130,15 +146,20 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
             modifiedShape.object.removeShape(modifiedShape.shape, this);
         }
         this.addShapes(fusionResult.newShapes);
+        if (fusionResult.toolHistory) {
+            this.remapClassifiedFaces(fusionResult.toolHistory);
+        }
+        this.classifyExtrudeEdges();
+        this.setFinalShapes(this.getShapes());
     }
     getDependencies() {
-        return this.extrudable ? [this.extrudable] : [];
+        const source = this.getSource();
+        return source ? [source] : [];
     }
     createCopy(remap) {
-        const extrudable = this.extrudable
-            ? (remap.get(this.extrudable) || this.extrudable)
-            : undefined;
-        return new ExtrudeTwoDistances(this.distance1, this.distance2, extrudable).syncWith(this);
+        const source = this.getSource();
+        const remapped = source ? (remap.get(source) || source) : undefined;
+        return new ExtrudeTwoDistances(this.distance1, this.distance2, remapped).syncWith(this);
     }
     compareTo(other) {
         if (!(other instanceof ExtrudeTwoDistances)) {
@@ -150,7 +171,12 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         if (this.distance1 !== other.distance1 || this.distance2 !== other.distance2) {
             return false;
         }
-        if (!this.extrudable.compareTo(other.extrudable)) {
+        const thisSource = this.getSource();
+        const otherSource = other.getSource();
+        if (!thisSource !== !otherSource) {
+            return false;
+        }
+        if (thisSource && otherSource && !thisSource.compareTo(otherSource)) {
             return false;
         }
         return true;
@@ -163,7 +189,7 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
     }
     serialize() {
         return {
-            extrudable: this.extrudable.serialize(),
+            extrudable: this.getSource()?.serialize(),
             distance1: this.distance1,
             distance2: this.distance2,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,

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

@@ -3,7 +3,7 @@ import { Extrudable } from "../helpers/types.js";
 import { ExtrudeBase } from "./extrude-base.js";
 export declare class Extrude extends ExtrudeBase {
     distance: number;
-    constructor(distance: number, extrudable?: Extrudable);
+    constructor(distance: number, source?: Extrudable | SceneObject);
     build(context: BuildSceneObjectContext): void;
     private buildAdd;
     private buildSymmetric;