@mindexec/cli 0.2.436 → 0.2.437

package/wwwroot/_content/MindExecution.Shared/js/mind-map-lod-renderer.js

@@ -51,7 +51,7 @@
     // ▲▲▲ [Usage] ▲▲▲
 
     // Procedural line rendering settings
-    const LOD_RENDERER_BUILD_ID = '20260628-pan-wheel-resident-defer-v840';
+    const LOD_RENDERER_BUILD_ID = '20260713-normal-boundary-delta-v844';
     const DirtyKind = Object.freeze({
         ResidentFullRebuild: 'resident-full-rebuild',
         ResidentPatch: 'resident-patch',
@@ -896,6 +896,12 @@
             this._css3dPrewarmMax = 128;
             this._css3dPrewarmPerIdle = 4;
             this._css3dPrewarmBudgetMs = 6;
+            this._fullResCssFringePrewarmState = null;
+            this._fullResCssFringePrewarmCount = 0;
+            this._fullResCssFringePrewarmCandidateCount = 0;
+            this._fullResCssFringeLayoutWarmCount = 0;
+            this._fullResCssFringePreparedIds = new Set();
+            this._disposed = false;
             // ▲▲▲ [Perf] ▲▲▲
 
             // ▼▼▼ [State] Loading flag ▼▼▼
@@ -940,7 +946,15 @@
             this._currentLodBand = null; // 'NEAR' | 'NORMAL' | 'MID' | 'FAR'
             this._nearCssVisibleIds = new Set();
             this._activeFullResCssNodeIds = new Set();
+            this._lastFullResCssAllowVisibilityVersion = -1;
+            this._lastFullResCssAllowSelectionKey = '';
+            this._lastFullResCssAllowNodeMap = null;
+            this._fullResCssPendingReadyIds = new Set();
+            this._lastFullResReadinessVisibilityVersion = -1;
+            this._lastFullResReadinessSelectionKey = '';
+            this._lastFullResReadinessNodeMap = null;
             this._nearPriorityBuffer = [];
+            this._nearPriorityRecordById = new Map();
             this._nearEntryBoostFrames = 0;
             this._warmCss3dNodeIds = new Set();
             this._warmCss3dMax = 128;
@@ -991,6 +1005,10 @@
             this._postLoadVisualSyncPending = false;
             this._postLoadVisualSyncReason = '';
             this._fullResImageVisualIds = new Set();
+            this._lastFullResImageSyncVisibilityVersion = -1;
+            this._lastFullResImageSyncSelectionKey = '';
+            this._lastFullResImageSyncLodBand = '';
+            this._lastFullResImageSyncNodeMap = null;
             this._fullResMotionHiddenGlIds = new Set();
             this._lastImageFallbackRevealKey = '';
             this._fullResCssImageBridgeSettleMs = 48;
@@ -2996,6 +3014,13 @@
             this._lastLodScanSelectionKey = '';
             this._lastLodScanVisibilityVersion = -1;
             this._lastNearCssNoWorkKey = '';
+            this._lastFullResCssAllowVisibilityVersion = -1;
+            this._lastFullResCssAllowSelectionKey = '';
+            this._lastFullResCssAllowNodeMap = null;
+            this._lastFullResReadinessVisibilityVersion = -1;
+            this._lastFullResReadinessSelectionKey = '';
+            this._lastFullResReadinessNodeMap = null;
+            this._fullResCssPendingReadyIds.clear();
             this._pendingLodVisibilityVersion = -1;
             this._lastImageFallbackRevealKey = '';
             if (resetCursor) {
@@ -4013,6 +4038,10 @@
 
         _clearFullResImageVisuals(nodeObjectsById) {
             window.MindMapRenderPlan?.clearFullResImageVisuals?.(this, nodeObjectsById);
+            this._lastFullResImageSyncVisibilityVersion = -1;
+            this._lastFullResImageSyncSelectionKey = '';
+            this._lastFullResImageSyncLodBand = '';
+            this._lastFullResImageSyncNodeMap = null;
         }
 
         _syncFullResImageVisuals(visibleIds, nodeObjectsById, module, lodBand, selectionKey = '') {
@@ -4021,26 +4050,56 @@
                 return;
             }
 
-            const nextVisibleImageIds = new Set();
             const multiSelectedIds = module?.multiSelectedNodeIds || new Set();
             const selectedNodeId = module?.selectedNodeIdJs || null;
             const interactionState = {
                 hoveredNodeId: this._getCurrentHoveredNodeId(module),
                 draggedNodeId: module?.draggedNodeId || null
             };
-            if (visibleIds?.size > 0) {
+            const visibilityVersion = Number(module?._visibilityVersion || 0);
+            const normalizedSelectionKey = String(selectionKey || '');
+            const canApplyVisibilityDelta =
+                this._lastFullResImageSyncNodeMap === nodeObjectsById &&
+                this._lastFullResImageSyncSelectionKey === normalizedSelectionKey &&
+                this._lastFullResImageSyncLodBand === lodBand &&
+                visibilityVersion === this._lastFullResImageSyncVisibilityVersion + 1 &&
+                module?._lastVisibilityDiffComplete === true &&
+                Number(module?._lastVisibilityDiffVersion ?? -1) === visibilityVersion;
+            const nextVisibleImageIds = canApplyVisibilityDelta
+                ? new Set(this._fullResImageVisualIds)
+                : new Set();
+            const imageIdsToSync = new Set();
+
+            if (canApplyVisibilityDelta) {
+                for (const nodeIdValue of module._lastVisibilityExitedIds || []) {
+                    nextVisibleImageIds.delete(String(nodeIdValue || '').trim());
+                }
+                for (const nodeIdValue of module._lastVisibilityEnteredIds || []) {
+                    const nodeId = String(nodeIdValue || '').trim();
+                    if (this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, nodeId)) {
+                        imageIdsToSync.add(nodeId);
+                    }
+                }
+            } else if (visibleIds?.size > 0) {
                 for (const nodeId of visibleIds) {
-                    this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, nodeId);
+                    if (this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, nodeId)) {
+                        imageIdsToSync.add(nodeId);
+                    }
                 }
             }
 
-            this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, selectedNodeId);
-            if (multiSelectedIds?.forEach) {
-                multiSelectedIds.forEach(id => this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, id));
-            }
-            this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, module?.draggedNodeId || null);
+            const addStickyImage = (nodeId) => {
+                if (this._addFullResImageVisualIfEligible(nextVisibleImageIds, nodeObjectsById, nodeId)) {
+                    imageIdsToSync.add(String(nodeId || '').trim());
+                } else if (nextVisibleImageIds.has(String(nodeId || '').trim())) {
+                    imageIdsToSync.add(String(nodeId || '').trim());
+                }
+            };
+            addStickyImage(selectedNodeId);
+            multiSelectedIds?.forEach?.(addStickyImage);
+            addStickyImage(module?.draggedNodeId || null);
 
