fluidcad 0.0.26 → 0.0.27

package/lib/dist/common/shape-factory.d.ts

@@ -4,5 +4,5 @@ import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 export declare class ShapeFactory {
-    static fromShape(shape: TopoDS_Shape): Wire | Edge | Solid | Face;
+    static fromShape(shape: TopoDS_Shape): Wire | Edge | Face | Solid;
 }

package/lib/dist/common/shapes.d.ts

@@ -3,4 +3,3 @@ export { Edge } from "./edge.js";
 export { Vertex } from "./vertex.js";
 export { Face } from "./face.js";
 export { Solid } from "./solid.js";
-export { SolidFace } from "./solid-face.js";

package/lib/dist/common/shapes.js

@@ -3,4 +3,3 @@ export { Edge } from "./edge.js";
 export { Vertex } from "./vertex.js";
 export { Face } from "./face.js";
 export { Solid } from "./solid.js";
-export { SolidFace } from "./solid-face.js";

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

@@ -2,45 +2,44 @@ import { IExtrude, ISceneObject } from "./interfaces.js";
 interface ExtrudeFunction {
     /**
      * Extrudes the last sketch with a default distance.
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch by a given distance.
+     * Extrudes by a given distance.
      * @param distance - The extrusion distance
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (distance: number, target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch between two distances.
+     * Extrudes between two distances.
      * @param distance1 - The first extrusion distance
      * @param distance2 - The second extrusion distance
-     * @param target - The sketch to extrude
      */
     (distance1: number, distance2: number): IExtrude;
     /**
-     * Extrudes the given sketch between two distances.
+     * Extrudes between two distances.
      * @param distance1 - The first extrusion distance
      * @param distance2 - The second extrusion distance
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (distance1: number, distance2: number, target: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to a specific face.
+     * Extrudes up to a specific face.
      * @param face - A face selection to extrude up to
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: ISceneObject, target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to the first intersecting face.
+     * Extrudes up to the first intersecting face.
      * @param face - The literal `'first-face'`
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: 'first-face', target?: ISceneObject): IExtrude;
     /**
-     * Extrudes the last sketch up to the last intersecting face.
+     * Extrudes up to the last intersecting face.
      * @param face - The literal `'last-face'`
-     * @param target - The sketch to extrude
+     * @param target - The sketch or face-bearing scene object to extrude
      */
     (face: 'last-face', target?: ISceneObject): IExtrude;
 }

package/lib/dist/core/extrude.js

@@ -3,9 +3,22 @@ import { registerBuilder } from "../index.js";
 import { Extrude } from "../features/extrude.js";
 import { ExtrudeTwoDistances } from "../features/extrude-two-distances.js";
 import { ExtrudeToFace } from "../features/extrude-to-face.js";
+import { SelectSceneObject } from "../features/select.js";
 function isExtrudable(obj) {
     return obj instanceof SceneObject && obj.isExtrudable();
 }
