brep-io-kernel 1.0.21 → 1.0.23

package/src/UI/assembly/constraintSelectionUtils.js

@@ -1,185 +1,6 @@
+import { resolveSelectionObject as resolveSelectionObjectBase, scoreObjectForNormal } from '../../utils/selectionResolver.js';
+
 export function resolveSelectionObject(scene, selection, options = {}) {
   const scoreFn = typeof options.scoreFn === 'function' ? options.scoreFn : scoreObjectForNormal;
-  return internalResolveSelectionObject(scene, selection, { scoreFn });
-}
-
-function internalResolveSelectionObject(scene, selection, options) {
-  if (!scene || selection == null) return null;
-  if (selection.isObject3D) return selection;
-
-  if (Array.isArray(selection)) {
-    for (const item of selection) {
-      const resolved = internalResolveSelectionObject(scene, item, options);
-      if (resolved) return resolved;
-    }
-    return null;
-  }
-
-  if (typeof selection === 'string') {
-    return resolveObjectFromString(scene, selection, options);
-  }
-
-  if (typeof selection === 'object') {
-    if (selection.isObject3D) return selection;
-    const {
-      uuid,
-      name,
-      id,
-      path,
-      reference,
-      target,
-    } = selection;
-
-    if (typeof uuid === 'string') {
-      try {
-        const found = scene.getObjectByProperty?.('uuid', uuid);
-        if (found) return found;
-      } catch { /* ignore */ }
-    }
-
-    const resolveCandidate = (candidate) => (
-      typeof candidate === 'string'
-        ? resolveObjectFromString(scene, candidate, options)
-        : null
-    );
-
-    const nameCandidate = typeof name === 'string'
-      ? name
-      : (typeof selection?.selectionName === 'string' ? selection.selectionName : null);
-    const idCandidate = typeof id === 'string' ? id : null;
-
-    const nameResolved = resolveCandidate(nameCandidate);
-    if (nameResolved) return nameResolved;
-
-    const idResolved = resolveCandidate(idCandidate);
-    if (idResolved) return idResolved;
-
-    if (Array.isArray(path)) {
-      for (let i = path.length - 1; i >= 0; i -= 1) {
-        const segment = path[i];
-        if (typeof segment !== 'string') continue;
-        const resolved = resolveObjectFromString(scene, segment, options);
-        if (resolved) return resolved;
-      }
-    }
-
-    if (reference != null) {
-      const resolved = internalResolveSelectionObject(scene, reference, options);
-      if (resolved) return resolved;
-    }
-
-    if (target != null) {
-      const resolved = internalResolveSelectionObject(scene, target, options);
-      if (resolved) return resolved;
-    }
-  }
-
-  return null;
-}
-
-function resolveObjectFromString(scene, value, options) {
-  if (!scene || typeof value !== 'string') return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-
-  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed != null) {
-        const resolved = internalResolveSelectionObject(scene, parsed, options);
-        if (resolved) return resolved;
-      }
-    } catch { /* ignore JSON parse errors */ }
-  }
-
-  const direct = findObjectByName(scene, trimmed, options.scoreFn);
-  if (direct) return direct;
-
-  if (looksLikeUUID(trimmed)) {
-    try {
-      const byUuid = scene.getObjectByProperty?.('uuid', trimmed);
-      if (byUuid) return byUuid;
-    } catch { /* ignore */ }
-  }
-
-  const candidates = new Set();
-  candidates.add(trimmed);
-
-  const splitByDelims = trimmed.split(/›|>|\/|\||→|->/);
-  if (splitByDelims.length > 1) {
-    for (const segment of splitByDelims) {
-      const s = segment.trim();
-      if (s) candidates.add(s);
-    }
-  }
-
-  if (trimmed.includes(':')) {
-    for (const segment of trimmed.split(':')) {
-      const s = segment.trim();
-      if (s) candidates.add(s);
-    }
-  }
-
-  for (const candidate of candidates) {
-    const found = findObjectByName(scene, candidate, options.scoreFn);
-    if (found) return found;
-  }
-
-  let fallback = null;
-  try {
-    scene.traverse?.((obj) => {
-      if (fallback || !obj?.name) return;
-      if (!trimmed.includes(obj.name)) return;
-      if (!fallback) {
-        fallback = obj;
-        return;
-      }
-      const currentScore = options.scoreFn(fallback);
-      const nextScore = options.scoreFn(obj);
-      if (nextScore > currentScore || obj.name.length > fallback.name.length) {
-        fallback = obj;
-      }
-    });
-  } catch { /* ignore */ }
-
-  return fallback;
-}
-
-function findObjectByName(scene, name, scoreFn) {
-  if (!scene || typeof name !== 'string' || !name) return null;
-
-  if (typeof scene.traverse !== 'function') {
-    return scene?.getObjectByName?.(name) || null;
-  }
-
-  let best = null;
-  scene.traverse((obj) => {
-    if (!obj || obj.name !== name) return;
-    if (!best) {
-      best = obj;
-      return;
-    }
-    const currentScore = scoreFn(best);
-    const newScore = scoreFn(obj);
-    if (newScore > currentScore) best = obj;
-  });
-
-  if (best) return best;
-  if (typeof scene.getObjectByName === 'function') return scene.getObjectByName(name);
-  return null;
-}
-
-function looksLikeUUID(value) {
-  if (typeof value !== 'string') return false;
-  const trimmed = value.trim();
-  if (trimmed.length !== 36) return false;
-  return /^[0-9a-fA-F-]{36}$/.test(trimmed);
-}
-
-function scoreObjectForNormal(object) {
-  if (!object) return -Infinity;
-  const type = object.userData?.type || object.userData?.brepType || object.type;
-  if (String(type).toUpperCase() === 'FACE') return 3;
-  if (object.geometry) return 2;
-  return 1;
+  return resolveSelectionObjectBase(scene, selection, { ...options, scoreFn });
 }

