@mindexec/cli 0.2.430 → 0.2.432

package/wwwroot/_content/MindExecution.Shared/js/mind-map-render-plan.js

@@ -0,0 +1,572 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260712-stable-fullres-plan-v12';
+    const FRAME_SAMPLE_LIMIT = 240;
+    const INITIAL_LINE_TEXTURE_ROWS = 1024;
+    const GPU_WARM_RETRY_DELAY_MS = 120;
+    const IMAGE_ATLAS_TILE_SIZE = 128;
+    const frameSampleStates = new WeakMap();
+    const residentLinePrewarmStates = new WeakMap();
+    const VIEW_SYNC_SECTION_KEYS = [
+        'fullResSetup', 'fullResImages', 'fullResCssQueue', 'fullResHandoff', 'fullResOther',
+        'lodCleanup', 'lodNodeScan', 'lodResidentApply', 'lodImageInstances',
+        'lodPositionPatch', 'lodFallbacks', 'lodOther'
+    ];
+
+    function isFullResMotionOptimizationActive(module) {
+        return (module?._viewSyncMotionActive === true ||
+                module?.isPanning === true ||
+                module?.isZooming === true ||
+                module?._fullResMotionFrozen === true) &&
+            module?.isDraggingNode !== true &&
+            module?.isDraggingMultipleNodes !== true &&
+            module?.isResizing !== true &&
+            module?.isWindowResizing !== true;
+    }
+
+    function buildFullResKey(
+        lodBand,
+        visibilityVersion,
+        selectionKey,
+        nodeCount,
+        visibleCount,
+        nearVisibleCount,
+        allowedCssCount,
+        css3dEnabled,
+        module,
+        renderer) {
+        return [
+            String(lodBand || ''),
+            Number(visibilityVersion || 0),
+            String(selectionKey || ''),
+            Number(nodeCount || 0),
+            Number(visibleCount || 0),
+            Number(nearVisibleCount || 0),
+            Number(allowedCssCount || 0),
+            css3dEnabled === false ? 'css3d:off' : 'css3d:on',
+            String(module?.draggedNodeId || ''),
+            String(module?._textOverlayV2State?.editing?.nodeId || ''),
+            String(module?._editingOverlayState?.nodeId || ''),
+            String(module?._textOverlayV2State?.selectionNodeId || ''),
+            String(renderer?._getCurrentHoveredNodeId?.(module) || ''),
+            isFullResMotionOptimizationActive(module) ? 'motion:on' : 'motion:off'
+        ].join('|');
+    }
+
+    function hasPendingFullResWork(renderer, module, bandChanged, cssReadinessDrift) {
+        return !renderer || !module ||
+            bandChanged === true ||
+            cssReadinessDrift === true ||
+            renderer._hasCss3dQueueItems?.() === true ||
+            Number(renderer._css3dQueuedMap?.size || 0) > 0 ||
+            renderer._css3dProcessing === true ||
+            Number(renderer._nearEntryBoostFrames || 0) > 0 ||
+            renderer._fullResHandoffActive === true ||
+            module._fullResMotionFrozen === true ||
+            module._cssParentRepairNeeded === true ||
+            module._css3dVisualChangedThisFrame === true ||
+            module._css3dVisualChangedSinceLastRender === true ||
+            Number(module._cssTransformDirtyIds?.size || 0) > 0;
+    }
+
+    function shouldSkipStableFullRes(renderer, module, key, bandChanged) {
+        const canSkip = !!key &&
+            renderer?._lastNearCssNoWorkKey === key &&
+            hasPendingFullResWork(renderer, module, bandChanged, false) !== true;
+
+        if (renderer) {
+            renderer._lastFullResStablePlanSkipped = canSkip;
+            if (canSkip) {
+                renderer._fullResStablePlanSkipCount = Number(renderer._fullResStablePlanSkipCount || 0) + 1;
+            }
+        }
+
+        return canSkip;
+    }
+
+    function commitStableFullRes(renderer, module, key, bandChanged, cssReadinessDrift) {
+        if (!key || renderer?._lastNearCssNoWorkKey !== key ||
+            hasPendingFullResWork(renderer, module, bandChanged, cssReadinessDrift)) {
+            if (renderer) renderer._lastFullResStablePlanSkipped = false;
+            return false;
+        }
+
+        renderer._lastNearCssNoWorkKey = key;
+        renderer._lastFullResStablePlanSkipped = false;
+        return true;
+    }
+
+    function getLineModelSource(model) {
+        return model?._visibleContent ?? model?.response ?? model?.Response ??
+            model?.content ?? model?.Content ?? model?.text ?? model?.Text ?? '';
+    }
+
+    function getPreparedLineData(renderer, entry, width, height) {
+        const prepared = entry?._lodResidentPreparedLine || null;
+        const model = entry?.model || null;
+        const nodeId = model?.id || model?.Id || '';
+        const element = entry?.cssObject?.element || null;
+        if (!prepared || !model || !nodeId ||
+            prepared.data !== renderer?.lineDataCache?.get?.(nodeId) ||
+            prepared.model !== model ||
+            prepared.width !== Number(width || 0) ||
+            prepared.height !== Number(height || 0) ||
+            prepared.source !== getLineModelSource(model) ||
+            prepared.prompt !== (model?.prompt ?? model?.Prompt ?? '') ||
+            prepared.elementClass !== String(element?.className || '') ||
+            prepared.rootClass !== String(globalThis.document?.documentElement?.className || '') ||
+            prepared.viewportWidth !== Number(globalThis.innerWidth || 0) ||
+            prepared.viewportHeight !== Number(globalThis.innerHeight || 0)) {
+            return null;
+        }
+        return prepared.data;
+    }
+
+    function rememberPreparedLine(renderer, entry, width, height, data) {
+        const model = entry?.model || null;
+        const element = entry?.cssObject?.element || null;
+        if (!model || !data) return data || null;
+        entry._lodResidentPreparedLine = {
+            data,
+            model,
+            width: Number(width || 0),
+            height: Number(height || 0),
+            source: getLineModelSource(model),
+            prompt: model?.prompt ?? model?.Prompt ?? '',
+            elementClass: String(element?.className || ''),
+            rootClass: String(globalThis.document?.documentElement?.className || ''),
+            viewportWidth: Number(globalThis.innerWidth || 0),
+            viewportHeight: Number(globalThis.innerHeight || 0)
+        };
+        return data;
+    }
+
+    function resolveResidentLineData(renderer, entry, width, height, allowExact, maxSamples, lineHeight, padding) {
+        const prepared = getPreparedLineData(renderer, entry, width, height);
+        if (prepared) return prepared;
+        const model = entry?.model || null;
+        if (!renderer || !model) return null;
+        if (allowExact === true) {
+            return rememberPreparedLine(renderer, entry, width, height,
+                renderer._getLineDataForNode?.(model, entry.lodSeed, width, height, entry));
+        }
+        renderer._residentLineFallbackUsed = true;
+        const safeLineHeight = Math.max(1, Number(lineHeight || 1));
+        const safePadding = Math.max(0, Number(padding || 0));
+        const maxLines = Math.max(1, Math.min(
+            Number(maxSamples || 1),
+            Math.floor(Math.max(safeLineHeight, Number(height || 0) - safePadding * 2) / safeLineHeight)
+        ));
+        const fallback = renderer._computeFallbackLineData?.(entry.lodSeed, maxLines) || { lineCount: 0, lineLengths: [] };
+        return {
+            lineCount: Number(fallback.lineCount || 0),
+            lineLengths: fallback.lineLengths || [],
+            lineHeightPx: safeLineHeight,
+            paddingX: safePadding,
+            paddingY: safePadding
+        };
+    }
+
+    function isPrewarmInteractionActive(module) {
+        return module?.isPanning === true || module?.isZooming === true ||
+            module?.isDraggingNode === true || module?.isDraggingMultipleNodes === true ||
+            module?.isResizing === true || module?.isWindowResizing === true;
+    }
+
+    function prepareImageAtlasCapacity(renderer, imageCount) {
+        if (!renderer?.imageAtlasCanvas || Number(renderer.imageAtlasSlots?.size || 0) > 0) return false;
+        let columns = 8;
+        const targetSlots = Math.max(1, Number(imageCount || 0) * 2);
+        while (columns < 32 && columns * columns < targetSlots) columns *= 2;
+        const size = columns * IMAGE_ATLAS_TILE_SIZE;
+        renderer.imageAtlasColumns = columns;
+        renderer.imageAtlasSize = size;
+        renderer.imageAtlasMaxSlots = columns * columns;
+        if (renderer.imageAtlasCanvas.width === size && renderer.imageAtlasCanvas.height === size) return false;
+        renderer.imageAtlasCanvas.width = size;
+        renderer.imageAtlasCanvas.height = size;
+        const context = renderer.imageAtlasCanvas.getContext?.('2d', { alpha: false }) || null;
+        if (context) {
+            context.fillStyle = '#eef2f7';
+            context.fillRect(0, 0, size, size);
+        }
+        if (renderer.imageAtlasTexture) renderer.imageAtlasTexture.needsUpdate = true;
+        renderer._residentGpuWarmKey = '';
+        return true;
+    }
+
+    function fallbackBatch(renderer, fallbackIds, limit = 12) {
+        const ids = Array.from(fallbackIds || []);
+        const safeLimit = Math.max(1, Number(limit || 1));
+        if (ids.length <= safeLimit) return ids;
+        const cursor = Math.max(0, Number(renderer?._residentFallbackCleanupCursor || 0)) % ids.length;
+        const batch = [];
+        for (let i = 0; i < safeLimit; i++) batch.push(ids[(cursor + i) % ids.length]);
+        if (renderer) renderer._residentFallbackCleanupCursor = (cursor + safeLimit) % ids.length;
+        return batch;
+    }
+
+    function reusePreparedImageInstances(renderer, state) {
+        if (renderer?.isInLODMode !== false || renderer?._imageInstancesDirtyReason !== 'image-slot-invalidated' ||
+            state?.imageCandidateIds?.size !== state?.imagePreparedIds?.size) return false;
+        const priorIds = Array.isArray(renderer.imageInstanceData?.nodeIds) ? renderer.imageInstanceData.nodeIds : [];
+        if (priorIds.length !== state.imagePreparedIds.size) return false;
+        for (let i = 0; i < priorIds.length; i++) {
+            const nodeId = priorIds[i];
+            if (!state.imagePreparedIds.has(nodeId) || renderer.imageAtlasSlots?.get?.(nodeId)?.ready !== true) return false;
+        }
+        renderer._clearImageInstancesDirty?.();
+        renderer._residentImageBufferReuseCount = Number(renderer._residentImageBufferReuseCount || 0) + 1;
+        return true;
+    }
+
+    function queueResidentLinePrewarm(state) {
+        if (!state || state.scheduled || state.complete) return;
+        state.scheduled = true;
+        const run = deadline => {
+            state.scheduled = false;
+            if (residentLinePrewarmStates.get(state.renderer) !== state || state.renderer?._disposed === true ||
+                state.renderer?._module !== state.module ||
+                state.module?.nodeObjectsById !== state.nodeObjectsById ||
+                state.module?.isLoading === true ||
+                state.key !== `${Number(state.renderer?._instancesDirtySerial || 0)}:${Number(state.nodeObjectsById.size || 0)}` ||
+                isPrewarmInteractionActive(state.module)) {
+                return;
+            }
+            if (!state.entries) state.entries = Array.from(state.nodeObjectsById.values());
+            const startedAt = performance.now();
+            let processed = 0;
+            while (state.cursor < state.entries.length && processed < 4) {
+                const entry = state.entries[state.cursor++];
+                const model = entry?.model || null;
+                const contentType = String(model?.contentType ?? model?.ContentType ?? '').toLowerCase();
+                if (model && !['image', 'video', 'youtube', 'pdf', 'audio', 'webpage', 'iframe'].includes(contentType)) {
+                    const width = Number(model.width || 400);
+                    const height = Number(model.height || 200);
+                    if (entry.lodSeed === undefined) entry.lodSeed = Math.random() * 100;
+                    if (!getPreparedLineData(state.renderer, entry, width, height)) {
+                        rememberPreparedLine(state.renderer, entry, width, height,
+                            state.renderer._getLineDataForNode?.(model, entry.lodSeed, width, height, entry));
+                    }
+                    state.prepared++;
+                } else if (model && contentType === 'image') {
+                    const nodeId = String(model.id || model.Id || '');
+                    if (nodeId) state.imageCandidateIds.add(nodeId);
+                    const slot = state.imagePass > 0 ? state.renderer._ensureImageLodThumbnail?.(entry) || null : null;
+                    if (slot?.ready === true) {
+                        if (nodeId) state.imagePreparedIds.add(nodeId);
+                    } else {
+                        state.pendingImageEntries.push(entry);
+                    }
+                }
+                processed++;
+                if (performance.now() - startedAt >= 3 && Number(deadline?.timeRemaining?.() || 0) < 1) break;
+            }
+            if (state.cursor >= state.entries.length) {
+                if (state.pendingImageEntries.length > 0 && state.imagePass < 20) {
+                    const isFirstImagePass = state.imagePass === 0;
+                    if (isFirstImagePass) prepareImageAtlasCapacity(state.renderer, state.imageCandidateIds.size);
+                    state.entries = Array.from(new Set(state.pendingImageEntries));
+                    state.pendingImageEntries.length = 0;
+                    state.cursor = 0;
+                    state.imagePass++;
+                    if (isFirstImagePass) {
+                        queueResidentLinePrewarm(state);
+                    } else {
+                        setTimeout(() => {
+                            if (residentLinePrewarmStates.get(state.renderer) === state) queueResidentLinePrewarm(state);
+                        }, 250);
+                    }
+                    return;
+                }
+                state.complete = true;
+                state.renderer._residentLinePrewarmCount = state.prepared;
+                state.renderer._residentImagePrewarmCount = state.imagePreparedIds.size;
+                state.renderer._residentImagePrewarmCandidateCount = state.imageCandidateIds.size;
+                state.renderer._residentImagePrewarmComplete = state.pendingImageEntries.length === 0;
+                if (state.renderer.isInLODMode === true && state.renderer._lineDetailsPatchPending === true) {
+                    state.renderer._markLineDetailsDirty?.();
+                }
+                queueResidentGpuWarm(state);
+                return;
+            }
+            queueResidentLinePrewarm(state);
+        };
+        if (typeof globalThis.requestIdleCallback === 'function') {
+            globalThis.requestIdleCallback(run, { timeout: 120 });
+        } else {
+            setTimeout(() => run({ timeRemaining: () => 3, didTimeout: true }), 16);
+        }
+    }
+
+    function getResidentGpuKey(renderer) {
+        return `${Number(renderer?.lineDataTexture?.version || 0)}:${Number(renderer?.imageAtlasTexture?.version || 0)}:${Number(renderer?.lineTextureRows || 0)}`;
+    }
+
+    function retryResidentGpuWarm(state) {
+        if (!state || state.gpuRetryTimer) return;
+        state.gpuRetryTimer = setTimeout(() => {
+            state.gpuRetryTimer = null;
+            if (residentLinePrewarmStates.get(state.renderer) === state) queueResidentGpuWarm(state);
+        }, GPU_WARM_RETRY_DELAY_MS);
+    }
+
+    function queueResidentGpuWarm(state) {
+        if (!state?.complete || state.gpuScheduled) return;
+        const renderer = state.renderer;
+        if (residentLinePrewarmStates.get(renderer) !== state || renderer?._disposed === true ||
+            renderer?._module !== state.module || state.module?.nodeObjectsById !== state.nodeObjectsById ||
+            state.module?.isLoading === true ||
+            state.key !== `${Number(renderer?._instancesDirtySerial || 0)}:${Number(state.nodeObjectsById.size || 0)}`) return;
+        if (isPrewarmInteractionActive(state.module)) {
+            retryResidentGpuWarm(state);
+            return;
+        }
+        const webglRenderer = renderer?.renderer || null;
+        const gpuKey = getResidentGpuKey(renderer);
+        if (!webglRenderer || renderer._residentGpuWarmKey === gpuKey) return;
+        if (renderer._hasPendingImageAtlasWork?.() === true) {
+            retryResidentGpuWarm(state);
+            return;
+        }
+        state.gpuScheduled = true;
+        const run = () => {
+            state.gpuScheduled = false;
+            if (residentLinePrewarmStates.get(renderer) !== state || renderer?._disposed === true ||
+                renderer?._module !== state.module || state.module?.nodeObjectsById !== state.nodeObjectsById ||
+                state.module?.isLoading === true || state.key !== `${Number(renderer._instancesDirtySerial || 0)}:${Number(state.nodeObjectsById.size || 0)}`) return;
+            if (isPrewarmInteractionActive(state.module) || renderer._hasPendingImageAtlasWork?.() === true) {
+                retryResidentGpuWarm(state);
+                return;
+            }
+            try {
+                if (renderer.lineDataTexture) webglRenderer.initTexture?.(renderer.lineDataTexture);
+                if (renderer.imageAtlasTexture && Number(renderer.imageAtlasSlots?.size || 0) > 0) {
+                    webglRenderer.initTexture?.(renderer.imageAtlasTexture);
+                    renderer._residentImageAtlasWarmVersion = Number(renderer.imageAtlasTexture.version || 0);
+                }
+                const THREE = globalThis.THREE;
+                if (THREE?.Scene && typeof webglRenderer.compile === 'function' && state.module?.camera) {
+                    const warmScene = new THREE.Scene();
+                    [renderer.instancedMesh, renderer.instancedBorderLineMesh, renderer.instancedLineMesh,
+                        renderer.instancedHaloMesh, renderer.instancedConsoleMesh, renderer.instancedImageMesh]
+                        .filter(Boolean)
+                        .forEach(mesh => {
+                            const clone = mesh.clone?.();
+                            if (!clone) return;
+                            clone.visible = true;
+                            clone.frustumCulled = false;
+                            warmScene.add(clone);
+                        });
+                    webglRenderer.compile(warmScene, state.module.camera);
+                    warmScene.clear?.();
+                }
+                renderer._residentGpuWarmKey = getResidentGpuKey(renderer);
+                renderer._residentGpuWarmComplete = true;
+                reusePreparedImageInstances(renderer, state);
+                state.gpuFailureCount = 0;
+            } catch (error) {
+                console.warn('[RenderPlan] Resident GPU warmup deferred.', error);
+                state.gpuFailureCount = Number(state.gpuFailureCount || 0) + 1;
+                if (state.gpuFailureCount <= 3) retryResidentGpuWarm(state);
+            }
+        };
+        if (typeof globalThis.requestIdleCallback === 'function') {
+            globalThis.requestIdleCallback(run, { timeout: 300 });
+        } else {
+            setTimeout(run, 32);
+        }
+    }
+
+    function scheduleResidentLinePrewarm(renderer, module, nodeObjectsById) {
+        if (!renderer || !module || !nodeObjectsById?.values || module.isLoading === true) return;
+        const key = `${Number(renderer._instancesDirtySerial || 0)}:${Number(nodeObjectsById.size || 0)}`;
+        let state = residentLinePrewarmStates.get(renderer);
+        if (!state || state.key !== key || state.nodeObjectsById !== nodeObjectsById) {
+            const entries = Array.from(nodeObjectsById.values());
+            const imageCandidateIds = new Set();
+            for (let i = 0; i < entries.length; i++) {
+                const model = entries[i]?.model || null;
+                if (String(model?.contentType ?? model?.ContentType ?? '').toLowerCase() !== 'image') continue;
+                const nodeId = String(model?.id || model?.Id || '');
+                if (nodeId) imageCandidateIds.add(nodeId);
+            }
+            prepareImageAtlasCapacity(renderer, imageCandidateIds.size);
+            state = {
+                renderer, module, nodeObjectsById, key, entries, cursor: 0, prepared: 0,
+                scheduled: false, complete: false, gpuScheduled: false, gpuRetryTimer: null, gpuFailureCount: 0,
+                imagePass: 0, imageCandidateIds, imagePreparedIds: new Set(), pendingImageEntries: []
+            };
+            residentLinePrewarmStates.set(renderer, state);
+        }
+        if (state.complete && renderer.isInLODMode === false &&
+            renderer._imageInstancesDirtyReason === 'image-slot-invalidated') {
+            const staleImageEntries = [];
+            for (const nodeId of state.imageCandidateIds) {
+                if (renderer.imageAtlasSlots?.get?.(nodeId)?.ready === true) continue;
+                const entry = nodeObjectsById.get?.(nodeId) || null;
+                if (entry) {
+                    state.imagePreparedIds.delete(nodeId);
+                    staleImageEntries.push(entry);
+                }
+            }
+            if (staleImageEntries.length > 0) {
+                state.entries = staleImageEntries;
+                state.cursor = 0;
+                state.complete = false;
+                state.imagePass = 1;
+                state.pendingImageEntries.length = 0;
+            }
+        }
+        queueResidentLinePrewarm(state);
+        if (state.complete) queueResidentGpuWarm(state);
+    }
+
+    function areResidentLinesPrepared(renderer, nodeObjectsById, nodeIds) {
+        if (!renderer || !nodeObjectsById?.get || !Array.isArray(nodeIds)) return false;
+        for (let i = 0; i < nodeIds.length; i++) {
+            const entry = nodeObjectsById.get(nodeIds[i]);
+            const model = entry?.model || null;
+            if (!model || !getPreparedLineData(renderer, entry, model.width || 400, model.height || 200)) return false;
+        }
+        return true;
+    }
+
+    function initialLineTextureRows(maxInstances) {
+        return Math.min(Math.max(1, Number(maxInstances || 1)), INITIAL_LINE_TEXTURE_ROWS);
+    }
+
+    function ensureLineTextureCapacity(renderer, requiredCount, width) {
+        const currentRows = Number(renderer?.lineTextureRows || 0);
+        const maxRows = Math.max(1, Number(renderer?.maxInstances || requiredCount || 1));
+        if (!renderer || Number(requiredCount || 0) <= currentRows || currentRows >= maxRows) return false;
+        let nextRows = Math.max(INITIAL_LINE_TEXTURE_ROWS, currentRows || 1);
+        while (nextRows < requiredCount && nextRows < maxRows) nextRows *= 2;
+        nextRows = Math.min(nextRows, maxRows);
+        const THREE = globalThis.THREE;
+        if (!THREE?.DataTexture) return false;
+        const rowWidth = Math.max(1, Number(width || 1));
+        const data = new Uint8Array(nextRows * rowWidth);
+        data.set(renderer.lineDataArray?.subarray?.(0, data.length) || []);
+        const previous = renderer.lineDataTexture || null;
+        const texture = new THREE.DataTexture(data, rowWidth, nextRows, THREE.RedFormat, THREE.UnsignedByteType);
+        texture.minFilter = previous?.minFilter ?? THREE.NearestFilter;
+        texture.magFilter = previous?.magFilter ?? THREE.NearestFilter;
+        texture.wrapS = previous?.wrapS ?? THREE.ClampToEdgeWrapping;
+        texture.wrapT = previous?.wrapT ?? THREE.ClampToEdgeWrapping;
+        texture.needsUpdate = true;
+        renderer.lineDataArray = data;
+        renderer.lineDataTexture = texture;
+        renderer.lineTextureRows = nextRows;
+        renderer._residentGpuWarmKey = '';
+        const uniforms = renderer.instancedLineMesh?.material?.uniforms || null;
+        if (uniforms?.uLineDataTex) uniforms.uLineDataTex.value = texture;
+        if (uniforms?.uLineDataSize?.value?.set) uniforms.uLineDataSize.value.set(rowWidth, nextRows);
+        previous?.dispose?.();
+        return true;
+    }
+
+    function getFrameSampleState(renderer) {
+        let state = frameSampleStates.get(renderer);
+        if (!state) {
+            state = { samples: new Array(FRAME_SAMPLE_LIMIT), cursor: 0, count: 0 };
+            frameSampleStates.set(renderer, state);
+        }
+        return state;
+    }
+
+    function recordFrame(renderer, profile) {
+        if (!renderer || !profile) return;
+        const state = getFrameSampleState(renderer);
+        const sections = profile.sections || {};
+        let viewSyncMs = 0;
+        for (let i = 0; i < VIEW_SYNC_SECTION_KEYS.length; i++) {
+            viewSyncMs += Number(sections[VIEW_SYNC_SECTION_KEYS[i]] || 0);
+        }
+        const sample = state.samples[state.cursor] || {};
+        sample.frameMs = Number(profile.durationMs || 0);
+        sample.visibilityMs = Number(sections.visibility || 0);
+        sample.viewSyncMs = viewSyncMs;
+        sample.css3dRenderMs = Number(sections.css3dRender || 0);
+        sample.stableFullResSkipped = renderer._lastFullResStablePlanSkipped === true;
+        state.samples[state.cursor] = sample;
+        state.cursor = (state.cursor + 1) % FRAME_SAMPLE_LIMIT;
+        state.count = Math.min(FRAME_SAMPLE_LIMIT, state.count + 1);
+    }
+
+    function beginFrame(renderer) {
+        if (renderer) renderer._lastFullResStablePlanSkipped = false;
+    }
+
+    function percentile(state, field, ratio) {
+        if (!state?.count) return 0;
+        const values = [];
+        for (let i = 0; i < state.count; i++) {
+            const value = Number(state.samples[i]?.[field] || 0);
+            if (Number.isFinite(value)) values.push(value);
+        }
+        if (values.length === 0) return 0;
+        values.sort((a, b) => a - b);
+        return Number(values[Math.max(0, Math.ceil(values.length * ratio) - 1)].toFixed(2));
+    }
+
+    function getDiagnostics(renderer) {
+        const state = renderer ? frameSampleStates.get(renderer) : null;
+        let stableFullResSampleCount = 0;
+        for (let i = 0; i < Number(state?.count || 0); i++) {
+            if (state.samples[i]?.stableFullResSkipped === true) stableFullResSampleCount++;
+        }
+        return {
+            build: BUILD_ID,
+            stableFullResSkipCount: Number(renderer?._fullResStablePlanSkipCount || 0),
+            skippedLastPlan: renderer?._lastFullResStablePlanSkipped === true,
+            sampleCount: Number(state?.count || 0),
+            stableFullResSampleCount,
+            frameP50Ms: percentile(state, 'frameMs', 0.50),
+            frameP95Ms: percentile(state, 'frameMs', 0.95),
+            visibilityP95Ms: percentile(state, 'visibilityMs', 0.95),
+            viewSyncP95Ms: percentile(state, 'viewSyncMs', 0.95),
+            css3dRenderP95Ms: percentile(state, 'css3dRenderMs', 0.95),
+            residentLinePrewarmCount: Number(renderer?._residentLinePrewarmCount || 0),
+            residentImagePrewarmCount: Number(renderer?._residentImagePrewarmCount || 0),
+            residentImagePrewarmCandidateCount: Number(renderer?._residentImagePrewarmCandidateCount || 0),
+            residentImageBufferReuseCount: Number(renderer?._residentImageBufferReuseCount || 0),
+            lineTextureRows: Number(renderer?.lineTextureRows || 0),
+            residentGpuWarmComplete: !!renderer &&
+                renderer._hasPendingImageAtlasWork?.() !== true &&
+                renderer._residentGpuWarmKey === getResidentGpuKey(renderer),
+            residentAtlasWarmComplete: !!renderer && Number(renderer.imageAtlasSlots?.size || 0) > 0 &&
+                renderer._hasPendingImageAtlasWork?.() !== true &&
+                Number(renderer._residentImageAtlasWarmVersion ?? -1) === Number(renderer.imageAtlasTexture?.version || 0)
+        };
+    }
+
+    function resetDiagnostics(renderer) {
+        if (!renderer) return;
+        frameSampleStates.delete(renderer);
+        renderer._fullResStablePlanSkipCount = 0;
+        renderer._lastFullResStablePlanSkipped = false;
+    }
+
+    window.MindMapRenderPlan = Object.freeze({
+        buildFullResKey,
+        shouldSkipStableFullRes,
+        commitStableFullRes,
+        scheduleResidentLinePrewarm,
+        resolveResidentLineData,
+        getPreparedLineData,
+        areResidentLinesPrepared,
+        initialLineTextureRows,
+        ensureLineTextureCapacity,
+        prepareImageAtlasCapacity,
+        fallbackBatch,
+        reusePreparedImageInstances,
+        beginFrame,
+        recordFrame,
+        getDiagnostics,
+        resetDiagnostics
+    });
+
+    window.MindCanvasBuildInfo?.registerPart?.('renderPlan', BUILD_ID);
+})();

