@mindexec/cli 0.2.435 → 0.2.437

package/wwwroot/_content/MindExecution.Shared/js/mind-map-normal-boundary-optimizer.js

@@ -0,0 +1,624 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260713-normal-boundary-optimizer-v002';
+
+    function install(prototype, helpers = {}) {
+        if (!prototype || prototype._normalBoundaryOptimizerBuild === BUILD_ID) return true;
+
+        const supportsCss3dNodeModel = helpers.supportsCss3dNodeModel;
+        const isTextLikeModel = helpers.isTextLikeModel;
+        const isLivePortalCssLodModel = helpers.isLivePortalCssLodModel;
+        const hasAgentConsoleOpenForEntry = helpers.hasAgentConsoleOpenForEntry;
+        const getNodeContentType = helpers.getNodeContentType;
+        const getLodBandForCameraZ = helpers.getLodBandForCameraZ;
+        if ([supportsCss3dNodeModel, isTextLikeModel, isLivePortalCssLodModel,
+            hasAgentConsoleOpenForEntry, getNodeContentType, getLodBandForCameraZ]
+            .some(value => typeof value !== 'function')) {
+            throw new Error('[NormalBoundaryOptimizer] Missing LOD renderer helper contract.');
+        }
+
+        Object.assign(prototype, {
+            _getFullResCssOwnershipKey(module, selectionKey = '') {
+                return [
+                    String(selectionKey || ''),
+                    String(module?.draggedNodeId || ''),
+                    String(module?._textOverlayV2State?.editing?.nodeId || ''),
+                    String(module?._editingOverlayState?.nodeId || ''),
+                    String(module?._textOverlayV2State?.selectionNodeId || ''),
+                    String(this._getCurrentHoveredNodeId(module) || '')
+                ].join('|');
+            },
+
+            _buildFullResCssAllowSet(prioritizedVisible, nodeObjectsById, module = this._module,
+                lodBand = this._currentLodBand, selectionKey = '') {
+                const stickyAllowedIds = new Set();
+                const addStickyId = (value) => {
+                    const nodeId = String(value || '').trim();
+                    if (!nodeId) return;
+                    const entry = nodeObjectsById?.get?.(nodeId) || null;
+                    if (entry && supportsCss3dNodeModel(entry.model)) stickyAllowedIds.add(nodeId);
+                };
+                const stickyIds = [
+                    module?.selectedNodeIdJs || null,
+                    module?.draggedNodeId || null,
+                    module?._textOverlayV2State?.editing?.nodeId || null,
+                    module?._editingOverlayState?.nodeId || null,
+                    module?._textOverlayV2State?.selectionNodeId || null,
+                    this._getCurrentHoveredNodeId(module)
+                ];
+                for (const stickyId of stickyIds) addStickyId(stickyId);
+                module?.multiSelectedNodeIds?.forEach?.(addStickyId);
+
+                const visibilityVersion = Number(module?._visibilityVersion || 0);
+                const normalizedSelectionKey = this._getFullResCssOwnershipKey(module, selectionKey);
+                const ownsCachedSet =
+                    this._lastFullResCssAllowNodeMap === nodeObjectsById &&
+                    this._lastFullResCssAllowSelectionKey === normalizedSelectionKey &&
+                    this._activeFullResCssNodeIds instanceof Set &&
+                    this._isNodeArrayDirty !== true;
+                const hasExactDelta =
+                    ownsCachedSet &&
+                    visibilityVersion === this._lastFullResCssAllowVisibilityVersion + 1 &&
+                    module?._lastVisibilityDiffComplete === true &&
+                    Number(module?._lastVisibilityDiffVersion ?? -1) === visibilityVersion;
+
+                if (ownsCachedSet && visibilityVersion === this._lastFullResCssAllowVisibilityVersion) {
+                    stickyAllowedIds.forEach(nodeId => this._activeFullResCssNodeIds.add(nodeId));
+                    return this._activeFullResCssNodeIds;
+                }
+
+                if (hasExactDelta) {
+                    const allowedIds = this._activeFullResCssNodeIds;
+                    for (const nodeIdValue of module._lastVisibilityExitedIds || []) {
+                        const nodeId = String(nodeIdValue || '').trim();
+                        if (nodeId && !stickyAllowedIds.has(nodeId)) allowedIds.delete(nodeId);
+                    }
+                    for (const nodeIdValue of module._lastVisibilityEnteredIds || []) {
+                        const nodeId = String(nodeIdValue || '').trim();
+                        const entry = nodeObjectsById?.get?.(nodeId) || null;
+                        if (nodeId && entry && supportsCss3dNodeModel(entry.model)) allowedIds.add(nodeId);
+                    }
+                    stickyAllowedIds.forEach(nodeId => allowedIds.add(nodeId));
+                    this._lastFullResCssAllowVisibilityVersion = visibilityVersion;
+                    return allowedIds;
+                }
+
+                const allowedIds = new Set(stickyAllowedIds);
+                // Full-res NEAR/NORMAL is the readable CSS3D path. Preserve every
+                // visible supported owner; exact deltas only avoid rebuilding the set.
+                if (Array.isArray(prioritizedVisible)) {
+                    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)) allowedIds.add(nodeId);
+                    }
+                }
+                this._activeFullResCssNodeIds = allowedIds;
+                this._lastFullResCssAllowVisibilityVersion = visibilityVersion;
+                this._lastFullResCssAllowSelectionKey = normalizedSelectionKey;
+                this._lastFullResCssAllowNodeMap = nodeObjectsById;
+                return allowedIds;
+            },
+
+            _hasFullResCssReadinessDrift(prioritizedVisible, nodeObjectsById, allowedCssIds,
+                module = this._module, selectionKey = '') {
+                const visibilityVersion = Number(module?._visibilityVersion || 0);
+                const normalizedSelectionKey = this._getFullResCssOwnershipKey(module, selectionKey);
+                const ownsPendingSet =
+                    this._lastFullResReadinessNodeMap === nodeObjectsById &&
+                    this._lastFullResReadinessSelectionKey === normalizedSelectionKey &&
+                    this._isNodeArrayDirty !== true;
+                const hasExactDelta =
+                    ownsPendingSet &&
+                    visibilityVersion === this._lastFullResReadinessVisibilityVersion + 1 &&
+                    module?._lastVisibilityDiffComplete === true &&
+                    Number(module?._lastVisibilityDiffVersion ?? -1) === visibilityVersion;
+
+                if (!ownsPendingSet ||
+                    (visibilityVersion !== this._lastFullResReadinessVisibilityVersion && !hasExactDelta)) {
+                    this._fullResCssPendingReadyIds.clear();
+                    for (let i = 0; i < (prioritizedVisible?.length || 0); i++) {
+                        const nodeId = prioritizedVisible[i]?.nodeId;
+                        if (!nodeId || allowedCssIds?.has?.(nodeId) !== true) continue;
+                        const entry = nodeObjectsById?.get?.(nodeId) || null;
+                        if (entry && supportsCss3dNodeModel(entry.model) && this._isFullResCssReady(entry) !== true) {
+                            this._fullResCssPendingReadyIds.add(nodeId);
+                        }
+                    }
+                } else if (hasExactDelta) {
+                    for (const nodeIdValue of module._lastVisibilityExitedIds || []) {
+                        this._fullResCssPendingReadyIds.delete(String(nodeIdValue || '').trim());
+                    }
+                    for (const nodeIdValue of module._lastVisibilityEnteredIds || []) {
+                        const nodeId = String(nodeIdValue || '').trim();
+                        if (!nodeId || allowedCssIds?.has?.(nodeId) !== true) continue;
+                        const entry = nodeObjectsById?.get?.(nodeId) || null;
+                        if (entry && supportsCss3dNodeModel(entry.model) && this._isFullResCssReady(entry) !== true) {
+                            this._fullResCssPendingReadyIds.add(nodeId);
+                        }
+                    }
+                }
+
+                for (const nodeId of this._fullResCssPendingReadyIds) {
+                    const entry = nodeObjectsById?.get?.(nodeId) || null;
+                    if (allowedCssIds?.has?.(nodeId) !== true || !entry ||
+                        !supportsCss3dNodeModel(entry.model) || this._isFullResCssReady(entry) === true) {
+                        this._fullResCssPendingReadyIds.delete(nodeId);
+                    }
+                }
+                this._lastFullResReadinessVisibilityVersion = visibilityVersion;
+                this._lastFullResReadinessSelectionKey = normalizedSelectionKey;
+                this._lastFullResReadinessNodeMap = nodeObjectsById;
+                return this._fullResCssPendingReadyIds.size > 0;
+            },
+
+            _restoreCss3dTextSourceForHighDetail(entry) {
+                const root = entry?.cssObject?.element || null;
+                if (!root || !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;
+
+                const suspensionSelector =
+                    '[data-text-overlay-source-suspended], .mind-map-text-overlay-source-suspended, .mind-map-v2-source-suspended';
+                if (entry._css3dSourceSuspended !== true && root.matches?.(suspensionSelector) !== true) 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) return;
+                    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?.(suspensionSelector)?.forEach?.(clearSuspendedTarget);
+                entry._css3dSourceSuspended = false;
+            },
+
+            _getCss3dDetailTargets(entry) {
+                const root = entry?.cssObject?.element || null;
+                if (!root) return [];
+                const cached = entry?._css3dDetailTargetCache || null;
+                const firstChild = root.firstElementChild || null;
+                if (cached?.root === root && cached.firstChild === firstChild) return cached.targets;
+                const targets = [root];
+                const inner = root.querySelector?.('.node-container') || null;
+                if (inner && inner !== root) targets.push(inner);
+                const resolvedTargets = targets.filter(target => !!target?.classList);
+                entry._css3dDetailTargetCache = { root, firstChild, targets: resolvedTargets };
+                return resolvedTargets;
+            },
+
+            _areCss3dDetailTargetsAtLevel(entry, isHigh) {
+                const targets = this._getCss3dDetailTargets(entry);
+                if (targets.length === 0) return false;
+                const expected = isHigh ? 'lod-high' : 'lod-low';
+                const rejected = isHigh ? 'lod-low' : 'lod-high';
+                for (let i = 0; i < targets.length; i++) {
+                    const classList = targets[i]?.classList;
+                    if (!classList || classList.contains(expected) !== true || classList.contains(rejected) === true) {
+                        return false;
+                    }
+                }
+                return true;
+            },
+
+            _isCss3dSourceSuspended(entry) {
+                const root = entry?.cssObject?.element || null;
+                if (!root) return false;
+                if (entry._css3dSourceSuspended === true) return true;
+                return root.matches?.(
+                    '[data-text-overlay-source-suspended],.mind-map-text-overlay-source-suspended,.mind-map-v2-source-suspended') === true;
+            },
+
+            _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 false;
+                const targets = this._getCss3dDetailTargets(entry);
+                if (targets.length === 0) return false;
+                const isHigh = level === 'HIGH';
+                const expected = isHigh ? 'lod-high' : 'lod-low';
+                const rejected = isHigh ? 'lod-low' : 'lod-high';
+                let changed = false;
+                for (const target of targets) {
+                    if (target.classList.contains(rejected)) {
+                        target.classList.remove(rejected);
+                        changed = true;
+                    }
+                    if (!target.classList.contains(expected)) {
+                        target.classList.add(expected);
+                        changed = true;
+                    }
+                }
+                if (isHigh) this._restoreCss3dTextSourceForHighDetail(entry);
+                return changed;
+            },
+
+            _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;
+                const visitedIds = new Set();
+                const restoreNode = (nodeIdValue) => {
+                    const nodeId = String(nodeIdValue || '').trim();
+                    if (!nodeId || visitedIds.has(nodeId)) return;
+                    visitedIds.add(nodeId);
+                    const entry = nodeObjectsById.get(nodeId) || null;
+                    const cssElement = entry?.cssObject?.element || null;
+                    const isRecordedVisible = this._nearCssVisibleIds.has(nodeId);
+                    if (!cssElement ||
+                        (entry.cssObject?.visible !== true && !isRecordedVisible) ||
+                        (cssElement.style.display === 'none' && !isRecordedVisible) ||
+                        this._isCss3dLowDetail(entry) !== true) return;
+                    this._setCss3dLodClass(entry, true);
+                    restoredCount++;
+                };
+                const visibleIds = module?._visibleIds || module?._prevVisibleIds || null;
+                visibleIds?.forEach?.(restoreNode);
+                this._nearCssVisibleIds.forEach(restoreNode);
+                this._activeFullResCssNodeIds.forEach(restoreNode);
+                this._fullResImageVisualIds?.forEach?.(restoreNode);
+                restoreNode(module?.selectedNodeIdJs || module?.selectedNodeId);
+                restoreNode(module?.draggedNodeId);
+                module?.multiSelectedNodeIds?.forEach?.(restoreNode);
+                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 nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
+                const selectedNodeId = String(module?.selectedNodeIdJs || module?.selectedNodeId || '').trim();
+                return !!nodeId && !!selectedNodeId && nodeId === selectedNodeId;
+            },
+
+            _isFullResCssFringePrewarmBlocked(module) {
+                return module?.isPanning === true || module?.isZooming === true ||
+                    module?._panSmoothingActive === true || module?._viewSyncMotionActive === true ||
+                    module?._cameraMovingThisFrame === true || module?.isDraggingNode === true ||
+                    module?.isDraggingMultipleNodes === true || module?.isResizing === true ||
+                    module?.isWindowResizing === true;
+            },
+
+            _clearFullResCssFringePrepared(entry) {
+                const cssObject = entry?.cssObject || null;
+                const element = cssObject?.element || null;
+                const userData = cssObject?.userData || null;
+                if (!cssObject || userData?._fullResFringePrepared !== true) return false;
+                const nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
+                const pointerEvents = String(userData._fullResFringePointerEvents ?? '');
+                delete userData._fullResFringePrepared;
+                delete userData._fullResFringePointerEvents;
+                if (element?.style) {
+                    if (pointerEvents) element.style.setProperty?.('pointer-events', pointerEvents, 'important');
+                    else element.style.removeProperty?.('pointer-events');
+                    if (cssObject.visible !== true) {
+                        element.style.setProperty?.('display', 'none', 'important');
+                        element.style.setProperty?.('opacity', '1', 'important');
+                    }
+                }
+                if (nodeId) this._fullResCssFringePreparedIds.delete(nodeId);
+                return true;
+            },
+
+            _promoteFullResCssFringePrepared(entry) {
+                const cssObject = entry?.cssObject || null;
+                const element = cssObject?.element || null;
+                const userData = cssObject?.userData || null;
+                if (!cssObject || userData?._fullResFringePrepared !== true) return false;
+                const nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
+                const pointerEvents = String(userData._fullResFringePointerEvents ?? '');
+                delete userData._fullResFringePrepared;
+                delete userData._fullResFringePointerEvents;
+                delete userData._fullResFringeCreated;
+                if (element?.style) {
+                    if (pointerEvents) element.style.setProperty?.('pointer-events', pointerEvents, 'important');
+                    else element.style.removeProperty?.('pointer-events');
+                }
+                if (nodeId) this._fullResCssFringePreparedIds.delete(nodeId);
+                return true;
+            },
+
+            _releaseFullResCssFringeObject(entry) {
+                const cssObject = entry?.cssObject || null;
+                if (!cssObject || cssObject.userData?._fullResFringeCreated !== true ||
+                    cssObject.visible === true || entry?.currentType === 'CSS') return false;
+                this._clearFullResCssFringePrepared(entry);
+                this._detachCss3dObject(entry);
+                delete cssObject.userData._fullResFringeCreated;
+                if (entry.cssObject === cssObject) {
+                    entry.cssObject = null;
+                    entry._css3dDetailTargetCache = null;
+                }
+                return true;
+            },
+
+            _cancelFullResCssFringePrewarm(nodeObjectsById, releaseCreated = true) {
+                const state = this._fullResCssFringePrewarmState;
+                if (state?.retryTimer) clearTimeout(state.retryTimer);
+                if (state) {
+                    state.retryTimer = 0;
+                    state.complete = true;
+                }
+                this._fullResCssFringePrewarmState = null;
+                const nodeMap = nodeObjectsById || state?.nodeObjectsById || null;
+                for (const nodeId of Array.from(this._fullResCssFringePreparedIds)) {
+                    const entry = nodeMap?.get?.(nodeId) || null;
+                    if (!entry) continue;
+                    if (releaseCreated && this._releaseFullResCssFringeObject(entry)) continue;
+                    this._clearFullResCssFringePrepared(entry);
+                    this._detachCss3dObject(entry);
+                }
+                this._fullResCssFringePreparedIds.clear();
+                this._fullResCssFringePrewarmCandidateCount = 0;
+            },
+
+            _prepareFullResCssFringeLayout(entry, module, nodeIdValue) {
+                const cssObject = entry?.cssObject || null;
+                const element = cssObject?.element || null;
+                const nodeId = String(nodeIdValue || entry?.model?.id || entry?.model?.Id || '').trim();
+                if (!cssObject || !element || !nodeId || cssObject.visible === true || entry?.currentType === 'CSS' ||
+                    this._nearCssVisibleIds.has(nodeId)) return false;
+                if (cssObject.userData?._fullResFringePrepared === true) {
+                    this._fullResCssFringePreparedIds.add(nodeId);
+                    return false;
+                }
+                const cssScene = module?.cssScene || module?.scene || null;
+                if (!cssScene) return false;
+                if (cssObject.parent !== cssScene) cssScene.add(cssObject);
+                const glPos = entry.glObject?.position || null;
+                if (glPos) cssObject.position.copy(glPos);
+                cssObject.visible = false;
+                cssObject.userData ||= {};
+                cssObject.userData._fullResFringePrepared = true;
+                cssObject.userData._fullResFringePointerEvents = element.style?.pointerEvents || '';
+                element.style?.setProperty?.('visibility', 'visible', 'important');
+                element.style?.setProperty?.('opacity', '0', 'important');
+                element.style?.setProperty?.('pointer-events', 'none', 'important');
+                element.style?.setProperty?.('display', 'block', 'important');
+                const rootStyle = element.firstElementChild?.style || null;
+                rootStyle?.setProperty?.('content-visibility', 'visible', 'important');
+                rootStyle?.setProperty?.('contain-intrinsic-size', 'auto', 'important');
+                const cameraElement = module?.cssRenderer?.getCameraElement?.() || null;
+                if (cameraElement && element.parentNode !== cameraElement) cameraElement.appendChild(element);
+                cssObject.updateMatrixWorld?.(true);
+                module?.cssRenderer?.prepareObjectLayout?.(cssObject);
+                this._fullResCssFringePreparedIds.add(nodeId);
+                this._fullResCssFringeLayoutWarmCount = Number(this._fullResCssFringeLayoutWarmCount || 0) + 1;
+                return true;
+            },
+
+            _retryFullResCssFringePrewarm(state, delayMs = 80) {
+                if (!state || state.retryTimer) return;
+                state.retryTimer = setTimeout(() => {
+                    state.retryTimer = 0;
+                    if (this._fullResCssFringePrewarmState === state) this._queueFullResCssFringePrewarm(state);
+                }, delayMs);
+            },
+
+            _queueFullResCssFringePrewarm(state) {
+                if (!state || state.scheduled || state.complete || this._fullResCssFringePrewarmState !== state) return false;
+                state.scheduled = true;
+                const run = (deadline) => {
+                    state.scheduled = false;
+                    if (this._fullResCssFringePrewarmState !== state || this._disposed === true ||
+                        this._module !== state.module || state.module?.nodeObjectsById !== state.nodeObjectsById) return;
+                    if (this.isLoading === true || state.module?.isLoading === true || this.isInLODMode !== false) return;
+                    if (this._isFullResCssFringePrewarmBlocked(state.module)) {
+                        this._retryFullResCssFringePrewarm(state);
+                        return;
+                    }
+                    const hasIdleTime = () =>
+                        !deadline || typeof deadline.timeRemaining !== 'function' || deadline.timeRemaining() > 1;
+
+                    if (!state.scanComplete) {
+                        state.entryIterator ||= state.nodeObjectsById.values();
+                        const scanStartedAt = performance.now();
+                        let scanned = 0;
+                        let iteratorDone = false;
+                        while (scanned < 192 &&
+                            (scanned === 0 || performance.now() - scanStartedAt < 2 || hasIdleTime())) {
+                            const next = state.entryIterator.next();
+                            if (next.done) {
+                                iteratorDone = true;
+                                break;
+                            }
+                            const entry = next.value;
+                            const model = entry?.model || null;
+                            const nodeId = String(model?.id || model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
+                            const cssAlreadyVisible = !!nodeId && (
+                                entry?.cssObject?.visible === true || entry?.currentType === 'CSS' ||
+                                this._nearCssVisibleIds.has(nodeId)
+                            );
+                            if (!model || !isTextLikeModel(model) || isLivePortalCssLodModel(model) ||
+                                hasAgentConsoleOpenForEntry(entry) || cssAlreadyVisible) {
+                                scanned++;
+                                continue;
+                            }
+                            const position = entry.glObject?.position || entry.cssObject?.position || null;
+                            const x = Number(position?.x ?? model.x ?? model.X ?? 0);
+                            const y = Number(position?.y ?? model.y ?? model.Y ?? 0);
+                            const width = Math.max(1, Number(model.width ?? model.Width ?? 400));
+                            const height = Math.max(1, Number(model.height ?? model.Height ?? 200));
+                            const halfW = width * 0.5;
+                            const halfH = height * 0.5;
+                            if (x + halfW >= state.rect.left && x - halfW <= state.rect.right &&
+                                y + halfH >= state.rect.bottom && y - halfH <= state.rect.top && nodeId) {
+                                const dx = x - state.centerX;
+                                const dy = y - state.centerY;
+                                state.candidates.push({ nodeId, distSq: dx * dx + dy * dy });
+                            }
+                            scanned++;
+                        }
+                        if (!iteratorDone) {
+                            this._queueFullResCssFringePrewarm(state);
+                            return;
+                        }
+                        state.candidates.sort((a, b) => a.distSq - b.distSq);
+                        if (state.candidates.length > state.maxCandidates) state.candidates.length = state.maxCandidates;
+                        const nextPreparedIds = new Set(state.candidates.map(candidate => candidate.nodeId));
+                        const currentVisibleIds = state.module?._visibleIds || state.module?._prevVisibleIds || null;
+                        for (const preparedNodeId of Array.from(this._fullResCssFringePreparedIds)) {
+                            if (nextPreparedIds.has(preparedNodeId) || currentVisibleIds?.has?.(preparedNodeId)) continue;
+                            const preparedEntry = state.nodeObjectsById.get(preparedNodeId) || null;
+                            if (!preparedEntry) {
+                                this._fullResCssFringePreparedIds.delete(preparedNodeId);
+                                continue;
+                            }
+                            if (!this._releaseFullResCssFringeObject(preparedEntry)) {
+                                this._clearFullResCssFringePrepared(preparedEntry);
+                                this._detachCss3dObject(preparedEntry);
+                            }
+                        }
+                        state.scanComplete = true;
+                        this._fullResCssFringePrewarmCandidateCount = state.candidates.length;
+                    }
+
+                    const prepareStartedAt = performance.now();
+                    let processed = 0;
+                    while (state.candidateCursor < state.candidates.length && processed < 2 &&
+                        (processed === 0 || (performance.now() - prepareStartedAt < 4 && hasIdleTime()))) {
+                        const candidate = state.candidates[state.candidateCursor++];
+                        processed++;
+                        const entry = state.nodeObjectsById.get(candidate.nodeId) || null;
+                        if (!entry || !isTextLikeModel(entry.model) || isLivePortalCssLodModel(entry.model) ||
+                            hasAgentConsoleOpenForEntry(entry)) continue;
+                        let didPrepare = false;
+                        if (!entry.cssObject) {
+                            didPrepare = this._ensureHiddenCss3dObject(entry, state.module) === true;
+                            if (didPrepare && entry.cssObject?.userData) {
+                                entry.cssObject.userData._fullResFringeCreated = true;
+                            }
+                        }
+                        if (entry.cssObject && entry.isCssDirty === true &&
+                            window.MindMapCss3DManager?.syncCss3dContent) {
+                            entry._css3dDetailTargetCache = null;
+                            window.MindMapCss3DManager.syncCss3dContent(entry.model, entry.cssObject);
+                            entry.isCssDirty = false;
+                            didPrepare = true;
+                        }
+                        this._prepareFullResCssFringeLayout(entry, state.module, candidate.nodeId);
+                        if (didPrepare) {
+                            this._fullResCssFringePrewarmCount = Number(this._fullResCssFringePrewarmCount || 0) + 1;
+                        }
+                    }
+                    if (state.candidateCursor >= state.candidates.length) {
+                        state.complete = true;
+                        return;
+                    }
+                    this._queueFullResCssFringePrewarm(state);
+                };
+                if (typeof globalThis.requestIdleCallback === 'function') {
+                    globalThis.requestIdleCallback(run, { timeout: 140 });
+                } else {
+                    setTimeout(() => run({ timeRemaining: () => 4, didTimeout: true }), 16);
+                }
+                return true;
+            },
+
+            _scheduleFullResCssFringePrewarm(nodeObjectsById, module = this._module) {
+                if (!nodeObjectsById?.values || !module || this._disposed === true || this.isLoading === true ||
+                    module.isLoading === true || this.isInLODMode !== false ||
+                    this._isFullResCssFringePrewarmBlocked(module)) return false;
+                const normalBoundary = Number(this.constructor?.LOD_THRESHOLDS?.NORMAL || 9000);
+                const cameraZ = Number(module.camera?.position?.z || 0);
+                const viewportRect = module._lastVisibilityViewportWorldRect || null;
+                if (!(cameraZ > 0) || cameraZ >= normalBoundary || viewportRect?.mode !== 'full-res') return false;
+                const centerX = Number(module.camera?.position?.x || 0);
+                const centerY = Number(module.camera?.position?.y || 0);
+                const currentHalfW = Math.max(1, (Number(viewportRect.right) - Number(viewportRect.left)) * 0.5);
+                const currentHalfH = Math.max(1, (Number(viewportRect.top) - Number(viewportRect.bottom)) * 0.5);
+                if (!Number.isFinite(currentHalfW) || !Number.isFinite(currentHalfH)) return false;
+                const boundaryScale = Math.max(1.15, Math.min(4,
+                    (normalBoundary / Math.max(2250, cameraZ)) * 1.08));
+                const halfW = currentHalfW * boundaryScale;
+                const halfH = currentHalfH * boundaryScale;
+                const visibleCount = Number(module._visibleIds?.size || module._prevVisibleIds?.size || 0);
+                const maxCandidates = Math.min(320, Math.max(160, Math.ceil(visibleCount * 3)));
+                const key = [
+                    Number(nodeObjectsById.size || 0),
+                    Math.round(centerX / 250),
+                    Math.round(centerY / 250),
+                    Math.round(halfW / 250),
+                    Math.round(halfH / 250),
+                    maxCandidates
+                ].join('|');
+                let state = this._fullResCssFringePrewarmState;
+                if (!state || state.key !== key || state.module !== module || state.nodeObjectsById !== nodeObjectsById) {
+                    if (state?.retryTimer) clearTimeout(state.retryTimer);
+                    state = {
+                        key, module, nodeObjectsById, centerX, centerY, maxCandidates,
+                        rect: {
+                            left: centerX - halfW,
+                            right: centerX + halfW,
+                            bottom: centerY - halfH,
+                            top: centerY + halfH
+                        },
+                        entryIterator: null,
+                        scanComplete: false,
+                        candidates: [],
+                        candidateCursor: 0,
+                        scheduled: false,
+                        retryTimer: 0,
+                        complete: false
+                    };
+                    this._fullResCssFringePrewarmState = state;
+                }
+                if (state.complete) return false;
+                return this._queueFullResCssFringePrewarm(state);
+            }
+        });
+
+        Object.defineProperty(prototype, '_normalBoundaryOptimizerBuild', {
+            configurable: true,
+            value: BUILD_ID
+        });
+        window.MindCanvasBuildInfo?.registerPart?.('normalBoundaryOptimizer', BUILD_ID, {
+            file: 'mind-map-normal-boundary-optimizer.js'
+        });
+        return true;
+    }
+
+    window.MindMapNormalBoundaryOptimizer = Object.freeze({ BUILD_ID, install });
+})();