package/src/UI/{assembly/constraintFaceUtils.js → faceUtils.js}

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import { objectRepresentativePoint } from '../pmi/annUtils.js';
+import { objectRepresentativePoint } from './pmi/annUtils.js';
 
 export function isFaceObject(object) {
   if (!object) return false;
@@ -35,6 +35,21 @@ export function computeFaceOrigin(object) {
   return null;
 }
 
+export function computeFaceCenter(object) {
+  if (!object) return null;
+  try { object.updateMatrixWorld?.(true); } catch { /* ignore */ }
+  try {
+    const box = new THREE.Box3().setFromObject(object);
+    if (!box.isEmpty()) return box.getCenter(new THREE.Vector3());
+  } catch { /* ignore */ }
+  try {
+    const geom = object.geometry;
+    const bs = geom?.boundingSphere || (geom?.computeBoundingSphere && (geom.computeBoundingSphere(), geom.boundingSphere));
+    if (bs) return object.localToWorld(bs.center.clone());
+  } catch { /* ignore */ }
+  return computeFaceOrigin(object);
+}
+
 export function computeFaceNormal(object) {
   if (!object) return null;
   try {
@@ -45,9 +60,11 @@ export function computeFaceNormal(object) {
   } catch { /* ignore */ }
 
   const geom = object.geometry;
-  if (!geom?.isBufferGeometry) return null;
+  if (!geom?.isBufferGeometry) {
+    return fallbackQuaternionNormal(object);
+  }
   const pos = geom.getAttribute?.('position');
-  if (!pos || pos.itemSize !== 3 || pos.count < 3) return null;
+  if (!pos || pos.itemSize !== 3 || pos.count < 3) return fallbackQuaternionNormal(object);
   const index = geom.getIndex?.();
 
   const v0 = new THREE.Vector3();
@@ -94,10 +111,10 @@ export function computeFaceNormal(object) {
     }
   }
 
-  if (count === 0) return null;
+  if (count === 0) return fallbackQuaternionNormal(object);
 
   accum.divideScalar(count);
-  if (accum.lengthSq() <= 1e-10) return null;
+  if (accum.lengthSq() <= 1e-10) return fallbackQuaternionNormal(object);
 
   return accum.normalize();
 }
@@ -113,3 +130,11 @@ export function estimateArrowLength(object) {
   }
   return 10;
 }
