fluidcad 0.0.27 → 0.0.28

package/lib/dist/common/scene-object.d.ts

@@ -1,4 +1,6 @@
 import { Shape, ShapeFilter } from "./shape.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
@@ -8,6 +10,19 @@ export type SourceLocation = {
     line: number;
     column: number;
 };
+export type AdditionRecord<T> = {
+    shape: T;
+    addedBy: SceneObject;
+};
+export type RemovalRecord<T> = {
+    shape: T;
+    removedBy: SceneObject;
+};
+export type ModificationRecord<T> = {
+    sources: T[];
+    results: T[];
+    modifiedBy: SceneObject;
+};
 export interface Comparable<T> {
     compareTo(other: T): boolean;
 }
@@ -74,11 +89,41 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     private set addedShapes(value);
     private get removedShapes();
     private set removedShapes(value);
+    private get addedFaces();
+    private set addedFaces(value);
+    private get modifiedFaces();
+    private set modifiedFaces(value);
+    private get removedFaces();
+    private set removedFaces(value);
+    private get addedEdges();
+    private set addedEdges(value);
+    private get modifiedEdges();
+    private set modifiedEdges(value);
+    private get removedEdges();
+    private set removedEdges(value);
+    private get finalShapes();
+    private set finalShapes(value);
     getUniqueType(): string;
     addShape(shape: Shape): void;
     addShapes(shapes: Shape[]): void;
     removeShape(shape: Shape, removedBy: SceneObject): void;
     removeShapes(removedBy: SceneObject, force?: boolean): void;
+    recordAddedFace(face: Face, addedBy: SceneObject): void;
+    recordAddedEdge(edge: Edge, addedBy: SceneObject): void;
+    recordModifiedFaces(sources: Face[], results: Face[], modifiedBy: SceneObject): void;
+    recordModifiedEdges(sources: Edge[], results: Edge[], modifiedBy: SceneObject): void;
+    recordRemovedFace(face: Face, removedBy: SceneObject): void;
+    recordRemovedEdge(edge: Edge, removedBy: SceneObject): void;
+    private ownsFace;
+    private ownsEdge;
+    getAddedFaces(scope?: Set<SceneObject>): Face[];
+    getModifiedFaces(scope?: Set<SceneObject>): ModificationRecord<Face>[];
+    getRemovedFaces(scope?: Set<SceneObject>): Face[];
+    getAddedEdges(scope?: Set<SceneObject>): Edge[];
+    getModifiedEdges(scope?: Set<SceneObject>): ModificationRecord<Edge>[];
+    getRemovedEdges(scope?: Set<SceneObject>): Edge[];
+    setFinalShapes(shapes: Shape[]): void;
+    getFinalShapes(): Shape[];
     getOwnShapes(filter?: ShapeFilter, scope?: Set<SceneObject>): Shape[];
     getChildShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];
     getShapes(filter?: ShapeFilter, type?: ShapeType): Shape[];

package/lib/dist/common/scene-object.js

