brep-io-kernel 1.0.21 → 1.0.23

package/src/BREP/Vertex.js

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import { CADmaterials } from "../UI/CADmaterials.js";
+import { SelectionState } from "../UI/SelectionState.js";
 
 // Vertex: container at a specific position with a point marker.
 // When selected, swaps to the selected PointsMaterial; no extra sphere.
@@ -22,22 +23,6 @@ export class Vertex extends THREE.Object3D {
         this._point = new THREE.Points(ptGeom, ptMat);
         this.add(this._point);
 
-        // Selection flag accessor toggles point material
-        this._selected = false;
-        Object.defineProperty(this, 'selected', {
-            get: () => this._selected,
-            set: (v) => {
-                const nv = !!v;
-                this._selected = nv;
-                try {
-                    if (this._point && this._point.material && CADmaterials?.VERTEX) {
-                        this._point.material = nv ? (CADmaterials.VERTEX.SELECTED || this._point.material)
-                            : (CADmaterials.VERTEX.BASE || this._point.material);
-                    }
-                } catch { }
-            },
-            configurable: true,
-            enumerable: true,
-        });
+        SelectionState.attach(this);
     }
 }

package/src/BREP/fillets/fillet.js

@@ -22,6 +22,83 @@ import { computeFaceAreaFromTriangles } from "./filletGeometry.js";
 export { clearFilletCaches, trimFilletCaches } from './inset.js';
 export { fixTJunctionsAndPatchHoles } from './outset.js';
 