package/wwwroot/_content/MindExecution.Shared/js/renderers/CSS3DRenderer.js

@@ -31,19 +31,76 @@
     }
 
     function CSS3DRenderer(){
-        var _width, _height; var _widthHalf, _heightHalf; var cache = { camera:{ fov:0, style:'' }, objects: new WeakMap() };
-        var domElement = document.createElement('div'); domElement.style.overflow = 'hidden'; this.domElement = domElement;
-        var cameraElement = document.createElement('div'); cameraElement.style.webkitTransformStyle = cameraElement.style.transformStyle = 'preserve-3d'; cameraElement.style.pointerEvents = 'none'; domElement.appendChild(cameraElement);
-
+        var _width, _height, _widthHalf, _heightHalf;
+        var cache = { camera:{ fov:0, style:'' }, objects: new WeakMap() };
+        var domElement = document.createElement('div');
+        domElement.style.overflow = 'hidden';
+        this.domElement = domElement;
+        var cameraElement = document.createElement('div');
+        cameraElement.style.webkitTransformStyle = cameraElement.style.transformStyle = 'preserve-3d';
+        cameraElement.style.pointerEvents = 'none';
+        domElement.appendChild(cameraElement);
+
         this.getSize = function(){ return { width:_width, height:_height }; };
         this.getCameraElement = function(){ return cameraElement; };
-        this.setSize = function(width, height){ _width=width; _height=height; _widthHalf=_width/2; _heightHalf=_height/2; domElement.style.width=width+'px'; domElement.style.height=height+'px'; cameraElement.style.width=width+'px'; cameraElement.style.height=height+'px'; };
+        this.setSize = function(width, height){
+            _width=width; _height=height; _widthHalf=_width/2; _heightHalf=_height/2;
+            domElement.style.width=width+'px'; domElement.style.height=height+'px';
+            cameraElement.style.width=width+'px'; cameraElement.style.height=height+'px';
+        };
+
         function getCameraCSSMatrix(matrix){ var e=matrix.elements; return 'matrix3d('+epsilon(e[0])+','+epsilon(-e[1])+','+epsilon(e[2])+','+epsilon(e[3])+','+epsilon(e[4])+','+epsilon(-e[5])+','+epsilon(e[6])+','+epsilon(e[7])+','+epsilon(e[8])+','+epsilon(-e[9])+','+epsilon(e[10])+','+epsilon(e[11])+','+epsilon(e[12])+','+epsilon(-e[13])+','+epsilon(e[14])+','+epsilon(e[15])+')'; }
-        function getObjectCSSMatrix(matrix){ var e=matrix.elements; var m='matrix3d('+epsilon(e[0])+','+epsilon(e[1])+','+epsilon(e[2])+','+epsilon(e[3])+','+epsilon(-e[4])+','+epsilon(-e[5])+','+epsilon(-e[6])+','+epsilon(-e[7])+','+epsilon(e[8])+','+epsilon(e[9])+','+epsilon(e[10])+','+epsilon(e[11])+','+epsilon(e[12])+','+epsilon(e[13])+','+epsilon(e[14])+','+epsilon(e[15])+')'; return m; }
-        function renderObject(object, scene, camera, cameraCSSMatrix){ if (object.isCSS3DObject){ var style=getObjectCSSMatrix(object.matrixWorld); var display=object.visible ? '' : 'none'; var element=object.element; var cached=cache.objects.get(object); var changed=false; if (cached===undefined || cached.style!==style){ element.style.webkitTransform=element.style.transform=style; changed=true; } if (cached===undefined || cached.display!==display){ element.style.display=display; changed=true; } if (changed){ cache.objects.set(object, { style, display }); } if (element.parentNode !== cameraElement){ cameraElement.appendChild(element); } } for (var i=0,l=object.children.length;i<l;i++){ renderObject(object.children[i], scene, camera, cameraCSSMatrix); } }
-        function renderCameraOnly(renderer, camera){ var fov=camera.projectionMatrix.elements[5]*_heightHalf; if (cache.camera.fov!==fov){ renderer.domElement.style.webkitPerspective=renderer.domElement.style.perspective=fov+'px'; cache.camera.fov=fov; } if (camera.parent===null) camera.updateMatrixWorld(); var cameraCSSMatrix='translateZ('+fov+'px)'+getCameraCSSMatrix(camera.matrixWorldInverse); var style=cameraCSSMatrix+'translate('+_widthHalf+'px,'+_heightHalf+'px)'; if (cache.camera.style!==style){ cameraElement.style.webkitTransform=cameraElement.style.transform=style; cache.camera.style=style; } return cameraCSSMatrix; }
-        this.renderCamera = function(camera){ renderCameraOnly(this, camera); };
-        this.render = function(scene, camera){ if (scene.autoUpdate===true) scene.updateMatrixWorld(); var cameraCSSMatrix=renderCameraOnly(this, camera); renderObject(scene, scene, camera, cameraCSSMatrix); };
+        function getObjectCSSMatrix(matrix){ var e=matrix.elements; return 'matrix3d('+epsilon(e[0])+','+epsilon(e[1])+','+epsilon(e[2])+','+epsilon(e[3])+','+epsilon(-e[4])+','+epsilon(-e[5])+','+epsilon(-e[6])+','+epsilon(-e[7])+','+epsilon(e[8])+','+epsilon(e[9])+','+epsilon(e[10])+','+epsilon(e[11])+','+epsilon(e[12])+','+epsilon(e[13])+','+epsilon(e[14])+','+epsilon(e[15])+')'; }
+        function hasMatrixChanged(elements, values){
+            if (!values) return true;
+            for (var i=0;i<16;i++) if (epsilon(elements[i])!==values[i]) return true;
+            return false;
+        }
+        function copyMatrix(elements, values){
+            var next=values || new Float64Array(16);
+            for (var i=0;i<16;i++) next[i]=epsilon(elements[i]);
+            return next;
+        }
+        function renderObject(object){
+            if (object.isCSS3DObject){
+                var visible=object.visible===true;
+                var display=visible ? '' : 'none';
+                var element=object.element;
+                var cached=cache.objects.get(object);
+                if (cached===undefined){
+                    cached={ element:null, matrix:null, display:null };
+                    cache.objects.set(object,cached);
+                }
+                var elementChanged=cached.element!==element;
+                var becameVisible=visible && cached.display==='none';
+                if (visible && (elementChanged || becameVisible || hasMatrixChanged(object.matrixWorld.elements,cached.matrix))){
+                    var style=getObjectCSSMatrix(object.matrixWorld);
+                    element.style.webkitTransform=element.style.transform=style;
+                    cached.matrix=copyMatrix(object.matrixWorld.elements,cached.matrix);
+                }
+                if (elementChanged || cached.display!==display) element.style.display=display;
+                cached.element=element;
+                cached.display=display;
+                if (element.parentNode!==cameraElement) cameraElement.appendChild(element);
+            }
+            for (var i=0,l=object.children.length;i<l;i++) renderObject(object.children[i]);
+        }
+        function renderCameraOnly(renderer, camera, matrixWorldIsCurrent){
+            var fov=camera.projectionMatrix.elements[5]*_heightHalf;
+            if (cache.camera.fov!==fov){
+                renderer.domElement.style.webkitPerspective=renderer.domElement.style.perspective=fov+'px';
+                cache.camera.fov=fov;
+            }
+            if (matrixWorldIsCurrent!==true && camera.parent===null) camera.updateMatrixWorld();
+            var cameraCSSMatrix='translateZ('+fov+'px)'+getCameraCSSMatrix(camera.matrixWorldInverse);
+            var style=cameraCSSMatrix+'translate('+_widthHalf+'px,'+_heightHalf+'px)';
+            if (cache.camera.style!==style){
+                cameraElement.style.webkitTransform=cameraElement.style.transform=style;
+                cache.camera.style=style;
+            }
+        }
+        this.renderCamera = function(camera, matrixWorldIsCurrent){ renderCameraOnly(this, camera, matrixWorldIsCurrent); };
+        this.render = function(scene, camera){ if (scene.autoUpdate===true) scene.updateMatrixWorld(); renderCameraOnly(this, camera, false); renderObject(scene); };
     }
 
     window.CSS3DObject = CSS3DObject; window.CSS3DSprite = CSS3DSprite; window.CSS3DRenderer = CSS3DRenderer;