+function isFaceSource(obj) {
+    if (!(obj instanceof SceneObject)) {
+        return false;
+    }
+    if (isExtrudable(obj)) {
+        return false;
+    }
+    if (obj instanceof SelectSceneObject) {
+        return obj.shapeType() === 'face';
+    }
+    return true;
+}
 function build(context) {
     function doExtrude(params, extrudable) {
         const defaultDistance = 25;
@@ -41,8 +54,13 @@ function build(context) {
     return function extrude() {
         const args = [...arguments];
         let extrudable;
-        if (args.length > 0 && isExtrudable(args[args.length - 1])) {
+        const last = args.length > 0 ? args[args.length - 1] : undefined;
+        if (last !== undefined && isExtrudable(last)) {
+            extrudable = args.pop();
+        }
+        else if (last !== undefined && args.length >= 2 && isFaceSource(last)) {
             extrudable = args.pop();
+            context.addSceneObject(extrudable);
         }
         else {
             extrudable = context.getLastExtrudable() || undefined;

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

@@ -1,3 +1,4 @@
 import { ISceneObject } from "./interfaces.js";
-declare function part(name: string, callback: () => void): ISceneObject;
+type Extend<T> = T extends object ? T : {};
+declare function part<T>(name: string, callback: () => T): ISceneObject & Extend<T>;
 export default part;

package/lib/dist/core/part.js

@@ -12,8 +12,11 @@ function part(name, callback) {
         partObj.setSourceLocation(sourceLocation);
     }
     scene.startProgressiveContainer(partObj);
-    callback();
+    const extensions = callback();
     scene.endProgressiveContainer();
+    if (extensions && typeof extensions === 'object') {
+        Object.assign(partObj, extensions);
+    }
     return partObj;
 }
 export default part;

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

@@ -1,24 +1,25 @@
 import { PlaneLike } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
+type Extend<T> = T extends object ? T : {};
 interface SketchFunction {
     /**
      * Draws 2D geometry on a standard plane.
      * @param plane - The plane to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (plane: PlaneLike, sketcher: () => void): ISceneObject;
+    <T>(plane: PlaneLike, sketcher: () => T): ISceneObject & Extend<T>;
     /**
      * Draws 2D geometry on a face selection.
      * @param face - The face to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (face: ISceneObject, sketcher: () => void): ISceneObject;
+    <T>(face: ISceneObject, sketcher: () => T): ISceneObject & Extend<T>;
     /**
      * Draws 2D geometry on an existing Plane object.
      * @param plane - The Plane object to sketch on
      * @param sketcher - Callback containing sketch operations
      */
-    (plane: IPlane, sketcher: () => void): ISceneObject;
+    <T>(plane: IPlane, sketcher: () => T): ISceneObject & Extend<T>;
 }
 declare const _default: SketchFunction;
 export default _default;

package/lib/dist/core/sketch.js

@@ -26,8 +26,11 @@ function build(context) {
         }
         const sketch = new Sketch(planeObj);
         context.startProgressiveContainer(sketch);
-        sketcher();
+        const extensions = sketcher();
         context.endProgressiveContainer();
+        if (extensions && typeof extensions === 'object') {
+            Object.assign(sketch, extensions);
+        }
         return sketch;
     };
 }

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

@@ -10,14 +10,20 @@ import { FaceFilterBuilder } from "../filters/face/face-filter.js";
 import { EdgeFilterBuilder } from "../filters/edge/edge-filter.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;

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

@@ -1,3 +1,4 @@
+import { Face } from "../common/face.js";
 import { SceneObject } from "../common/scene-object.js";
 import { LazySelectionSceneObject } from "./lazy-scene-object.js";
 import { normalizePoint2D } from "../helpers/normalize.js";
@@ -9,19 +10,51 @@ import { ShapeFilter } from "../filters/filter.js";
 import { EdgeOps } from "../oc/edge-ops.js";
 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) => {
@@ -230,7 +263,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,7 +85,7 @@ 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);
         }
@@ -128,7 +134,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 +171,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 +227,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 +249,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 +262,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 +273,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 +301,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;
@@ -112,7 +118,7 @@ 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);
@@ -132,13 +138,13 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         this.addShapes(fusionResult.newShapes);
     }
     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 +156,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 +174,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;

package/lib/dist/features/extrude.js

@@ -9,20 +9,32 @@ import { ExtrudeThroughAll } from "./infinite-extrude.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class Extrude extends ExtrudeBase {
     distance;