-            for (const nodeId of nextVisibleImageIds) {
+            for (const nodeId of imageIdsToSync) {
                 const entry = nodeObjectsById.get(nodeId);
                 if (!entry) continue;
 
@@ -4069,6 +4128,10 @@
             }
 
             this._fullResImageVisualIds = nextVisibleImageIds;
+            this._lastFullResImageSyncVisibilityVersion = visibilityVersion;
+            this._lastFullResImageSyncSelectionKey = normalizedSelectionKey;
+            this._lastFullResImageSyncLodBand = String(lodBand || '');
+            this._lastFullResImageSyncNodeMap = nodeObjectsById;
             this._syncInstancedImageMeshVisibility();
         }
         // ▲▲▲ [New] ▲▲▲
@@ -4216,73 +4279,6 @@
             return currentVisibleIds.has(nodeId);
         }
 
-        _buildFullResCssAllowSet(prioritizedVisible, nodeObjectsById, module = this._module, lodBand = this._currentLodBand) {
-            const allowedIds = new Set();
-
-            const stickyIds = [
-                module?.selectedNodeIdJs || null,
-                module?.draggedNodeId || null,
-                module?._textOverlayV2State?.editing?.nodeId || null,
-                module?._editingOverlayState?.nodeId || null,
-                module?._textOverlayV2State?.selectionNodeId || null
-            ];
-            for (const stickyId of stickyIds) {
-                const nodeId = String(stickyId || '').trim();
-                if (!nodeId) continue;
-                const entry = nodeObjectsById?.get?.(nodeId) || null;
-                if (entry && supportsCss3dNodeModel(entry.model)) {
-                    allowedIds.add(nodeId);
-                }
-            }
-
-            const multiSelectedIds = module?.multiSelectedNodeIds || null;
-            if (multiSelectedIds?.forEach) {
-                multiSelectedIds.forEach((nodeId) => {
-                    const entry = nodeObjectsById?.get?.(nodeId) || null;
-                    if (entry && supportsCss3dNodeModel(entry.model)) {
-                        allowedIds.add(nodeId);
-                    }
-                });
-            }
-
-            if (!Array.isArray(prioritizedVisible) || prioritizedVisible.length === 0) {
-                return allowedIds;
-            }
-
-            // Full-res NEAR/NORMAL is the readable CSS3D path. Do not drop visible
-            // text nodes during pan/zoom/cooldown; otherwise the expanded NORMAL band
-            // shows empty cards until the throttled activation queue catches up.
-            for (let i = 0; i < prioritizedVisible.length; i++) {
-                const nodeId = prioritizedVisible[i]?.nodeId;
-                if (!nodeId || allowedIds.has(nodeId)) continue;
-                const entry = nodeObjectsById?.get?.(nodeId) || null;
-                if (!entry || !supportsCss3dNodeModel(entry.model)) continue;
-                allowedIds.add(nodeId);
-            }
-
-            return allowedIds;
-        }
-
-        _hasFullResCssReadinessDrift(prioritizedVisible, nodeObjectsById, allowedCssIds) {
-            if (!Array.isArray(prioritizedVisible) || prioritizedVisible.length === 0) {
-                return false;
-            }
-
-            for (let i = 0; i < prioritizedVisible.length; i++) {
-                const nodeId = prioritizedVisible[i]?.nodeId;
-                if (!nodeId || allowedCssIds?.has?.(nodeId) !== true) continue;
-
-                const entry = nodeObjectsById?.get?.(nodeId) || null;
-                if (!entry || !supportsCss3dNodeModel(entry.model)) continue;
-
-                if (this._isFullResCssReady(entry) !== true) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
         _reprioritizeNearCss3dQueue(prioritizedVisible, nodeObjectsById, module) {
             this._compactCss3dQueue(true);
             if (this.isInLODMode === true || !this._hasCss3dQueueItems()) {
@@ -4408,155 +4404,6 @@
             }
         }
 
-        _restoreCss3dTextSourceForHighDetail(entry) {
-            const root = entry?.cssObject?.element || null;
-            if (!root) return;
-            if (!isTextLikeModel(entry?.model)) return;
-
-            const nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
-            const module = this._module || null;
-            const overlayV2 = window.MindMapTextOverlayV2 || null;
-            const overlayActive = !!nodeId && (
-                overlayV2?.hasSelection?.(module, nodeId) === true ||
-                overlayV2?.hasEditing?.(module, nodeId) === true
-            );
-
-            if (overlayActive) {
-                return;
-            }
-
-            overlayV2?.resumeSource?.(entry);
-
-            const clearSuspendedTarget = (target) => {
-                if (!target) return;
-                target.classList?.remove?.('mind-map-v2-source-suspended');
-                target.classList?.remove?.('mind-map-text-overlay-source-suspended');
-                target.removeAttribute?.('data-text-overlay-source-suspended');
-                if (target.style) {
-                    target.style.opacity = '';
-                    target.style.pointerEvents = '';
-                    target.style.userSelect = '';
-                    target.style.webkitUserSelect = '';
-                    target.style.caretColor = '';
-                    target.style.contentVisibility = '';
-                    target.style.containIntrinsicSize = '';
-                    target.style.contain = '';
-                }
-            };
-
-            clearSuspendedTarget(root);
-            root.querySelectorAll?.('[data-text-overlay-source-suspended], .mind-map-text-overlay-source-suspended, .mind-map-v2-source-suspended')?.forEach?.(clearSuspendedTarget);
-        }
-
-        _getCss3dDetailTargets(entry) {
-            const root = entry?.cssObject?.element || null;
-            if (!root) return [];
-
-            const targets = [root];
-            const inner = root.querySelector?.('.node-container') || null;
-            if (inner && inner !== root) {
-                targets.push(inner);
-            }
-
-            return targets.filter(target => !!target?.classList);
-        }
-
-        _isCss3dLowDetail(entry) {
-            return this._getCss3dDetailTargets(entry)
-                .some(target => target.classList.contains('lod-low'));
-        }
-
-        _isFullResCssReady(entry) {
-            const cssObject = entry?.cssObject || null;
-            const element = cssObject?.element || null;
-            if (!cssObject || !element || cssObject.visible !== true || entry?.currentType !== 'CSS') {
-                return false;
-            }
-
-            if (element.style?.display === 'none' ||
-                element.style?.visibility === 'hidden' ||
-                element.style?.opacity === '0') {
-                return false;
-            }
-
-            return this._isCss3dLowDetail(entry) !== true;
-        }
-
-        _setNodeDetailLevel(entry, level) {
-            if (!entry?.cssObject?.element) return;
-
-            const targets = this._getCss3dDetailTargets(entry);
-            if (targets.length === 0) return;
-
-            if (level === 'HIGH') {
-                for (const target of targets) {
-                    target.classList.remove('lod-low');
-                    target.classList.add('lod-high');
-                }
-                this._restoreCss3dTextSourceForHighDetail(entry);
-            } else {
-                for (const target of targets) {
-                    target.classList.remove('lod-high');
-                    target.classList.add('lod-low');
-                }
-            }
-        }
-
-        _setCss3dLodClass(entry, isHigh) {
-            this._setNodeDetailLevel(entry, isHigh ? 'HIGH' : 'LOW');
-            if (getNodeContentType(entry?.model) === 'video' &&
-                window.MindMapCss3DManager?.syncCss3dVideoLodMediaSource) {
-                window.MindMapCss3DManager.syncCss3dVideoLodMediaSource(entry.model, entry.cssObject, isHigh === true);
-            }
-        }
-
-        _restoreVisibleCss3dHighDetailForNear(nodeObjectsById, module, lodBand) {
-            // Full-res: NEAR / NORMAL. MID/FAR use resident instances.
-            if ((lodBand !== 'NEAR' && lodBand !== 'NORMAL') || !nodeObjectsById) {
-                return 0;
-            }
-
-            let restoredCount = 0;
-            for (const entry of nodeObjectsById.values()) {
-                const cssElement = entry?.cssObject?.element || null;
-                const nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
-                const isRecordedVisible = !!nodeId && this._nearCssVisibleIds.has(nodeId);
-                if (!cssElement ||
-                    (entry.cssObject?.visible !== true && !isRecordedVisible) ||
-                    (cssElement.style.display === 'none' && !isRecordedVisible) ||
-                    this._isCss3dLowDetail(entry) !== true) {
-                    continue;
-                }
-
-                this._setCss3dLodClass(entry, true);
-                restoredCount++;
-            }
-
-            if (restoredCount > 0 && module) {
-                module._css3dVisualChangedThisFrame = true;
-                module._css3dVisualChangedSinceLastRender = true;
-            }
-
-            return restoredCount;
-        }
-
-        _shouldUseHighCss3dDetail(entry, module) {
-            const cameraZ = Number(module?.camera?.position?.z || 0);
-            const cameraBand = getLodBandForCameraZ(cameraZ);
-            if (cameraBand === 'NEAR' || cameraBand === 'NORMAL') {
-                return true;
-            }
-
-            const lodBand = this._currentLodBand || cameraBand;
-            const nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
-            const selectedNodeId = String(module?.selectedNodeIdJs || module?.selectedNodeId || '').trim();
-            if (nodeId && selectedNodeId && nodeId === selectedNodeId) {
-                return true;
-            }
-
-            return false;
-        }
-
         _shouldKeepMountedEmbedResident(entry) {
             return getNodeContentType(entry?.model) === 'embed' &&
                 window.MindMapCss3DManager?.hasMountedEmbedIframe?.(entry.cssObject) === true;
@@ -4564,6 +4411,7 @@
 
         _detachCss3dObject(entry) {
             if (!entry?.cssObject) return;
+            this._clearFullResCssFringePrepared(entry);
             if (getNodeContentType(entry?.model) === 'video' &&
                 window.MindMapCss3DManager?.syncVideoNodeVisibilityPlayback) {
                 window.MindMapCss3DManager.syncVideoNodeVisibilityPlayback(entry.model, entry.cssObject, false);
@@ -4655,6 +4503,7 @@
             }
 
             entry.cssObject = cssObject;
+            entry._css3dDetailTargetCache = null;
             window.MindMapRenderPlan?.cachePreparedResidentCss?.(this, entry, module, module.nodeObjectsById);
             return true;
         }
@@ -4810,11 +4659,16 @@
                 isHighDetail: shouldUseHighCss3dDetail,
                 allowResident: isLivePortalCssLodModel(model)
             }) === true) return;
