fluidcad 0.0.15 → 0.0.16

package/lib/dist/features/extrude.js

@@ -3,6 +3,7 @@ import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-help
 import { ExtrudeBase } from "./extrude-base.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
+import { EdgeOps } from "../oc/edge-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { ExtrudeThroughAll } from "./infinite-extrude.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
@@ -18,27 +19,46 @@ export class Extrude extends ExtrudeBase {
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
-        const faces = this.isThin()
-            ? ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1])
-            : pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        let faces;
+        let inwardEdges;
+        let outwardEdges;
+        if (this.isThin()) {
+            const thinResult = ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1]);
+            faces = thinResult.faces;
+            inwardEdges = thinResult.inwardEdges;
+            outwardEdges = thinResult.outwardEdges;
+        }
+        else {
+            faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        }
         if (this._operationMode === 'remove') {
             this.buildRemove(faces, plane, context);
         }
         else if (this._symmetric) {
-            this.buildSymmetric(faces, plane, context);
+            this.buildSymmetric(faces, plane, context, inwardEdges, outwardEdges);
         }
         else {
-            this.buildAdd(faces, plane, context);
+            this.buildAdd(faces, plane, context, inwardEdges, outwardEdges);
         }
     }
-    buildAdd(faces, plane, context) {
+    buildAdd(faces, plane, context, inwardEdges, outwardEdges) {
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
         const extruder = new Extruder(faces, plane, this.distance, this.getDraft(), this.getEndOffset());
         let extrusions = extruder.extrude();
+        let sideFaces = extruder.getSideFaces();
+        let internalFaces = extruder.getInternalFaces();
+        let capFaces = [];
+        if (inwardEdges && inwardEdges.length > 0) {
+            const result = this.reclassifyThinFaces([...sideFaces, ...internalFaces], extruder.getStartFaces(), plane, inwardEdges, outwardEdges || []);
+            sideFaces = result.sideFaces;
+            internalFaces = result.internalFaces;
+            capFaces = result.capFaces;
+        }
         this.setState('start-faces', extruder.getStartFaces());
         this.setState('end-faces', extruder.getEndFaces());
-        this.setState('side-faces', extruder.getSideFaces());
-        this.setState('internal-faces', extruder.getInternalFaces());
+        this.setState('side-faces', sideFaces);
+        this.setState('internal-faces', internalFaces);
+        this.setState('cap-faces', capFaces);
         this.extrudable.removeShapes(this);
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);
@@ -53,7 +73,7 @@ export class Extrude extends ExtrudeBase {
         }
         this.addShapes(fusionResult.newShapes);
     }