+function buildPointInsideTester(solid) {
+    if (!solid) return null;
+    const tv = solid._triVerts;
+    const vp = solid._vertProperties;
+    if (!tv || !vp || typeof tv.length !== 'number' || typeof vp.length !== 'number') return null;
+    const triCount = (tv.length / 3) | 0;
+    if (triCount === 0 || vp.length < 9) return null;
+
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (let i = 0; i < vp.length; i += 3) {
+        const x = vp[i], y = vp[i + 1], z = vp[i + 2];
+        if (x < minX) minX = x; if (x > maxX) maxX = x;
+        if (y < minY) minY = y; if (y > maxY) maxY = y;
+        if (z < minZ) minZ = z; if (z > maxZ) maxZ = z;
+    }
+    const diag = Math.hypot(maxX - minX, maxY - minY, maxZ - minZ) || 1;
+    const jitter = 1e-6 * diag;
+
+    const rayTri = (ox, oy, oz, dx, dy, dz, ax, ay, az, bx, by, bz, cx, cy, cz) => {
+        const EPS = 1e-12;
+        const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
+        const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
+        const px = dy * e2z - dz * e2y;
+        const py = dz * e2x - dx * e2z;
+        const pz = dx * e2y - dy * e2x;
+        const det = e1x * px + e1y * py + e1z * pz;
+        if (Math.abs(det) < EPS) return null;
+        const invDet = 1.0 / det;
+        const tvecx = ox - ax, tvecy = oy - ay, tvecz = oz - az;
+        const u = (tvecx * px + tvecy * py + tvecz * pz) * invDet;
+        if (u < -1e-12 || u > 1 + 1e-12) return null;
+        const qx = tvecy * e1z - tvecz * e1y;
+        const qy = tvecz * e1x - tvecx * e1z;
+        const qz = tvecx * e1y - tvecy * e1x;
+        const v = (dx * qx + dy * qy + dz * qz) * invDet;
+        if (v < -1e-12 || u + v > 1 + 1e-12) return null;
+        const tHit = (e2x * qx + e2y * qy + e2z * qz) * invDet;
+        return tHit > 1e-10 ? tHit : null;
+    };
+
+    const dirs = [
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+    ];
+
+    return (pt) => {
+        if (!pt || !Number.isFinite(pt.x) || !Number.isFinite(pt.y) || !Number.isFinite(pt.z)) return false;
+        const px = pt.x, py = pt.y, pz = pt.z;
+        let votes = 0;
+        for (let k = 0; k < dirs.length; k++) {
+            const dir = dirs[k];
+            const ox = px + (k + 1) * jitter;
+            const oy = py + (k + 2) * jitter;
+            const oz = pz + (k + 3) * jitter;
+            let hits = 0;
+            for (let t = 0; t < triCount; t++) {
+                const b = t * 3;
+                const ia = (tv[b + 0] >>> 0) * 3;
+                const ib = (tv[b + 1] >>> 0) * 3;
+                const ic = (tv[b + 2] >>> 0) * 3;
+                const hit = rayTri(
+                    ox, oy, oz,
+                    dir[0], dir[1], dir[2],
+                    vp[ia + 0], vp[ia + 1], vp[ia + 2],
+                    vp[ib + 0], vp[ib + 1], vp[ib + 2],
+                    vp[ic + 0], vp[ic + 1], vp[ic + 2]
+                );
+                if (hit !== null) hits++;
+            }
+            if ((hits % 2) === 1) votes++;
+        }
+        return votes >= 2;
+    };
+}
+
 /**
  * Compute the fillet centerline polyline for an input edge without building the fillet solid.
  *
@@ -823,52 +900,129 @@ export function filletSolid({ edgeToFillet, radius = 1, sideMode = 'INSET', debu
         // large displacements on big models.
         const outsetInsetMagnitude = Math.max(1e-4, Math.min(0.05, Math.abs(radius) * 0.05));
         const wedgeInsetMagnitude = closedLoop ? 0 : ((side === 'INSET') ? Math.abs(inflate) : outsetInsetMagnitude);
-        for (let i = 0; i < edgeWedgeCopy.length; i++) {
-            const edgeWedgePt = edgeWedgeCopy[i];
-            const centerPt = centerlineCopy[i] || centerlineCopy[centerlineCopy.length - 1]; // Fallback to last point
-
-            if (edgeWedgePt && centerPt) {
-                try {
-                    const origWedgeEdge = { ...edgeWedgePt };
-
-                    // Calculate direction from edge point toward the centerline (inward direction)
-                    const inwardDir = {
-                        x: centerPt.x - edgeWedgePt.x,
-                        y: centerPt.y - edgeWedgePt.y,
-                        z: centerPt.z - edgeWedgePt.z
-                    };
-                    const inwardLength = Math.sqrt(inwardDir.x * inwardDir.x + inwardDir.y * inwardDir.y + inwardDir.z * inwardDir.z);
-
-                    if (inwardLength > 1e-12) {
-                        // Normalize and apply inset
-                        const normalizedInward = {
-                            x: inwardDir.x / inwardLength,
-                            y: inwardDir.y / inwardLength,
-                            z: inwardDir.z / inwardLength
+        const useInsideCheck = wedgeInsetMagnitude && side === 'OUTSET';
+        const pointInsideTarget = useInsideCheck
+            ? buildPointInsideTester(edgeToFillet?.parentSolid || edgeToFillet?.parent || null)
+            : null;
+        let preferredDirSign = null;
+        let insideResults = null;
+        if (pointInsideTarget) {
+            insideResults = new Array(edgeWedgeCopy.length);
+            let countIn = 0;
+            let countOut = 0;
+            for (let i = 0; i < edgeWedgeCopy.length; i++) {
+                const edgeWedgePt = edgeWedgeCopy[i];
+                const centerPt = centerlineCopy[i] || centerlineCopy[centerlineCopy.length - 1];
+                if (!edgeWedgePt || !centerPt) continue;
+                const inwardDir = {
+                    x: centerPt.x - edgeWedgePt.x,
+                    y: centerPt.y - edgeWedgePt.y,
+                    z: centerPt.z - edgeWedgePt.z
+                };
+                const inwardLength = Math.sqrt(inwardDir.x * inwardDir.x + inwardDir.y * inwardDir.y + inwardDir.z * inwardDir.z);
+                if (inwardLength <= 1e-12) continue;
+                const nx = inwardDir.x / inwardLength;
+                const ny = inwardDir.y / inwardLength;
+                const nz = inwardDir.z / inwardLength;
+                const candidateIn = {
+                    x: edgeWedgePt.x + nx * wedgeInsetMagnitude,
+                    y: edgeWedgePt.y + ny * wedgeInsetMagnitude,
+                    z: edgeWedgePt.z + nz * wedgeInsetMagnitude
+                };
+                const candidateOut = {
+                    x: edgeWedgePt.x - nx * wedgeInsetMagnitude,
+                    y: edgeWedgePt.y - ny * wedgeInsetMagnitude,
+                    z: edgeWedgePt.z - nz * wedgeInsetMagnitude
+                };
+                const inInside = pointInsideTarget(candidateIn);
+                const outInside = pointInsideTarget(candidateOut);
+                insideResults[i] = { inInside, outInside };
+                if (inInside !== outInside) {
+                    if (inInside) countIn++; else countOut++;
+                }
+            }
+            if (countIn || countOut) {
+                preferredDirSign = countIn >= countOut ? 1 : -1;
+            }
+        }
+        if (wedgeInsetMagnitude) {
+            for (let i = 0; i < edgeWedgeCopy.length; i++) {
+                const edgeWedgePt = edgeWedgeCopy[i];
+                const centerPt = centerlineCopy[i] || centerlineCopy[centerlineCopy.length - 1]; // Fallback to last point
+
+                if (edgeWedgePt && centerPt) {
+                    try {
+                        const origWedgeEdge = { ...edgeWedgePt };
+
+                        // Calculate direction from edge point toward the centerline (inward direction)
+                        const inwardDir = {
+                            x: centerPt.x - edgeWedgePt.x,
+                            y: centerPt.y - edgeWedgePt.y,
+                            z: centerPt.z - edgeWedgePt.z
                         };
-                        // Determine direction: OUTSET -> inward, INSET -> outward (opposite)
-                        const dirSign = (side === 'INSET') ? -1 : 1;
-                        const step = dirSign * wedgeInsetMagnitude;
-                        // Apply
-                        edgeWedgePt.x += normalizedInward.x * step;
-                        edgeWedgePt.y += normalizedInward.y * step;
-                        edgeWedgePt.z += normalizedInward.z * step;
-
-                        // Validate the result
-                        if (!isFiniteVec3(edgeWedgePt)) {
-                            console.warn(`Invalid wedge edge point after inset at index ${i}, reverting to original`);
-                            Object.assign(edgeWedgePt, origWedgeEdge);
+                        const inwardLength = Math.sqrt(inwardDir.x * inwardDir.x + inwardDir.y * inwardDir.y + inwardDir.z * inwardDir.z);
+
+                        if (inwardLength > 1e-12) {
+                            // Normalize and apply inset
+                            const normalizedInward = {
+                                x: inwardDir.x / inwardLength,
+                                y: inwardDir.y / inwardLength,
+                                z: inwardDir.z / inwardLength
+                            };
+                            const candidateIn = {
+                                x: origWedgeEdge.x + normalizedInward.x * wedgeInsetMagnitude,
+                                y: origWedgeEdge.y + normalizedInward.y * wedgeInsetMagnitude,
+                                z: origWedgeEdge.z + normalizedInward.z * wedgeInsetMagnitude
+                            };
+                            const candidateOut = {
+                                x: origWedgeEdge.x - normalizedInward.x * wedgeInsetMagnitude,
+                                y: origWedgeEdge.y - normalizedInward.y * wedgeInsetMagnitude,
+                                z: origWedgeEdge.z - normalizedInward.z * wedgeInsetMagnitude
+                            };
+                            let chosen = null;
+
+                            if (pointInsideTarget) {
+                                const insideRes = insideResults ? insideResults[i] : null;
+                                const inInside = insideRes ? insideRes.inInside : pointInsideTarget(candidateIn);
+                                const outInside = insideRes ? insideRes.outInside : pointInsideTarget(candidateOut);
+                                if (inInside !== outInside) {
+                                    chosen = inInside ? candidateIn : candidateOut;
+                                }
+                            }
+
+                            if (!chosen) {
+                                // Fallback to previous sign-based behavior.
+                                const dirSign = (preferredDirSign !== null)
+                                    ? preferredDirSign
+                                    : ((side === 'INSET') ? -1 : 1);
+                                const step = dirSign * wedgeInsetMagnitude;
+                                chosen = {
+                                    x: origWedgeEdge.x + normalizedInward.x * step,
+                                    y: origWedgeEdge.y + normalizedInward.y * step,
+                                    z: origWedgeEdge.z + normalizedInward.z * step
+                                };
+                            }
+
+                            edgeWedgePt.x = chosen.x;
+                            edgeWedgePt.y = chosen.y;
+                            edgeWedgePt.z = chosen.z;
+
+                            // Validate the result
+                            if (!isFiniteVec3(edgeWedgePt)) {
+                                console.warn(`Invalid wedge edge point after inset at index ${i}, reverting to original`);
+                                Object.assign(edgeWedgePt, origWedgeEdge);
+                            }
+                        } else {
+                            console.warn(`Edge point ${i} is too close to centerline, skipping wedge inset`);
                         }
-                    } else {
-                        console.warn(`Edge point ${i} is too close to centerline, skipping wedge inset`);
+                    } catch (insetError) {
+                        console.warn(`Wedge edge inset failed at index ${i}: ${insetError?.message || insetError}`);
                     }
-                } catch (insetError) {
-                    console.warn(`Wedge edge inset failed at index ${i}: ${insetError?.message || insetError}`);
                 }
             }
         }
 
-        if (wedgeInsetMagnitude) logDebug(`Applied wedge inset of ${wedgeInsetMagnitude} units (${side === 'INSET' ? 'outward' : 'inward'}) to ${edgeWedgeCopy.length} edge points`);
+        if (wedgeInsetMagnitude) logDebug(`Applied wedge inset of ${wedgeInsetMagnitude} units (inside-aware) to ${edgeWedgeCopy.length} edge points`);
 
 
         // Do not reorder edge points. Centerline/tangent/edge points are produced in

package/src/PartHistory.js

@@ -572,11 +572,12 @@ export class PartHistory {
         const objType = String(obj.type || '').toUpperCase();
         const sourceUuid = obj.uuid || null;
         const sourceFeatureId = obj.owningFeatureID ?? null;
+        const sourceTimestamp = (obj.timestamp ?? obj.userData?.timestamp ?? null);
         if (objType === SelectionFilter.EDGE || objType === 'EDGE') {
           const positions = extractEdgeWorldPositions(obj);
           if (positions && positions.length >= 6) {
             for (const bucket of buckets) {
-              bucket[refName] = { type: 'EDGE', positions, sourceUuid, sourceFeatureId };
+              bucket[refName] = { type: 'EDGE', positions, sourceUuid, sourceFeatureId, sourceTimestamp };
             }
           }
         } else if (objType === SelectionFilter.FACE || objType === 'FACE' || objType === SelectionFilter.PLANE || objType === 'PLANE') {
@@ -584,7 +585,7 @@ export class PartHistory {
           if (edgePositions && edgePositions.length) {
             const snapType = (objType === SelectionFilter.PLANE || objType === 'PLANE') ? 'PLANE' : 'FACE';
             for (const bucket of buckets) {
-              bucket[refName] = { type: snapType, edgePositions, sourceUuid, sourceFeatureId };
+              bucket[refName] = { type: snapType, edgePositions, sourceUuid, sourceFeatureId, sourceTimestamp };
             }
           }
         } else if (objType === SelectionFilter.VERTEX || objType === 'VERTEX') {
@@ -594,7 +595,7 @@ export class PartHistory {
             else pos.set(obj.position?.x || 0, obj.position?.y || 0, obj.position?.z || 0);
           } catch { }
           for (const bucket of buckets) {
-            bucket[refName] = { type: 'VERTEX', position: [pos.x, pos.y, pos.z], sourceUuid, sourceFeatureId };
+            bucket[refName] = { type: 'VERTEX', position: [pos.x, pos.y, pos.z], sourceUuid, sourceFeatureId, sourceTimestamp };
           }
         }
       }
@@ -662,7 +663,6 @@ export class PartHistory {
           applyTimeStampToChildrenRecursively(a, feature.timestamp);
         } catch { }
 
-        this._attachSelectionHandlers(a);
       }
     }
 
@@ -677,27 +677,6 @@ export class PartHistory {
 
 
 
-  _attachSelectionHandlers(obj) {
-    if (!obj || typeof obj !== 'object') return;
-    obj.onClick = () => {
-      try {
-        if (obj.type === SelectionFilter.SOLID && obj.parent && obj.parent.type === SelectionFilter.COMPONENT) {
-          const handledByParent = SelectionFilter.toggleSelection(obj.parent);
-          if (!handledByParent) SelectionFilter.toggleSelection(obj);
-          return;
-        }
-        SelectionFilter.toggleSelection(obj);
-      } catch (error) {
-        try { console.warn('[PartHistory] toggleSelection failed:', error); }
-        catch (_) { /* no-op */ }
-      }
-    };
-    const children = Array.isArray(obj.children) ? obj.children : [];
-    for (const child of children) {
-      this._attachSelectionHandlers(child);
-    }
-  }
-
   _safeRemove(obj) {
     if (!obj) return;
     try {

package/src/SketchSolver2D.js

@@ -0,0 +1,3 @@
+// Standalone 2D sketch solver entry point
+export { ConstraintSolver, ConstraintEngine } from './features/sketch/sketchSolver2D/ConstraintEngine.js';
+export { constraints } from './features/sketch/sketchSolver2D/constraintDefinitions.js';

package/src/UI/AccordionWidget.js

@@ -2,7 +2,7 @@
 // ES6, framework-free, dark mode, no animations.
 // All public methods are async and resolve AFTER the DOM has painted.
 
-export class AccordionSection {
+class AccordionSection {
   /**
    * Represents a single accordion section.
    * Properties:

package/src/UI/EnvMonacoEditor.js

@@ -517,6 +517,3 @@ EnvMonacoEditor._runtimeCompletionRegistered = false;
 if (!customElements.get('env-monaco-editor')) {
   customElements.define('env-monaco-editor', EnvMonacoEditor);
 }
-
-export { EnvMonacoEditor };
-export default EnvMonacoEditor;

package/src/UI/HistoryWidget.js

@@ -386,6 +386,9 @@ export class HistoryWidget extends HistoryCollectionWidget {
       if (this._extractEntryId(entry, i) !== String(target)) continue;
       if (!this.#shouldExpandEntry(entry)) return;
       this._expandedId = String(target);
+      if (this._autoFocusOnExpand) {
+        this._pendingFocusEntryId = String(target);
+      }
       this.render();
       return;
     }

package/src/UI/SceneListing.js

@@ -38,11 +38,14 @@ export class SceneListing {
         this._expandedByName = new Map(); // name -> boolean
         // Remember expand/collapse state for non-solid nodes when showing all objects
         this._expandedByUuid = new Map(); // uuid -> boolean
+        this._hoveredUuids = new Set();
         this._running = false;
         this._raf = 0;
 
         this.#attachTypeVisibilityButtons();
         this.#attachDisplayModeToggle();
+        this._hoverListener = (ev) => this.#syncHoverFromScene(ev);
+        window.addEventListener('hover-changed', this._hoverListener);
 
         // Wire toolbar
         // this.toolbar.querySelector(".st-expand").addEventListener("click", () => this.#setAllOpen(true));
@@ -99,6 +102,10 @@ export class SceneListing {
     dispose() {
         this.stop();
         this.clear();
+        if (this._hoverListener) {
+            try { window.removeEventListener('hover-changed', this._hoverListener); } catch { }
+            this._hoverListener = null;
+        }
         this.uiElement.remove();
     }
 
@@ -228,6 +235,13 @@ export class SceneListing {
             e.stopPropagation();
         });
 
+        const hoverOn = () => {
+            try { SelectionFilter.setHoverObject(obj, { ignoreFilter: true }); } catch (_) { }
+        };
+        const hoverOff = () => {
+            try { SelectionFilter.clearHover(); } catch (_) { }
+        };
+
         // Selection: name click -> recursive toggle selection (unchanged)
         nameBtn.addEventListener("click", (e) => {
             // If any descendant (including self) is not selected, select all; otherwise deselect all.
@@ -243,13 +257,9 @@ export class SceneListing {
             e.stopPropagation();
         });
 
-        // Hover highlight respecting selection filter
-        nameBtn.addEventListener('mouseenter', () => {
-            try { SelectionFilter.setHoverByName(this.scene, obj.name); } catch (_) { }
-        });
-        nameBtn.addEventListener('mouseleave', () => {
-            try { SelectionFilter.clearHover(); } catch (_) { }
-        });
+        // Hover highlight for the full row (ignore selection filter)
+        row.addEventListener('pointerenter', hoverOn);
+        row.addEventListener('pointerleave', hoverOff);
 
         // Row assembly
         row.appendChild(toggle);
@@ -300,6 +310,8 @@ export class SceneListing {
                 info.lastSelected = sel;
                 info.li.classList.toggle("is-selected", sel);
             }
+            const hovered = this._hoveredUuids.has(obj.uuid);
+            info.li.classList.toggle("is-hovered", hovered);
 
             // Keep label fresh (names may change externally)
             const wantLabel = this.#labelFor(obj);
@@ -310,6 +322,28 @@ export class SceneListing {
         }
     }
 
+    #syncHoverFromScene(ev) {
+        const detail = ev?.detail || {};
+        let uuids = [];
+        if (Array.isArray(detail.uuids) && detail.uuids.length) {
+            uuids = detail.uuids;
+        } else if (Array.isArray(detail.objects)) {
+            uuids = detail.objects.map((obj) => obj?.uuid).filter(Boolean);
+        }
+        const next = new Set(uuids);
+        for (const uuid of this._hoveredUuids) {
+            if (next.has(uuid)) continue;
+            const info = this.nodes.get(uuid);
+            if (info) info.li.classList.remove('is-hovered');
+        }
+        for (const uuid of next) {
+            if (this._hoveredUuids.has(uuid)) continue;
+            const info = this.nodes.get(uuid);
+            if (info) info.li.classList.add('is-hovered');
+        }
+        this._hoveredUuids = next;
+    }
+
     // ---- Actions --------------------------------------------------------------
 
     #setSelectedRecursive(obj, sel) {
@@ -568,6 +602,10 @@ export class SceneListing {
   background: var(--sel);
   box-shadow: inset 0 0 0 1px var(--accent);
 }
+.scene-tree__item.is-hovered > .scene-tree__row{
+  background: #142033;
+  box-shadow: inset 0 0 0 1px rgba(74,163,255,.45);
+}
 .scene-tree__item.is-parent.open > .scene-tree__row{ border-bottom:1px solid #111a26; }
 .st-caret{
   width:20px; height:20px; border:0; background:transparent; color:var(--muted);