+            if (this._promoteFullResCssFringePrepared(entry) !== true) {
+                this._clearFullResCssFringePrepared(entry);
+                if (entry.cssObject?.userData) delete entry.cssObject.userData._fullResFringeCreated;
+            }
 
             // Create if not exists
             if (!entry.cssObject) {
                 entry.cssObject = window.MindMapCss3DManager.createCss3dObject(module, model);
                 if (entry.cssObject) {
+                    entry._css3dDetailTargetCache = null;
                     const glPos = entry.glObject?.position;
                     if (glPos) entry.cssObject.position.copy(glPos);
                     cssParentScene?.add(entry.cssObject);
@@ -4862,6 +4716,7 @@
                     !cssMediaEl.getAttribute('src') &&
                     isLowDetailVideoProxy !== true;
                 if ((entry.isCssDirty || needsInitialMediaSync) && window.MindMapCss3DManager?.syncCss3dContent) {
+                    entry._css3dDetailTargetCache = null;
                     window.MindMapCss3DManager.syncCss3dContent(model, entry.cssObject);
                     entry.isCssDirty = false; // sync 완료 후 clean
                 }
@@ -5435,7 +5290,12 @@
                     const obj = entry.glObject || entry.cssObject;
                     if (!obj) continue;
 
-                    buffer.push({ nodeId });
+                    let record = this._nearPriorityRecordById.get(nodeId);
+                    if (!record) {
+                        record = { nodeId };
+                        this._nearPriorityRecordById.set(nodeId, record);
+                    }
+                    buffer.push(record);
                 }
 
                 if (buffer.length === visibleIds.size) {
@@ -5463,7 +5323,16 @@
                 const hasCssPenalty = entry.cssObject ? 0 : 1; // existing CSS first within the same content tier
                 const mediaPriority = isImageLodProxyModel(entry.model) ? 0 : 1;
 
-                buffer.push({ nodeId, textPriority, hasCssPenalty, mediaPriority, distSq });
+                let record = this._nearPriorityRecordById.get(nodeId);
+                if (!record) {
+                    record = { nodeId };
+                    this._nearPriorityRecordById.set(nodeId, record);
+                }
+                record.textPriority = textPriority;
+                record.hasCssPenalty = hasCssPenalty;
+                record.mediaPriority = mediaPriority;
+                record.distSq = distSq;
+                buffer.push(record);
             }
 
             buffer.sort((a, b) => {
@@ -5786,6 +5655,9 @@
                 }
 
                 if (modeChanged) {
+                    if (shouldUseLOD) {
+                        this._cancelFullResCssFringePrewarm(nodeObjectsById, true);
+                    }
                     const transitionPlan = window.MindMapRenderPlan;
                     transitionPlan?.beginResidentCssTransition?.(
                         this, module, nodeObjectsById, previousLodBand, lodBand, lodSelectionKey);
@@ -5805,6 +5677,9 @@
                         }
                         this._fullResMotionHiddenGlIds.clear();
                         this._currentLodBand = lodBand;
+                        this._lastFullResCssAllowVisibilityVersion = -1;
+                        this._lastFullResReadinessVisibilityVersion = -1;
+                        this._fullResCssPendingReadyIds.clear();
                         transitionPlan?.ensureResidentLineDetails?.(this, lodBand);
                         if (this.instancedHaloMesh) this.instancedHaloMesh.visible = shouldShowInstancedHaloInLodBand(lodBand);
                     this.instancedMesh.visible = true;
@@ -6030,8 +5905,10 @@
                     });
 
                     const prioritizedVisible = this._getNearVisiblePriority(visibleIds, nodeObjectsById, camera);
