brep-io-kernel 1.0.20 → 1.0.22

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

@@ -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') {
@@ -1001,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,
+                });
             }
         }
     }
@@ -1060,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();
@@ -1082,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 (_) { }
@@ -1229,64 +1278,100 @@ 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 (_) { }
     }
 
     _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();