@@ -21,6 +21,13 @@ export class SceneObject {
         this.state = new Map();
         this.state.set('addedShapes', []);
         this.state.set('removedShapes', []);
+        this.state.set('addedFaces', []);
+        this.state.set('modifiedFaces', []);
+        this.state.set('removedFaces', []);
+        this.state.set('addedEdges', []);
+        this.state.set('modifiedEdges', []);
+        this.state.set('removedEdges', []);
+        this.state.set('finalShapes', []);
         this._id = randomUUID().toString();
     }
     get id() {
@@ -208,6 +215,48 @@ export class SceneObject {
     set removedShapes(shapes) {
         this.state.set('removedShapes', shapes);
     }
+    get addedFaces() {
+        return this.state.get('addedFaces');
+    }
+    set addedFaces(records) {
+        this.state.set('addedFaces', records);
+    }
+    get modifiedFaces() {
+        return this.state.get('modifiedFaces');
+    }
+    set modifiedFaces(records) {
+        this.state.set('modifiedFaces', records);
+    }
+    get removedFaces() {
+        return this.state.get('removedFaces');
+    }
+    set removedFaces(records) {
+        this.state.set('removedFaces', records);
+    }
+    get addedEdges() {
+        return this.state.get('addedEdges');
+    }
+    set addedEdges(records) {
+        this.state.set('addedEdges', records);
+    }
+    get modifiedEdges() {
+        return this.state.get('modifiedEdges');
+    }
+    set modifiedEdges(records) {
+        this.state.set('modifiedEdges', records);
+    }
+    get removedEdges() {
+        return this.state.get('removedEdges');
+    }
+    set removedEdges(records) {
+        this.state.set('removedEdges', records);
+    }
+    get finalShapes() {
+        return this.state.get('finalShapes');
+    }
+    set finalShapes(shapes) {
+        this.state.set('finalShapes', shapes);
+    }
     getUniqueType() {
         return this.getType();
     }
@@ -251,6 +300,78 @@ export class SceneObject {
             this.removeShape(shape, removedBy);
         }
     }
+    recordAddedFace(face, addedBy) {
+        this.addedFaces.push({ shape: face, addedBy });
+    }
+    recordAddedEdge(edge, addedBy) {
+        this.addedEdges.push({ shape: edge, addedBy });
+    }
+    recordModifiedFaces(sources, results, modifiedBy) {
+        this.modifiedFaces.push({ sources, results, modifiedBy });
+    }
+    recordModifiedEdges(sources, results, modifiedBy) {
+        this.modifiedEdges.push({ sources, results, modifiedBy });
+    }
+    recordRemovedFace(face, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                if (child.ownsFace(face)) {
+                    child.recordRemovedFace(face, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedFaces.push({ shape: face, removedBy });
+    }
+    recordRemovedEdge(edge, removedBy) {
+        if (this.isContainer()) {
+            for (const child of this.children) {
+                if (child.ownsEdge(edge)) {
+                    child.recordRemovedEdge(edge, removedBy);
+                }
+            }
+            return;
+        }
+        this.removedEdges.push({ shape: edge, removedBy });
+    }
+    ownsFace(face) {
+        return this.addedFaces.some(r => r.shape === face);
+    }
+    ownsEdge(edge) {
+        return this.addedEdges.some(r => r.shape === edge);
+    }
+    getAddedFaces(scope) {
+        return this.addedFaces
+            .filter(r => !scope || scope.has(r.addedBy))
+            .map(r => r.shape);
+    }
+    getModifiedFaces(scope) {
+        return this.modifiedFaces.filter(r => !scope || scope.has(r.modifiedBy));
+    }
+    getRemovedFaces(scope) {
+        return this.removedFaces
+            .filter(r => !scope || scope.has(r.removedBy))
+            .map(r => r.shape);
+    }
+    getAddedEdges(scope) {
+        return this.addedEdges
+            .filter(r => !scope || scope.has(r.addedBy))
+            .map(r => r.shape);
+    }
+    getModifiedEdges(scope) {
+        return this.modifiedEdges.filter(r => !scope || scope.has(r.modifiedBy));
+    }
+    getRemovedEdges(scope) {
+        return this.removedEdges
+            .filter(r => !scope || scope.has(r.removedBy))
+            .map(r => r.shape);
+    }
+    setFinalShapes(shapes) {
+        this.finalShapes = shapes;
+    }
+    getFinalShapes() {
+        return this.finalShapes;
+    }
     getOwnShapes(filter, scope) {
         filter = {
             excludeMeta: filter?.excludeMeta ?? true,

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 | Face | Solid;
+    static fromShape(shape: TopoDS_Shape): Solid | Face | Edge | Wire;
 }

package/lib/dist/common/shape-history-tracker.d.ts

@@ -0,0 +1,35 @@
+import type { BRepBuilderAPI_MakeShape } from "occjs-wrapper";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+import { Shape } from "./shape.js";
+export type ShapeHistoryRecord<T> = {
+    sources: T[];
+    results: T[];
+};
+export type ShapeHistory = {
+    addedFaces: Face[];
+    modifiedFaces: ShapeHistoryRecord<Face>[];
+    generatedFaces: ShapeHistoryRecord<Face>[];
+    removedFaces: Face[];
+    addedEdges: Edge[];
+    modifiedEdges: ShapeHistoryRecord<Edge>[];
+    generatedEdges: ShapeHistoryRecord<Edge>[];
+    removedEdges: Edge[];
+};
+export declare class ShapeHistoryTracker {
+    /**
+     * Remap a list of pre-operation faces through a `ShapeHistory`'s
+     * modifications. For each input face:
+     *   - If it appears as a source in `modifiedFaces`, emit the corresponding
+     *     result faces (1:N).
+     *   - Otherwise, pass it through unchanged (it survived the operation with
+     *     the same TShape pointer).
+     *
+     * Use this to keep classification arrays (start/end/side/…) valid after a
+     * fusion has modified some of their faces.
+     */
+    static remapFaces(faces: Face[], history: ShapeHistory): Face[];
+    static remapEdges(edges: Edge[], history: ShapeHistory): Edge[];
+    static collect(maker: BRepBuilderAPI_MakeShape, inputs: Shape[]): ShapeHistory;
+    private static collectForType;
+}

package/lib/dist/common/shape-history-tracker.js

@@ -0,0 +1,114 @@
+import { getOC } from "../oc/init.js";
+import { Explorer } from "../oc/explorer.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { Face } from "./face.js";
+import { Edge } from "./edge.js";
+export class ShapeHistoryTracker {
+    /**
+     * Remap a list of pre-operation faces through a `ShapeHistory`'s
+     * modifications. For each input face:
+     *   - If it appears as a source in `modifiedFaces`, emit the corresponding
+     *     result faces (1:N).
+     *   - Otherwise, pass it through unchanged (it survived the operation with
+     *     the same TShape pointer).
+     *
+     * Use this to keep classification arrays (start/end/side/…) valid after a
+     * fusion has modified some of their faces.
+     */
+    static remapFaces(faces, history) {
+        const result = [];
+        for (const face of faces) {
+            const record = history.modifiedFaces.find(m => m.sources.some(s => s.getShape().IsSame(face.getShape())));
+            if (record) {
+                result.push(...record.results);
+            }
+            else {
+                result.push(face);
+            }
+        }
+        return result;
+    }
+    static remapEdges(edges, history) {
+        const result = [];
+        for (const edge of edges) {
+            const record = history.modifiedEdges.find(m => m.sources.some(s => s.getShape().IsSame(edge.getShape())));
+            if (record) {
+                result.push(...record.results);
+            }
+            else {
+                result.push(edge);
+            }
+        }
+        return result;
+    }
+    static collect(maker, inputs) {
+        const oc = getOC();
+        const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
+        const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
+        const output = maker.Shape();
+        const outputFaces = Explorer.findShapes(output, FACE);
+        const outputEdges = Explorer.findShapes(output, EDGE);
+        const faces = ShapeHistoryTracker.collectForType(maker, inputs, FACE, outputFaces, (raw) => Face.fromTopoDSFace(Explorer.toFace(raw)));
+        const edges = ShapeHistoryTracker.collectForType(maker, inputs, EDGE, outputEdges, (raw) => Edge.fromTopoDSEdge(Explorer.toEdge(raw)));
+        return {
+            addedFaces: faces.added,
+            modifiedFaces: faces.modified,
+            generatedFaces: faces.generated,
+            removedFaces: faces.removed,
+            addedEdges: edges.added,
+            modifiedEdges: edges.modified,
+            generatedEdges: edges.generated,
+            removedEdges: edges.removed,
+        };
+    }
+    static collectForType(maker, inputs, type, outputRaws, wrap) {
+        const oc = getOC();
+        const modified = [];
+        const generated = [];
+        const removed = [];
+        // Collect every output raw that was either Modified or Generated from an input,
+        // so we can later classify the remaining outputs as pure additions.
+        const claimed = new oc.TopTools_MapOfShape();
+        const isOfType = (raw) => raw.ShapeType() === type;
+        for (const input of inputs) {
+            const inputRaws = Explorer.findShapes(input.getShape(), type);
+            for (const inputRaw of inputRaws) {
+                const modifiedRaws = ShapeOps.shapeListToArray(maker.Modified(inputRaw)).filter(isOfType);
+                const generatedRaws = ShapeOps.shapeListToArray(maker.Generated(inputRaw)).filter(isOfType);
+                const isDeleted = maker.IsDeleted(inputRaw);
+                if (modifiedRaws.length > 0) {
+                    modified.push({
+                        sources: [wrap(inputRaw)],
+                        results: modifiedRaws.map(wrap),
+                    });
+                    for (const r of modifiedRaws) {
+                        claimed.Add(r);
+                    }
+                }
+                if (generatedRaws.length > 0) {
+                    generated.push({
+                        sources: [wrap(inputRaw)],
+                        results: generatedRaws.map(wrap),
+                    });
+                    for (const r of generatedRaws) {
+                        claimed.Add(r);
+                    }
+                }
+                // An input that is deleted with no successor is a removal. If it was
+                // Modified into something, the modification record already captures
+                // its fate — don't double-count as removed.
+                if (isDeleted && modifiedRaws.length === 0 && generatedRaws.length === 0) {
+                    removed.push(wrap(inputRaw));
+                }
+            }
+        }
+        const added = [];
+        for (const raw of outputRaws) {
+            if (!claimed.Contains(raw)) {
+                added.push(wrap(raw));
+            }
+        }
+        claimed.delete();
+        return { added, modified, generated, removed };
+    }
+}

package/lib/dist/common/shape.js

@@ -87,7 +87,13 @@ export class Shape {
         if (this.isVertex()) {
             throw new Error("Cannot set color on vertex shape");
         }
-        this.colorMap.push({ shape: face, color });
+        const existing = this.colorMap.findIndex(c => c.shape.IsSame(face));
+        if (existing >= 0) {
+            this.colorMap[existing] = { shape: face, color };
+        }
+        else {
+            this.colorMap.push({ shape: face, color });
+        }
     }
     getColor(face) {
         const entry = this.colorMap.find(c => c.shape.IsSame(face));

package/lib/dist/common/solid.js

@@ -60,7 +60,11 @@ export class Solid extends Shape {
         return null;
     }
     copy() {
-        return new Solid(this.getShape());
+        const copied = new Solid(this.getShape());
+        for (const entry of this.colorMap) {
+            copied.colorMap.push({ shape: entry.shape, color: entry.color });
+        }
+        return copied;
     }
     static fromTopoDSSolid(solid) {
         return new Solid(solid);

package/lib/dist/features/chamfer.js

@@ -2,6 +2,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { FilletOps } from "../oc/fillet-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { ColorTransfer } from "../oc/color-transfer.js";
 export class Chamfer extends SceneObject {
     distance;
     distance2;
@@ -62,9 +63,9 @@ export class Chamfer extends SceneObject {
             }
             edges = edges.filter(e => !targetEdges.includes(e));
             try {
-                let newShape;
+                let preCleanSolids;
                 if (!this.distance2) {
-                    newShape = FilletOps.makeChamfer(solid, targetEdges, this.distance);
+                    preCleanSolids = FilletOps.makeChamfer(solid, targetEdges, this.distance);
                 }
                 else {
                     const faces = solid.getFaces();
@@ -78,13 +79,18 @@ export class Chamfer extends SceneObject {
                         }
                         commonFaces.push(firstCommonFace);
                     }
-                    newShape = FilletOps.makeChamferTwoDistances(solid, targetEdges, this.distance, this.distance2, commonFaces, this.isAngle);
+                    preCleanSolids = FilletOps.makeChamferTwoDistances(solid, targetEdges, this.distance, this.distance2, commonFaces, this.isAngle);
                 }
                 const obj = shapeObjectMap.get(shape);
                 obj.removeShape(shape, this);
-                const subShapes = Explorer.findSolidsWrapped(ShapeOps.cleanShape(newShape));
-                for (const subShape of subShapes) {
-                    newShapes.push(subShape);
+                // Clean each chamfer result and chain colors through the cleanup's
+                // UnifySameDomain history so any merged faces keep their colors.
+                for (const preClean of preCleanSolids) {
+                    const cleanup = ShapeOps.cleanShapeWithLineage(preClean);
+                    ColorTransfer.applyThroughCleanup(preClean, cleanup);
+                    const cleaned = cleanup.shape;
+                    cleanup.dispose();
+                    newShapes.push(cleaned);
                 }
             }
             catch {

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,6 +9,7 @@ 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;
@@ -39,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;