-                    const allowedCssIds = this._buildFullResCssAllowSet(prioritizedVisible, nodeObjectsById, module, lodBand);
-                    const cssReadinessDrift = this._hasFullResCssReadinessDrift(prioritizedVisible, nodeObjectsById, allowedCssIds);
+                    const allowedCssIds = this._buildFullResCssAllowSet(
+                        prioritizedVisible, nodeObjectsById, module, lodBand, lodSelectionKey);
+                    const cssReadinessDrift = this._hasFullResCssReadinessDrift(
+                        prioritizedVisible, nodeObjectsById, allowedCssIds, module, lodSelectionKey);
                     this._activeFullResCssNodeIds = allowedCssIds;
 
                     if (bandChangedWithoutModeSwitch) {
@@ -6052,6 +5929,7 @@
                             }
                             for (const nodeId of staleIds) {
                                 this._css3dQueuedMap.delete(nodeId);
+                                this._fullResCssPendingReadyIds.delete(nodeId);
                                 const entry = nodeObjectsById.get(nodeId);
                                 if (entry) {
                                     this._hideNodeCss3d(entry);
@@ -6066,6 +5944,7 @@
                         this._applyFullResCssMotionOptimization(nodeObjectsById, module, lodBand);
                     });
 
+                    const nearCssNoWorkKey = renderPlan?.buildFullResKey(lodBand, visibilityVersion, lodSelectionKey, nodeObjectsById.size, visibleIds.size, this._nearCssVisibleIds.size, allowedCssIds.size, css3dEnabled, module, this);
                     if (module?._fullResMotionFrozen === true) {
                         if (this._fullResHandoffActive === true) {
                             this._fullResHandoffUntil = Math.max(
@@ -6077,11 +5956,11 @@
                         if (this._hasCss3dQueueItems()) {
                             this._requestCss3dQueueProcess(module, true);
                         }
-                        this._lastNearCssNoWorkKey = '';
+                        renderPlan?.recordStableFullRes?.(
+                            this, module, nearCssNoWorkKey, bandChangedWithoutModeSwitch, cssReadinessDrift);
                         return;
                     }
 
-                    const nearCssNoWorkKey = renderPlan?.buildFullResKey(lodBand, visibilityVersion, lodSelectionKey, nodeObjectsById.size, visibleIds.size, this._nearCssVisibleIds.size, allowedCssIds.size, css3dEnabled, module, this);
                     if (renderPlan?.commitStableFullRes(this, module, nearCssNoWorkKey, bandChangedWithoutModeSwitch, cssReadinessDrift)) return;
 
                     let hasNearCssWork =
@@ -6164,6 +6043,9 @@
                                 this, entry, module, nodeObjectsById, lodSelectionKey, lodBand, nodeId) !== true) {
                                 this._showNodeCss3d(entry, module);
                             }
