brep-io-kernel 1.0.19 → 1.0.21

package/src/UI/featureDialogs.js

@@ -455,6 +455,52 @@ export class SchemaForm {
         return false;
     }
 
+    // Focus the first available field in this form (or activate a reference selection when needed).
+    focusFirstField() {
+        const canFocus = (el) => {
+            if (!el || typeof el.focus !== 'function') return false;
+            if (el.disabled) return false;
+            const ariaDisabled = el.getAttribute ? el.getAttribute('aria-disabled') : null;
+            if (ariaDisabled === 'true') return false;
+            return true;
+        };
+        const tryFocus = (el) => {
+            if (!canFocus(el)) return false;
+            try { el.focus(); } catch (_) { return false; }
+            return true;
+        };
+
+        for (const key in this.schema) {
+            if (!Object.prototype.hasOwnProperty.call(this.schema, key)) continue;
+            if (this._excludedKeys.has(key)) continue;
+            const def = this.schema[key];
+            const row = this._fieldsWrap?.querySelector?.(`[data-key="${key}"]`) || null;
+
+            // Reference selections should auto-activate instead of just focusing the display button.
+            if (def && def.type === 'reference_selection') {
+                if (this.activateField(key)) return true;
+            }
+
+            // Prefer direct inputs first.
+            if (row) {
+                const input = row.querySelector('input:not([type="hidden"]), select, textarea');
+                if (tryFocus(input)) return true;
+                const btn = row.querySelector('button, [tabindex]:not([tabindex="-1"])');
+                if (tryFocus(btn)) return true;
+            }
+
+            const inputEl = this._inputs.get(key);
+            if (inputEl && inputEl.getAttribute && inputEl.getAttribute('type') !== 'hidden') {
+                if (tryFocus(inputEl)) return true;
+            }
+        }
+
+        const root = this._shadow || this.uiElement;
+        const any = root?.querySelector?.('input:not([type="hidden"]), select, textarea, button, [tabindex]:not([tabindex="-1"])');
+        if (tryFocus(any)) return true;
+        return false;
+    }
+
     readFieldValue(key) {
         const widget = this._widgets.get(key);
         if (widget && typeof widget.readValue === 'function') {
@@ -1287,6 +1333,15 @@ export class SchemaForm {
     }
 
     _activateReferenceSelection(inputEl, def) {
+        // If switching between reference fields, fully stop the previous session so
+        // selection filters restore correctly (prevents sticky FACE-only state).
+        try {
+            const prevActive = SchemaForm.__activeRefInput || null;
+            if (prevActive && prevActive !== inputEl) {
+                this._stopActiveReferenceSelection();
+            }
+        } catch (_) { }
+
         // Clear any lingering scene selection so the new reference starts fresh
         try {
             const scene = this._getReferenceSelectionScene();

package/src/UI/history/HistoryCollectionWidget.js

@@ -95,6 +95,8 @@ export class HistoryCollectionWidget {
     this._itemEls = new Map();
     this._forms = new Map();
     this._uiFieldSignatures = new Map();
+    this._autoFocusOnExpand = false;
+    this._pendingFocusEntryId = null;
     this._boundHistoryListener = null;
     this._listenerUnsub = null;
     this._suppressHistoryListener = false;
@@ -157,6 +159,7 @@ export class HistoryCollectionWidget {
 
     if (!entries.length) {
       this._setContextSuppression(false);
+      this._pendingFocusEntryId = null;
       const empty = document.createElement('div');
       empty.className = 'hc-empty';
       empty.textContent = 'No entries yet.';
@@ -198,6 +201,8 @@ export class HistoryCollectionWidget {
       const itemEl = this._renderEntry(entry, id, i, targetId === id, entries.length);
       this._listEl.appendChild(itemEl);
     }
+
+    this._applyPendingFocus();
   }
 
   _destroyForm(id) {
@@ -223,6 +228,36 @@ export class HistoryCollectionWidget {
     return this._forms.get(String(id)) || null;
   }
 
+  // Close any expanded entry dialog and optionally clear stored open state.
+  collapseExpandedEntries({ clearOpenState = true, notify = true } = {}) {
+    const prevId = this._expandedId != null ? String(this._expandedId) : null;
+    let prevEntry = null;
+    if (prevId) {
+      const info = this._findEntryInfoById(prevId);
+      prevEntry = info?.entry || null;
+    }
+
+    if (clearOpenState && this._autoSyncOpenState) {
+      if (prevEntry) {
+        this._applyOpenState(prevEntry, false);
+      } else {
+        const entries = this._getEntries();
+        for (const entry of entries) {
+          this._applyOpenState(entry, false);
+        }
+      }
+    }
+
+    if (!prevId) {
+      this._setContextSuppression(false);
+      return;
+    }
+
+    this._expandedId = null;
+    this.render();
+    if (notify) this._notifyEntryToggle(prevEntry, false);
+  }
+
   _getEntries() {
     if (!this.history) return [];
     if (Array.isArray(this.history.entries)) return this.history.entries;
@@ -414,6 +449,7 @@ export class HistoryCollectionWidget {
         this._applyOpenState(targetEntry, false);
       }
       this._expandedId = null;
+      this._pendingFocusEntryId = null;
       this.render();
       this._notifyEntryToggle(targetEntry, false);
       return;
@@ -425,6 +461,9 @@ export class HistoryCollectionWidget {
       if (targetEntry) this._applyOpenState(targetEntry, true);
     }
     this._expandedId = targetEntry ? targetId : null;
+    if (this._autoFocusOnExpand && targetEntry) {
+      this._pendingFocusEntryId = targetId;
+    }
     this.render();
     if (previousInfo?.entry) this._notifyEntryToggle(previousInfo.entry, false);
     if (targetEntry) this._notifyEntryToggle(targetEntry, true);
@@ -613,6 +652,30 @@ export class HistoryCollectionWidget {
     }
   }
 
+  _applyPendingFocus() {
+    if (!this._autoFocusOnExpand) return;
+    const targetId = this._pendingFocusEntryId;
+    if (!targetId) return;
+    if (!this._expandedId || String(this._expandedId) !== String(targetId)) {
+      this._pendingFocusEntryId = null;
+      return;
+    }
+    const form = this.getFormForEntry(targetId);
+    if (!form) {
+      this._pendingFocusEntryId = null;
+      return;
+    }
+    const focus = () => {
+      try {
+        if (typeof form.focusFirstField === 'function') form.focusFirstField();
+        else if (typeof form.activateFirstReferenceSelection === 'function') form.activateFirstReferenceSelection();
+      } catch (_) { /* ignore */ }
+    };
+    if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => focus());
+    else setTimeout(focus, 0);
+    this._pendingFocusEntryId = null;
+  }
+
   async _moveEntry(id, delta) {
     if (!id) return;
     const entries = this._getEntries();
@@ -671,6 +734,7 @@ export class HistoryCollectionWidget {
           }
           if (this._autoSyncOpenState) this._applyOpenState(entry, true);
           this._expandedId = normalizedId;
+          if (this._autoFocusOnExpand) this._pendingFocusEntryId = normalizedId;
           createdEntryId = normalizedId;
         }
       } catch (_) { /* ignore */ }
@@ -693,6 +757,7 @@ export class HistoryCollectionWidget {
       }
       if (this._autoSyncOpenState) this._applyOpenState(entry, true);
       this._expandedId = normalizedId;
+      if (this._autoFocusOnExpand) this._pendingFocusEntryId = normalizedId;
       createdEntryId = normalizedId;
     }
     this.render();

package/src/UI/pmi/AnnotationCollectionWidget.js

@@ -53,6 +53,7 @@ export class AnnotationCollectionWidget extends HistoryCollectionWidget {
     });
 
     this.pmimode = pmimode || null;
+    this._autoFocusOnExpand = true;
   }
 
   #applyEntryChange({ entry, details }) {

package/src/UI/pmi/BaseAnnotation.js

@@ -15,6 +15,43 @@ export class BaseAnnotation extends ListEntityBase {
     this.resultArtifacts = [];
   }
 
+  static _normalizeSelectionItems(selectedItems) {
+    return Array.isArray(selectedItems) ? selectedItems : [];
+  }
+
+  static _normalizeSelectionType(type) {
+    return String(type || '').toUpperCase();
+  }
+
+  static _isSelectionType(item, allowed) {
+    if (!allowed || !allowed.size) return true;
+    return allowed.has(BaseAnnotation._normalizeSelectionType(item?.type));
+  }
+
+  static _selectionRefName(item) {
+    return item?.name
+      || item?.userData?.faceName
+      || item?.userData?.edgeName
+      || item?.userData?.vertexName
+      || item?.userData?.solidName
+      || item?.userData?.name
+      || null;
+  }
+
+  static _collectSelectionRefs(selectedItems, types = null) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    const allowed = Array.isArray(types)
+      ? new Set(types.map((t) => BaseAnnotation._normalizeSelectionType(t)))
+      : null;
+    const refs = [];
+    for (const item of items) {
+      if (!BaseAnnotation._isSelectionType(item, allowed)) continue;
+      const ref = BaseAnnotation._selectionRefName(item);
+      if (ref) refs.push(ref);
+    }
+    return refs;
+  }
+
   async run(renderingContext) {
     // Base implementation - subclasses should override
     // renderingContext contains: { pmimode, group, idx, ctx }

package/src/UI/pmi/PMIMode.js

@@ -168,6 +168,10 @@ export class PMIMode {
     try { if (v.controls) v.controls.enabled = true; } catch { }
   }
 
+  collapseExpandedDialogs() {
+    try { this._annotationWidget?.collapseExpandedEntries?.({ clearOpenState: true }); } catch { /* ignore */ }
+  }
+
   applyViewTransformsSequential() {
     try {
       this.#applyViewTransforms();

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

@@ -71,6 +71,11 @@ export class AngleDimensionAnnotation extends BaseAnnotation {
   static longName = 'Angle Dimension';
   static title = 'Angle';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['FACE', 'EDGE']);
+    if (refs.length < 2) return false;
+    return { params: { targets: refs.slice(0, 2) } };
+  }
 
   constructor(opts = {}) {
     super(opts);

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

@@ -41,6 +41,11 @@ export class ExplodeBodyAnnotation extends BaseAnnotation {
   static title = 'Explode Body';
   static inputParamsSchema = inputParamsSchema;
   static aliases = ['viewTransform'];
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['SOLID']);
+    if (!refs.length) return false;
+    return { params: { targets: refs } };
+  }
 
   constructor(opts = {}) {
     super(opts);

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

@@ -71,6 +71,17 @@ export class HoleCalloutAnnotation extends BaseAnnotation {
   static longName = 'Hole Callout';
   static title = 'Hole Callout';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    const allowed = new Set(['VERTEX', 'EDGE', 'FACE']);
+    for (const item of items) {
+      if (!BaseAnnotation._isSelectionType(item, allowed)) continue;
+      if (!hasHoleMetadata(item)) continue;
+      const ref = BaseAnnotation._selectionRefName(item);
+      if (ref) return { params: { target: ref } };
+    }
+    return false;
+  }
 
   constructor(opts = {}) {
     super(opts);
@@ -293,6 +304,46 @@ function findHoleDescriptor(partHistory, targetObj, fallbackPoint, targetName =
   return descriptors[0];
 }
 
+function readHoleMetadata(obj) {
+  if (!obj) return null;
+  const ud = obj.userData || null;
+  if (ud?.hole) return ud.hole;
+  if (ud?.metadata?.hole) return ud.metadata.hole;
+  if (typeof obj.getMetadata === 'function') {
+    try {
+      const meta = obj.getMetadata();
+      if (meta?.hole) return meta.hole;
+      if (meta?.metadata?.hole) return meta.metadata.hole;
+    } catch { /* ignore */ }
+  }
+  const faceName = obj?.name || ud?.faceName || null;
+  const parentSolid = obj?.parentSolid || ud?.parentSolid || null;
+  if (faceName && parentSolid && typeof parentSolid.getFaceMetadata === 'function') {
+    try {
+      const meta = parentSolid.getFaceMetadata(faceName);
+      if (meta?.hole) return meta.hole;
+    } catch { /* ignore */ }
+  }
+  return null;
+}
+
+function hasHoleMetadata(target) {
+  if (!target) return false;
+  const queue = [target];
+  const visited = new Set();
+  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)) {
+      for (const face of obj.faces) queue.push(face);
+    }
+    if (obj.parent) queue.push(obj.parent);
+  }
+  return false;
+}
+
 
 function formatHoleCallout(desc, quantity = 1, options = {}) {
   if (!desc) return '';

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

@@ -65,6 +65,11 @@ export class LeaderAnnotation extends BaseAnnotation {
   static longName = 'Leader';
   static title = 'Leader';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['VERTEX']);
+    if (!refs.length) return false;
+    return { params: { target: refs } };
+  }
 
   constructor(opts = {}) {
     super(opts);

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

@@ -9,22 +9,7 @@ const inputParamsSchema = {
     label: 'ID',
     hint: 'unique identifier for the linear dimension',
   },
-  decimals: {
-    type: 'number',
-    default_value: 3,
-    defaultResolver: ({ pmimode }) => {
-      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
-        ? (pmimode._opts.dimDecimals | 0)
-        : undefined;
-      if (!Number.isFinite(dec)) return undefined;
-      return Math.max(0, Math.min(8, dec));
-    },
-    label: 'Decimals',
-    hint: 'Number of decimal places to display',
-    min: 0,
-    max: 8,
-    step: 1,
-  },
+
   targets: {
     type: 'reference_selection',
     selectionFilter: ['VERTEX', 'EDGE'],
@@ -67,6 +52,22 @@ const inputParamsSchema = {
     label: 'Reference',
     hint: 'Mark as reference dimension (parentheses)',
   },
+  decimals: {
+    type: 'number',
+    default_value: 3,
+    defaultResolver: ({ pmimode }) => {
+      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
+        ? (pmimode._opts.dimDecimals | 0)
+        : undefined;
+      if (!Number.isFinite(dec)) return undefined;
+      return Math.max(0, Math.min(8, dec));
+    },
+    label: 'Decimals',
+    hint: 'Number of decimal places to display',
+    min: 0,
+    max: 8,
+    step: 1,
+  },
 };
 
 export class LinearDimensionAnnotation extends BaseAnnotation {
@@ -76,6 +77,11 @@ export class LinearDimensionAnnotation extends BaseAnnotation {
   static longName = 'Linear Dimension';
   static title = 'Linear';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const refs = BaseAnnotation._collectSelectionRefs(selectedItems, ['VERTEX', 'EDGE']);
+    if (!refs.length) return false;
+    return { params: { targets: refs.slice(0, 2) } };
+  }
 
   constructor(opts = {}) {
     super(opts);

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

@@ -4,6 +4,7 @@
 import * as THREE from 'three';
 import { BaseAnnotation } from '../BaseAnnotation.js';
 import { getPMIStyle } from '../pmiStyle.js';
+import { objectRepresentativePoint } from '../annUtils.js';
 
 const inputParamsSchema = {
   id: {
@@ -34,6 +35,14 @@ export class NoteAnnotation extends BaseAnnotation {
   static longName = 'Note';
   static title = 'Note';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    if (!items.length) return false;
+    const anchor = items[0];
+    const point = objectRepresentativePoint(null, anchor);
+    if (!point) return false;
+    return { params: { position: { x: point.x, y: point.y, z: point.z } } };
+  }
 
   constructor(opts = {}) {
     super(opts);

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

@@ -9,22 +9,6 @@ const inputParamsSchema = {
     label: 'ID',
     hint: 'unique identifier for the radial dimension',
   },
-  decimals: {
-    type: 'number',
-    default_value: 3,
-    defaultResolver: ({ pmimode }) => {
-      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
-        ? (pmimode._opts.dimDecimals | 0)
-        : undefined;
-      if (!Number.isFinite(dec)) return undefined;
-      return Math.max(0, Math.min(8, dec));
-    },
-    label: 'Decimals',
-    hint: 'Number of decimal places to display',
-    min: 0,
-    max: 8,
-    step: 1,
-  },
   cylindricalFaceRef: {
     type: 'reference_selection',
     selectionFilter: ['FACE'],
@@ -68,6 +52,22 @@ const inputParamsSchema = {
     label: 'Reference',
     hint: 'Mark as reference dimension (parentheses)',
   },
+  decimals: {
+    type: 'number',
+    default_value: 3,
+    defaultResolver: ({ pmimode }) => {
+      const dec = Number.isFinite(pmimode?._opts?.dimDecimals)
+        ? (pmimode._opts.dimDecimals | 0)
+        : undefined;
+      if (!Number.isFinite(dec)) return undefined;
+      return Math.max(0, Math.min(8, dec));
+    },
+    label: 'Decimals',
+    hint: 'Number of decimal places to display',
+    min: 0,
+    max: 8,
+    step: 1,
+  },
 };
 
 export class RadialDimensionAnnotation extends BaseAnnotation {
@@ -77,6 +77,17 @@ export class RadialDimensionAnnotation extends BaseAnnotation {
   static longName = 'Radial Dimension';
   static title = 'Radial';
   static inputParamsSchema = inputParamsSchema;
+  static showContexButton(selectedItems) {
+    const items = BaseAnnotation._normalizeSelectionItems(selectedItems);
+    const allowed = new Set(['FACE']);
+    for (const item of items) {
+      if (!BaseAnnotation._isSelectionType(item, allowed)) continue;
+      if (!hasCylindricalMetadata(item)) continue;
+      const ref = BaseAnnotation._selectionRefName(item);
+      if (ref) return { params: { cylindricalFaceRef: ref } };
+    }
+    return false;
+  }
 
   constructor(opts = {}) {
     super(opts);
@@ -345,6 +356,60 @@ function computeRadialPoints(pmimode, ann, ctx) {
   }
 }
 
+function isCylindricalMetadata(meta) {
+  if (!meta || typeof meta !== 'object') return false;
+  const type = String(meta.type || '').toLowerCase();
+  if (type === 'cylindrical') {
+    const radius = Number(meta.radius);
+    return Number.isFinite(radius) && radius > 0;
+  }
+  if (type === 'conical') {
+    const r0 = Number(meta.radiusBottom);
+    const r1 = Number(meta.radiusTop);
+    if (!Number.isFinite(r0) || !Number.isFinite(r1)) return false;
+    if (Math.abs(r0 - r1) > 1e-6) return false;
+    return Math.max(r0, r1) > 0;
+  }
+  return false;
+}
+
+function readCylindricalMetadata(obj) {
+  if (!obj) return null;
+  const ud = obj.userData || null;
+  if (ud?.metadata && isCylindricalMetadata(ud.metadata)) return ud.metadata;
+  if (typeof obj.getMetadata === 'function') {
+    try {
+      const meta = obj.getMetadata();
+      if (isCylindricalMetadata(meta)) return meta;
+    } catch { /* ignore */ }
+  }
+  const faceName = obj?.name || ud?.faceName || null;
+  let owner = obj?.parentSolid || ud?.parentSolid || obj?.parent || null;
+  while (owner) {
+    if (faceName && typeof owner.getFaceMetadata === 'function') {
+      try {
+        const meta = owner.getFaceMetadata(faceName);
+        if (isCylindricalMetadata(meta)) return meta;
+      } catch { /* ignore */ }
+      break;
+    }
+    owner = owner.parent || null;
+  }
+  return null;
+}
+
+function hasCylindricalMetadata(target) {
+  if (!target) return false;
+  if (readCylindricalMetadata(target)) return true;
+  if (Array.isArray(target.faces)) {
+    for (const face of target.faces) {
+      if (readCylindricalMetadata(face)) return true;
+    }
+  }
+  if (target.parent && readCylindricalMetadata(target.parent)) return true;
+  return false;
+}
+
 function measureRadialValue(pmimode, ann) {
   try {
     const data = computeRadialPoints(pmimode, ann);

package/src/UI/viewer.js

@@ -533,6 +533,7 @@ export class Viewer {
         this._attachRendererEvents(el);
 
         SelectionFilter.viewer = this;
+        try { SelectionFilter._ensureSelectionFilterIndicator?.(this); } catch (_) { }
         // Use capture on pointerup to ensure we end interactions even if pointerup fires off-element
         window.addEventListener('pointerup', this._onPointerUp, { passive: false, capture: true });
         document.addEventListener('dblclick', this._onGlobalDoubleClick, { passive: false, capture: true });
@@ -1476,8 +1477,15 @@ export class Viewer {
     // ----------------------------------------
     // PMI Edit Mode API
     // ----------------------------------------
+    _collapseExpandedDialogsForModeSwitch() {
+        try { this.historyWidget?.collapseExpandedEntries?.({ clearOpenState: true, notify: false }); } catch { }
+        try { this.assemblyConstraintsWidget?.collapseExpandedDialogs?.(); } catch { }
+        try { this._pmiMode?.collapseExpandedDialogs?.(); } catch { }
+    }
+
     startPMIMode(viewEntry, viewIndex, widget = this.pmiViewsWidget) {
         const alreadyActive = !!this._pmiMode;
+        try { this._collapseExpandedDialogsForModeSwitch(); } catch { }
         if (!alreadyActive) {
             try { this.assemblyConstraintsWidget?.onPMIModeEnter?.(); } catch { }
         }
@@ -1506,6 +1514,9 @@ export class Viewer {
 
     endPMIMode() {
         const hadMode = !!this._pmiMode;
+        if (hadMode) {
+            try { this._collapseExpandedDialogsForModeSwitch(); } catch { }
+        }
         try { if (this._pmiMode) this._pmiMode.dispose(); } catch { }
         this._pmiMode = null;
         if (hadMode) {
@@ -2365,24 +2376,34 @@ export class Viewer {
 
         // Prefer the intersected object if it is clickable
         let obj = intersection.object;
+        if (obj && obj.type === 'POINTS' && obj.parent && String(obj.parent.type || '').toUpperCase() === SelectionFilter.VERTEX) {
+            obj = obj.parent;
+        }
 
         // If the object (or its ancestors) doesn't expose onClick, climb to one that does
         let target = obj;
         while (target && typeof target.onClick !== 'function' && target.visible) target = target.parent;
+        if (!target) target = obj;
         if (!target) return null;
 
         // Respect selection filter: ensure target is a permitted type, or ALL
         if (typeof isAllowed === 'function') {
             // Allow selecting already-selected items regardless (toggle off), consistent with SceneListing
             if (!isAllowed(target.type) && !target.selected) {
-                // Try to find a closer ancestor/descendant of allowed type that is clickable
+                // Try to find a closer ancestor of allowed type
                 // Ascend first (e.g., FACE hit while EDGE is active should try parent SOLID only if allowed)
                 let t = target.parent;
-                while (t && typeof t.onClick === 'function' && !isAllowed(t.type)) t = t.parent;
-                if (t && typeof t.onClick === 'function' && isAllowed(t.type)) target = t;
+                while (t && !isAllowed(t.type)) t = t.parent;
+                if (t && isAllowed(t.type)) target = t;
                 else return null;
             }
         }
+        if (target && typeof target.onClick !== 'function') {
+            try {
+                const deep = target.type === SelectionFilter.SOLID || target.type === SelectionFilter.COMPONENT;
+                SelectionFilter.ensureSelectionHandlers?.(target, { deep });
+            } catch { }
+        }
         return target;
     }