-    buildSymmetric(faces, plane, context) {
+    buildSymmetric(faces, plane, context, inwardEdges, outwardEdges) {
         const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
         const extruder1 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset());
         const extrusions1 = extruder1.extrude();
@@ -61,34 +81,83 @@ export class Extrude extends ExtrudeBase {
         const extruder2 = new Extruder(faces, plane, -this.distance / 2, this.getDraft(), this.getEndOffset());
         const extrusions2 = extruder2.extrude();
         const endFaces = extruder2.getEndFaces();
-        const preFusionInternalFaces = [
-            ...extruder1.getInternalFaces(),
-            ...extruder2.getInternalFaces(),
-        ];
         const all = [...extrusions1, ...extrusions2];
         const { result: extrusions } = BooleanOps.fuse(all);
-        const sideFaces = [];
-        const internalFaces = [];
+        // Collect remaining faces and fused start/end faces from the fused solid.
+        // We need the fused face objects (not pre-fusion) for IsPartner matching.
+        const remainingFaces = [];
+        const fusedStartFaces = [];
+        const fusedEndFaces = [];
         for (const solid of extrusions) {
             const allFaces = Explorer.findFacesWrapped(solid);
             for (const f of allFaces) {
                 const isStart = startFaces.some(sf => f.getShape().IsSame(sf.getShape()));
                 const isEnd = endFaces.some(ef => f.getShape().IsSame(ef.getShape()));
-                if (!isStart && !isEnd) {
-                    const isInternal = preFusionInternalFaces.some(pf => f.getShape().IsSame(pf.getShape()));
-                    if (isInternal) {
-                        internalFaces.push(f);
+                if (isStart) {
+                    fusedStartFaces.push(f);
+                }
+                else if (isEnd) {
+                    fusedEndFaces.push(f);
+                }
+                else {
+                    remainingFaces.push(f);
+                }
+            }
+        }
+        let sideFaces;
+        let internalFaces;
+        let capFaces = [];
+        if (inwardEdges && inwardEdges.length > 0) {
+            // For thin open profiles: reclassify using 2D midpoint matching on the fused solid
+            const result = this.reclassifyThinFaces(remainingFaces, [...fusedStartFaces, ...fusedEndFaces], plane, inwardEdges, outwardEdges || []);
+            sideFaces = result.sideFaces;
+            internalFaces = result.internalFaces;
+            capFaces = result.capFaces;
+        }
+        else {
+            // Detect inner wire edges from the extruder's firstFaces (at the sketch plane,
+            // pre-fusion). These have the same wire orientation the Extruder uses internally.
+            // Then map to fused solid edges using 2D midpoint matching, since SimplifyResult
+            // merges half-faces and breaks TShape identity.
+            const preInnerEdges = [];
+            for (const sf of extruder1.getStartFaces()) {
+                for (const wire of sf.getWires()) {
+                    if (!wire.isCW(plane.normal)) {
+                        for (const edge of wire.getEdges()) {
+                            preInnerEdges.push(edge);
+                        }
                     }
-                    else {
-                        sideFaces.push(f);
+                }
+            }
+            const fusedInnerEdges = [];
+            if (preInnerEdges.length > 0) {
+                const innerMids = preInnerEdges.map(e => plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(e.getShape())));
+                for (const sf of fusedStartFaces) {
+                    for (const sfe of sf.getEdges()) {
+                        const mid = plane.worldToLocal(EdgeOps.getEdgeMidPointRaw(sfe.getShape()));
+                        if (innerMids.some(im => mid.distanceTo(im) < 1e-4)) {
+                            fusedInnerEdges.push(sfe);
+                        }
                     }
                 }
             }
+            sideFaces = [];
+            internalFaces = [];
+            for (const f of remainingFaces) {
+                const isInternal = fusedInnerEdges.length > 0 && f.getEdges().some(fe => fusedInnerEdges.some(ie => fe.getShape().IsPartner(ie.getShape())));
+                if (isInternal) {
+                    internalFaces.push(f);
+                }
+                else {
+                    sideFaces.push(f);
+                }
+            }
         }
         this.setState('start-faces', startFaces);
         this.setState('end-faces', endFaces);
         this.setState('side-faces', sideFaces);
         this.setState('internal-faces', internalFaces);
+        this.setState('cap-faces', capFaces);
         this.extrudable.removeShapes(this);
         if (extrusions.length === 0 || sceneObjects.length === 0) {
             this.addShapes(extrusions);

package/lib/dist/features/mirror-shape2d.d.ts

@@ -9,6 +9,7 @@ export declare class MirrorShape2D extends GeometrySceneObject {
     build(context: BuildSceneObjectContext): void;
     start(): LazyVertex;
     end(): LazyVertex;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: MirrorShape2D): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/mirror-shape2d.js

@@ -74,6 +74,13 @@ export class MirrorShape2D extends GeometrySceneObject {
     end() {
         return new LazyVertex(this.generateUniqueName('end-vertex'), () => [this.getState('end')]);
     }
+    createCopy(remap) {
+        const axis = remap.get(this.axis) || this.axis;
+        const targetObjects = this.targetObjects
+            ? this.targetObjects.map(obj => remap.get(obj) || obj)
+            : null;
+        return new MirrorShape2D(axis, targetObjects);
+    }
     compareTo(other) {
         if (!(other instanceof MirrorShape2D)) {
             return false;

package/lib/dist/features/remove.js

@@ -7,7 +7,7 @@ export class Remove extends SceneObject {
     }
     build() {
         for (const obj of this.objects) {
-            obj.removeShapes(this);
+            obj.removeShapes(this, true);
         }
     }
     compareTo(other) {

package/lib/dist/filters/filter-builder-base.d.ts

@@ -3,7 +3,14 @@ import { Shape } from "../common/shapes.js";
 import { FilterBase } from "./filter-base.js";
 export declare class FilterBuilderBase<TShape extends Shape = Shape> {
     protected filters: FilterBase<TShape>[];
+    protected _withTangents: boolean;
     filter(filter: FilterBase<TShape>): this;
+    /**
+     * Expands the selection to include all shapes transitively connected
+     * by tangency (G1 continuity) to the initially matched shapes.
+     */
+    withTangents(): this;
+    hasTangentExpansion(): boolean;
     getFilters(): FilterBase<TShape>[];
     transform(matrix: Matrix4): FilterBuilderBase<TShape>;
     equals(other: FilterBuilderBase<TShape>): boolean;

package/lib/dist/filters/filter-builder-base.js

@@ -1,9 +1,21 @@
 export class FilterBuilderBase {
     filters = [];
+    _withTangents = false;
     filter(filter) {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Expands the selection to include all shapes transitively connected
+     * by tangency (G1 continuity) to the initially matched shapes.
+     */
+    withTangents() {
+        this._withTangents = true;
+        return this;
+    }
+    hasTangentExpansion() {
+        return this._withTangents;
+    }
     getFilters() {
         return this.filters;
     }
@@ -12,9 +24,13 @@ export class FilterBuilderBase {
         for (const filter of this.filters) {
             transformedBuilder.filter(filter.transform(matrix));
         }
+        transformedBuilder._withTangents = this._withTangents;
         return transformedBuilder;
     }
     equals(other) {
+        if (this._withTangents !== other._withTangents) {
+            return false;
+        }
         if (this.filters.length !== other.filters.length) {
             return false;
         }

package/lib/dist/filters/filter.js

@@ -1,3 +1,4 @@
+import { TangentExpander } from "./tangent-expander.js";
 export class ShapeFilter {
     shapes;
     builders;
@@ -28,6 +29,11 @@ export class ShapeFilter {
                 }
             }
         }
+        // Tangent expansion: if any builder requests it, expand result set via BFS
+        const needsExpansion = this.builders.some(b => b.hasTangentExpansion());
+        if (needsExpansion && result.length > 0) {
+            return TangentExpander.expand(result, this.shapes);
+        }
         return result;
     }
 }

package/lib/dist/filters/tangent-expander.d.ts

@@ -0,0 +1,47 @@
+import type { TopoDS_Edge } from "occjs-wrapper";
+import { Shape, Edge, Face } from "../common/shapes.js";
+export declare class TangentExpander {
+    /**
+     * Expands a set of seed shapes to include all transitively tangent-connected
+     * shapes from the pool. Dispatches to edge or face expansion based on shape type.
+     */
+    static expand(seeds: Shape[], pool: Shape[]): Shape[];
+    /**
+     * BFS expansion for edges. Two edges are tangent if they share a vertex
+     * and their tangent vectors at that vertex are parallel.
+     */
+    private static expandEdges;
+    /**
+     * BFS expansion for faces. Two faces are tangent if they share an edge
+     * and have G1 or higher continuity across that edge.
+     */
+    private static expandFaces;
+    /**
+     * Checks if two edges are tangent at a shared vertex by comparing
+     * their tangent vectors (parallel = tangent).
+     */
+    static areEdgesTangent(e1: Edge, e2: Edge): boolean;
+    /**
+     * Checks if two faces are tangent along a shared edge.
+     * Uses BRepLib.ContinuityOfFaces which computes the continuity from geometry
+     * on-the-fly (unlike BRep_Tool.Continuity which reads stored flags).
+     */
+    static areFacesTangent(f1: Face, f2: Face, sharedEdge: TopoDS_Edge): boolean;
+    /**
+     * Builds a map from vertex TShape hash to the list of edges that share that vertex.
+     */
+    private static buildVertexToEdgeMap;
+    /**
+     * Builds a map from edge TShape hash to the list of faces that share that edge.
+     */
+    private static buildEdgeToFaceMap;
+    /**
+     * Returns edges from the adjacency map that share a vertex with the given edge.
+     */
+    private static getAdjacentEdges;
+    /**
+     * Returns faces from the adjacency map that share an edge with the given face,
+     * along with the shared edge's raw TopoDS_Edge.
+     */
+    private static getAdjacentFaces;
+}

package/lib/dist/filters/tangent-expander.js

@@ -0,0 +1,223 @@
+import { getOC } from "../oc/init.js";
+export class TangentExpander {
+    /**
+     * Expands a set of seed shapes to include all transitively tangent-connected
+     * shapes from the pool. Dispatches to edge or face expansion based on shape type.
+     */
+    static expand(seeds, pool) {
+        if (seeds.length === 0) {
+            return [];
+        }
+        if (seeds[0].isEdge()) {
+            return TangentExpander.expandEdges(seeds, pool);
+        }
+        else {
+            return TangentExpander.expandFaces(seeds, pool);
+        }
+    }
+    /**
+     * BFS expansion for edges. Two edges are tangent if they share a vertex
+     * and their tangent vectors at that vertex are parallel.
+     */
+    static expandEdges(seeds, pool) {
+        // Build vertex → edge adjacency map for efficient lookup
+        const vertexToEdges = TangentExpander.buildVertexToEdgeMap(pool);
+        const included = new Set(seeds);
+        const queue = [...seeds];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const neighbors = TangentExpander.getAdjacentEdges(current, vertexToEdges);
+            for (const candidate of neighbors) {
+                if (included.has(candidate)) {
+                    continue;
+                }
+                if (TangentExpander.areEdgesTangent(current, candidate)) {
+                    included.add(candidate);
+                    queue.push(candidate);
+                }
+            }
+        }
+        return [...included];
+    }
+    /**
+     * BFS expansion for faces. Two faces are tangent if they share an edge
+     * and have G1 or higher continuity across that edge.
+     */
+    static expandFaces(seeds, pool) {
+        // Build edge → face adjacency map
+        const edgeToFaces = TangentExpander.buildEdgeToFaceMap(pool);
+        const included = new Set(seeds);
+        const queue = [...seeds];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const neighbors = TangentExpander.getAdjacentFaces(current, edgeToFaces);
+            for (const [candidate, sharedEdge] of neighbors) {
+                if (included.has(candidate)) {
+                    continue;
+                }
+                if (TangentExpander.areFacesTangent(current, candidate, sharedEdge)) {
+                    included.add(candidate);
+                    queue.push(candidate);
+                }
+            }
+        }
+        return [...included];
+    }
+    /**
+     * Checks if two edges are tangent at a shared vertex by comparing
+     * their tangent vectors (parallel = tangent).
+     */
+    static areEdgesTangent(e1, e2) {
+        const oc = getOC();
+        const angTol = 1e-4;
+        const e1Raw = e1.getShape();
+        const e2Raw = e2.getShape();
+        const e1First = oc.TopExp.FirstVertex(e1Raw, true);
+        const e1Last = oc.TopExp.LastVertex(e1Raw, true);
+        const e2First = oc.TopExp.FirstVertex(e2Raw, true);
+        const e2Last = oc.TopExp.LastVertex(e2Raw, true);
+        // Check all 4 vertex pairings for a shared vertex
+        const pairs = [
+            { v1: e1First, v2: e2First },
+            { v1: e1First, v2: e2Last },
+            { v1: e1Last, v2: e2First },
+            { v1: e1Last, v2: e2Last },
+        ];
+        for (const { v1, v2 } of pairs) {
+            if (!v1.IsPartner(v2)) {
+                continue;
+            }
+            // Get raw curves and parameters at the shared vertex
+            const curve1Handle = oc.BRep_Tool.Curve(e1Raw, 0, 1);
+            const curve1 = curve1Handle.get();
+            const param1 = oc.BRep_Tool.Parameter(v1, e1Raw);
+            const curve2Handle = oc.BRep_Tool.Curve(e2Raw, 0, 1);
+            const curve2 = curve2Handle.get();
+            const param2 = oc.BRep_Tool.Parameter(v2, e2Raw);
+            // Evaluate tangent vectors using D1
+            const pnt1 = new oc.gp_Pnt();
+            const vec1 = new oc.gp_Vec();
+            curve1.D1(param1, pnt1, vec1);
+            const pnt2 = new oc.gp_Pnt();
+            const vec2 = new oc.gp_Vec();
+            curve2.D1(param2, pnt2, vec2);
+            // Flip tangent if edge is reversed
+            if (e1Raw.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
+                vec1.Reverse();
+            }
+            if (e2Raw.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
+                vec2.Reverse();
+            }
+            // Check parallelism: |cos(angle)| > cos(angTol)
+            const mag1 = vec1.Magnitude();
+            const mag2 = vec2.Magnitude();
+            let tangent = false;
+            if (mag1 > 1e-10 && mag2 > 1e-10) {
+                const dot = Math.abs(vec1.Normalized().Dot(vec2.Normalized()));
+                tangent = dot > Math.cos(angTol);
+            }
+            // Cleanup
+            pnt1.delete();
+            vec1.delete();
+            pnt2.delete();
+            vec2.delete();
+            if (tangent) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Checks if two faces are tangent along a shared edge.
+     * Uses BRepLib.ContinuityOfFaces which computes the continuity from geometry
+     * on-the-fly (unlike BRep_Tool.Continuity which reads stored flags).
+     */
+    static areFacesTangent(f1, f2, sharedEdge) {
+        const oc = getOC();
+        const f1Raw = f1.getShape();
+        const f2Raw = f2.getShape();
+        const angTol = 0.01; // ~0.57 degrees
+        const continuity = oc.BRepLib.ContinuityOfFaces(sharedEdge, f1Raw, f2Raw, angTol);
+        // C0 = sharp edge (not tangent). Anything else (G1, C1, G2, C2, C3, CN) = tangent.
+        return continuity !== oc.GeomAbs_Shape.GeomAbs_C0;
+    }
+    /**
+     * Builds a map from vertex TShape hash to the list of edges that share that vertex.
+     */
+    static buildVertexToEdgeMap(edges) {
+        const oc = getOC();
+        const map = new Map();
+        for (const edge of edges) {
+            const raw = edge.getShape();
+            const first = oc.TopExp.FirstVertex(raw, true);
+            const last = oc.TopExp.LastVertex(raw, true);
+            for (const vertex of [first, last]) {
+                const hash = vertex.HashCode(2147483647);
+                if (!map.has(hash)) {
+                    map.set(hash, []);
+                }
+                map.get(hash).push(edge);
+            }
+        }
+        return map;
+    }
+    /**
+     * Builds a map from edge TShape hash to the list of faces that share that edge.
+     */
+    static buildEdgeToFaceMap(faces) {
+        const map = new Map();
+        for (const face of faces) {
+            const faceEdges = face.getEdges();
+            for (const edge of faceEdges) {
+                const hash = edge.getShape().HashCode(2147483647);
+                if (!map.has(hash)) {
+                    map.set(hash, []);
+                }
+                map.get(hash).push(face);
+            }
+        }
+        return map;
+    }
+    /**
+     * Returns edges from the adjacency map that share a vertex with the given edge.
+     */
+    static getAdjacentEdges(edge, vertexToEdges) {
+        const oc = getOC();
+        const raw = edge.getShape();
+        const first = oc.TopExp.FirstVertex(raw, true);
+        const last = oc.TopExp.LastVertex(raw, true);
+        const neighbors = new Set();
+        for (const vertex of [first, last]) {
+            const hash = vertex.HashCode(2147483647);
+            const candidates = vertexToEdges.get(hash);
+            if (candidates) {
+                for (const c of candidates) {
+                    if (c !== edge) {
+                        neighbors.add(c);
+                    }
+                }
+            }
+        }
+        return [...neighbors];
+    }
+    /**
+     * Returns faces from the adjacency map that share an edge with the given face,
+     * along with the shared edge's raw TopoDS_Edge.
+     */
+    static getAdjacentFaces(face, edgeToFaces) {
+        const result = [];
+        const faceEdges = face.getEdges();
+        for (const edge of faceEdges) {
+            const hash = edge.getShape().HashCode(2147483647);
+            const candidates = edgeToFaces.get(hash);
+            if (candidates) {
+                for (const c of candidates) {
+                    if (c !== face) {
+                        result.push([c, edge.getShape()]);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

package/lib/dist/index.js

@@ -9,8 +9,13 @@ export function captureSourceLocation() {
     for (const frame of lines) {
         const match = frame.match(/((?:[A-Za-z]:)?\/[^\s]+?\.fluid\.js):(\d+):(\d+)/);
         if (match) {
+            let filePath = match[1];
+            const virtualIdx = filePath.indexOf('virtual:live-render:');
+            if (virtualIdx !== -1) {
+                filePath = filePath.substring(virtualIdx + 'virtual:live-render:'.length);
+            }
             return {
-                filePath: match[1],
+                filePath,
                 line: parseInt(match[2], 10),
                 column: parseInt(match[3], 10),
             };

package/lib/dist/oc/thin-face-maker.d.ts

@@ -2,8 +2,13 @@ import { Edge } from "../common/edge.js";
 import { Face } from "../common/face.js";
 import { Wire } from "../common/wire.js";
 import { Plane } from "../math/plane.js";
+export interface ThinFaceResult {
+    faces: Face[];
+    inwardEdges: Edge[];
+    outwardEdges: Edge[];
+}
 export declare class ThinFaceMaker {
-    static make(edges: (Wire | Edge)[], plane: Plane, offset1: number, offset2?: number): Face[];
+    static make(edges: (Wire | Edge)[], plane: Plane, offset1: number, offset2?: number): ThinFaceResult;
     private static makeSingleOffsetFace;
     private static makeDualOffsetFace;
     /**
@@ -19,6 +24,12 @@ export declare class ThinFaceMaker {
      * Only handles positive distances — use doOffset for sign handling.
      */
     private static offsetWireOnPlane;
+    /**
+     * Finds face edges that geometrically match the given wire edges by comparing midpoints.
+     * This is needed because wire reversal (ShapeExtend_WireData.Reverse) creates new TShapes,
+     * breaking IsPartner identity between original wire edges and face edges.
+     */
+    private static matchFaceEdgesByMidpoint;
     private static makeLineEdge;
     /**
      * Creates a closed face from two open wires by capping the ends with straight lines.