+                            if (this._isFullResCssReady(entry)) {
+                                this._fullResCssPendingReadyIds.delete(nodeId);
+                            }
                             processedCount++;
                         }
                         renderPlan?.completeFullResTransition?.(this, allowedCssIds.size);
@@ -9505,12 +9387,25 @@
             this.lineDataCache.clear();
             this.lineDataArray.fill(0);
             this._nearCssVisibleIds.clear();
+            this._activeFullResCssNodeIds.clear();
+            this._fullResCssPendingReadyIds.clear();
+            this._lastFullResCssAllowVisibilityVersion = -1;
+            this._lastFullResCssAllowSelectionKey = '';
+            this._lastFullResCssAllowNodeMap = null;
+            this._lastFullResReadinessVisibilityVersion = -1;
+            this._lastFullResReadinessSelectionKey = '';
+            this._lastFullResReadinessNodeMap = null;
             this._lodConsoleProxyNodeIds.clear();
             this._lodImageCssFallbackNodeIds.clear();
             this._lodTemplateCssNodeIds.clear();
             this._clearCss3dQueue();
             this._clearCss3dPrewarmQueue();
             this._css3dProcessing = false;
+            if (this._fullResCssFringePrewarmState?.retryTimer) {
+                clearTimeout(this._fullResCssFringePrewarmState.retryTimer);
+            }
+            this._fullResCssFringePrewarmState = null;
+            this._fullResCssFringePrewarmCandidateCount = 0;
             this._visibilityKeys = [];
             this._visibilityKeysDirty = true;
             this._visibilityCursor = 0;