+
+function fallbackQuaternionNormal(object) {
+  try {
+    const q = object?.getWorldQuaternion?.(new THREE.Quaternion());
+    if (q) return new THREE.Vector3(0, 0, 1).applyQuaternion(q).normalize();
+  } catch { /* ignore */ }
+  return null;
+}

package/src/UI/featureDialogs.js

@@ -1047,50 +1047,50 @@ export class SchemaForm {
         for (const name of list) {
             if (!name) continue;
             const existing = cache.get(name) || null;
-            const snapshot = store ? store[name] : null;
-            if (snapshot) {
-                const snapType = String(snapshot.type || '').toUpperCase();
-                const snapEdges = Array.isArray(snapshot.edgePositions) ? snapshot.edgePositions : null;
-                const isFaceSnap = (snapType === 'FACE' || snapType === 'PLANE') && snapEdges && snapEdges.length;
-                const isEdgeSnap = snapType === 'EDGE' && Array.isArray(snapshot.positions) && snapshot.positions.length >= 6;
-                const isVertexSnap = snapType === 'VERTEX' && Array.isArray(snapshot.position) && snapshot.position.length >= 3;
-                if (isFaceSnap || isEdgeSnap || isVertexSnap) {
-                    const shouldOverride = !existing || !existing.fromSnapshot || isFaceSnap;
-                    if (shouldOverride) {
-                        const ghost = this._buildReferencePreviewFromSnapshot(name, snapshot);
-                        if (ghost) {
-                            cache.set(name, {
-                                object: ghost,
-                                type: snapshot.type || null,
-                                sourceUuid: snapshot.sourceUuid || null,
-                                sourceFeatureId: snapshot.sourceFeatureId || null,
-                                showWhenOriginalPresent: isFaceSnap || !!ghost?.userData?.previewHasEdges,
-                                fromSnapshot: true,
-                            });
-                            continue;
-                        }
-                    }
-                }
-            }
-            if (cache.has(name)) continue;
             const obj = scene.getObjectByName(name);
             if (obj && !obj?.userData?.refPreview) {
-                this._storeReferencePreviewSnapshot(inputEl, def, obj);
+                const objType = String(obj.type || '').toUpperCase();
+                const isEdgeObj = objType === SelectionFilter.EDGE || objType === 'EDGE';
+                const objTimestamp = (obj.timestamp ?? obj.userData?.timestamp ?? null);
+                const existingTimestamp = existing?.sourceTimestamp ?? null;
+                const shouldRefresh = !existing
+                    || existing.fromSnapshot
+                    || (!!existing?.sourceUuid && !!obj.uuid && existing.sourceUuid !== obj.uuid)
+                    || (!existing?.sourceUuid && !!obj.uuid)
+                    || (objTimestamp != null && existingTimestamp !== objTimestamp)
+                    || (isEdgeObj && !existing?.showWhenOriginalPresent);
+                if (shouldRefresh) {
+                    this._storeReferencePreviewSnapshot(inputEl, def, obj);
+                }
                 continue;
             }
-            if (store && store[name]) {
-                const snapshot = store[name];
-                const ghost = this._buildReferencePreviewFromSnapshot(name, snapshot);
-                if (ghost) {
-                    cache.set(name, {
-                        object: ghost,
-                        type: snapshot.type || null,
-                        sourceUuid: snapshot.sourceUuid || null,
-                        sourceFeatureId: snapshot.sourceFeatureId || null,
-                        showWhenOriginalPresent: String(snapshot.type || '').toUpperCase() === 'FACE' || String(snapshot.type || '').toUpperCase() === 'PLANE' || !!ghost?.userData?.previewHasEdges,
-                        fromSnapshot: true,
-                    });
-                }
+            const snapshot = store ? store[name] : null;
+            if (!snapshot) continue;
+            const snapType = String(snapshot.type || '').toUpperCase();
+            const snapEdges = Array.isArray(snapshot.edgePositions) ? snapshot.edgePositions : null;
+            const isFaceSnap = (snapType === 'FACE' || snapType === 'PLANE') && snapEdges && snapEdges.length;
+            const isEdgeSnap = snapType === 'EDGE' && Array.isArray(snapshot.positions) && snapshot.positions.length >= 6;
+            const isVertexSnap = snapType === 'VERTEX' && Array.isArray(snapshot.position) && snapshot.position.length >= 3;
+            if (!(isFaceSnap || isEdgeSnap || isVertexSnap)) continue;
+            const snapTimestamp = snapshot.sourceTimestamp ?? null;
+            const shouldOverride = !existing
+                || !existing.fromSnapshot
+                || isFaceSnap
+                || (!!snapshot.sourceUuid && !!existing?.sourceUuid && snapshot.sourceUuid !== existing.sourceUuid)
+                || (snapTimestamp != null && (existing?.sourceTimestamp ?? null) !== snapTimestamp)
+                || (isEdgeSnap && !existing?.showWhenOriginalPresent);
+            if (!shouldOverride) continue;
+            const ghost = this._buildReferencePreviewFromSnapshot(name, snapshot);
+            if (ghost) {
+                cache.set(name, {
+                    object: ghost,
+                    type: snapshot.type || null,
+                    sourceUuid: snapshot.sourceUuid || null,
+                    sourceFeatureId: snapshot.sourceFeatureId || null,
+                    sourceTimestamp: snapTimestamp,
+                    showWhenOriginalPresent: isFaceSnap || isEdgeSnap || !!ghost?.userData?.previewHasEdges,
+                    fromSnapshot: true,
+                });
             }
         }
     }
@@ -1106,21 +1106,24 @@ export class SchemaForm {
             if (!ghost) return;
             const sourceUuid = obj.uuid || null;
             const sourceFeatureId = this._getOwningFeatureIdForObject(obj);
+            const sourceTimestamp = (obj.timestamp ?? obj.userData?.timestamp ?? null);
+            const objType = String(obj.type || '').toUpperCase();
+            const isEdge = objType === SelectionFilter.EDGE || objType === 'EDGE';
             cache.set(refName, {
                 object: ghost,
                 type: obj.type || null,
                 sourceUuid,
                 sourceFeatureId,
-                showWhenOriginalPresent: !!ghost?.userData?.previewHasEdges,
+                sourceTimestamp,
+                showWhenOriginalPresent: isEdge || !!ghost?.userData?.previewHasEdges,
             });
             try {
                 const store = this._getReferencePreviewPersistentBucket(inputEl);
                 if (store) {
-                    const objType = String(obj.type || '').toUpperCase();
                     if (objType === SelectionFilter.EDGE || objType === 'EDGE') {
                         const positions = this._extractEdgeWorldPositions(obj);
                         if (positions && positions.length >= 6) {
-                            store[refName] = { type: 'EDGE', positions, sourceUuid, sourceFeatureId };
+                            store[refName] = { type: 'EDGE', positions, sourceUuid, sourceFeatureId, sourceTimestamp };
                         }
                     } else if (objType === SelectionFilter.VERTEX || objType === 'VERTEX') {
                         const pos = new THREE.Vector3();
@@ -1128,7 +1131,7 @@ export class SchemaForm {
                             if (typeof obj.getWorldPosition === 'function') obj.getWorldPosition(pos);
                             else pos.set(obj.position?.x || 0, obj.position?.y || 0, obj.position?.z || 0);
                         } catch (_) { }
-                        store[refName] = { type: 'VERTEX', position: [pos.x, pos.y, pos.z], sourceUuid, sourceFeatureId };
+                        store[refName] = { type: 'VERTEX', position: [pos.x, pos.y, pos.z], sourceUuid, sourceFeatureId, sourceTimestamp };
                     }
                 }
             } catch (_) { }
@@ -1275,60 +1278,87 @@ export class SchemaForm {
     _hoverReferenceSelectionItem(inputEl, def, name) {
         try {
             if (!inputEl) return;
-            const activeInput = SchemaForm.__activeRefInput || null;
-            if (activeInput !== inputEl) {
-                const wrap = inputEl.closest?.('.ref-active') || null;
-                if (!wrap) return;
-            }
+            const isActive = (SchemaForm.__activeRefInput || null) === inputEl;
             const normalized = normalizeReferenceName(name);
             if (!normalized) return;
             const scene = this._getReferenceSelectionScene();
             if (!scene) return;
             try { console.log('[ReferenceSelection] Hover', { name: normalized }); } catch (_) { }
-            try { this._ensureReferencePreviewSnapshots(inputEl, def); } catch (_) { }
-            try { this._seedReferencePreviewCacheFromScene(inputEl, def, [normalized], scene); } catch (_) { }
-            try { this._syncActiveReferenceSelectionPreview(inputEl, def); } catch (_) { }
-
-            let target = null;
-            try { target = scene.getObjectByName(normalized); } catch (_) { target = null; }
-            if (!target) {
-                const cache = this._getReferencePreviewCache(inputEl);
-                const entry = cache ? cache.get(normalized) : null;
-                target = entry?.object || entry || null;
+            if (isActive) {
+                try { this._ensureReferencePreviewSnapshots(inputEl, def); } catch (_) { }
             }
-            if (!target) {
-                try { target = scene.getObjectByName(`__refPreview__${normalized}`); } catch (_) { target = null; }
+            try { this._seedReferencePreviewCacheFromScene(inputEl, def, [normalized], scene); } catch (_) { }
+            if (isActive) {
+                try { this._syncActiveReferenceSelectionPreview(inputEl, def); } catch (_) { }
             }
-            if (!target) return;
-            if (!target.material && target.traverse) {
+
+            const resolveHoverCandidate = (obj) => {
+                if (!obj) return null;
+                if (obj.material) return obj;
+                if (!obj.traverse) return obj;
                 let candidate = null;
                 try {
-                    target.traverse((child) => {
+                    obj.traverse((child) => {
                         if (!child || candidate) return;
                         if (child.type === 'REF_PREVIEW_EDGE') { candidate = child; return; }
                         if (child.material) candidate = child;
                     });
                 } catch (_) { }
-                if (candidate) target = candidate;
+                return candidate || obj;
+            };
+
+            const targets = [];
+            const pushTarget = (obj) => {
+                if (!obj || !obj.isObject3D) return;
+                const candidate = resolveHoverCandidate(obj);
+                if (!candidate) return;
+                if (!targets.includes(candidate)) targets.push(candidate);
+            };
+
+            let sceneObj = null;
+            try { sceneObj = scene.getObjectByName(normalized); } catch (_) { sceneObj = null; }
+            if (sceneObj && !sceneObj?.userData?.refPreview) pushTarget(sceneObj);
+
+            const cache = this._getReferencePreviewCache(inputEl);
+            const entry = cache ? cache.get(normalized) : null;
+            const ghost = entry?.object || entry || null;
+            if (ghost && ghost !== sceneObj) pushTarget(ghost);
+
+            let namedPreview = null;
+            try { namedPreview = scene.getObjectByName(`__refPreview__${normalized}`); } catch (_) { namedPreview = null; }
+            if (namedPreview && namedPreview !== sceneObj && namedPreview !== ghost) pushTarget(namedPreview);
+
+            if (!targets.length) return;
+            if (!isActive && ghost && ghost.isObject3D && !ghost.parent) {
+                try {
+                    const group = this._ensureReferencePreviewGroup(inputEl);
+                    if (group && ghost.parent !== group) {
+                        group.add(ghost);
+                        inputEl.__refPreviewHoverGroup = true;
+                    }
+                } catch (_) { }
             }
             try {
                 console.log('[ReferenceSelection] Hover target', {
                     name: normalized,
-                    target: target || null,
-                    inScene: !!(target && target.parent),
+                    targetCount: targets.length,
                 });
             } catch (_) { }
             inputEl.__refChipHoverActive = true;
-            try { SelectionFilter.setHoverObject(target, { ignoreFilter: true }); } catch (_) { }
+            try { SelectionFilter.setHoverObjects(targets, { ignoreFilter: true }); } catch (_) { }
         } catch (_) { }
     }
 
     _clearReferenceSelectionHover(inputEl) {
         try {
-            if (!inputEl || SchemaForm.__activeRefInput !== inputEl) return;
+            if (!inputEl) return;
             if (!inputEl.__refChipHoverActive) return;
             inputEl.__refChipHoverActive = false;
             SelectionFilter.clearHover();
+            if (SchemaForm.__activeRefInput !== inputEl && inputEl.__refPreviewHoverGroup) {
+                inputEl.__refPreviewHoverGroup = false;
+                try { this._removeReferencePreviewGroup(inputEl); } catch (_) { }
+            }
         } catch (_) { }
     }
 

package/src/UI/pmi/LabelOverlay.js

@@ -65,6 +65,38 @@ export class LabelOverlay {
           }
         });
       }
+      if (!el.__wheelPassThrough) {
+        const onWheel = (e) => {
+          if (!el.classList.contains('constraint-label')) return;
+          const canvas = this.viewer?.renderer?.domElement;
+          if (!canvas) return;
+          let canceled = false;
+          try {
+            const forwarded = new WheelEvent(e.type, {
+              bubbles: true,
+              cancelable: true,
+              deltaX: e.deltaX,
+              deltaY: e.deltaY,
+              deltaZ: e.deltaZ,
+              deltaMode: e.deltaMode,
+              clientX: e.clientX,
+              clientY: e.clientY,
+              screenX: e.screenX,
+              screenY: e.screenY,
+              ctrlKey: e.ctrlKey,
+              shiftKey: e.shiftKey,
+              altKey: e.altKey,
+              metaKey: e.metaKey,
+            });
+            canceled = !canvas.dispatchEvent(forwarded);
+          } catch { }
+          if (canceled) {
+            try { e.preventDefault(); } catch { }
+          }
+        };
+        el.addEventListener('wheel', onWheel, { passive: false });
+        el.__wheelPassThrough = onWheel;
+      }
       if (this.onDblClick) el.addEventListener('dblclick', (e) => this.onDblClick(idx, ann, e));
       try { this._root.appendChild(el); this._labelMap.set(idx, el); } catch {}
     } else if (text != null) {

package/src/UI/pmi/PMIMode.js

@@ -12,6 +12,7 @@ import { getPMIStyle, setPMIStyle, sanitizePMIStyle } from './pmiStyle.js';
 import { AnnotationHistory } from './AnnotationHistory.js';
 import { LabelOverlay } from './LabelOverlay.js';
 import { AnnotationCollectionWidget } from './AnnotationCollectionWidget.js';
+import { SelectionFilter } from '../SelectionFilter.js';
 import { localStorage as LS } from '../../idbStorage.js';
 
 const cssEscape = (value) => {
@@ -89,6 +90,9 @@ export class PMIMode {
     const v = this.viewer;
     if (!v || !v.container) return;
 
+    // Clear any lingering reference-selection state before PMI interactions.
+    this.#clearActiveReferenceSelection();
+
     // Save and hide existing accordion sections instead of hiding the whole sidebar
     this.#hideOriginalSidebarSections();
 
@@ -172,6 +176,22 @@ export class PMIMode {
     try { this._annotationWidget?.collapseExpandedEntries?.({ clearOpenState: true }); } catch { /* ignore */ }
   }
 
+  #clearActiveReferenceSelection() {
+    try {
+      const active = document.querySelectorAll('[active-reference-selection="true"],[active-reference-selection=true]');
+      active.forEach((el) => {
+        try { el.style.filter = 'none'; } catch { }
+        try { el.removeAttribute('active-reference-selection'); } catch { }
+        try {
+          const wrap = el.closest('.ref-single-wrap, .ref-multi-wrap');
+          if (wrap) wrap.classList.remove('ref-active');
+        } catch { }
+      });
+    } catch { }
+    try { if (window.__BREP_activeRefInput) window.__BREP_activeRefInput = null; } catch { }
+    try { SelectionFilter.restoreAllowedSelectionTypes(); } catch { }
+  }
+
   applyViewTransformsSequential() {
     try {
       this.#applyViewTransforms();
@@ -599,6 +619,9 @@ export class PMIMode {
               this.#markAnnotationsDirty();
             },
           });
+          // Avoid auto-activating reference selection on expand; PMI scene clicks should
+          // stay as normal selections unless the user explicitly activates a ref field.
+          this._annotationWidget._autoFocusOnExpand = false;
           widgetWrap.appendChild(this._annotationWidget.uiElement);
 
           this._pmiAnnotationsSection = sec;

package/src/UI/pmi/dimensions/HoleCalloutAnnotation.js

@@ -331,13 +331,19 @@ function hasHoleMetadata(target) {
   if (!target) return false;
   const queue = [target];
   const visited = new Set();
+  const hasOwnFaces = (obj) => Object.prototype.hasOwnProperty.call(obj, 'faces');
   while (queue.length) {
     const obj = queue.shift();
     if (!obj || visited.has(obj)) continue;
     visited.add(obj);
     if (readHoleMetadata(obj)) return true;
-    if (Array.isArray(obj.faces)) {
+    if (hasOwnFaces(obj) && Array.isArray(obj.faces)) {
       for (const face of obj.faces) queue.push(face);
+    } else if (obj.type === 'SOLID' || obj.type === 'COMPONENT') {
+      const kids = Array.isArray(obj.children) ? obj.children : [];
+      for (const child of kids) {
+        if (child && child.type === 'FACE') queue.push(child);
+      }
     }
     if (obj.parent) queue.push(obj.parent);
   }

package/src/UI/toolbarButtons/orientToFaceButton.js

@@ -1,4 +1,5 @@
 import * as THREE from 'three';
+import { computeFaceCenter, computeFaceNormal } from '../faceUtils.js';
 
 const FACE_TYPES = new Set(['FACE', 'PLANE']);
 
@@ -26,46 +27,12 @@ function _findSelectedFace(viewer) {
   return found;
 }
 
-function _computeFaceCenter(obj) {
-  if (!obj) return null;
-  try { obj.updateMatrixWorld?.(true); } catch {}
-  try {
-    const box = new THREE.Box3().setFromObject(obj);
-    if (!box.isEmpty()) return box.getCenter(new THREE.Vector3());
-  } catch {}
-  try {
-    const geom = obj.geometry;
-    const bs = geom?.boundingSphere || (geom?.computeBoundingSphere && (geom.computeBoundingSphere(), geom.boundingSphere));
-    if (bs) return obj.localToWorld(bs.center.clone());
-  } catch {}
-  try {
-    return obj.getWorldPosition?.(new THREE.Vector3()) || null;
-  } catch {}
-  return null;
-}
-
-function _computeFaceNormal(obj) {
-  if (!obj) return null;
-  let n = null;
-  if (typeof obj.getAverageNormal === 'function') {
-    try { n = obj.getAverageNormal().clone(); } catch {}
-  }
-  if (!n || n.lengthSq() < 1e-10) {
-    try {
-      const q = obj.getWorldQuaternion?.(new THREE.Quaternion());
-      if (q) n = new THREE.Vector3(0, 0, 1).applyQuaternion(q);
-    } catch {}
-  }
-  if (!n || n.lengthSq() < 1e-10) return null;
-  return n.normalize();
-}
-
 function _orientCameraToFace(viewer, face) {
   const cam = viewer?.camera;
   if (!viewer || !cam || !face) return false;
 
-  const target = _computeFaceCenter(face);
-  const normal = _computeFaceNormal(face);
+  const target = computeFaceCenter(face);
+  const normal = computeFaceNormal(face);
   if (!target || !normal) return false;
 
   const toCam = cam.position.clone().sub(target);

package/src/UI/toolbarButtons/registerDefaultButtons.js

@@ -11,6 +11,7 @@ import { createFlatPatternButton } from './flatPatternButton.js';
 import { createAboutButton } from './aboutButton.js';
 import { createTestsButton } from './testsButton.js';
 import { createScriptRunnerButton } from './scriptRunnerButton.js';
+import { createSelectionStateButton } from './selectionStateButton.js';
 
 export function registerDefaultToolbarButtons(viewer) {
   if (!viewer || typeof viewer.addToolbarButton !== 'function') return;
@@ -25,6 +26,7 @@ export function registerDefaultToolbarButtons(viewer) {
     createAboutButton,
     createTestsButton,
     createScriptRunnerButton,
+    createSelectionStateButton,
     createUndoButton,
     createRedoButton,
   ];