@mindexec/cli 0.2.446 → 0.2.447

package/wwwroot/_content/MindExecution.Shared/js/mind-map-interactions.js

@@ -1649,65 +1649,18 @@ window.MindMapInteractions = (function () {
         return null;
     }
 
-    function getNodeProjectedClientFrame(module, entry) {
-        if (!module?.camera || !module?.container || !entry) {
-            return null;
-        }
-
-        const rect = module.container.getBoundingClientRect?.();
-        if (!rect || rect.width <= 0 || rect.height <= 0) {
-            return null;
-        }
-
-        const sourceObject = entry.glObject || entry.cssObject;
-        const position = sourceObject?.position;
-        if (!position) {
-            return null;
-        }
-
-        const width = Number(
-            entry.glObject?.userData?.worldWidth ||
-            entry.cssObject?.userData?.worldWidth ||
-            entry.model?.width ||
-            entry.model?.Width ||
-            0
-        );
-        const height = Number(
-            entry.glObject?.userData?.worldHeight ||
-            entry.cssObject?.userData?.worldHeight ||
-            entry.model?.height ||
-            entry.model?.Height ||
-            0
-        );
-        if (!(width > 0 && height > 0)) {
-            return null;
-        }
-
-        const corners = [
-            new THREE.Vector3(position.x, position.y, position.z || 0),
-            new THREE.Vector3(position.x + width, position.y, position.z || 0),
-            new THREE.Vector3(position.x, position.y - height, position.z || 0),
-            new THREE.Vector3(position.x + width, position.y - height, position.z || 0)
-        ];
-
-        const xs = [];
-        const ys = [];
-        for (const corner of corners) {
-            corner.project(module.camera);
-            xs.push(rect.left + ((corner.x + 1) * rect.width / 2));
-            ys.push(rect.top + ((-corner.y + 1) * rect.height / 2));
-        }
-
-        return {
-            left: Math.min(...xs),
-            right: Math.max(...xs),
-            top: Math.min(...ys),
-            bottom: Math.max(...ys)
-        };
+    function getNodeProjectedClientFrame(module, entry, context = null, nodeId = null) {
+        return window.MindMapCss3dHotPath?.getProjectedClientFrame?.(
+            module,
+            entry,
+            context,
+            getCachedViewportMetrics(module),
+            nodeId
+        ) || null;
     }
 
-    function isClientPointInsideNodeFrame(module, entry, clientX, clientY, padding = 2) {
-        const frame = getNodeProjectedClientFrame(module, entry);
+    function isClientPointInsideNodeFrame(module, entry, clientX, clientY, padding = 2, context = null, nodeId = null) {
+        const frame = getNodeProjectedClientFrame(module, entry, context, nodeId);
         if (!frame) {
             return true;
         }
@@ -1718,13 +1671,13 @@ window.MindMapInteractions = (function () {
             clientY <= frame.bottom + padding;
     }
 
-    function isOutOfFrameNodeDomHit(module, nodeId, clientX, clientY) {
+    function isOutOfFrameNodeDomHit(module, nodeId, clientX, clientY, context = null) {
         const entry = nodeId ? module?.nodeObjectsById?.get?.(nodeId) : null;
         if (!entry?.cssObject?.element) {
             return false;
         }
 
-        return !isClientPointInsideNodeFrame(module, entry, clientX, clientY, 3);
+        return !isClientPointInsideNodeFrame(module, entry, clientX, clientY, 3, context, nodeId);
     }
 
     function resolveNodeIdFromHitObject(object) {
@@ -1871,13 +1824,15 @@ window.MindMapInteractions = (function () {
         return bestHit;
     }
 
-    function findCssNodeHitAtClientPoint(module, clientX, clientY) {
+    function findCssNodeHitAtClientPoint(module, clientX, clientY, context = null) {
         if (!module?.nodeObjectsById) {
             return null;
         }
 
         if (typeof document !== 'undefined' && typeof document.elementsFromPoint === 'function') {
-            const domStack = document.elementsFromPoint(clientX, clientY);
+            const domStack = context
+                ? window.MindMapCss3dHotPath.getDomStack(module, context)
+                : document.elementsFromPoint(clientX, clientY);
             let bestHit = null;
             let bestPriority = -Infinity;
 
@@ -1903,7 +1858,7 @@ window.MindMapInteractions = (function () {
                     continue;
                 }
 
-                if (!isClientPointInsideNodeFrame(module, entry, clientX, clientY, 2)) {
+                if (!isClientPointInsideNodeFrame(module, entry, clientX, clientY, 2, context, nodeId)) {
                     continue;
                 }
 
@@ -1927,8 +1882,13 @@ window.MindMapInteractions = (function () {
 
         let bestHit = null;
         let bestPriority = -Infinity;
-        const worldPoint = getWorldPoint(module, clientX, clientY);
-        const candidateIds = getCssFallbackCandidateIds(module, worldPoint);
+        const worldPoint = window.MindMapCss3dHotPath
+            ? window.MindMapCss3dHotPath.getContextWorldPoint(
+                context,
+                () => getWorldPoint(module, clientX, clientY)
+            )
+            : getWorldPoint(module, clientX, clientY);
+        const candidateIds = getCssFallbackCandidateIds(module, worldPoint, context);
         for (let i = 0; i < candidateIds.length; i++) {
             const nodeId = candidateIds[i];
             const entry = module.nodeObjectsById.get(nodeId);
@@ -1945,7 +1905,7 @@ window.MindMapInteractions = (function () {
                 continue;
             }
 
-            if (!isClientPointInsideNodeFrame(module, entry, clientX, clientY, 2)) {
+            if (!isClientPointInsideNodeFrame(module, entry, clientX, clientY, 2, context, nodeId)) {
                 continue;
             }
 
@@ -2142,11 +2102,20 @@ window.MindMapInteractions = (function () {
             cellRadius: normalizedCellRadius
         });
         if (Array.isArray(cachedCandidateIds)) {
+            module._lastHitTestCandidateSource = 'worker';
+            window.MindMapCss3dHotPath?.recordHitCandidates?.(module, 'worker', cachedCandidateIds.length);
             return cachedCandidateIds;
         }
 
-        if (!module.spatialGrid) return null;
-        return collectLocalHitTestCandidateNodeIds(module, point, normalizedCellRadius);
+        if (!module.spatialGrid || module._spatialIndexRepairState) {
+            module._lastHitTestCandidateSource = 'unavailable';
+            window.MindMapCss3dHotPath?.noteUnavailableIndex?.(module, 'pointer-index-unavailable');
+            return null;
+        }
+        const localIds = collectLocalHitTestCandidateNodeIds(module, point, normalizedCellRadius);
+        module._lastHitTestCandidateSource = 'spatial-grid';
+        window.MindMapCss3dHotPath?.recordHitCandidates?.(module, 'spatial-grid', localIds.length);
+        return localIds;
     }
 
     function appendMeshesForHitTestCandidateIds(module, candidateIds, meshes, options = {}) {
@@ -2207,49 +2176,19 @@ window.MindMapInteractions = (function () {
         };
     }
 
-    function collectLocalSelectionCandidateNodeIds(module, selectionRect) {
-        if (!module?.spatialGrid || !selectionRect) {
-            return [];
-        }
-
-        const cellSize = Math.max(1, Number(module.GRID_CELL_SIZE || 500));
-        const startCellX = Math.floor(Number(selectionRect.left || 0) / cellSize);
-        const endCellX = Math.floor(Number(selectionRect.right || 0) / cellSize);
-        const startCellY = Math.floor(Number(selectionRect.bottom || 0) / cellSize);
-        const endCellY = Math.floor(Number(selectionRect.top || 0) / cellSize);
-        const candidateIds = [];
-        const seenIds = new Set();
-
-        for (let cellX = startCellX; cellX <= endCellX; cellX++) {
-            for (let cellY = startCellY; cellY <= endCellY; cellY++) {
-                const nodeIds = module.spatialGrid.get(`${cellX}:${cellY}`);
-                if (!nodeIds) {
-                    continue;
-                }
-
-                nodeIds.forEach((nodeId) => {
-                    const normalizedNodeId = String(nodeId || '').trim();
-                    if (!normalizedNodeId || seenIds.has(normalizedNodeId)) {
-                        return;
-                    }
-
-                    seenIds.add(normalizedNodeId);
-                    candidateIds.push(normalizedNodeId);
-                });
-            }
-        }
-
-        return candidateIds;
-    }
-
     function collectSelectionBoxNodeIdsLocal(module, selectionRect) {
         const selectedIds = new Set();
         if (!module?.nodeObjectsById || !selectionRect) {
             return selectedIds;
         }
 
-        const candidateIds = collectLocalSelectionCandidateNodeIds(module, selectionRect);
+        let candidateIds = window.MindMapCss3dHotPath?.collectSpatialRectCandidateIds?.(module, selectionRect) ?? null;
+        if (candidateIds === null) {
+            window.MindMapCss3dHotPath?.noteUnavailableIndex?.(module, 'selection-box-index-unavailable');
+            candidateIds = window.MindMapCss3dHotPath?.getBoundedFallbackIds?.(module) || [];
+        }
         const processCandidateNode = (nodeId) => {
+            window.MindMapCss3dHotPath?.increment?.(module, 'selection', 'nodesVisited');
             const nodeEntry = module.nodeObjectsById.get(nodeId);
             if (!nodeEntry?.glObject?.userData) {
                 return;
@@ -2271,12 +2210,8 @@ window.MindMapInteractions = (function () {
             }
         };
 
-        if (candidateIds.length > 0) {
-            for (let i = 0; i < candidateIds.length; i++) {
-                processCandidateNode(candidateIds[i]);
-            }
-        } else {
-            module.nodeObjectsById.forEach((_, nodeId) => processCandidateNode(nodeId));
+        for (let i = 0; i < candidateIds.length; i++) {
+            processCandidateNode(candidateIds[i]);
         }
 
         return selectedIds;
@@ -2331,27 +2266,28 @@ window.MindMapInteractions = (function () {
         });
     }
 
-    function getCssFallbackCandidateIds(module, worldPoint) {
+    function getCssFallbackCandidateIds(module, worldPoint, context = null) {
         if (!module?.nodeObjectsById) {
             return [];
         }
 
-        const candidateIds = worldPoint
-            ? getHitTestCandidateNodeIds(module, worldPoint, { visibleOnly: false })
-            : [];
+        if (context?.candidateIds !== undefined) return context.candidateIds;
+        const candidateIds = worldPoint ? getHitTestCandidateNodeIds(module, worldPoint, { visibleOnly: false }) : [];
         if (Array.isArray(candidateIds)) {
+            if (context) {
+                context.candidateIds = candidateIds;
+                context.candidateSource = module._lastHitTestCandidateSource || 'spatial-grid';
+            }
             return candidateIds;
         }
 
-        const fallbackIds = new Set();
-        const addId = value => { const id = String(value || '').trim(); if (id && module.nodeObjectsById.has(id)) fallbackIds.add(id); };
-        module._visibleIds?.forEach?.(addId);
-        module._prevVisibleIds?.forEach?.(addId);
-        addId(module.selectedNodeIdJs);
-        module.multiSelectedNodeIds?.forEach?.(addId);
-        addId(module.draggedNodeId);
-        module.container?.querySelectorAll?.('[data-node-id]')?.forEach?.(element => addId(element.dataset?.nodeId));
-        return Array.from(fallbackIds);
+        const fallbackIds = window.MindMapCss3dHotPath?.getBoundedFallbackIds?.(module) || [];
+        window.MindMapCss3dHotPath?.recordHitCandidates?.(module, 'bounded-fallback', fallbackIds.length);
+        if (context) {
+            context.candidateIds = fallbackIds;
+            context.candidateSource = 'bounded-fallback';
+        }
+        return fallbackIds;
     }
     // ▲▲▲ [New] ▲▲▲
 
@@ -2964,7 +2900,8 @@ window.MindMapInteractions = (function () {
         }
 
         const nodeId = getTargetNodeId(target);
-        if (nodeId && event && isOutOfFrameNodeDomHit(module, nodeId, event.clientX, event.clientY)) {
+        if (nodeId && event && isOutOfFrameNodeDomHit(
+            module, nodeId, event.clientX, event.clientY, getPointerHitContext(module, event))) {
             return false;
         }
 
@@ -2977,23 +2914,40 @@ window.MindMapInteractions = (function () {
             const topCssHit = event ? getPointerCssHit(module, event) : null;
             return topCssHit?.nodeId || nodeId;
         }
-
-        const topCssHit = getPointerCssHit(module, event);
-        if (topCssHit?.nodeId && topCssHit.nodeId !== nodeId) {
-            return topCssHit.nodeId;
+        const context = getPointerHitContext(module, event);
+        if (nodeId && !isOutOfFrameNodeDomHit(module, nodeId, event.clientX, event.clientY, context)) {
+            const entry = module.nodeObjectsById?.get?.(nodeId) || null;
+            if (entry) {
+                context.cssHit = {
+                    nodeId,
+                    entry,
+                    priority: getEntryInteractionPriority(module, entry, nodeId)
+                };
+            }
+            return nodeId;
         }
-
-        return isOutOfFrameNodeDomHit(module, nodeId, event.clientX, event.clientY)
-            ? null
-            : nodeId;
+        const topCssHit = getPointerCssHit(module, event);
+        return topCssHit?.nodeId || null;
     }
-    function getPointerCssHit(module, event) {
+    function getPointerHitContext(module, event) {
         if (!event || !module) return null;
         let context = pointerHitContexts.get(event);
         if (!context || context.module !== module) {
-            context = { module, cssHit: findCssNodeHitAtClientPoint(module, event.clientX, event.clientY) };
+            context = window.MindMapCss3dHotPath.createPointerHitContext(
+                module,
+                event,
+                getCachedViewportMetrics(module)
+            );
             pointerHitContexts.set(event, context);
         }
+        return context;
+    }
+    function getPointerCssHit(module, event) {
+        const context = getPointerHitContext(module, event);
+        if (!context) return null;
+        if (context.cssHit === undefined) {
+            context.cssHit = findCssNodeHitAtClientPoint(module, event.clientX, event.clientY, context);
+        }
         return context.cssHit;
     }
     function getMountedEmbedCanvasDragTarget(module, target, event) {
@@ -3025,7 +2979,8 @@ window.MindMapInteractions = (function () {
             return null;
         }
 
-        if (event && !isClientPointInsideNodeFrame(module, nodeEntry, event.clientX, event.clientY, 3)) {
+        if (event && !isClientPointInsideNodeFrame(
+            module, nodeEntry, event.clientX, event.clientY, 3, getPointerHitContext(module, event), nodeId)) {
             return null;
         }
 
@@ -3387,6 +3342,7 @@ window.MindMapInteractions = (function () {
         if (previousIds.size === selectedIds.size && [...selectedIds].every(id => previousIds.has(id))) return;
 
         const changedIds = new Set([...previousIds, ...selectedIds]);
+        window.MindMapCss3dHotPath?.increment?.(module, 'selection', 'nodesVisited', changedIds.size);
         changedIds.forEach(nodeId => {
             const entry = module.nodeObjectsById.get(nodeId);
             if (String(entry?.model?.contentType ?? entry?.model?.ContentType ?? '').toLowerCase() !== 'embed' || !entry?.cssObject?.element) return;

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 = '20260713-normal-boundary-delta-v844';
+    const LOD_RENDERER_BUILD_ID = '20260725-cold-mid-line-restore-v846';
     const DirtyKind = Object.freeze({
         ResidentFullRebuild: 'resident-full-rebuild',
         ResidentPatch: 'resident-patch',
@@ -585,7 +585,14 @@
             return !isAnimatedGifImageModel(model);
         }
 
-        if (contentType !== 'embed' && contentType !== 'video') {
+        // Every video needs a resident MID/FAR visual. Videos without an
+        // explicit preview use a lightweight atlas placeholder so the live
+        // <video> element can stay suspended without making the node vanish.
+        if (contentType === 'video') {
+            return true;
+        }
+
+        if (contentType !== 'embed') {
             return false;
         }
 
@@ -1255,6 +1262,33 @@
             return [invAtlas, invAtlas, invAtlas, invAtlas];
         }
 
+        _getOrCreateImageAtlasSlot(nodeId) {
+            const normalizedId = String(nodeId || '').trim();
+            if (!normalizedId) {
+                return null;
+            }
+
+            let slot = this.imageAtlasSlots.get(normalizedId) || null;
+            if (slot) {
+                return slot;
+            }
+
+            const slotIndex = this._allocateImageAtlasSlot();
+            if (slotIndex < 0) {
+                return null;
+            }
+
+            slot = {
+                slotIndex,
+                key: '',
+                uvRect: this._getImageAtlasUvRect(slotIndex),
+                ready: false,
+                unsupported: false
+            };
+            this.imageAtlasSlots.set(normalizedId, slot);
+            return slot;
+        }
+
         _compactImageAtlasLoadQueue(force = false) {
             const cursor = this._imageAtlasLoadCursor || 0;
             if (cursor <= 0) return;
@@ -1653,35 +1687,114 @@
             }
         }
 
+        _drawVideoLodPlaceholder(slot, nodeWidth, nodeHeight) {
+            if (!slot || !this.imageAtlasCanvas || typeof document === 'undefined') {
+                return false;
+            }
+
+            const ctx = this.imageAtlasCanvas.getContext('2d', { alpha: false });
+            if (!ctx) {
+                return false;
+            }
+
+            const columns = this.imageAtlasColumns || IMAGE_LOD_ATLAS_COLUMNS;
+            const col = slot.slotIndex % columns;
+            const row = Math.floor(slot.slotIndex / columns);
+            const x = col * IMAGE_LOD_THUMBNAIL_SIZE;
+            const y = row * IMAGE_LOD_THUMBNAIL_SIZE;
+            const size = IMAGE_LOD_THUMBNAIL_SIZE;
+            const safeWidth = Math.max(1, Number(nodeWidth || 300));
+            const safeHeight = Math.max(1, Number(nodeHeight || 300));
+            const targetAspect = safeWidth / safeHeight;
+
+            try {
+                ctx.save();
+
+                const background = ctx.createLinearGradient(x, y, x, y + size);
+                background.addColorStop(0, '#26364d');
+                background.addColorStop(1, '#0f172a');
+                ctx.fillStyle = background;
+                ctx.fillRect(x, y, size, size);
+
+                const inset = 4;
+                ctx.strokeStyle = 'rgba(148, 163, 184, 0.58)';
+                ctx.lineWidth = 2;
+                ctx.strokeRect(x + inset, y + inset, size - inset * 2, size - inset * 2);
+
+                // Pre-compensate the icon for the square atlas tile being
+                // stretched to the video's world-space aspect ratio.
+                const radiusX = size * 0.19;
+                const radiusY = Math.min(size * 0.34, radiusX * Math.max(0.55, targetAspect));
+                const centerX = x + size * 0.5;
+                const centerY = y + size * 0.48;
+                ctx.beginPath();
+                ctx.ellipse(centerX, centerY, radiusX, radiusY, 0, 0, Math.PI * 2);
+                ctx.fillStyle = 'rgba(255, 255, 255, 0.18)';
+                ctx.fill();
+                ctx.strokeStyle = 'rgba(255, 255, 255, 0.62)';
+                ctx.lineWidth = 2;
+                ctx.stroke();
+
+                const triangleWidth = size * 0.13;
+                const triangleHeight = Math.min(size * 0.24, triangleWidth * Math.max(0.85, targetAspect));
+                ctx.beginPath();
+                ctx.moveTo(centerX - triangleWidth * 0.35, centerY - triangleHeight * 0.5);
+                ctx.lineTo(centerX + triangleWidth * 0.7, centerY);
+                ctx.lineTo(centerX - triangleWidth * 0.35, centerY + triangleHeight * 0.5);
+                ctx.closePath();
+                ctx.fillStyle = '#f8fafc';
+                ctx.fill();
+
+                ctx.fillStyle = 'rgba(226, 232, 240, 0.35)';
+                ctx.fillRect(x + size * 0.18, y + size * 0.82, size * 0.64, 2);
+                ctx.fillStyle = 'rgba(248, 250, 252, 0.78)';
+                ctx.fillRect(x + size * 0.18, y + size * 0.82, size * 0.2, 2);
+                ctx.restore();
+
+                if (this.imageAtlasTexture) {
+                    this.imageAtlasTexture.needsUpdate = true;
+                }
+                return true;
+            } catch {
+                try { ctx.restore(); } catch { }
+                return false;
+            }
+        }
+
         _ensureImageLodThumbnail(entry) {
             const nodeId = entry?.model?.id;
             if (!nodeId) {
                 return null;
             }
 
+            const contentType = getNodeContentType(entry?.model);
+            const nodeWidth = Math.max(1, Number(entry?.model?.width || entry?.model?.Width || 300));
+            const nodeHeight = Math.max(1, Number(entry?.model?.height || entry?.model?.Height || 300));
             const source = this._getImageLodSource(entry);
             if (!source) {
+                if (contentType === 'video') {
+                    const placeholderKey = `video-placeholder|node:${Math.round(nodeWidth)}x${Math.round(nodeHeight)}`;
+                    const placeholderSlot = this._getOrCreateImageAtlasSlot(nodeId);
+                    if (!placeholderSlot) {
+                        return null;
+                    }
+                    if (placeholderSlot.ready && placeholderSlot.key === placeholderKey) {
+                        return placeholderSlot;
+                    }
+                    if (this._drawVideoLodPlaceholder(placeholderSlot, nodeWidth, nodeHeight)) {
+                        placeholderSlot.key = placeholderKey;
+                        placeholderSlot.ready = true;
+                        placeholderSlot.unsupported = false;
+                        return placeholderSlot;
+                    }
+                }
                 return null;
             }
 
-            const nodeWidth = Math.max(1, Number(entry?.model?.width || entry?.model?.Width || 300));
-            const nodeHeight = Math.max(1, Number(entry?.model?.height || entry?.model?.Height || 300));
             const sourceKey = `${source.key}|node:${Math.round(nodeWidth)}x${Math.round(nodeHeight)}`;
-
-            let slot = this.imageAtlasSlots.get(nodeId) || null;
+            const slot = this._getOrCreateImageAtlasSlot(nodeId);
             if (!slot) {
-                const slotIndex = this._allocateImageAtlasSlot();
-                if (slotIndex < 0) {
-                    return null;
-                }
-                slot = {
-                    slotIndex,
-                    key: '',
-                    uvRect: this._getImageAtlasUvRect(slotIndex),
-                    ready: false,
-                    unsupported: false
-                };
-                this.imageAtlasSlots.set(nodeId, slot);
+                return null;
             }
 
             if (slot.ready && slot.key === sourceKey) {
@@ -1699,6 +1812,14 @@
                 return slot;
             }
 
+            if (contentType === 'video' &&
+                this._drawVideoLodPlaceholder(slot, nodeWidth, nodeHeight)) {
+                slot.key = `video-placeholder|source:${sourceKey}`;
+                slot.ready = true;
+                slot.unsupported = false;
+                return slot;
+            }
+
             if (source.fetchFallbackOnDrawFailure === true) {
                 slot.key = '';
                 slot.ready = false;
@@ -3340,6 +3461,8 @@
         _hasPendingLineDetailRestore(lodBand = this._currentLodBand) {
             return ENABLE_INSTANCED_TEXT_LINES === true &&
                 this._lineDetailsPatchPending === true &&
+                this._deferLineRestorePending !== true &&
+                this._disableLineRender !== true &&
                 this.isInLODMode === true &&
                 lodBand === 'MID' &&
                 this.isLoading !== true;
@@ -6642,15 +6765,29 @@
 
                 if (disableLines) {
                     const cachedLineData = this.lineDataCache.get(nodeId) || null;
-                    if (cachedLineData) {
-                        lineCounts.push(cachedLineData.lineCount || 0);
-                        lineHeights.push(cachedLineData.lineHeightPx || LINE_HEIGHT_PX);
+                    const deferredLineData = cachedLineData || (
+                        this._deferLineRestorePending === true
+                            ? window.MindMapRenderPlan?.resolveResidentLineData?.(
+                                this,
+                                entry,
+                                w,
+                                h,
+                                false,
+                                MAX_LINE_SAMPLES,
+                                LINE_HEIGHT_PX,
+                                LINE_PADDING_PX
+                            ) || null
+                            : null
+                    );
+                    if (deferredLineData) {
+                        lineCounts.push(deferredLineData.lineCount || 0);
+                        lineHeights.push(deferredLineData.lineHeightPx || LINE_HEIGHT_PX);
                         linePaddings.push(
-                            cachedLineData.paddingX || LINE_PADDING_PX,
-                            cachedLineData.paddingY || LINE_PADDING_PX
+                            deferredLineData.paddingX || LINE_PADDING_PX,
+                            deferredLineData.paddingY || LINE_PADDING_PX
                         );
                         for (let i = 0; i < MAX_LINE_SAMPLES; i++) {
-                            lineLengths.push(cachedLineData.lineLengths?.[i] || 0);
+                            lineLengths.push(deferredLineData.lineLengths?.[i] || 0);
                         }
                     } else {
                         lineCounts.push(0);
@@ -7910,6 +8047,12 @@
                 if (!hasResidentInstances) {
                     this._setInstancesDirty('initial-board-build');
                 }
+                if (shouldDeferLineRestore) {
+                    this._scheduleResidentLodWake(
+                        'post-load-line-restore',
+                        POST_LOAD_LINE_RESTORE_DELAY_MS + 16
+                    );
+                }
                 // ▼▼▼ [UX] Show nodes immediately after loading ends ▼▼▼
                 if (this.instancedHaloMesh) this.instancedHaloMesh.visible = this.isInLODMode === true && shouldShowInstancedHaloInLodBand(this._currentLodBand);
                 if (this.instancedMesh) this.instancedMesh.visible = this.isInLODMode === true;