@@ -9538,8 +9433,13 @@
             this._lastBlockedResidentRebuildReason = '';
             this._lastBlockedResidentRebuildAt = 0;
             this._nearPriorityBuffer = [];
+            this._nearPriorityRecordById.clear();
             this._nearEntryBoostFrames = 0;
             this._fullResImageVisualIds?.clear?.();
+            this._lastFullResImageSyncVisibilityVersion = -1;
+            this._lastFullResImageSyncSelectionKey = '';
+            this._lastFullResImageSyncLodBand = '';
+            this._lastFullResImageSyncNodeMap = null;
             this._pendingSelectionRefreshIds.clear();
             if (this._idleRebuildTimer) {
                 clearTimeout(this._idleRebuildTimer);
@@ -9621,6 +9521,7 @@
                     if (!entry) return;
 
                     if (entry.cssObject) {
+                        this._clearFullResCssFringePrepared(entry);
                         entry.cssObject.visible = false;
                         if (entry.cssObject.parent) {
                             entry.cssObject.parent.remove(entry.cssObject);
@@ -9648,6 +9549,7 @@
                     this._setGlowVisibility(entry, false);
                 });
             }
+            this._fullResCssFringePreparedIds.clear();
 
             if (this.instancedHaloMesh) this.instancedHaloMesh.visible = false;
             if (this.instancedMesh) this.instancedMesh.visible = false;
