@mindexec/cli 0.2.446 → 0.2.448

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-hotpath.js

@@ -0,0 +1,902 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260724-near-css3d-hotpath-v001';
+    const projectedCorners = Array.from({ length: 4 }, () => new THREE.Vector3());
+
+    function createPerfCounters() {
+        return {
+            buildId: BUILD_ID,
+            hitTest: {
+                fullBoardFallbackCount: 0,
+                candidateSource: '',
+                candidateCount: 0,
+                elementsFromPointCalls: 0,
+                projectedFrameCalculations: 0
+            },
+            selection: {
+                nodesVisited: 0,
+                domQueries: 0
+            },
+            css3d: {
+                visibilityPatchEntered: 0,
+                visibilityPatchExited: 0,
+                visibilityPatchFallbacks: 0,
+                sceneObjectsVisited: 0
+            }
+        };
+    }
+
+    function ensurePerfCounters(module) {
+        if (!module) return null;
+        if (!module._nearCss3dPerfCounters ||
+            module._nearCss3dPerfCounters.buildId !== BUILD_ID) {
+            module._nearCss3dPerfCounters = createPerfCounters();
+        }
+        return module._nearCss3dPerfCounters;
+    }
+
+    function increment(module, section, key, amount = 1) {
+        const counters = ensurePerfCounters(module);
+        const target = counters?.[section];
+        if (!target || !(key in target)) return;
+        target[key] = Number(target[key] || 0) + Number(amount || 0);
+    }
+
+    function recordHitCandidates(module, source, count) {
+        const hitTest = ensurePerfCounters(module)?.hitTest;
+        if (!hitTest) return;
+        hitTest.candidateSource = String(source || '');
+        hitTest.candidateCount = Math.max(0, Number(count || 0));
+    }
+
+    function getPerfSnapshot(module) {
+        const counters = ensurePerfCounters(module);
+        if (!counters) return null;
+        return {
+            buildId: counters.buildId,
+            hitTest: { ...counters.hitTest },
+            selection: { ...counters.selection },
+            css3d: { ...counters.css3d }
+        };
+    }
+
+    function resetPerfCounters(module) {
+        if (!module) return false;
+        module._nearCss3dPerfCounters = createPerfCounters();
+        return true;
+    }
+
+    function createPointerHitContext(module, event, viewportMetrics = null) {
+        return {
+            module,
+            event,
+            clientX: Number(event?.clientX || 0),
+            clientY: Number(event?.clientY || 0),
+            viewportMetrics,
+            domStack: undefined,
+            worldPoint: undefined,
+            candidateIds: undefined,
+            candidateSource: '',
+            cssHit: undefined,
+            projectedFrames: new Map()
+        };
+    }
+
+    function getDomStack(module, context) {
+        if (!context) return [];
+        if (context.domStack !== undefined) return context.domStack;
+        increment(module, 'hitTest', 'elementsFromPointCalls');
+        context.domStack = typeof document !== 'undefined' &&
+            typeof document.elementsFromPoint === 'function'
+            ? document.elementsFromPoint(context.clientX, context.clientY)
+            : [];
+        return context.domStack;
+    }
+
+    function getContextWorldPoint(context, factory) {
+        if (!context) return typeof factory === 'function' ? factory() : null;
+        if (context.worldPoint !== undefined) return context.worldPoint;
+        const point = typeof factory === 'function' ? factory() : null;
+        context.worldPoint = point
+            ? new THREE.Vector3(Number(point.x || 0), Number(point.y || 0), Number(point.z || 0))
+            : null;
+        return context.worldPoint;
+    }
+
+    function getContextCandidateIds(module, context, factory, source = '') {
+        if (!context) {
+            const ids = typeof factory === 'function' ? factory() : [];
+            recordHitCandidates(module, source, Array.isArray(ids) ? ids.length : 0);
+            return ids;
+        }
+        if (context.candidateIds !== undefined) return context.candidateIds;
+        context.candidateIds = typeof factory === 'function' ? factory() : [];
+        context.candidateSource = String(source || '');
+        recordHitCandidates(
+            module,
+            context.candidateSource,
+            Array.isArray(context.candidateIds) ? context.candidateIds.length : 0
+        );
+        return context.candidateIds;
+    }
+
+    function getProjectedClientFrame(module, entry, context, viewportMetrics, cacheKey = null) {
+        if (!module?.camera || !entry) return null;
+        const metrics = context?.viewportMetrics || viewportMetrics || null;
+        if (!metrics || !(metrics.width > 0 && metrics.height > 0)) return null;
+
+        const frameKey = cacheKey || entry;
+        const cachedFrame = context?.projectedFrames?.get?.(frameKey);
+        if (cachedFrame) return cachedFrame;
+
+        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 z = Number(position.z || 0);
+        projectedCorners[0].set(position.x, position.y, z);
+        projectedCorners[1].set(position.x + width, position.y, z);
+        projectedCorners[2].set(position.x, position.y - height, z);
+        projectedCorners[3].set(position.x + width, position.y - height, z);
+
+        let left = Infinity;
+        let right = -Infinity;
+        let top = Infinity;
+        let bottom = -Infinity;
+        for (let i = 0; i < projectedCorners.length; i++) {
+            const corner = projectedCorners[i].project(module.camera);
+            const x = Number(metrics.left || 0) + ((corner.x + 1) * metrics.width / 2);
+            const y = Number(metrics.top || 0) + ((-corner.y + 1) * metrics.height / 2);
+            if (x < left) left = x;
+            if (x > right) right = x;
+            if (y < top) top = y;
+            if (y > bottom) bottom = y;
+        }
+
+        const frame = { left, right, top, bottom };
+        context?.projectedFrames?.set?.(frameKey, frame);
+        increment(module, 'hitTest', 'projectedFrameCalculations');
+        return frame;
+    }
+
+    function getDomRefs(entry, module = null, cssObjectOverride = null) {
+        const cssObject = cssObjectOverride || entry?.cssObject || null;
+        const wrapper = cssObject?.element || null;
+        if (!wrapper) return null;
+        const version = Number(entry?._css3dDomVersion || cssObject?.userData?._domVersion || 0);
+        const firstChild = wrapper.firstElementChild || null;
+        const cached = entry?.domRefs || cssObject?.userData?.domRefs || null;
+        if (cached?.wrapper === wrapper &&
+            cached.firstChild === firstChild &&
+            cached.version === version) {
+            return cached;
+        }
+
+        const query = (selector) => {
+            increment(module, 'selection', 'domQueries');
+            return wrapper.querySelector?.(selector) || null;
+        };
+        const refs = {
+            version,
+            wrapper,
+            firstChild,
+            innerRoot: query('.node-container, .map-node, .css3d-dynamic-node'),
+            response: query('.node-response, [id^="node-response-"]'),
+            textarea: query('textarea, [contenteditable="true"]'),
+            scrollable: query('.csv-table-scroll, .node-response, .note-content, .markdown-body, .code-body, .map-node-memo__body-view'),
+            memoTitle: query('.map-node-memo__title'),
+            memoBody: query('.map-node-memo__body'),
+            memoBodyView: query('.map-node-memo__body-view'),
+            resizeHandles: Array.from(wrapper.querySelectorAll?.('.resize-handle, [data-resize-handle]') || [])
+        };
+        if (entry) entry.domRefs = refs;
+        cssObject.userData ||= {};
+        cssObject.userData.domRefs = refs;
+        return refs;
+    }
+
+    function invalidateDomRefs(entry, cssObjectOverride = null) {
+        const cssObject = cssObjectOverride || entry?.cssObject || null;
+        const nextVersion = Math.max(
+            Number(entry?._css3dDomVersion || 0),
+            Number(cssObject?.userData?._domVersion || 0)
+        ) + 1;
+        if (entry) {
+            entry._css3dDomVersion = nextVersion;
+            entry.domRefs = null;
+        }
+        if (cssObject) {
+            cssObject.userData ||= {};
+            cssObject.userData._domVersion = nextVersion;
+            cssObject.userData.domRefs = null;
+        }
+        return nextVersion;
+    }
+
+    function invalidateDomRefsByCssObject(module, cssObject, nodeId = '') {
+        const normalizedId = String(nodeId || cssObject?.userData?.nodeId || '').trim();
+        const entry = normalizedId ? module?.nodeObjectsById?.get?.(normalizedId) : null;
+        return invalidateDomRefs(entry, cssObject);
+    }
+
+    function installTextSource(helpers = {}) {
+        const styleState = new WeakMap();
+        const suspendedClass = 'mind-map-text-overlay-source-suspended';
+        const suspendedAttr = 'data-text-overlay-source-suspended';
+
+        function getModule() {
+            return helpers.getModule?.() || null;
+        }
+
+        function getTextOverlaySourceTargets(nodeEntry) {
+            if (!nodeEntry?.cssObject?.element || !helpers.supportsTextOverlay?.(nodeEntry.model)) return [];
+            const module = getModule();
+            const refs = getDomRefs(nodeEntry, module);
+            if (helpers.getTextOverlayRenderMode?.(nodeEntry) === 'memo') {
+                return [refs?.memoTitle, refs?.memoBodyView].filter(element =>
+                    !!element && (element.style.display !== 'none' || element.offsetWidth > 0 || element.offsetHeight > 0));
+            }
+            const root = helpers.getTextOverlayRootElement?.(nodeEntry);
+            if (!root?.children?.length) return [];
+            return Array.from(root.children).filter(element =>
+                !!element &&
+                !element.classList?.contains?.('resize-handle') &&
+                (element.style.display !== 'none' || element.offsetWidth > 0 || element.offsetHeight > 0));
+        }
+
+        function ensureTextOverlaySourceStyleState(element) {
+            if (!element) return null;
+            let state = styleState.get(element) || null;
+            if (!state) {
+                state = {
+                    opacity: element.style.opacity,
+                    pointerEvents: element.style.pointerEvents,
+                    userSelect: element.style.userSelect,
+                    webkitUserSelect: element.style.webkitUserSelect,
+                    caretColor: element.style.caretColor,
+                    contentVisibility: element.style.contentVisibility,
+                    containIntrinsicSize: element.style.containIntrinsicSize,
+                    contain: element.style.contain
+                };
+                styleState.set(element, state);
+            }
+            return state;
+        }
+
+        function resetTextOverlaySourcePresentation(element) {
+            if (!element) return;
+            element.classList?.remove?.(suspendedClass);
+            element.removeAttribute?.(suspendedAttr);
+            element.style.opacity = '';
+            element.style.pointerEvents = '';
+            element.style.userSelect = '';
+            element.style.webkitUserSelect = '';
+            element.style.caretColor = '';
+            element.style.contentVisibility = '';
+            element.style.containIntrinsicSize = '';
+            element.style.contain = '';
+        }
+
+        function suspendTextOverlaySourceTarget(element) {
+            if (!element) return;
+            ensureTextOverlaySourceStyleState(element);
+            element.classList?.add?.(suspendedClass);
+            element.setAttribute?.(suspendedAttr, 'true');
+            element.style.pointerEvents = 'none';
+            element.style.userSelect = 'none';
+            element.style.webkitUserSelect = 'none';
+            element.style.caretColor = 'transparent';
+            element.style.opacity = '0';
+            element.style.contain = 'layout style paint';
+            element.style.contentVisibility = 'visible';
+            element.style.containIntrinsicSize = '';
+        }
+
+        function restoreTextOverlaySourceTarget(element) {
+            if (!element) return;
+            const state = styleState.get(element) || null;
+            if (!state) {
+                resetTextOverlaySourcePresentation(element);
+                return;
+            }
+            element.classList?.remove?.(suspendedClass);
+            element.removeAttribute?.(suspendedAttr);
+            Object.assign(element.style, state);
+            styleState.delete(element);
+        }
+
+        function stripTextOverlayPresentationOverrides(root) {
+            if (!root) return;
+            if (root.hasAttribute?.(suspendedAttr) || root.classList?.contains?.(suspendedClass)) {
+                resetTextOverlaySourcePresentation(root);
+            }
+            root.querySelectorAll?.(`[${suspendedAttr}], .${suspendedClass}`)
+                ?.forEach?.(resetTextOverlaySourcePresentation);
+        }
+
+        function getNativeTextSelectionSourceNodeId(module) {
+            return String(module?._nativeTextSelectionSourceNodeId || '').trim();
+        }
+
+        function hasNativeTextSelectionSource(module, nodeId = null) {
+            const activeId = getNativeTextSelectionSourceNodeId(module);
+            if (!activeId) return false;
+            return nodeId === null || activeId === String(nodeId || '').trim();
+        }
+
+        function setNativeTextSelectionOwnerClass(module, nodeId = null) {
+            if (!module) return false;
+            const nextId = String(nodeId || '').trim();
+            const previousId = String(module._nativeTextSelectionOwnerNodeId || '').trim();
+            if (previousId === nextId) return true;
+
+            const getWrapper = (id) => {
+                const entry = id ? module.nodeObjectsById?.get?.(id) : null;
+                return getDomRefs(entry, module)?.wrapper || null;
+            };
+            const previousWrapper = getWrapper(previousId);
+            const nextWrapper = getWrapper(nextId);
+            if (previousWrapper) {
+                previousWrapper.classList?.remove?.('is-text-selection-owner');
+                increment(module, 'selection', 'nodesVisited');
+            }
+            if (nextWrapper) {
+                nextWrapper.classList?.add?.('is-text-selection-owner');
+                increment(module, 'selection', 'nodesVisited');
+            }
+            module._nativeTextSelectionOwnerNodeId = nextId || null;
+            return true;
+        }
+
+        function activateNativeTextSelectionSource(module, nodeId) {
+            const id = String(nodeId || '').trim();
+            if (!module || !id) return false;
+            module._nativeTextSelectionSourceNodeId = id;
+            setNativeTextSelectionOwnerClass(module, id);
+            helpers.ensureTextOverlaySourceVisible?.(module, id);
+            return true;
+        }
+
+        function clearNativeTextSelectionSource(module, nodeId = null) {
+            const activeId = getNativeTextSelectionSourceNodeId(module);
+            const requestedId = nodeId === null ? activeId : String(nodeId || '').trim();
+            if (!module || !activeId || !requestedId || activeId !== requestedId) return false;
+            module._nativeTextSelectionSourceNodeId = null;
+            setNativeTextSelectionOwnerClass(module, null);
+            return true;
+        }
+
+        function isTextOverlaySelectionNode(module, nodeEntry) {
+            const contentType = String(nodeEntry?.model?.contentType ?? nodeEntry?.model?.ContentType ?? '').toLowerCase();
+            if (contentType !== 'text' && contentType !== 'markdown') return false;
+            const nodeId = String(helpers.getNodeId?.(nodeEntry?.model) || '').trim();
+            return hasNativeTextSelectionSource(module, nodeId);
+        }
+
+        function setTextOverlaySourceActive(nodeEntry, isActive) {
+            if (helpers.isCss3dMediaNode?.(nodeEntry?.model)) {
+                helpers.restoreCss3dMediaOverlayState?.(nodeEntry.model, nodeEntry.cssObject);
+                nodeEntry._textOverlayActive = false;
+                nodeEntry._css3dSourceSuspended = false;
+                return;
+            }
+            const host = helpers.getTextOverlayHostElement?.(nodeEntry);
+            if (!host?.classList) return;
+            host.classList.toggle('mind-map-text-overlay-active', !!isActive);
+            getTextOverlaySourceTargets(nodeEntry).forEach(target => {
+                if (isActive) suspendTextOverlaySourceTarget(target);
+                else restoreTextOverlaySourceTarget(target);
+            });
+            nodeEntry._textOverlayActive = nodeEntry._css3dSourceSuspended = !!isActive;
+        }
+
+        return {
+            getTextOverlaySourceTargets,
+            ensureTextOverlaySourceStyleState,
+            resetTextOverlaySourcePresentation,
+            suspendTextOverlaySourceTarget,
+            restoreTextOverlaySourceTarget,
+            stripTextOverlayPresentationOverrides,
+            getNativeTextSelectionSourceNodeId,
+            hasNativeTextSelectionSource,
+            setNativeTextSelectionOwnerClass,
+            activateNativeTextSelectionSource,
+            clearNativeTextSelectionSource,
+            isTextOverlaySelectionNode,
+            setTextOverlaySourceActive
+        };
+    }
+
+    function installOverlayGeometry(helpers = {}) {
+        function getTextOverlayPlacementInfo(module, element) {
+            if (!module?.container || !element) return null;
+            const rect = element.getBoundingClientRect();
+            const containerRect = module.container.getBoundingClientRect();
+            const width = Math.max(0, rect.width || 0);
+            const height = Math.max(0, rect.height || 0);
+            if (width < 1 || height < 1) return null;
+            const left = rect.left - containerRect.left;
+            const top = rect.top - containerRect.top;
+            return {
+                left,
+                top,
+                width,
+                height,
+                baseWidth: Math.max(1, Number(element.offsetWidth || width || 1)),
+                baseHeight: Math.max(1, Number(element.offsetHeight || height || 1)),
+                right: left + width,
+                bottom: top + height
+            };
+        }
+
+        function doesTextOverlayRectOverlap(a, b, padding = 0) {
+            if (!a || !b) return false;
+            const inset = Number.isFinite(Number(padding)) ? Number(padding) : 0;
+            return !(
+                (a.left + a.width + inset) < b.left ||
+                (b.left + b.width + inset) < a.left ||
+                (a.top + a.height + inset) < b.top ||
+                (b.top + b.height + inset) < a.top
+            );
+        }
+
+        function isTextOverlayPlacementVisible(module, placement, options = {}) {
+            if (!module?.container || !placement) return false;
+            const { ignoreMinSize = false } = options;
+            if (!ignoreMinSize &&
+                (placement.width < Number(helpers.minWidth || 0) ||
+                    placement.height < Number(helpers.minHeight || 0))) {
+                return false;
+            }
+            const maxWidth = Number(module.container.clientWidth || 0);
+            const maxHeight = Number(module.container.clientHeight || 0);
+            if (!(maxWidth > 0) || !(maxHeight > 0)) return false;
+            return !(
+                placement.right < 0 ||
+                placement.left > maxWidth ||
+                placement.bottom < 0 ||
+                placement.top > maxHeight
+            );
+        }
+
+        function getTextOverlayPriority(module, nodeEntry) {
+            const nodeModel = nodeEntry?.model;
+            const nodeId = String(helpers.getNodeId?.(nodeModel) || '').trim();
+            if (!nodeModel || !nodeId) return Number.NEGATIVE_INFINITY;
+            let priority = 0;
+            if (String(module?.selectedNodeIdJs || '').trim() === nodeId) priority += 100000;
+            else if (module?.multiSelectedNodeIds?.has?.(nodeId)) priority += 50000;
+            const width = Math.max(1, Number(nodeModel.width || nodeModel.Width || 0));
+            const height = Math.max(1, Number(nodeModel.height || nodeModel.Height || 0));
+            priority += Math.min(6000, (width * height) / 18);
+            if (module?.camera) {
+                const centerX = Number(nodeModel.positionX ?? nodeModel.PositionX ?? nodeModel.x ?? nodeModel.X ?? 0) + (width * 0.5);
+                const centerY = Number(nodeModel.positionY ?? nodeModel.PositionY ?? nodeModel.y ?? nodeModel.Y ?? 0) - (height * 0.5);
+                priority += Math.max(
+                    0,
+                    24000 -
+                    Math.abs(centerX - Number(module.camera.position?.x || 0)) -
+                    Math.abs(centerY - Number(module.camera.position?.y || 0))
+                );
+            }
+            const zIndex = Number(nodeEntry?.cssObject?.element?.style?.zIndex || 0);
+            if (Number.isFinite(zIndex)) priority += zIndex * 10;
+            return priority;
+        }
+
+        function isAlwaysTextOverlayNode(nodeEntry) {
+            const contentType = String(
+                nodeEntry?.model?.contentType ??
+                nodeEntry?.model?.ContentType ??
+                ''
+            ).toLowerCase();
+            return contentType === 'markdown' || contentType === 'text';
+        }
+
+        function getTextOverlayContentSignature(nodeEntry) {
+            const model = nodeEntry?.model || {};
+            const contentType = String(model.contentType ?? model.ContentType ?? '').toLowerCase();
+            const prompt = String(model.prompt ?? model.Prompt ?? '');
+            const response = String(model.response ?? model.Response ?? '');
+            const isLoading = (model.isLoading ?? model.IsLoading ?? false) ? '1' : '0';
+            const width = Math.max(0, Number(model.width ?? model.Width ?? 0));
+            const height = Math.max(0, Number(model.height ?? model.Height ?? 0));
+            return `${contentType}||${prompt}||${response}||${isLoading}||${width}||${height}`;
+        }
+
+        function getTextOverlayLayoutSignature(sourceElement, mode = 'full', hostPlacement = null) {
+            if (!sourceElement) return '';
+            if (mode === 'memo') {
+                const titleInput = sourceElement.querySelector('.map-node-memo__title');
+                const bodyView = sourceElement.querySelector('.map-node-memo__body-view');
+                const hostWidth = Math.round(Number(hostPlacement?.baseWidth || sourceElement.offsetWidth || 0));
+                const hostHeight = Math.round(Number(hostPlacement?.baseHeight || sourceElement.offsetHeight || 0));
+                const titleSignature = titleInput
+                    ? `${titleInput.offsetLeft}:${titleInput.offsetTop}:${titleInput.offsetWidth}:${titleInput.offsetHeight}:${titleInput.style.display}`
+                    : 'title:none';
+                const bodySignature = bodyView
+                    ? `${bodyView.offsetLeft}:${bodyView.offsetTop}:${bodyView.offsetWidth}:${bodyView.offsetHeight}:${bodyView.style.display}`
+                    : 'body:none';
+                return `${mode}||${hostWidth}x${hostHeight}||${titleSignature}||${bodySignature}`;
+            }
+            const rootWidth = Math.round(Number(sourceElement.offsetWidth || 0));
+            const rootHeight = Math.round(Number(sourceElement.offsetHeight || 0));
+            const childSignature = Array.from(sourceElement.children || [])
+                .map(child => `${child.tagName}:${child.offsetWidth}:${child.offsetHeight}:${child.style.display}`)
+                .join('|');
+            return `${mode}||${rootWidth}x${rootHeight}||${childSignature}`;
+        }
+
+        return {
+            getTextOverlayPlacementInfo,
+            doesTextOverlayRectOverlap,
+            isTextOverlayPlacementVisible,
+            getTextOverlayPriority,
+            isAlwaysTextOverlayNode,
+            getTextOverlayContentSignature,
+            getTextOverlayLayoutSignature
+        };
+    }
+
+    function getNodeBounds(entry) {
+        const shared = window.MindMapNodeBounds?.getNodeWorldBounds?.(entry);
+        if (shared) return shared;
+        const model = entry?.model || null;
+        const object = entry?.glObject || entry?.cssObject || null;
+        if (!model && !object) return null;
+        const width = Math.max(1, Number(
+            entry?.glObject?.userData?.worldWidth ??
+            entry?.cssObject?.userData?.worldWidth ??
+            model?.width ??
+            model?.Width ??
+            400
+        ));
+        const height = Math.max(1, Number(
+            entry?.glObject?.userData?.worldHeight ??
+            entry?.cssObject?.userData?.worldHeight ??
+            model?.height ??
+            model?.Height ??
+            200
+        ));
+        const x = Number(object?.position?.x ?? model?.positionX ?? model?.x ?? 0);
+        const y = Number(object?.position?.y ?? model?.positionY ?? model?.y ?? 0);
+        return { minX: x, maxX: x + width, minY: y - height, maxY: y };
+    }
+
+    function getSpatialGridKeysForBounds(module, entry) {
+        const bounds = getNodeBounds(entry);
+        if (!bounds) return new Set();
+        const cellSize = Math.max(1, Number(module?.GRID_CELL_SIZE || 500));
+        const keys = new Set();
+        const startX = Math.floor(bounds.minX / cellSize);
+        const endX = Math.floor(bounds.maxX / cellSize);
+        const startY = Math.floor(bounds.minY / cellSize);
+        const endY = Math.floor(bounds.maxY / cellSize);
+        for (let x = startX; x <= endX; x++) {
+            for (let y = startY; y <= endY; y++) keys.add(`${x}:${y}`);
+        }
+        return keys;
+    }
+
+    function setEntrySpatialKeys(entry, keys) {
+        if (!entry) return;
+        entry._spatialGridKeys = keys;
+        if (entry.glObject) {
+            entry.glObject.userData ||= {};
+            entry.glObject.userData.spatialGridKeys = keys;
+        }
+        if (entry.cssObject) {
+            entry.cssObject.userData ||= {};
+            entry.cssObject.userData.spatialGridKeys = keys;
+        }
+    }
+
+    function collectSpatialRectCandidateIds(module, rect) {
+        if (!module?.spatialGrid || module._spatialIndexRepairState || !rect) return null;
+        const cellSize = Math.max(1, Number(module.GRID_CELL_SIZE || 500));
+        const ids = [];
+        const seen = new Set();
+        const startX = Math.floor(Number(rect.left || 0) / cellSize);
+        const endX = Math.floor(Number(rect.right || 0) / cellSize);
+        const startY = Math.floor(Number(rect.bottom || 0) / cellSize);
+        const endY = Math.floor(Number(rect.top || 0) / cellSize);
+        for (let x = startX; x <= endX; x++) {
+            for (let y = startY; y <= endY; y++) {
+                module.spatialGrid.get(`${x}:${y}`)?.forEach?.(nodeId => {
+                    const id = String(nodeId || '').trim();
+                    if (id && !seen.has(id)) {
+                        seen.add(id);
+                        ids.push(id);
+                    }
+                });
+            }
+        }
+        return ids;
+    }
+
+    function getBoundedFallbackIds(module) {
+        const ids = new Set();
+        const add = (value) => {
+            const id = String(value || '').trim();
+            if (id && module?.nodeObjectsById?.has?.(id)) ids.add(id);
+        };
+        module?._visibleIds?.forEach?.(add);
+        module?._prevVisibleIds?.forEach?.(add);
+        add(module?.selectedNodeIdJs);
+        module?.multiSelectedNodeIds?.forEach?.(add);
+        add(module?.draggedNodeId);
+        add(module?._nativeTextSelectionSourceNodeId);
+        add(module?._editingOverlayState?.nodeId);
+        add(module?._textOverlayV2State?.editing?.nodeId);
+        module?.lodRenderer?._nearCssVisibleIds?.forEach?.(add);
+        module?.lodRenderer?._lodImageCssFallbackNodeIds?.forEach?.(add);
+        module?.lodRenderer?._lodTemplateCssNodeIds?.forEach?.(add);
+        return Array.from(ids);
+    }
+
+    function scheduleSpatialIndexRepair(module, reason = 'index-unavailable') {
+        if (!module?.nodeObjectsById || module._spatialIndexRepairState) return false;
+        const ownerMap = module.nodeObjectsById;
+        const state = {
+            ownerMap,
+            iterator: ownerMap.entries(),
+            reason: String(reason || 'index-unavailable'),
+            processed: 0
+        };
+        module._spatialIndexRepairState = state;
+        module.spatialGrid = new Map();
+        window.MindCanvasTrace?.emit?.('hitTest.spatialRepairScheduled', {
+            reason: state.reason,
+            nodeCount: ownerMap.size
+        });
+
+        const schedule = (callback) => {
+            if (typeof requestIdleCallback === 'function') requestIdleCallback(callback, { timeout: 120 });
+            else setTimeout(() => callback(null), 0);
+        };
+        const run = (deadline) => {
+            if (module._spatialIndexRepairState !== state || module.nodeObjectsById !== ownerMap) return;
+            let processedThisSlice = 0;
+            while (processedThisSlice < 128 &&
+                (!deadline?.timeRemaining || deadline.timeRemaining() > 1)) {
+                const next = state.iterator.next();
+                if (next.done) {
+                    module._spatialIndexRepairState = null;
+                    module.logicWorkerBridge?.rebuildNodeTables?.(module, {
+                        reason: 'hit-test-spatial-repair'
+                    });
+                    window.MindCanvasTrace?.emit?.('hitTest.spatialRepairCompleted', {
+                        reason: state.reason,
+                        processed: state.processed
+                    });
+                    return;
+                }
+                const [nodeId, entry] = next.value;
+                const keys = getSpatialGridKeysForBounds(module, entry);
+                keys.forEach(key => {
+                    if (!module.spatialGrid.has(key)) module.spatialGrid.set(key, new Set());
+                    module.spatialGrid.get(key).add(nodeId);
+                });
+                setEntrySpatialKeys(entry, keys);
+                processedThisSlice++;
+                state.processed++;
+            }
+            schedule(run);
+        };
+        schedule(run);
+        return true;
+    }
+
+    function noteUnavailableIndex(module, reason = 'index-unavailable') {
+        window.MindCanvasTrace?.emit?.('hitTest.fullBoardFallback', {
+            blocked: true,
+            reason
+        });
+        scheduleSpatialIndexRepair(module, reason);
+    }
+
+    function ensureCssRendererHooks(module) {
+        const renderer = module?.cssRenderer || null;
+        if (!renderer) return false;
+        if (renderer._nearCss3dHooksInstalled === BUILD_ID) return true;
+
+        const counters = {
+            sceneObjectsVisited: 0,
+            visibilityPatchEntered: 0,
+            visibilityPatchExited: 0
+        };
+        const existingGetDebugCounters =
+            typeof renderer.getDebugCounters === 'function'
+                ? renderer.getDebugCounters.bind(renderer)
+                : null;
+        const existingResetDebugCounters =
+            typeof renderer.resetDebugCounters === 'function'
+                ? renderer.resetDebugCounters.bind(renderer)
+                : null;
+        const originalRender =
+            typeof renderer.render === 'function'
+                ? renderer.render.bind(renderer)
+                : null;
+
+        if (!existingGetDebugCounters && originalRender) {
+            renderer.render = (scene, camera) => {
+                let visited = 0;
+                if (module.renderDebugFlags?.enableFramePerfProbe === true) {
+                    scene?.traverse?.(() => {
+                        visited++;
+                    });
+                }
+                const result = originalRender(scene, camera);
+                counters.sceneObjectsVisited += visited;
+                return result;
+            };
+        }
+
+        if (typeof renderer.applyVisibilityDiff !== 'function') {
+            renderer.applyVisibilityDiff = (enteredObjects, exitedObjects) => {
+                const entered = Array.isArray(enteredObjects) ? enteredObjects : [];
+                const exited = Array.isArray(exitedObjects) ? exitedObjects : [];
+                const cameraElement = renderer.getCameraElement?.() || null;
+                let visited = 0;
+                const patchObject = (object) => {
+                    if (!object?.isCSS3DObject || !object.element) return;
+                    object.updateMatrixWorld?.(true);
+                    const layoutPrepared =
+                        object.userData?._residentTransitionPrepared === true ||
+                        object.userData?._fullResFringePrepared === true;
+                    object.element.style.removeProperty?.('display');
+                    if (object.visible !== true && layoutPrepared !== true) {
+                        object.element.style.display = 'none';
+                    }
+                    if (cameraElement && object.element.parentNode !== cameraElement) {
+                        cameraElement.appendChild(object.element);
+                    }
+                    visited++;
+                };
+                try {
+                    exited.forEach(patchObject);
+                    entered.forEach(patchObject);
+                } catch (error) {
+                    return {
+                        complete: false,
+                        reason: 'visibility-diff-exception',
+                        visited,
+                        error
+                    };
+                }
+                counters.visibilityPatchEntered += entered.length;
+                counters.visibilityPatchExited += exited.length;
+                return {
+                    complete: true,
+                    entered: entered.length,
+                    exited: exited.length,
+                    visited
+                };
+            };
+        }
+
+        if (!existingGetDebugCounters) {
+            renderer.getDebugCounters = () => ({ ...counters });
+        }
+        if (!existingResetDebugCounters) {
+            renderer.resetDebugCounters = () => {
+                counters.sceneObjectsVisited = 0;
+                counters.visibilityPatchEntered = 0;
+                counters.visibilityPatchExited = 0;
+            };
+        }
+        renderer._nearCss3dHooksInstalled = BUILD_ID;
+        return true;
+    }
+
+    function applyVisibilityDiff(module, enteredIds, exitedIds) {
+        const fallback = (reason) => {
+            increment(module, 'css3d', 'visibilityPatchFallbacks');
+            return { complete: false, reason };
+        };
+        const renderer = module?.cssRenderer;
+        ensureCssRendererHooks(module);
+        if (!renderer || typeof renderer.applyVisibilityDiff !== 'function') return fallback('renderer-api-unavailable');
+        if (module._cssParentRepairNeeded === true) return fallback('parent-repair-pending');
+        if ((module._cssTransformDirtyIds?.size || 0) > 0) return fallback('transform-dirty');
+
+        const cssScene = module.cssScene || module.scene || null;
+        const enteredObjects = [];
+        const exitedObjects = [];
+
+        for (const value of enteredIds || []) {
+            const nodeId = String(value || '').trim();
+            const entry = nodeId ? module.nodeObjectsById?.get?.(nodeId) : null;
+            if (!entry) continue;
+            if (entry.currentType !== 'CSS') {
+                if (entry.cssObject?.visible === true) return fallback('entered-owner-mismatch');
+                continue;
+            }
+            if (!entry.cssObject?.element || entry.cssObject.visible !== true || entry.isCssDirty === true) {
+                return fallback('entered-owner-not-ready');
+            }
+            if (cssScene && entry.cssObject.parent !== cssScene) return fallback('entered-parent-mismatch');
+            enteredObjects.push(entry.cssObject);
+        }
+
+        for (const value of exitedIds || []) {
+            const nodeId = String(value || '').trim();
+            const entry = nodeId ? module.nodeObjectsById?.get?.(nodeId) : null;
+            const cssObject = entry?.cssObject || null;
+            if (!cssObject) continue;
+            if (entry.isCssDirty === true) return fallback('exited-content-dirty');
+            if (cssObject.parent === cssScene) {
+                exitedObjects.push(cssObject);
+            } else if (cssObject.visible === true || entry.currentType === 'CSS') {
+                return fallback('exited-owner-mismatch');
+            }
+        }
+
+        const result = renderer.applyVisibilityDiff(enteredObjects, exitedObjects);
+        if (result?.complete !== true) return fallback(result?.reason || 'renderer-patch-failed');
+
+        increment(module, 'css3d', 'visibilityPatchEntered', Number(result.entered || 0));
+        increment(module, 'css3d', 'visibilityPatchExited', Number(result.exited || 0));
+        increment(module, 'css3d', 'sceneObjectsVisited', Number(result.visited || 0));
+        return {
+            complete: true,
+            entered: Number(result.entered || 0),
+            exited: Number(result.exited || 0),
+            visited: Number(result.visited || 0)
+        };
+    }
+
+    function replaceGeometryIfSizeChanged(object, key, createGeometry) {
+        if (!object || typeof createGeometry !== 'function') return false;
+        object.userData ||= {};
+        if (object.geometry && object.userData.geometrySizeKey === key) return false;
+        const previous = object.geometry || null;
+        object.geometry = createGeometry();
+        object.userData.geometrySizeKey = key;
+        previous?.dispose?.();
+        return true;
+    }
+
+    window.MindMapCss3dHotPath = {
+        BUILD_ID,
+        applyVisibilityDiff,
+        collectSpatialRectCandidateIds,
+        createPointerHitContext,
+        ensureCssRendererHooks,
+        ensurePerfCounters,
+        getBoundedFallbackIds,
+        getContextCandidateIds,
+        getContextWorldPoint,
+        getDomRefs,
+        getDomStack,
+        getPerfSnapshot,
+        getProjectedClientFrame,
+        getSpatialGridKeysForBounds,
+        increment,
+        installOverlayGeometry,
+        installTextSource,
+        invalidateDomRefs,
+        invalidateDomRefsByCssObject,
+        noteUnavailableIndex,
+        recordHitCandidates,
+        replaceGeometryIfSizeChanged,
+        resetPerfCounters,
+        scheduleSpatialIndexRepair
+    };
+})();