-    constructor(distance, extrudable) {
-        super(extrudable);
+    constructor(distance, source) {
+        super(source);
         this.distance = distance;
     }
     build(context) {
-        const plane = this.extrudable.getPlane();
+        const tBuild = performance.now();
+        let t = performance.now();
+        const plane = this.getSourcePlane();
+        console.log(`[perf] Extrude.getSourcePlane: ${(performance.now() - t).toFixed(1)} ms`);
+        t = performance.now();
         const pickedFaces = this.resolvePickedFaces(plane);
+        console.log(`[perf] Extrude.resolvePickedFaces: ${(performance.now() - t).toFixed(1)} ms`);
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
         let faces;
         let inwardEdges;
         let outwardEdges;
-        if (this.isThin()) {
+        t = performance.now();
+        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;
@@ -31,6 +43,7 @@ export class Extrude extends ExtrudeBase {
         else {
             faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
         }
+        console.log(`[perf] Extrude.resolveFaces (faces=${faces.length}, faceSourced=${this.isFaceSourced()}): ${(performance.now() - t).toFixed(1)} ms`);
         if (this._operationMode === 'remove') {
             this.buildRemove(faces, plane, context);
         }
@@ -40,11 +53,16 @@ export class Extrude extends ExtrudeBase {
         else {
             this.buildAdd(faces, plane, context, inwardEdges, outwardEdges);
         }
+        console.log(`[perf] Extrude.build TOTAL: ${(performance.now() - tBuild).toFixed(1)} ms`);
     }
     buildAdd(faces, plane, context, inwardEdges, outwardEdges) {
+        let t = performance.now();
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        console.log(`[perf] Extrude.buildAdd.resolveFusionScope (n=${sceneObjects.length}): ${(performance.now() - t).toFixed(1)} ms`);
+        t = performance.now();
         const extruder = new Extruder(faces, plane, this.distance, this.getDraft(), this.getEndOffset());
         let extrusions = extruder.extrude();
+        console.log(`[perf] Extrude.buildAdd.extruder.extrude (extrusions=${extrusions.length}): ${(performance.now() - t).toFixed(1)} ms`);
         let sideFaces = extruder.getSideFaces();
         let internalFaces = extruder.getInternalFaces();
         let capFaces = [];
@@ -59,12 +77,15 @@ export class Extrude 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);
+        console.log("Extrusions before fusion:", extrusions.length);
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
             return;
         }
-        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        const tFuse = performance.now();
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions, this.isFaceSourced() ? { glue: 'full' } : undefined);
+        console.log(`[perf] Extrude.buildAdd.fuseWithSceneObjects: ${(performance.now() - tFuse).toFixed(1)} ms`);
         for (const modifiedShape of fusionResult.modifiedShapes) {
             if (!modifiedShape.object) {
                 continue;
@@ -158,7 +179,7 @@ export class Extrude 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 (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
             return;
@@ -179,6 +200,9 @@ export class Extrude extends ExtrudeBase {
         if (this._symmetric) {
             // Symmetric cut: create tool centered on sketch plane
             if (isThroughAll) {
+                if (this.isFaceSourced()) {
+                    throw new Error("through-all is not supported with a face-sourced extrude");
+                }
                 const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, true, faces);
                 toolShapes = extrudeThroughAll.build();
             }
@@ -193,6 +217,9 @@ export class Extrude extends ExtrudeBase {
             }
         }
         else if (isThroughAll) {
+            if (this.isFaceSourced()) {
+                throw new Error("through-all is not supported with a face-sourced extrude");
+            }
             const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true, faces);
             toolShapes = extrudeThroughAll.build();
         }
@@ -201,17 +228,17 @@ export class Extrude extends ExtrudeBase {
             const extruder = new Extruder(faces, plane, distance, this.getDraft(), this.getEndOffset());
             toolShapes = extruder.extrude();
         }
-        this.extrudable.removeShapes(this);
+        this.getSource()?.removeShapes(this);
         cutWithSceneObjects(scope, toolShapes, plane, this.distance, this);
     }
     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 Extrude(this.distance, extrudable).syncWith(this);
+        const source = this.getSource();
+        const remapped = source ? (remap.get(source) || source) : undefined;
+        return new Extrude(this.distance, remapped).syncWith(this);
     }
     compareTo(other) {
         if (!(other instanceof Extrude)) {
@@ -220,7 +247,12 @@ export class Extrude 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 (this.distance !== other.distance) {
@@ -242,7 +274,7 @@ export class Extrude extends ExtrudeBase {
     }
     serialize() {
         return {
-            extrudable: this.extrudable.serialize(),
+            extrudable: this.getSource()?.serialize(),
             distance: this.distance,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             symmetric: this._symmetric || undefined,