@mindexec/cli 0.2.0

package/wwwroot/_content/MindExecution.Shared/js/mind-map-logic-workers.js

@@ -0,0 +1,977 @@
+(function () {
+    'use strict';
+
+    const LOGIC_WORKER_BRIDGE_BUILD_ID = '20260606-worker-pan-enter-only-v006';
+    const VISIBILITY_WORKER_URL = `_content/MindExecution.Shared/js/mind-map-visibility-worker.js?v=${LOGIC_WORKER_BRIDGE_BUILD_ID}`;
+    const LOD_PLAN_WORKER_URL = `_content/MindExecution.Shared/js/mind-map-lod-plan-worker.js?v=${LOGIC_WORKER_BRIDGE_BUILD_ID}`;
+    const NODE_SEARCH_WORKER_URL = `_content/MindExecution.Shared/js/mind-map-node-search-worker.js?v=${LOGIC_WORKER_BRIDGE_BUILD_ID}`;
+    const CTRL_WHEEL_SCROLL_ACTIVE_WINDOW_MS = 140;
+    const SEARCH_METADATA_TEXT_LIMIT = 8192;
+
+    function getNodeContentType(model) {
+        return String(model?.contentType ?? model?.ContentType ?? '').trim().toLowerCase();
+    }
+
+    function isTextLikeContentType(contentType) {
+        return contentType === 'text' ||
+            contentType === 'note' ||
+            contentType === 'memo' ||
+            contentType === 'markdown' ||
+            contentType === 'code';
+    }
+
+    function getNodeSpatialGridKeys(entry) {
+        if (entry?._spatialGridKeys instanceof Set) {
+            return entry._spatialGridKeys;
+        }
+        if (entry?.glObject?.userData?.spatialGridKeys instanceof Set) {
+            return entry.glObject.userData.spatialGridKeys;
+        }
+        if (entry?.cssObject?.userData?.spatialGridKeys instanceof Set) {
+            return entry.cssObject.userData.spatialGridKeys;
+        }
+
+        return new Set();
+    }
+
+    function normalizeBoardId(boardId) {
+        return String(boardId ?? '').trim();
+    }
+
+    function cloneCellKeys(cellKeys) {
+        if (Array.isArray(cellKeys)) {
+            return cellKeys
+                .map((key) => String(key || '').trim())
+                .filter(Boolean);
+        }
+        if (cellKeys instanceof Set) {
+            return Array.from(cellKeys)
+                .map((key) => String(key || '').trim())
+                .filter(Boolean);
+        }
+
+        return [];
+    }
+
+    function limitSearchText(value, maxLength) {
+        const text = String(value ?? '');
+        if (!text) {
+            return '';
+        }
+
+        return text.length <= maxLength
+            ? text
+            : text.slice(0, maxLength);
+    }
+
+    function buildSearchMetadataText(metadata) {
+        if (!metadata) {
+            return '';
+        }
+
+        if (typeof metadata === 'string') {
+            return limitSearchText(metadata, SEARCH_METADATA_TEXT_LIMIT);
+        }
+
+        const values = [];
+        const entries = Array.isArray(metadata)
+            ? metadata
+            : Object.entries(metadata);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (Array.isArray(entry)) {
+                const key = limitSearchText(entry[0], 128).trim();
+                const value = limitSearchText(entry[1], 1024).trim();
+                if (key) values.push(key);
+                if (value) values.push(value);
+            } else if (entry) {
+                const value = limitSearchText(entry, 1024).trim();
+                if (value) values.push(value);
+            }
+
+            if (values.join(' ').length >= SEARCH_METADATA_TEXT_LIMIT) {
+                break;
+            }
+        }
+
+        return limitSearchText(values.join(' '), SEARCH_METADATA_TEXT_LIMIT);
+    }
+
+    function buildWorkerNodeSnapshot(entry, fallbackNodeId = null, boundsOverride = null, cellKeysOverride = null) {
+        const model = entry?.model || null;
+        const nodeId = String(
+            model?.id ??
+            entry?.glObject?.userData?.nodeId ??
+            entry?.cssObject?.userData?.nodeId ??
+            fallbackNodeId ??
+            ''
+        ).trim();
+        if (!nodeId) {
+            return null;
+        }
+
+        const bounds = boundsOverride || window.MindMapNodeBounds?.getNodeWorldBounds?.(entry);
+        if (!bounds) {
+            return null;
+        }
+
+        const contentType = getNodeContentType(model);
+        const cellKeys = cloneCellKeys(cellKeysOverride || getNodeSpatialGridKeys(entry));
+
+        return {
+            id: nodeId,
+            contentType,
+            textLike: isTextLikeContentType(contentType),
+            x: Number(bounds.x || 0),
+            y: Number(bounds.y || 0),
+            z: Number(bounds.z || 0),
+            width: Math.max(1, Number(bounds.width || 1)),
+            height: Math.max(1, Number(bounds.height || 1)),
+            minX: Number(bounds.minX || 0),
+            maxX: Number(bounds.maxX || 0),
+            minY: Number(bounds.minY || 0),
+            maxY: Number(bounds.maxY || 0),
+            cellKeys
+        };
+    }
+
+    function buildWorkerSearchSnapshot(source, fallbackNodeId = null, boundsOverride = null) {
+        const model = source?.model || source || null;
+        const nodeId = String(
+            model?.id ??
+            model?.Id ??
+            source?.glObject?.userData?.nodeId ??
+            source?.cssObject?.userData?.nodeId ??
+            fallbackNodeId ??
+            ''
+        ).trim();
+        if (!nodeId) {
+            return null;
+        }
+
+        const bounds = boundsOverride || window.MindMapNodeBounds?.getNodeWorldBounds?.(source) || null;
+        const contentType = String(model?.contentType ?? model?.ContentType ?? source?.contentType ?? source?.ContentType ?? '').trim().toLowerCase();
+
+        return {
+            id: nodeId,
+            contentType,
+            prompt: limitSearchText(model?.prompt ?? model?.Prompt ?? source?.prompt ?? source?.Prompt, 2048),
+            response: limitSearchText(model?.response ?? model?.Response ?? source?.response ?? source?.Response, 16000),
+            metadataText: buildSearchMetadataText(model?.metadata ?? model?.Metadata ?? source?.metadataText ?? source?.MetadataText ?? source?.metadata ?? source?.Metadata),
+            sourcePath: limitSearchText(model?.sourceFilePath ?? model?.SourceFilePath ?? source?.sourcePath ?? source?.SourcePath, 2048),
+            positionX: Number(model?.positionX ?? model?.PositionX ?? model?.x ?? bounds?.x ?? source?.positionX ?? source?.PositionX ?? 0),
+            positionY: Number(model?.positionY ?? model?.PositionY ?? model?.y ?? bounds?.y ?? source?.positionY ?? source?.PositionY ?? 0),
+            width: Math.max(1, Number(model?.width ?? model?.Width ?? bounds?.width ?? source?.width ?? source?.Width ?? 1)),
+            height: Math.max(1, Number(model?.height ?? model?.Height ?? bounds?.height ?? source?.height ?? source?.Height ?? 1))
+        };
+    }
+
+    class MindMapLogicWorkerBridge {
+        constructor(module) {
+            this.module = module || null;
+            this.boardId = normalizeBoardId(module?.activeBoardId || window.mindMap?.activeBoardId || '');
+
+            this._visibilityWorker = null;
+            this._lodPlanWorker = null;
+            this._searchWorker = null;
+            this._visibilityReady = false;
+            this._lodPlanReady = false;
+            this._searchReady = false;
+            this._visibilityDisabled = false;
+            this._lodPlanDisabled = false;
+            this._searchDisabled = false;
+            this._latestVisibilityRequestSeq = 0;
+            this._latestHitTestRequestSeq = 0;
+            this._latestSelectionRequestSeq = 0;
+            this._latestLodPlanRequestSeq = 0;
+            this._latestSearchRequestSeq = 0;
+            this._pendingLodPlanKey = '';
+            this._visibilityQueryPending = false;
+            this._deferredVisibilityPayload = null;
+            this._hitTestQueryPending = false;
+            this._deferredHitTestPayload = null;
+            this._pendingSelectionResolvers = new Map();
+            this._pendingSearchResolvers = new Map();
+
+            this._createWorkers();
+        }
+
+        _createWorkers() {
+            this._visibilityWorker = this._createWorker(
+                'visibility',
+                VISIBILITY_WORKER_URL,
+                (data) => this._handleVisibilityMessage(data)
+            );
+            this._lodPlanWorker = this._createWorker(
+                'lod-plan',
+                LOD_PLAN_WORKER_URL,
+                (data) => this._handleLodPlanMessage(data)
+            );
+            this._searchWorker = this._createWorker(
+                'node-search',
+                NODE_SEARCH_WORKER_URL,
+                (data) => this._handleSearchMessage(data)
+            );
+        }
+
+        _createWorker(kind, url, onMessage) {
+            try {
+                const worker = new Worker(url);
+                worker.onmessage = (event) => {
+                    const data = event?.data || null;
+                    if (!data || typeof data !== 'object') {
+                        return;
+                    }
+
+                    if (data.type === 'READY') {
+                        if (kind === 'visibility') {
+                            this._visibilityReady = true;
+                        } else if (kind === 'lod-plan') {
+                            this._lodPlanReady = true;
+                        } else if (kind === 'node-search') {
+                            this._searchReady = true;
+                        }
+                        return;
+                    }
+
+                    onMessage(data);
+                };
+                worker.onerror = (error) => {
+                    console.warn(`[MindMapLogicWorkerBridge] ${kind} worker disabled after error.`, error);
+                    if (kind === 'visibility') {
+                        this._visibilityDisabled = true;
+                        this._visibilityReady = false;
+                        this._clearHitTestCache(this.module);
+                        this._hitTestQueryPending = false;
+                        this._deferredHitTestPayload = null;
+                        this._resolvePendingSelectionQueries(null);
+                    } else if (kind === 'lod-plan') {
+                        this._lodPlanDisabled = true;
+                        this._lodPlanReady = false;
+                    } else {
+                        this._searchDisabled = true;
+                        this._searchReady = false;
+                        this._resolvePendingSearches(null);
+                    }
+                    try {
+                        worker.terminate();
+                    } catch { }
+                };
+                return worker;
+            } catch (error) {
+                console.warn(`[MindMapLogicWorkerBridge] Failed to create ${kind} worker.`, error);
+                if (kind === 'visibility') {
+                    this._visibilityDisabled = true;
+                } else if (kind === 'lod-plan') {
+                    this._lodPlanDisabled = true;
+                } else {
+                    this._searchDisabled = true;
+                }
+                return null;
+            }
+        }
+
+        _post(worker, payload) {
+            if (!worker || !payload) {
+                return false;
+            }
+
+            try {
+                worker.postMessage(payload);
+                return true;
+            } catch (error) {
+                console.warn('[MindMapLogicWorkerBridge] Failed to post worker message.', payload?.type, error);
+                return false;
+            }
+        }
+
+        _stampVisibilityPayloadForPost(payload) {
+            if (!payload || String(payload.type || '') !== 'VISIBILITY_QUERY') {
+                return payload;
+            }
+
+            payload.mainLastAppliedSeq = Math.max(
+                0,
+                Math.floor(Number(this.module?._workerVisibilitySeq || 0))
+            );
+            return payload;
+        }
+
+        _resolveBoardId(module = this.module, fallbackBoardId = null) {
+            const candidate = normalizeBoardId(
+                fallbackBoardId ??
+                module?.activeBoardId ??
+                window.mindMap?.activeBoardId ??
+                this.boardId
+            );
+            if (candidate) {
+                this.boardId = candidate;
+            }
+            return candidate;
+        }
+
+        _clearHitTestCache(module = this.module) {
+            if (!module) {
+                return;
+            }
+
+            module._workerHitTestRangeKey = '';
+            module._workerHitTestBoardId = '';
+            module._workerHitTestCandidateIds = [];
+            module._workerHitTestSeq = 0;
+            module._workerHitTestCellX = 0;
+            module._workerHitTestCellY = 0;
+            module._workerHitTestCellRadius = 0;
+            module._workerHitTestUpdatedAt = 0;
+            module._workerHitTestProfile = null;
+        }
+
+        _handleVisibilityMessage(data) {
+            if (String(data?.type || '') === 'HIT_TEST_RESULT') {
+                this._handleHitTestMessage(data);
+                return;
+            }
+            if (String(data?.type || '') === 'SELECTION_QUERY_RESULT') {
+                this._handleSelectionQueryMessage(data);
+                return;
+            }
+
+            const module = this.module;
+            const boardId = this._resolveBoardId(module);
+            if (!module || !boardId) {
+                return;
+            }
+
+            if (normalizeBoardId(data.boardId) !== boardId) {
+                return;
+            }
+
+            if (Number(data.seq || 0) < Number(this._latestVisibilityRequestSeq || 0)) {
+                this._visibilityQueryPending = false;
+                this._flushDeferredVisibilityRequest();
+                return;
+            }
+
+            module._applyWorkerVisibilityResult?.(data);
+            this._visibilityQueryPending = false;
+            this._flushDeferredVisibilityRequest();
+        }
+
+        _handleHitTestMessage(data) {
+            const module = this.module;
+            const boardId = this._resolveBoardId(module);
+            this._hitTestQueryPending = false;
+
+            if (!module || !boardId) {
+                this._flushDeferredHitTestRequest();
+                return;
+            }
+
+            if (normalizeBoardId(data.boardId) !== boardId) {
+                this._flushDeferredHitTestRequest();
+                return;
+            }
+
+            if (Number(data.seq || 0) < Number(this._latestHitTestRequestSeq || 0)) {
+                this._flushDeferredHitTestRequest();
+                return;
+            }
+
+            module._workerHitTestRangeKey = String(data.rangeKey || '').trim();
+            module._workerHitTestBoardId = boardId;
+            module._workerHitTestCandidateIds = Array.isArray(data.candidateIds)
+                ? data.candidateIds.map((nodeId) => String(nodeId || '').trim()).filter(Boolean)
+                : [];
+            module._workerHitTestSeq = Number(data.seq || 0);
+            module._workerHitTestCellX = Number(data.cellX || 0);
+            module._workerHitTestCellY = Number(data.cellY || 0);
+            module._workerHitTestCellRadius = Number(data.cellRadius || 0);
+            module._workerHitTestUpdatedAt = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+                ? performance.now()
+                : Date.now();
+            module._workerHitTestProfile = data.profile || null;
+
+            this._flushDeferredHitTestRequest();
+        }
+
+        _handleSelectionQueryMessage(data) {
+            const boardId = this._resolveBoardId(this.module);
+            const seq = Number(data.seq || 0);
+            const resolver = this._pendingSelectionResolvers.get(seq) || null;
+            if (resolver) {
+                this._pendingSelectionResolvers.delete(seq);
+            }
+
+            if (!resolver) {
+                return;
+            }
+
+            if (seq < Number(this._latestSelectionRequestSeq || 0)) {
+                resolver(null);
+                return;
+            }
+
+            if (!boardId || normalizeBoardId(data.boardId) !== boardId) {
+                resolver(null);
+                return;
+            }
+
+            const selectedIds = Array.isArray(data.selectedIds)
+                ? data.selectedIds.map((nodeId) => String(nodeId || '').trim()).filter(Boolean)
+                : [];
+            resolver(selectedIds);
+        }
+
+        _handleLodPlanMessage(data) {
+            const module = this.module;
+            const boardId = this._resolveBoardId(module);
+            if (!module || !module.lodRenderer || !boardId) {
+                return;
+            }
+
+            if (normalizeBoardId(data.boardId) !== boardId) {
+                return;
+            }
+
+            if (Number(data.seq || 0) < Number(this._latestLodPlanRequestSeq || 0)) {
+                return;
+            }
+
+            if (String(data.key || '') === this._pendingLodPlanKey) {
+                this._pendingLodPlanKey = '';
+            }
+
+            module.lodRenderer._applyWorkerLodPlanResult?.(data);
+        }
+
+        _handleSearchMessage(data) {
+            const boardId = this._resolveBoardId(this.module);
+            const normalizedBoardId = normalizeBoardId(data.boardId);
+            const seq = Number(data.seq || 0);
+            const resolver = this._pendingSearchResolvers.get(seq) || null;
+            if (resolver) {
+                this._pendingSearchResolvers.delete(seq);
+            }
+
+            if (!resolver) {
+                return;
+            }
+
+            if (!boardId || normalizedBoardId !== boardId) {
+                resolver([]);
+                return;
+            }
+
+            const hits = Array.isArray(data.hits)
+                ? data.hits.map((hit) => ({
+                    nodeId: String(hit?.nodeId ?? hit?.id ?? '').trim(),
+                    score: Number(hit?.score || 0)
+                })).filter((hit) => hit.nodeId)
+                : [];
+            resolver(hits);
+        }
+
+        _resolvePendingSearches(hits) {
+            const resolvers = Array.from(this._pendingSearchResolvers.values());
+            this._pendingSearchResolvers.clear();
+            for (let i = 0; i < resolvers.length; i++) {
+                try {
+                    resolvers[i](hits);
+                } catch {
+                }
+            }
+        }
+
+        _resolvePendingSelectionQueries(nodeIds) {
+            const resolvers = Array.from(this._pendingSelectionResolvers.values());
+            this._pendingSelectionResolvers.clear();
+            for (let i = 0; i < resolvers.length; i++) {
+                try {
+                    resolvers[i](nodeIds);
+                } catch {
+                }
+            }
+        }
+
+        dispose() {
+            try {
+                this._visibilityWorker?.terminate?.();
+            } catch { }
+            try {
+                this._lodPlanWorker?.terminate?.();
+            } catch { }
+            try {
+                this._searchWorker?.terminate?.();
+            } catch { }
+
+            this._visibilityWorker = null;
+            this._lodPlanWorker = null;
+            this._searchWorker = null;
+            this._visibilityReady = false;
+            this._lodPlanReady = false;
+            this._searchReady = false;
+            this._hitTestQueryPending = false;
+            this._deferredHitTestPayload = null;
+            this._resolvePendingSelectionQueries(null);
+            this._clearHitTestCache(this.module);
+            this._resolvePendingSearches(null);
+        }
+
+        resetBoard(boardId, reason = 'reset-board') {
+            const normalizedBoardId = this._resolveBoardId(this.module, boardId);
+            this._latestVisibilityRequestSeq = 0;
+            this._latestHitTestRequestSeq = 0;
+            this._latestSelectionRequestSeq = 0;
+            this._latestLodPlanRequestSeq = 0;
+            this._latestSearchRequestSeq = 0;
+            this._pendingLodPlanKey = '';
+            this._visibilityQueryPending = false;
+            this._deferredVisibilityPayload = null;
+            this._hitTestQueryPending = false;
+            this._deferredHitTestPayload = null;
+            this._resolvePendingSelectionQueries(null);
+            this._resolvePendingSearches(null);
+            this._clearHitTestCache(this.module);
+
+            if (this.module) {
+                this.module._visibilityWorkerPrimed = false;
+            }
+
+            const payload = {
+                type: 'RESET_BOARD',
+                boardId: normalizedBoardId,
+                reason,
+                cellSize: Math.max(1, Number(this.module?.GRID_CELL_SIZE || 500))
+            };
+            this._post(this._visibilityWorker, payload);
+            this._post(this._lodPlanWorker, payload);
+            this._post(this._searchWorker, payload);
+        }
+
+        rebuildNodeTables(module = this.module, options = {}) {
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule, options.boardId);
+            if (!activeModule || !boardId) {
+                return false;
+            }
+
+            const nodes = [];
+            const searchNodes = [];
+            activeModule.nodeObjectsById?.forEach?.((entry, nodeId) => {
+                const snapshot = buildWorkerNodeSnapshot(entry, nodeId);
+                if (snapshot) {
+                    nodes.push(snapshot);
+                }
+
+                const searchSnapshot = buildWorkerSearchSnapshot(entry, nodeId);
+                if (searchSnapshot) {
+                    searchNodes.push(searchSnapshot);
+                }
+            });
+
+            const payload = {
+                type: 'REBUILD_BOARD',
+                boardId,
+                reason: String(options.reason || 'rebuild-node-tables'),
+                cellSize: Math.max(1, Number(activeModule.GRID_CELL_SIZE || 500)),
+                nodes
+            };
+
+            const postedVisibility = this._post(this._visibilityWorker, payload);
+            const postedLodPlan = this._post(this._lodPlanWorker, payload);
+            const postedSearch = this._post(this._searchWorker, {
+                type: 'REBUILD_BOARD',
+                boardId,
+                reason: String(options.reason || 'rebuild-search-index'),
+                nodes: searchNodes
+            });
+            if (postedVisibility || postedLodPlan || postedSearch) {
+                activeModule._visibilityWorkerPrimed = false;
+                this._clearHitTestCache(activeModule);
+            }
+            return postedVisibility || postedLodPlan || postedSearch;
+        }
+
+        upsertNodeEntry(entry, module = this.module, options = {}) {
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule, options.boardId);
+            if (!activeModule || !boardId) {
+                return false;
+            }
+
+            const snapshot = buildWorkerNodeSnapshot(
+                entry,
+                options.nodeId,
+                options.bounds || null,
+                options.cellKeys || null
+            );
+            const searchSnapshot = buildWorkerSearchSnapshot(
+                entry,
+                options.nodeId,
+                options.bounds || null
+            );
+            if (!snapshot && !searchSnapshot) {
+                return false;
+            }
+
+            let postedVisibility = false;
+            let postedLodPlan = false;
+            let postedSearch = false;
+            if (snapshot) {
+                const payload = {
+                    type: 'UPSERT_NODE',
+                    boardId,
+                    node: snapshot
+                };
+                postedVisibility = this._post(this._visibilityWorker, payload);
+                postedLodPlan = this._post(this._lodPlanWorker, payload);
+            }
+            if (searchSnapshot) {
+                postedSearch = this._post(this._searchWorker, {
+                    type: 'UPSERT_NODE',
+                    boardId,
+                    node: searchSnapshot
+                });
+            }
+            if (postedVisibility || postedLodPlan) {
+                this._clearHitTestCache(activeModule);
+            }
+            return postedVisibility || postedLodPlan || postedSearch;
+        }
+
+        removeNode(nodeId, module = this.module, options = {}) {
+            const boardId = this._resolveBoardId(module, options.boardId);
+            const normalizedNodeId = String(nodeId || '').trim();
+            if (!boardId || !normalizedNodeId) {
+                return false;
+            }
+
+            const payload = {
+                type: 'REMOVE_NODE',
+                boardId,
+                nodeId: normalizedNodeId
+            };
+
+            const postedVisibility = this._post(this._visibilityWorker, payload);
+            const postedLodPlan = this._post(this._lodPlanWorker, payload);
+            const postedSearch = this._post(this._searchWorker, payload);
+            if (postedVisibility || postedLodPlan) {
+                this._clearHitTestCache(module || this.module);
+            }
+            return postedVisibility || postedLodPlan || postedSearch;
+        }
+
+        batchSyncSearchNodes(boardId, nodes = null, removedIds = null) {
+            if (this._searchDisabled || !this._searchWorker) {
+                return false;
+            }
+
+            const normalizedBoardId = this._resolveBoardId(this.module, boardId);
+            if (!normalizedBoardId) {
+                return false;
+            }
+
+            const normalizedNodes = Array.isArray(nodes)
+                ? nodes.map((node) => buildWorkerSearchSnapshot(node)).filter(Boolean)
+                : [];
+            const normalizedRemovedIds = Array.isArray(removedIds)
+                ? removedIds.map((nodeId) => String(nodeId || '').trim()).filter(Boolean)
+                : [];
+            if (normalizedNodes.length === 0 && normalizedRemovedIds.length === 0) {
+                return false;
+            }
+
+            return this._post(this._searchWorker, {
+                type: 'BATCH_SYNC',
+                boardId: normalizedBoardId,
+                nodes: normalizedNodes,
+                removedIds: normalizedRemovedIds
+            });
+        }
+
+        requestVisibility(module = this.module, camera) {
+            if (this._visibilityDisabled || !this._visibilityReady) {
+                return false;
+            }
+
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule);
+            if (!activeModule || !camera || !boardId) {
+                return false;
+            }
+
+            const viewportWidth = Math.max(1, Number(activeModule.container?.clientWidth || activeModule._lastViewportWidth || 1));
+            const viewportHeight = Math.max(1, Number(activeModule.container?.clientHeight || activeModule._lastViewportHeight || 1));
+            const now = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+                ? performance.now()
+                : Date.now();
+            const isCtrlWheelVerticalScrolling =
+                (now - Number(activeModule._ctrlWheelScrollInputTime || 0)) <= CTRL_WHEEL_SCROLL_ACTIVE_WINDOW_MS;
+            const seq = ++this._latestVisibilityRequestSeq;
+
+            const payload = {
+                type: 'VISIBILITY_QUERY',
+                boardId,
+                seq,
+                cellSize: Math.max(1, Number(activeModule.GRID_CELL_SIZE || 500)),
+                camera: {
+                    x: Number(camera.position?.x || 0),
+                    y: Number(camera.position?.y || 0),
+                    z: Number(camera.position?.z || 0),
+                    near: Number(camera.near || 0),
+                    far: Number(camera.far || Number.MAX_SAFE_INTEGER),
+                    fov: Number(camera.fov || 45),
+                    aspect: Math.max(0.1, Number(camera.aspect || 1)),
+                    viewportW: viewportWidth,
+                    viewportH: viewportHeight
+                },
+                state: {
+                    isPanning: activeModule.isPanning === true,
+                    isZooming: activeModule.isZooming === true,
+                    isWindowResizing: activeModule.isWindowResizing === true,
+                    isResizing: activeModule.isResizing === true,
+                    isFullResMode: activeModule.lodRenderer?.isInLODMode !== true,
+                    isCtrlWheelVerticalScrolling,
+                    lastCtrlWheelDeltaY: Number(activeModule._ctrlWheelScrollLastDeltaY || 0),
+                    lastPanWorldDeltaX: Number(activeModule._lastPanWorldDeltaX || 0),
+                    lastPanWorldDeltaY: Number(activeModule._lastPanWorldDeltaY || 0)
+                }
+            };
+
+            if (this._visibilityQueryPending === true) {
+                this._deferredVisibilityPayload = payload;
+                return true;
+            }
+
+            const posted = this._post(this._visibilityWorker, this._stampVisibilityPayloadForPost(payload));
+            this._visibilityQueryPending = posted;
+            return posted;
+        }
+
+        _flushDeferredVisibilityRequest() {
+            if (!this._deferredVisibilityPayload || !this._visibilityWorker || this._visibilityDisabled || !this._visibilityReady) {
+                return;
+            }
+
+            const payload = this._deferredVisibilityPayload;
+            this._deferredVisibilityPayload = null;
+            const posted = this._post(this._visibilityWorker, this._stampVisibilityPayloadForPost(payload));
+            this._visibilityQueryPending = posted;
+        }
+
+        _describeHitTestQuery(module = this.module, options = {}) {
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule);
+            const point = options.point || null;
+            const pointX = Number(point?.x);
+            const pointY = Number(point?.y);
+            if (!activeModule || !boardId || !Number.isFinite(pointX) || !Number.isFinite(pointY)) {
+                return null;
+            }
+
+            const cellSize = Math.max(1, Number(activeModule.GRID_CELL_SIZE || 500));
+            const cellRadius = Math.max(0, Math.min(3, Math.round(Number(options.cellRadius || 1))));
+            const cellX = Math.floor(pointX / cellSize);
+            const cellY = Math.floor(pointY / cellSize);
+
+            return {
+                boardId,
+                cellRadius,
+                cellSize,
+                cellX,
+                cellY,
+                rangeKey: `${cellX}:${cellY}:${cellRadius}`
+            };
+        }
+
+        primeHitTestCandidates(module = this.module, options = {}) {
+            if (this._visibilityDisabled || !this._visibilityReady) {
+                return false;
+            }
+
+            const activeModule = module || this.module;
+            const query = this._describeHitTestQuery(activeModule, options);
+            if (!activeModule || !query) {
+                return false;
+            }
+
+            if (String(activeModule._workerHitTestBoardId || '') === query.boardId &&
+                String(activeModule._workerHitTestRangeKey || '') === query.rangeKey) {
+                return true;
+            }
+
+            const payload = {
+                type: 'HIT_TEST_QUERY',
+                boardId: query.boardId,
+                seq: ++this._latestHitTestRequestSeq,
+                cellX: query.cellX,
+                cellY: query.cellY,
+                cellRadius: query.cellRadius
+            };
+
+            if (this._hitTestQueryPending === true) {
+                this._deferredHitTestPayload = payload;
+                return true;
+            }
+
+            const posted = this._post(this._visibilityWorker, payload);
+            this._hitTestQueryPending = posted;
+            return posted;
+        }
+
+        _flushDeferredHitTestRequest() {
+            if (!this._deferredHitTestPayload || !this._visibilityWorker || this._visibilityDisabled || !this._visibilityReady) {
+                return;
+            }
+
+            const payload = this._deferredHitTestPayload;
+            this._deferredHitTestPayload = null;
+            const posted = this._post(this._visibilityWorker, payload);
+            this._hitTestQueryPending = posted;
+        }
+
+        getCachedHitTestCandidateIds(module = this.module, options = {}) {
+            const activeModule = module || this.module;
+            const query = this._describeHitTestQuery(activeModule, options);
+            if (!activeModule || !query) {
+                return null;
+            }
+
+            if (String(activeModule._workerHitTestBoardId || '') !== query.boardId) {
+                return null;
+            }
+
+            if (String(activeModule._workerHitTestRangeKey || '') !== query.rangeKey) {
+                return null;
+            }
+
+            return Array.isArray(activeModule._workerHitTestCandidateIds)
+                ? activeModule._workerHitTestCandidateIds.slice()
+                : [];
+        }
+
+        requestSelectionQuery(module = this.module, options = {}) {
+            if (this._visibilityDisabled || !this._visibilityReady) {
+                return Promise.resolve(null);
+            }
+
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule);
+            const selectionRect = options.selectionRect || null;
+            if (!activeModule || !boardId || !selectionRect) {
+                return Promise.resolve(null);
+            }
+
+            const payload = {
+                type: 'SELECTION_QUERY',
+                boardId,
+                seq: ++this._latestSelectionRequestSeq,
+                cellSize: Math.max(1, Number(activeModule.GRID_CELL_SIZE || 500)),
+                selectionRect: {
+                    left: Number(selectionRect.left || 0),
+                    right: Number(selectionRect.right || 0),
+                    bottom: Number(selectionRect.bottom || 0),
+                    top: Number(selectionRect.top || 0)
+                }
+            };
+
+            return new Promise((resolve) => {
+                this._pendingSelectionResolvers.set(payload.seq, resolve);
+                const posted = this._post(this._visibilityWorker, payload);
+                if (!posted) {
+                    this._pendingSelectionResolvers.delete(payload.seq);
+                    resolve(null);
+                }
+            });
+        }
+
+        requestLodPlan(module = this.module, options = {}) {
+            if (this._lodPlanDisabled || !this._lodPlanReady) {
+                return false;
+            }
+
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule);
+            const visibleIds = options.visibleIds instanceof Set
+                ? Array.from(options.visibleIds)
+                : Array.isArray(options.visibleIds)
+                    ? options.visibleIds
+                    : [];
+            const key = String(options.key || '').trim();
+
+            if (!activeModule || !boardId || !key || visibleIds.length === 0 && Number(options.totalNodeCount || 0) === 0) {
+                return false;
+            }
+
+            if (this._pendingLodPlanKey === key) {
+                return true;
+            }
+
+            this._pendingLodPlanKey = key;
+            const seq = ++this._latestLodPlanRequestSeq;
+            return this._post(this._lodPlanWorker, {
+                type: 'LOD_PLAN_QUERY',
+                boardId,
+                seq,
+                key,
+                visibilityVersion: Number(options.visibilityVersion || 0),
+                lodBand: String(options.lodBand || '').trim(),
+                selectionKey: String(options.selectionKey || '').trim(),
+                totalNodeCount: Number(options.totalNodeCount || 0),
+                visibleIds: visibleIds.map((id) => String(id || '').trim()).filter(Boolean)
+            });
+        }
+
+        requestNodeSearch(module = this.module, options = {}) {
+            if (this._searchDisabled || !this._searchReady) {
+                return Promise.resolve(null);
+            }
+
+            const activeModule = module || this.module;
+            const boardId = this._resolveBoardId(activeModule);
+            const query = String(options.query || '').trim();
+            if (!activeModule || !boardId || !query) {
+                return Promise.resolve(null);
+            }
+
+            const seq = ++this._latestSearchRequestSeq;
+            const limit = Math.max(1, Number(options.limit || 12));
+            const contentTypes = Array.isArray(options.contentTypes)
+                ? options.contentTypes.map((value) => String(value || '').trim().toLowerCase()).filter(Boolean)
+                : [];
+            const payload = {
+                type: 'SEARCH_QUERY',
+                boardId,
+                seq,
+                query,
+                limit,
+                contentTypes,
+                camera: {
+                    x: Number(activeModule.camera?.position?.x || 0),
+                    y: Number(activeModule.camera?.position?.y || 0),
+                    z: Number(activeModule.camera?.position?.z || 0),
+                    aspect: Math.max(0.1, Number(activeModule.camera?.aspect || 1))
+                }
+            };
+
+            return new Promise((resolve) => {
+                this._pendingSearchResolvers.set(seq, resolve);
+                const posted = this._post(this._searchWorker, payload);
+                if (!posted) {
+                    this._pendingSearchResolvers.delete(seq);
+                    resolve(null);
+                }
+            });
+        }
+    }
+
+    window.MindMapLogicWorkers = Object.assign(window.MindMapLogicWorkers || {}, {
+        BUILD_ID: LOGIC_WORKER_BRIDGE_BUILD_ID,
+        createBridge(module) {
+            return new MindMapLogicWorkerBridge(module);
+        },
+        buildWorkerNodeSnapshot,
+        buildWorkerSearchSnapshot,
+        isTextLikeContentType
+    });
+})();