@@ -9706,10 +9608,14 @@
                 this._css3dPrewarmQueuedIds?.delete?.(nodeId);
                 this._warmCss3dNodeIds?.delete?.(nodeId);
                 this._nearCssVisibleIds?.delete?.(nodeId);
+                this._activeFullResCssNodeIds?.delete?.(nodeId);
+                this._fullResCssPendingReadyIds?.delete?.(nodeId);
                 this._fullResImageVisualIds?.delete?.(nodeId);
+                this._nearPriorityRecordById?.delete?.(nodeId);
                 this._lodConsoleProxyNodeIds?.delete?.(nodeId);
                 this._lodImageCssFallbackNodeIds?.delete?.(nodeId);
                 this._lodTemplateCssNodeIds?.delete?.(nodeId);
+                this._fullResCssFringePreparedIds?.delete?.(nodeId);
                 removedAny = true;
             }
 
@@ -10238,6 +10144,8 @@
         }
 
         dispose() {
+            this._disposed = true;
+            this._cancelFullResCssFringePrewarm(this._module?.nodeObjectsById, true);
             this.textureArrays.forEach(arr => arr.texture.dispose());
             if (this.instancedHaloMesh) {
                 this.instancedHaloMesh.material.dispose();
@@ -10310,7 +10218,19 @@
     // Export
     // ═══════════════════════════════════════════════════════════════════════════
 
-    window.LODRenderer = LODRenderer;
+    const normalBoundaryOptimizer = window.MindMapNormalBoundaryOptimizer;
+    if (!normalBoundaryOptimizer?.install?.(LODRenderer.prototype, {
+        supportsCss3dNodeModel,
+        isTextLikeModel,
+        isLivePortalCssLodModel,
+        hasAgentConsoleOpenForEntry,
+        getNodeContentType,
+        getLodBandForCameraZ
+    })) {
+        throw new Error('[LODRenderer] Normal boundary optimizer module is unavailable.');
+    }
+
+    window.LODRenderer = LODRenderer;
 
     // Export constants for external use
     window.LODRenderer.THUMBNAIL_SIZE = THUMBNAIL_SIZE;