@mindexec/cli 0.2.483 → 0.2.494

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

@@ -1,12 +1,45 @@
 (function () {
     'use strict';
 
-    const LOGIC_WORKER_BRIDGE_BUILD_ID = '20260728-cached-viewport-v008';
-    const VISIBILITY_WORKER_URL = `_content/MindExecution.Shared/js/mind-map-visibility-worker.js?v=${LOGIC_WORKER_BRIDGE_BUILD_ID}`;
+    const LOGIC_WORKER_BRIDGE_BUILD_ID = '20260830-native-primary-v013';
+    const LEGACY_VISIBILITY_WORKER_URL = `_content/MindExecution.Shared/js/mind-map-visibility-worker.js?v=${LOGIC_WORKER_BRIDGE_BUILD_ID}`;
+    const NATIVE_CORE_MODE = String(window.MindMapNativeCoreBridge?.getMode?.() || 'off');
+    const NATIVE_PRIMARY_ENABLED = NATIVE_CORE_MODE === 'native';
+    const VISIBILITY_WORKER_URL = window.MindMapNativeCoreBridge?.getPrimaryWorkerUrl?.(LEGACY_VISIBILITY_WORKER_URL)
+        || LEGACY_VISIBILITY_WORKER_URL;
     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;
+    const WORKER_TIMEOUT_OVERRIDES = window.__MIND_EXECUTION_WORKER_TIMEOUTS || {};
+    const NATIVE_READY_TIMEOUT_MS = normalizeTimeout(WORKER_TIMEOUT_OVERRIDES.nativeReadyMs, 10000, 10, 60000);
+    const NATIVE_QUERY_TIMEOUT_MS = normalizeTimeout(WORKER_TIMEOUT_OVERRIDES.nativeQueryMs, 1200, 10, 10000);
+    const LEGACY_FALLBACK_READY_TIMEOUT_MS = normalizeTimeout(
+        WORKER_TIMEOUT_OVERRIDES.legacyFallbackReadyMs,
+        NATIVE_READY_TIMEOUT_MS,
+        10,
+        60000
+    );
+    const LEGACY_FALLBACK_QUERY_TIMEOUT_MS = normalizeTimeout(
+        WORKER_TIMEOUT_OVERRIDES.legacyFallbackQueryMs,
+        NATIVE_QUERY_TIMEOUT_MS,
+        10,
+        10000
+    );
+    const SEARCH_QUERY_TIMEOUT_MS = normalizeTimeout(WORKER_TIMEOUT_OVERRIDES.searchQueryMs, 5000, 10, 30000);
+    let nextEngineGeneration = 1;
+
+    function normalizeTimeout(value, fallback, minimum, maximum) {
+        const number = Number(value);
+        if (!Number.isFinite(number)) return fallback;
+        return Math.max(minimum, Math.min(maximum, Math.floor(number)));
+    }
+
+    function monotonicNow() {
+        return (typeof performance !== 'undefined' && typeof performance.now === 'function')
+            ? performance.now()
+            : Date.now();
+    }
 
     function getNodeContentType(model) {
         return String(model?.contentType ?? model?.ContentType ?? '').trim().toLowerCase();
@@ -170,6 +203,10 @@
         constructor(module) {
             this.module = module || null;
             this.boardId = normalizeBoardId(module?.activeBoardId || window.mindMap?.activeBoardId || '');
+            this._engineGeneration = nextEngineGeneration++;
+            this._boardEpoch = 0;
+            this._boardRevision = 0;
+            this._searchRevision = 0;
 
             this._visibilityWorker = null;
             this._lodPlanWorker = null;
@@ -178,6 +215,16 @@
             this._lodPlanReady = false;
             this._searchReady = false;
             this._visibilityDisabled = false;
+            this._visibilityBackend = NATIVE_PRIMARY_ENABLED ? 'native' : 'legacy';
+            this._nativeFallbackActive = false;
+            this._disposed = false;
+            this._visibilityReadyTimer = null;
+            this._visibilityQueryTimer = null;
+            this._hitTestQueryTimer = null;
+            this._visibilityQueryStartedAt = 0;
+            this._hitTestQueryStartedAt = 0;
+            this._visibilityNodeIds = new Set();
+            this._visibilityNodeSnapshots = new Map();
             this._lodPlanDisabled = false;
             this._searchDisabled = false;
             this._latestVisibilityRequestSeq = 0;
@@ -188,21 +235,31 @@
             this._pendingLodPlanKey = '';
             this._visibilityQueryPending = false;
             this._inFlightVisibilityRequestSeq = 0;
+            this._visibilityQueryStartedAt = 0;
             this._deferredVisibilityPayload = null;
             this._hitTestQueryPending = false;
+            this._inFlightHitTestRequestSeq = 0;
+            this._hitTestQueryStartedAt = 0;
+            this._inFlightHitTestPayload = null;
             this._deferredHitTestPayload = null;
             this._pendingSelectionResolvers = new Map();
             this._pendingSearchResolvers = new Map();
+            this._nativeCoreShadow = window.MindMapNativeCoreBridge?.createShadow?.() || null;
 
             this._createWorkers();
         }
 
         _createWorkers() {
-            this._visibilityWorker = this._createWorker(
-                'visibility',
-                VISIBILITY_WORKER_URL,
-                (data) => this._handleVisibilityMessage(data)
-            );
+            if (!this._startVisibilityWorker(
+                NATIVE_PRIMARY_ENABLED ? 'native' : 'legacy',
+                VISIBILITY_WORKER_URL
+            )) {
+                if (NATIVE_PRIMARY_ENABLED) {
+                    this._activateLegacyVisibilityFallback('native visibility worker creation failed');
+                } else {
+                    this._visibilityDisabled = true;
+                }
+            }
             this._lodPlanWorker = this._createWorker(
                 'lod-plan',
                 LOD_PLAN_WORKER_URL,
@@ -213,12 +270,54 @@
                 NODE_SEARCH_WORKER_URL,
                 (data) => this._handleSearchMessage(data)
             );
+            this._lodPlanDisabled = !this._lodPlanWorker;
+            this._searchDisabled = !this._searchWorker;
         }
 
-        _createWorker(kind, url, onMessage) {
+        _startVisibilityWorker(backend, url) {
+            this._visibilityBackend = backend;
+            this._visibilityReady = false;
+            this._visibilityDisabled = false;
+            const worker = this._createWorker(
+                'visibility',
+                url,
+                (data) => this._handleVisibilityMessage(data),
+                { backend }
+            );
+            this._visibilityWorker = worker;
+            if (!worker) {
+                return false;
+            }
+
+            const fallbackLegacy = backend === 'legacy' && this._nativeFallbackActive === true;
+            if (backend === 'native' || fallbackLegacy) {
+                const timeoutMs = backend === 'native'
+                    ? NATIVE_READY_TIMEOUT_MS
+                    : LEGACY_FALLBACK_READY_TIMEOUT_MS;
+                this._clearVisibilityReadyTimer();
+                this._visibilityReadyTimer = setTimeout(() => {
+                    if (this._disposed !== true &&
+                        this._visibilityWorker === worker &&
+                        this._visibilityBackend === backend &&
+                        this._visibilityReady !== true) {
+                        if (backend === 'native') {
+                            this._activateLegacyVisibilityFallback(`native READY timeout after ${timeoutMs}ms`);
+                        } else if (this._nativeFallbackActive === true) {
+                            this._disableVisibilityWorker(`legacy fallback READY timeout after ${timeoutMs}ms`);
+                        }
+                    }
+                }, timeoutMs);
+            }
+            return true;
+        }
+
+        _createWorker(kind, url, onMessage, options = {}) {
             try {
                 const worker = new Worker(url);
                 worker.onmessage = (event) => {
+                    if (this._disposed === true || (kind === 'visibility' && worker !== this._visibilityWorker)) {
+                        return;
+                    }
                     const data = event?.data || null;
                     if (!data || typeof data !== 'object') {
                         return;
@@ -226,7 +325,14 @@
 
                     if (data.type === 'READY') {
                         if (kind === 'visibility') {
+                            this._clearVisibilityReadyTimer();
                             this._visibilityReady = true;
+                            this._visibilityDisabled = false;
+                            if (options.backend === 'native') {
+                                window.MindMapNativeCoreBridge?.notifyPrimaryReady?.(data);
+                            } else if (this._nativeFallbackActive === true) {
+                                window.MindMapNativeCoreBridge?.notifyFallbackReady?.();
+                            }
                         } else if (kind === 'lod-plan') {
                             this._lodPlanReady = true;
                         } else if (kind === 'node-search') {
@@ -238,17 +344,16 @@
                     onMessage(data);
                 };
                 worker.onerror = (error) => {
+                    if (this._disposed === true || (kind === 'visibility' && worker !== this._visibilityWorker)) {
+                        return;
+                    }
                     console.warn(`[MindMapLogicWorkerBridge] ${kind} worker disabled after error.`, error);
                     if (kind === 'visibility') {
-                        this._visibilityDisabled = true;
-                        this._visibilityReady = false;
-                        this._visibilityQueryPending = false;
-                        this._inFlightVisibilityRequestSeq = 0;
-                        this._deferredVisibilityPayload = null;
-                        this._clearHitTestCache(this.module);
-                        this._hitTestQueryPending = false;
-                        this._deferredHitTestPayload = null;
-                        this._resolvePendingSelectionQueries(null);
+                        if (options.backend === 'native') {
+                            this._activateLegacyVisibilityFallback(String(error?.message || 'native visibility worker error'));
+                            return;
+                        }
+                        this._disableVisibilityWorker(String(error?.message || 'legacy visibility worker error'));
                     } else if (kind === 'lod-plan') {
                         this._lodPlanDisabled = true;
                         this._lodPlanReady = false;
@@ -257,30 +362,31 @@
                         this._searchReady = false;
                         this._resolvePendingSearches(null);
                     }
-                    try {
-                        worker.terminate();
-                    } catch { }
+                    if (kind !== 'visibility') {
+                        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') {
+                if (kind === 'lod-plan') {
                     this._lodPlanDisabled = true;
-                } else {
+                } else if (kind === 'node-search') {
                     this._searchDisabled = true;
                 }
                 return null;
             }
         }
 
-        _post(worker, payload) {
+        _post(worker, payload, boardRevision = this._boardRevision) {
             if (!worker || !payload) {
                 return false;
             }
 
             try {
+                this._stampOwnerPayload(payload, boardRevision);
                 worker.postMessage(payload);
                 return true;
             } catch (error) {
@@ -289,28 +395,285 @@
             }
         }
 
+        _postVisibility(payload) {
+            this._stampOwnerPayload(payload);
+            const posted = this._post(this._visibilityWorker, payload);
+            this._nativeCoreShadow?.post?.(payload);
+            if (!posted) {
+                if (this._visibilityBackend === 'native') {
+                    this._activateLegacyVisibilityFallback(`native ${String(payload?.type || 'message')} post failed`);
+                } else if (this._visibilityBackend === 'legacy' && this._nativeFallbackActive === true) {
+                    this._disableVisibilityWorker(`legacy fallback ${String(payload?.type || 'message')} post failed`);
+                }
+            }
+            return posted;
+        }
+
+        _postSearch(payload) {
+            return this._post(this._searchWorker, payload, this._searchRevision);
+        }
+
+        _clearVisibilityReadyTimer() {
+            if (this._visibilityReadyTimer !== null) {
+                clearTimeout(this._visibilityReadyTimer);
+                this._visibilityReadyTimer = null;
+            }
+        }
+
+        _clearVisibilityQueryTimer() {
+            if (this._visibilityQueryTimer !== null) {
+                clearTimeout(this._visibilityQueryTimer);
+                this._visibilityQueryTimer = null;
+            }
+        }
+
+        _clearHitTestQueryTimer() {
+            if (this._hitTestQueryTimer !== null) {
+                clearTimeout(this._hitTestQueryTimer);
+                this._hitTestQueryTimer = null;
+            }
+        }
+
+        _armVisibilityQueryTimer(seq) {
+            this._clearVisibilityQueryTimer();
+            const backend = this._visibilityBackend;
+            const fallbackLegacy = backend === 'legacy' && this._nativeFallbackActive === true;
+            if (backend !== 'native' && !fallbackLegacy) return;
+            const timeoutMs = backend === 'native'
+                ? NATIVE_QUERY_TIMEOUT_MS
+                : LEGACY_FALLBACK_QUERY_TIMEOUT_MS;
+            const expectedSeq = Math.max(0, Math.floor(Number(seq || 0)));
+            this._visibilityQueryTimer = setTimeout(() => {
+                if (this._disposed !== true &&
+                    this._visibilityBackend === backend &&
+                    this._visibilityQueryPending === true &&
+                    Number(this._inFlightVisibilityRequestSeq || 0) === expectedSeq) {
+                    if (backend === 'native') {
+                        this._activateLegacyVisibilityFallback(
+                            `native VISIBILITY_QUERY ${expectedSeq} timeout after ${timeoutMs}ms`
+                        );
+                    } else if (this._nativeFallbackActive === true) {
+                        this._disableVisibilityWorker(
+                            `legacy fallback VISIBILITY_QUERY ${expectedSeq} timeout after ${timeoutMs}ms`
+                        );
+                    }
+                }
+            }, timeoutMs);
+        }
+
+        _armHitTestQueryTimer(seq) {
+            this._clearHitTestQueryTimer();
+            const backend = this._visibilityBackend;
+            const fallbackLegacy = backend === 'legacy' && this._nativeFallbackActive === true;
+            if (backend !== 'native' && !fallbackLegacy) return;
+            const timeoutMs = backend === 'native'
+                ? NATIVE_QUERY_TIMEOUT_MS
+                : LEGACY_FALLBACK_QUERY_TIMEOUT_MS;
+            const expectedSeq = Math.max(0, Math.floor(Number(seq || 0)));
+            this._hitTestQueryTimer = setTimeout(() => {
+                if (this._disposed !== true &&
+                    this._visibilityBackend === backend &&
+                    this._hitTestQueryPending === true &&
+                    Number(this._inFlightHitTestRequestSeq || 0) === expectedSeq) {
+                    if (backend === 'native') {
+                        this._activateLegacyVisibilityFallback(
+                            `native HIT_TEST_QUERY ${expectedSeq} timeout after ${timeoutMs}ms`
+                        );
+                    } else if (this._nativeFallbackActive === true) {
+                        this._disableVisibilityWorker(
+                            `legacy fallback HIT_TEST_QUERY ${expectedSeq} timeout after ${timeoutMs}ms`
+                        );
+                    }
+                }
+            }, timeoutMs);
+        }
+
+        _armSelectionQueryTimer(seq, pending) {
+            const backend = this._visibilityBackend;
+            const fallbackLegacy = backend === 'legacy' && this._nativeFallbackActive === true;
+            if (!pending || (backend !== 'native' && !fallbackLegacy)) return;
+            const timeoutMs = backend === 'native'
+                ? NATIVE_QUERY_TIMEOUT_MS
+                : LEGACY_FALLBACK_QUERY_TIMEOUT_MS;
+            pending.timer = setTimeout(() => {
+                if (!this._pendingSelectionResolvers.has(seq) ||
+                    this._disposed === true ||
+                    this._visibilityBackend !== backend) {
+                    return;
+                }
+                if (backend === 'native') {
+                    this._activateLegacyVisibilityFallback(
+                        `native SELECTION_QUERY ${seq} timeout after ${timeoutMs}ms`
+                    );
+                } else if (this._nativeFallbackActive === true) {
+                    this._disableVisibilityWorker(
+                        `legacy fallback SELECTION_QUERY ${seq} timeout after ${timeoutMs}ms`
+                    );
+                }
+            }, timeoutMs);
+        }
+
+        _wakeVisibilityFallback(reason) {
+            const module = this.module;
+            if (!module) return;
+            module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), 1);
+            module.requestAnimationWake?.(String(reason || 'visibility-fallback'));
+        }
+
+        _resetPendingVisibilityQueries() {
+            this._clearVisibilityQueryTimer();
+            this._clearHitTestQueryTimer();
+            this._visibilityQueryPending = false;
+            this._inFlightVisibilityRequestSeq = 0;
+            this._deferredVisibilityPayload = null;
+            this._hitTestQueryPending = false;
+            this._inFlightHitTestRequestSeq = 0;
+            this._inFlightHitTestPayload = null;
+            this._deferredHitTestPayload = null;
+            this._clearHitTestCache(this.module);
+            this._resolvePendingSelectionQueries(null);
+        }
+
+        _disableVisibilityWorker(reason) {
+            const worker = this._visibilityWorker;
+            this._visibilityWorker = null;
+            this._visibilityDisabled = true;
+            this._visibilityReady = false;
+            this._clearVisibilityReadyTimer();
+            this._resetPendingVisibilityQueries();
+            if (this.module) {
+                this.module._visibilityWorkerPrimed = false;
+                this.module._preserveVisibleSetThisFrame = false;
+            }
+            if (this._nativeFallbackActive === true) {
+                window.MindMapNativeCoreBridge?.notifyFallbackUnavailable?.(reason);
+                this._wakeVisibilityFallback('native-primary-main-thread-fallback');
+            }
+            try { worker?.terminate?.(); } catch { }
+            window.MindCanvasTrace?.emit?.('logicWorker.visibilityDisabled', {
+                backend: this._visibilityBackend,
+                reason: String(reason || 'visibility worker disabled')
+            });
+        }
+
+        _snapshotCurrentSpatialNodes(module = this.module) {
+            const nodes = Array.from(this._visibilityNodeSnapshots.values());
+            this._visibilityNodeIds = new Set(nodes.map((node) => node.id));
+            return nodes;
+        }
+
+        _synchronizeVisibilityWorker(worker, reason) {
+            const module = this.module;
+            const boardId = this._resolveBoardId(module);
+            if (!worker || !module || !boardId) return false;
+            return this._post(worker, {
+                type: 'REBUILD_BOARD',
+                boardId,
+                reason: String(reason || 'visibility-worker-synchronize'),
+                cellSize: Math.max(1, Number(module.GRID_CELL_SIZE || 500)),
+                nodes: this._snapshotCurrentSpatialNodes(module)
+            });
+        }
+
+        _activateLegacyVisibilityFallback(reason) {
+            if (this._disposed === true || this._visibilityBackend !== 'native') {
+                return false;
+            }
+
+            const message = String(reason || 'native visibility fallback');
+            const nativeWorker = this._visibilityWorker;
+            this._visibilityWorker = null;
+            this._visibilityReady = false;
+            this._visibilityDisabled = false;
+            this._nativeFallbackActive = true;
+            this._clearVisibilityReadyTimer();
+            this._resetPendingVisibilityQueries();
+            if (this.module) {
+                this.module._visibilityWorkerPrimed = false;
+                this.module._preserveVisibleSetThisFrame = false;
+            }
+            this._wakeVisibilityFallback('native-primary-fallback');
+            try { nativeWorker?.terminate?.(); } catch { }
+
+            window.MindMapNativeCoreBridge?.notifyPrimaryFallback?.(message);
+            console.warn('[MindMapLogicWorkerBridge] Native visibility fell back to the JS worker.', message);
+
+            if (!this._startVisibilityWorker('legacy', LEGACY_VISIBILITY_WORKER_URL)) {
+                this._disableVisibilityWorker('legacy visibility fallback creation failed');
+                return false;
+            }
+
+            if (!this._synchronizeVisibilityWorker(this._visibilityWorker, 'native-primary-fallback')) {
+                this._disableVisibilityWorker('legacy visibility fallback synchronization failed');
+                return false;
+            }
+            return true;
+        }
+
+        _handleVisibilityProtocolFailure(reason) {
+            if (this._visibilityBackend === 'native') {
+                this._activateLegacyVisibilityFallback(reason);
+            } else {
+                this._disableVisibilityWorker(reason);
+            }
+        }
+
+        _stampOwnerPayload(payload, boardRevision = this._boardRevision) {
+            if (!payload || typeof payload !== 'object') {
+                return payload;
+            }
+
+            payload.engineGeneration = Number(this._engineGeneration || 0);
+            payload.boardEpoch = Number(this._boardEpoch || 0);
+            payload.boardRevision = Number(boardRevision || 0);
+            return payload;
+        }
+
+        _isCurrentWorkerOwner(data, boardId = this._resolveBoardId(this.module), boardRevision = this._boardRevision) {
+            const owner = this._classifyWorkerOwner(data, boardId, boardRevision);
+            return owner.identityMatches && owner.revisionMatches;
+        }
+
+        _classifyWorkerOwner(data, boardId = this._resolveBoardId(this.module), boardRevision = this._boardRevision) {
+            const identityMatches = normalizeBoardId(data?.boardId) === normalizeBoardId(boardId) &&
+                Number(data?.engineGeneration || 0) === Number(this._engineGeneration || 0) &&
+                Number(data?.boardEpoch || 0) === Number(this._boardEpoch || 0);
+            const revisionMatches = Number(data?.boardRevision || 0) === Number(boardRevision || 0);
+            return { identityMatches, revisionMatches };
+        }
+
         _stampVisibilityPayloadForPost(payload) {
             if (!payload || String(payload.type || '') !== 'VISIBILITY_QUERY') {
                 return payload;
             }
 
-            payload.mainLastAppliedSeq = Math.max(
-                0,
-                Math.floor(Number(this.module?._workerVisibilitySeq || 0))
-            );
+            payload.mainLastAppliedSeq = this.module?._visibilityWorkerPrimed === true
+                ? Math.max(0, Math.floor(Number(this.module?._workerVisibilitySeq || 0)))
+                : 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;
+        _resolveBoardId(module = this.module, fallbackBoardId = undefined) {
+            let sourceValue;
+            let ownerSourcePresent = false;
+            if (fallbackBoardId !== undefined) {
+                sourceValue = fallbackBoardId;
+                ownerSourcePresent = true;
+            } else if (module && 'activeBoardId' in Object(module)) {
+                sourceValue = module.activeBoardId;
+                ownerSourcePresent = true;
+            } else if (typeof module?.getCurrentBoardId === 'function') {
+                sourceValue = module.getCurrentBoardId();
+                ownerSourcePresent = true;
+            } else if (window.mindMap && 'activeBoardId' in Object(window.mindMap)) {
+                sourceValue = window.mindMap.activeBoardId;
+                ownerSourcePresent = true;
+            } else {
+                sourceValue = this.boardId;
             }
+
+            const candidate = normalizeBoardId(sourceValue);
+            if (ownerSourcePresent || candidate) this.boardId = candidate;
             return candidate;
         }
 
@@ -330,15 +693,156 @@
             module._workerHitTestProfile = null;
         }
 
+        _validateWorkerNodeIds(source, required = true) {
+            if (!Array.isArray(source)) {
+                return required ? { valid: false, ids: [] } : { valid: true, ids: null };
+            }
+
+            const ids = [];
+            const seen = new Set();
+            for (let index = 0; index < source.length; index++) {
+                const nodeId = String(source[index] || '').trim();
+                if (!nodeId || seen.has(nodeId) || !this._visibilityNodeIds.has(nodeId)) {
+                    return { valid: false, ids: [] };
+                }
+                seen.add(nodeId);
+                ids.push(nodeId);
+            }
+            return { valid: true, ids };
+        }
+
+        _validateWorkerRect(source) {
+            if (!source || typeof source !== 'object') return false;
+            const left = Number(source.left);
+            const right = Number(source.right);
+            const bottom = Number(source.bottom);
+            const top = Number(source.top);
+            return Number.isFinite(left) && Number.isFinite(right) &&
+                Number.isFinite(bottom) && Number.isFinite(top) &&
+                right >= left && top >= bottom;
+        }
+
+        _validateVisibilityResult(data) {
+            if (String(data?.type || '') !== 'VISIBILITY_RESULT') {
+                return { valid: false, reason: 'unexpected visibility result type' };
+            }
+            const visibleCount = Number(data.visibleCount);
+            if (!Number.isInteger(visibleCount) || visibleCount < 0 || visibleCount > this._visibilityNodeIds.size) {
+                return { valid: false, reason: 'invalid visibleCount' };
+            }
+            if (typeof data.visibilityChanged !== 'boolean' ||
+                typeof data.fullResVisibilityReconcilePending !== 'boolean' ||
+                !this._validateWorkerRect(data.viewportRect) ||
+                Number(data.lastVisibilityNodeCount) !== this._visibilityNodeIds.size) {
+                return { valid: false, reason: 'invalid visibility state fields' };
+            }
+
+            const entered = this._validateWorkerNodeIds(data.enteredIds, true);
+            const exited = this._validateWorkerNodeIds(data.exitedIds, true);
+            const visible = this._validateWorkerNodeIds(data.visibleIds, false);
+            const priority = this._validateWorkerNodeIds(data.priorityIds, false);
+            if (!entered.valid || !exited.valid || !visible.valid || !priority.valid) {
+                return { valid: false, reason: 'invalid or unknown visibility node id' };
+            }
+            const exitedSet = new Set(exited.ids);
+            if (entered.ids.some((nodeId) => exitedSet.has(nodeId))) {
+                return { valid: false, reason: 'visibility enter and exit overlap' };
+            }
+            if (data.visibilityChanged !== (entered.ids.length > 0 || exited.ids.length > 0)) {
+                return { valid: false, reason: 'visibilityChanged does not match diff' };
+            }
+
+            const lastAppliedSeq = Math.max(0, Math.floor(Number(this.module?._workerVisibilitySeq || 0)));
+            const resultSeq = Math.max(0, Math.floor(Number(data.seq || 0)));
+            const hasExactDiffBase = this.module?._visibilityWorkerPrimed === true &&
+                lastAppliedSeq > 0 && resultSeq === lastAppliedSeq + 1;
+            if (!hasExactDiffBase && visible.ids === null) {
+                return { valid: false, reason: 'full visibility result is required without an exact diff base' };
+            }
+
+            let expectedVisibleIds = visible.ids !== null ? new Set(visible.ids) : new Set();
+            if (hasExactDiffBase) {
+                const previousVisibleIds = new Set();
+                this.module?._visibleIds?.forEach?.((nodeId) => {
+                    const normalizedId = String(nodeId || '').trim();
+                    if (this._visibilityNodeIds.has(normalizedId)) previousVisibleIds.add(normalizedId);
+                });
+                for (let index = 0; index < entered.ids.length; index++) {
+                    if (previousVisibleIds.has(entered.ids[index])) {
+                        return { valid: false, reason: 'entered visibility id was already visible' };
+                    }
+                }
+                for (let index = 0; index < exited.ids.length; index++) {
+                    if (!previousVisibleIds.has(exited.ids[index])) {
+                        return { valid: false, reason: 'exited visibility id was not visible' };
+                    }
+                }
+                for (let index = 0; index < exited.ids.length; index++) previousVisibleIds.delete(exited.ids[index]);
+                for (let index = 0; index < entered.ids.length; index++) previousVisibleIds.add(entered.ids[index]);
+                if (visible.ids !== null &&
+                    (previousVisibleIds.size !== expectedVisibleIds.size ||
+                        Array.from(previousVisibleIds).some((nodeId) => !expectedVisibleIds.has(nodeId)))) {
+                    return { valid: false, reason: 'full visibility set does not match diff' };
+                }
+                expectedVisibleIds = previousVisibleIds;
+            }
+
+            if (expectedVisibleIds.size !== visibleCount) {
+                return { valid: false, reason: 'visibleCount does not match visible set' };
+            }
+            if (priority.ids !== null) {
+                if (priority.ids.length !== visibleCount ||
+                    priority.ids.some((nodeId) => !expectedVisibleIds.has(nodeId))) {
+                    return { valid: false, reason: 'priorityIds do not match visible set' };
+                }
+            }
+            return { valid: true, reason: '' };
+        }
+
+        _validateHitTestResult(data, payload) {
+            const candidates = this._validateWorkerNodeIds(data?.candidateIds, true);
+            if (String(data?.type || '') !== 'HIT_TEST_RESULT' || !candidates.valid || !payload) return false;
+            return String(data.rangeKey || '') === `${payload.cellX}:${payload.cellY}:${payload.cellRadius}` &&
+                Number(data.cellX) === Number(payload.cellX) &&
+                Number(data.cellY) === Number(payload.cellY) &&
+                Number(data.cellRadius) === Number(payload.cellRadius);
+        }
+
+        _validateSelectionResult(data, payload) {
+            const selected = this._validateWorkerNodeIds(data?.selectedIds, true);
+            if (String(data?.type || '') !== 'SELECTION_QUERY_RESULT' || !selected.valid || !payload) return false;
+            const expected = payload.selectionRect;
+            const actual = data.selectionRect;
+            if (!this._validateWorkerRect(actual) || !expected || typeof expected !== 'object') return false;
+            const expectedLeft = Number(expected.left);
+            const expectedRight = Number(expected.right);
+            const expectedBottom = Number(expected.bottom);
+            const expectedTop = Number(expected.top);
+            if (!Number.isFinite(expectedLeft) || !Number.isFinite(expectedRight) ||
+                !Number.isFinite(expectedBottom) || !Number.isFinite(expectedTop)) return false;
+            const epsilon = 0.000001;
+            return Math.abs(Number(actual.left) - Math.min(expectedLeft, expectedRight)) <= epsilon &&
+                Math.abs(Number(actual.right) - Math.max(expectedLeft, expectedRight)) <= epsilon &&
+                Math.abs(Number(actual.bottom) - Math.min(expectedBottom, expectedTop)) <= epsilon &&
+                Math.abs(Number(actual.top) - Math.max(expectedBottom, expectedTop)) <= epsilon;
+        }
+
         _handleVisibilityMessage(data) {
-            if (String(data?.type || '') === 'HIT_TEST_RESULT') {
+            const messageType = String(data?.type || '');
+            if (messageType === 'NATIVE_CORE_INIT_ERROR' || messageType === 'NATIVE_CORE_RUNTIME_ERROR') {
+                this._handleVisibilityProtocolFailure(String(data?.message || messageType));
+                return;
+            }
+            this._nativeCoreShadow?.observePrimaryResult?.(data);
+            if (messageType === 'HIT_TEST_RESULT') {
                 this._handleHitTestMessage(data);
                 return;
             }
-            if (String(data?.type || '') === 'SELECTION_QUERY_RESULT') {
+            if (messageType === 'SELECTION_QUERY_RESULT') {
                 this._handleSelectionQueryMessage(data);
                 return;
             }
+            if (messageType !== 'VISIBILITY_RESULT') return;
 
             const module = this.module;
             const boardId = this._resolveBoardId(module);
@@ -346,42 +850,142 @@
                 return;
             }
 
-            if (normalizeBoardId(data.boardId) !== boardId) {
-                return;
-            }
-
             const resultSeq = Math.max(0, Math.floor(Number(data.seq || 0)));
             const inFlightSeq = Math.max(0, Math.floor(Number(this._inFlightVisibilityRequestSeq || 0)));
             if (resultSeq <= 0 || resultSeq !== inFlightSeq) {
                 return;
             }
+            const roundTripMs = this._visibilityQueryStartedAt > 0
+                ? Math.max(0, monotonicNow() - this._visibilityQueryStartedAt)
+                : 0;
+
+            const owner = this._classifyWorkerOwner(data, boardId);
+            if (data?.stale === true || !owner.identityMatches || !owner.revisionMatches) {
+                this._clearVisibilityQueryTimer();
+                this._visibilityQueryPending = false;
+                this._inFlightVisibilityRequestSeq = 0;
+                this._visibilityQueryStartedAt = 0;
+                module._visibilityWorkerPrimed = false;
+                module._preserveVisibleSetThisFrame = false;
+                if (!owner.identityMatches) {
+                    if (this._visibilityBackend === 'native' || this._nativeFallbackActive === true) {
+                        this._handleVisibilityProtocolFailure('visibility result owner identity mismatch');
+                    } else {
+                        this._flushDeferredVisibilityRequest();
+                    }
+                    return;
+                }
+                if ((this._visibilityBackend === 'native' || this._nativeFallbackActive === true) &&
+                    data?.stale === true && owner.revisionMatches) {
+                    this._handleVisibilityProtocolFailure(
+                        this._visibilityBackend === 'native'
+                            ? 'native rejected a current visibility owner'
+                            : 'legacy fallback rejected a current visibility owner'
+                    );
+                    return;
+                }
+                this._flushDeferredVisibilityRequest();
+                return;
+            }
 
-            module._applyWorkerVisibilityResult?.(data);
+            const validation = this._validateVisibilityResult(data);
+            if (!validation.valid) {
+                this._clearVisibilityQueryTimer();
+                this._visibilityQueryPending = false;
+                this._inFlightVisibilityRequestSeq = 0;
+                this._visibilityQueryStartedAt = 0;
+                module._visibilityWorkerPrimed = false;
+                module._preserveVisibleSetThisFrame = false;
+                this._handleVisibilityProtocolFailure(validation.reason);
+                return;
+            }
+
+            this._clearVisibilityQueryTimer();
+            try {
+                if (typeof module._applyWorkerVisibilityResult !== 'function') {
+                    throw new Error('renderer visibility apply hook is missing');
+                }
+                module._applyWorkerVisibilityResult(data);
+                if (Math.max(0, Math.floor(Number(module._workerVisibilitySeq || 0))) !== resultSeq) {
+                    throw new Error(`renderer did not acknowledge visibility seq ${resultSeq}`);
+                }
+            } catch (error) {
+                const message = `visibility result apply failed: ${String(error?.message || error || 'unknown error')}`;
+                window.MindCanvasTrace?.emit?.('logicWorker.visibilityApplyFailed', {
+                    backend: this._visibilityBackend,
+                    resultType: String(data?.type || ''),
+                    seq: resultSeq,
+                    reason: message
+                });
+                console.error('[MindMapLogicWorkerBridge] Visibility result apply failed.', error);
+                this._handleVisibilityProtocolFailure(message);
+                return;
+            }
+            if (this._visibilityBackend === 'native') {
+                window.MindMapNativeCoreBridge?.notifyPrimaryResultAccepted?.(data, roundTripMs);
+            }
             this._visibilityQueryPending = false;
             this._inFlightVisibilityRequestSeq = 0;
+            this._visibilityQueryStartedAt = 0;
             this._flushDeferredVisibilityRequest();
         }
 
         _handleHitTestMessage(data) {
             const module = this.module;
             const boardId = this._resolveBoardId(module);
+            const seq = Number(data?.seq || 0);
+            if (seq !== Number(this._inFlightHitTestRequestSeq || 0)) {
+                return;
+            }
+
+            const inFlightPayload = this._inFlightHitTestPayload;
+            const roundTripMs = this._hitTestQueryStartedAt > 0
+                ? Math.max(0, monotonicNow() - this._hitTestQueryStartedAt)
+                : 0;
+            this._clearHitTestQueryTimer();
             this._hitTestQueryPending = false;
+            this._inFlightHitTestRequestSeq = 0;
+            this._hitTestQueryStartedAt = 0;
+            this._inFlightHitTestPayload = null;
 
             if (!module || !boardId) {
                 this._flushDeferredHitTestRequest();
                 return;
             }
 
-            if (normalizeBoardId(data.boardId) !== boardId) {
+            const owner = this._classifyWorkerOwner(data, boardId);
+            if (data?.stale === true || !owner.identityMatches || !owner.revisionMatches) {
+                if (!owner.identityMatches) {
+                    if (this._visibilityBackend === 'native' || this._nativeFallbackActive === true) {
+                        this._handleVisibilityProtocolFailure('hit-test result owner identity mismatch');
+                    } else {
+                        this._flushDeferredHitTestRequest();
+                    }
+                    return;
+                }
+                if ((this._visibilityBackend === 'native' || this._nativeFallbackActive === true) &&
+                    data?.stale === true && owner.revisionMatches) {
+                    this._handleVisibilityProtocolFailure(
+                        this._visibilityBackend === 'native'
+                            ? 'native rejected a current hit-test owner'
+                            : 'legacy fallback rejected a current hit-test owner'
+                    );
+                    return;
+                }
                 this._flushDeferredHitTestRequest();
                 return;
             }
 
-            if (Number(data.seq || 0) < Number(this._latestHitTestRequestSeq || 0)) {
+            if (seq !== Number(this._latestHitTestRequestSeq || 0)) {
                 this._flushDeferredHitTestRequest();
                 return;
             }
 
+            if (!this._validateHitTestResult(data, inFlightPayload)) {
+                this._handleVisibilityProtocolFailure('invalid hit-test result payload');
+                return;
+            }
+
             module._workerHitTestRangeKey = String(data.rangeKey || '').trim();
             module._workerHitTestBoardId = boardId;
             module._workerHitTestCandidateIds = Array.isArray(data.candidateIds)
@@ -395,6 +999,9 @@
                 ? performance.now()
                 : Date.now();
             module._workerHitTestProfile = data.profile || null;
+            if (this._visibilityBackend === 'native') {
+                window.MindMapNativeCoreBridge?.notifyPrimaryResultAccepted?.(data, roundTripMs);
+            }
 
             this._flushDeferredHitTestRequest();
         }
@@ -402,29 +1009,59 @@
         _handleSelectionQueryMessage(data) {
             const boardId = this._resolveBoardId(this.module);
             const seq = Number(data.seq || 0);
-            const resolver = this._pendingSelectionResolvers.get(seq) || null;
-            if (resolver) {
+            const pending = this._pendingSelectionResolvers.get(seq) || null;
+            if (pending) {
                 this._pendingSelectionResolvers.delete(seq);
+                if (pending.timer !== null) clearTimeout(pending.timer);
             }
 
-            if (!resolver) {
+            if (!pending) {
                 return;
             }
 
-            if (seq < Number(this._latestSelectionRequestSeq || 0)) {
-                resolver(null);
+            if (seq !== Number(this._latestSelectionRequestSeq || 0)) {
+                pending.resolve(null);
                 return;
             }
 
-            if (!boardId || normalizeBoardId(data.boardId) !== boardId) {
-                resolver(null);
+            const owner = this._classifyWorkerOwner(data, boardId);
+            if (!owner.identityMatches) {
+                pending.resolve(null);
+                if (this._visibilityBackend === 'native' || this._nativeFallbackActive === true) {
+                    this._handleVisibilityProtocolFailure('selection result owner identity mismatch');
+                }
+                return;
+            }
+
+            if (data?.stale === true || !owner.revisionMatches) {
+                pending.resolve(null);
+                if (data?.stale === true && owner.revisionMatches &&
+                    (this._visibilityBackend === 'native' || this._nativeFallbackActive === true)) {
+                    this._handleVisibilityProtocolFailure(
+                        this._visibilityBackend === 'native'
+                            ? 'native rejected a current selection owner'
+                            : 'legacy fallback rejected a current selection owner'
+                    );
+                }
+                return;
+            }
+
+            if (!this._validateSelectionResult(data, pending.payload)) {
+                pending.resolve(null);
+                this._handleVisibilityProtocolFailure('invalid selection result payload');
                 return;
             }
 
             const selectedIds = Array.isArray(data.selectedIds)
                 ? data.selectedIds.map((nodeId) => String(nodeId || '').trim()).filter(Boolean)
                 : [];
-            resolver(selectedIds);
+            if (this._visibilityBackend === 'native') {
+                const roundTripMs = pending.startedAt > 0
+                    ? Math.max(0, monotonicNow() - pending.startedAt)
+                    : 0;
+                window.MindMapNativeCoreBridge?.notifyPrimaryResultAccepted?.(data, roundTripMs);
+            }
+            pending.resolve(selectedIds);
         }
 
         _handleLodPlanMessage(data) {
@@ -434,7 +1071,7 @@
                 return;
             }
 
-            if (normalizeBoardId(data.boardId) !== boardId) {
+            if (!this._isCurrentWorkerOwner(data, boardId)) {
                 return;
             }
 
@@ -442,9 +1079,10 @@
                 return;
             }
 
-            if (String(data.key || '') === this._pendingLodPlanKey) {
-                this._pendingLodPlanKey = '';
+            if (String(data.key || '') !== this._pendingLodPlanKey) {
+                return;
             }
+            this._pendingLodPlanKey = '';
 
             module.lodRenderer._applyWorkerLodPlanResult?.(data);
         }
@@ -453,52 +1091,68 @@
             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) {
+            const pending = this._pendingSearchResolvers.get(seq) || null;
+            if (pending) {
                 this._pendingSearchResolvers.delete(seq);
+                if (pending.timer !== null) clearTimeout(pending.timer);
             }
 
-            if (!resolver) {
+            if (!pending) {
                 return;
             }
 
-            if (!boardId || normalizedBoardId !== boardId) {
-                resolver([]);
+            if (String(data?.type || '') !== 'SEARCH_RESULT' ||
+                data?.stale === true ||
+                !boardId ||
+                normalizedBoardId !== boardId ||
+                !this._isCurrentWorkerOwner(data, boardId, this._searchRevision) ||
+                !Array.isArray(data.hits)) {
+                pending.resolve(null);
                 return;
             }
 
-            const hits = Array.isArray(data.hits)
-                ? data.hits.map((hit) => ({
+            const hits = data.hits
+                .map((hit) => ({
                     nodeId: String(hit?.nodeId ?? hit?.id ?? '').trim(),
                     score: Number(hit?.score || 0)
-                })).filter((hit) => hit.nodeId)
-                : [];
-            resolver(hits);
+                }))
+                .filter((hit) => hit.nodeId && Number.isFinite(hit.score));
+            if (hits.length !== data.hits.length ||
+                hits.some((hit) => !this.module?.nodeObjectsById?.has?.(hit.nodeId))) {
+                pending.resolve(null);
+                return;
+            }
+            pending.resolve(hits);
         }
 
         _resolvePendingSearches(hits) {
-            const resolvers = Array.from(this._pendingSearchResolvers.values());
+            const pendingQueries = Array.from(this._pendingSearchResolvers.values());
             this._pendingSearchResolvers.clear();
-            for (let i = 0; i < resolvers.length; i++) {
+            for (let i = 0; i < pendingQueries.length; i++) {
                 try {
-                    resolvers[i](hits);
+                    if (pendingQueries[i].timer !== null) clearTimeout(pendingQueries[i].timer);
+                    pendingQueries[i].resolve(hits);
                 } catch {
                 }
             }
         }
 
         _resolvePendingSelectionQueries(nodeIds) {
-            const resolvers = Array.from(this._pendingSelectionResolvers.values());
+            const pendingQueries = Array.from(this._pendingSelectionResolvers.values());
             this._pendingSelectionResolvers.clear();
-            for (let i = 0; i < resolvers.length; i++) {
+            for (let i = 0; i < pendingQueries.length; i++) {
                 try {
-                    resolvers[i](nodeIds);
+                    if (pendingQueries[i].timer !== null) clearTimeout(pendingQueries[i].timer);
+                    pendingQueries[i].resolve(nodeIds);
                 } catch {
                 }
             }
         }
 
         dispose() {
+            this._disposed = true;
+            this._clearVisibilityReadyTimer();
+            this._resetPendingVisibilityQueries();
             try {
                 this._visibilityWorker?.terminate?.();
             } catch { }
@@ -512,35 +1166,29 @@
             this._visibilityWorker = null;
             this._lodPlanWorker = null;
             this._searchWorker = null;
+            this._nativeCoreShadow?.dispose?.();
+            this._nativeCoreShadow = null;
             this._visibilityReady = false;
             this._lodPlanReady = false;
             this._searchReady = false;
-            this._visibilityQueryPending = false;
-            this._inFlightVisibilityRequestSeq = 0;
-            this._deferredVisibilityPayload = null;
-            this._hitTestQueryPending = false;
-            this._deferredHitTestPayload = null;
-            this._resolvePendingSelectionQueries(null);
-            this._clearHitTestCache(this.module);
             this._resolvePendingSearches(null);
+            this._visibilityNodeIds.clear();
+            this._visibilityNodeSnapshots.clear();
+            if (NATIVE_PRIMARY_ENABLED) {
+                window.MindMapNativeCoreBridge?.notifyPrimaryDisposed?.('logic-worker-dispose');
+            }
         }
 
         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._boardEpoch++;
+            this._boardRevision = 0;
+            this._searchRevision = 0;
             this._pendingLodPlanKey = '';
-            this._visibilityQueryPending = false;
-            this._inFlightVisibilityRequestSeq = 0;
-            this._deferredVisibilityPayload = null;
-            this._hitTestQueryPending = false;
-            this._deferredHitTestPayload = null;
-            this._resolvePendingSelectionQueries(null);
+            this._resetPendingVisibilityQueries();
             this._resolvePendingSearches(null);
-            this._clearHitTestCache(this.module);
+            this._visibilityNodeIds.clear();
+            this._visibilityNodeSnapshots.clear();
 
             if (this.module) {
                 this.module._visibilityWorkerPrimed = false;
@@ -552,9 +1200,9 @@
                 reason,
                 cellSize: Math.max(1, Number(this.module?.GRID_CELL_SIZE || 500))
             };
-            this._post(this._visibilityWorker, payload);
+            this._postVisibility(payload);
             this._post(this._lodPlanWorker, payload);
-            this._post(this._searchWorker, payload);
+            this._postSearch(payload);
         }
 
         rebuildNodeTables(module = this.module, options = {}) {
@@ -577,6 +1225,10 @@
                     searchNodes.push(searchSnapshot);
                 }
             });
+            this._boardRevision++;
+            this._searchRevision++;
+            this._visibilityNodeIds = new Set(nodes.map((node) => node.id));
+            this._visibilityNodeSnapshots = new Map(nodes.map((node) => [node.id, node]));
 
             const payload = {
                 type: 'REBUILD_BOARD',
@@ -586,9 +1238,9 @@
                 nodes
             };
 
-            const postedVisibility = this._post(this._visibilityWorker, payload);
+            const postedVisibility = this._postVisibility(payload);
             const postedLodPlan = this._post(this._lodPlanWorker, payload);
-            const postedSearch = this._post(this._searchWorker, {
+            const postedSearch = this._postSearch({
                 type: 'REBUILD_BOARD',
                 boardId,
                 reason: String(options.reason || 'rebuild-search-index'),
@@ -622,6 +1274,14 @@
             if (!snapshot && !searchSnapshot) {
                 return false;
             }
+            if (snapshot) {
+                this._boardRevision++;
+                this._visibilityNodeIds.add(snapshot.id);
+                this._visibilityNodeSnapshots.set(snapshot.id, snapshot);
+            }
+            if (searchSnapshot) {
+                this._searchRevision++;
+            }
 
             let postedVisibility = false;
             let postedLodPlan = false;
@@ -632,11 +1292,11 @@
                     boardId,
                     node: snapshot
                 };
-                postedVisibility = this._post(this._visibilityWorker, payload);
+                postedVisibility = this._postVisibility(payload);
                 postedLodPlan = this._post(this._lodPlanWorker, payload);
             }
             if (searchSnapshot) {
-                postedSearch = this._post(this._searchWorker, {
+                postedSearch = this._postSearch({
                     type: 'UPSERT_NODE',
                     boardId,
                     node: searchSnapshot
@@ -654,6 +1314,10 @@
             if (!boardId || !normalizedNodeId) {
                 return false;
             }
+            this._boardRevision++;
+            this._searchRevision++;
+            this._visibilityNodeIds.delete(normalizedNodeId);
+            this._visibilityNodeSnapshots.delete(normalizedNodeId);
 
             const payload = {
                 type: 'REMOVE_NODE',
@@ -661,9 +1325,9 @@
                 nodeId: normalizedNodeId
             };
 
-            const postedVisibility = this._post(this._visibilityWorker, payload);
+            const postedVisibility = this._postVisibility(payload);
             const postedLodPlan = this._post(this._lodPlanWorker, payload);
-            const postedSearch = this._post(this._searchWorker, payload);
+            const postedSearch = this._postSearch(payload);
             if (postedVisibility || postedLodPlan) {
                 this._clearHitTestCache(module || this.module);
             }
@@ -690,7 +1354,8 @@
                 return false;
             }
 
-            return this._post(this._searchWorker, {
+            this._searchRevision++;
+            return this._postSearch({
                 type: 'BATCH_SYNC',
                 boardId: normalizedBoardId,
                 nodes: normalizedNodes,
@@ -766,9 +1431,15 @@
                 return true;
             }
 
-            const posted = this._post(this._visibilityWorker, this._stampVisibilityPayloadForPost(payload));
+            const posted = this._postVisibility(this._stampVisibilityPayloadForPost(payload));
             this._visibilityQueryPending = posted;
             this._inFlightVisibilityRequestSeq = posted ? seq : 0;
+            if (posted) {
+                this._visibilityQueryStartedAt = monotonicNow();
+                this._armVisibilityQueryTimer(seq);
+            } else if (this._visibilityBackend === 'native') {
+                this._activateLegacyVisibilityFallback('native visibility query post failed');
+            }
             return posted;
         }
 
@@ -779,11 +1450,17 @@
 
             const payload = this._deferredVisibilityPayload;
             this._deferredVisibilityPayload = null;
-            const posted = this._post(this._visibilityWorker, this._stampVisibilityPayloadForPost(payload));
+            const posted = this._postVisibility(this._stampVisibilityPayloadForPost(payload));
             this._visibilityQueryPending = posted;
             this._inFlightVisibilityRequestSeq = posted
                 ? Math.max(0, Math.floor(Number(payload.seq || 0)))
                 : 0;
+            if (posted) {
+                this._visibilityQueryStartedAt = monotonicNow();
+                this._armVisibilityQueryTimer(this._inFlightVisibilityRequestSeq);
+            } else if (this._visibilityBackend === 'native') {
+                this._activateLegacyVisibilityFallback('deferred native visibility query post failed');
+            }
         }
 
         _describeHitTestQuery(module = this.module, options = {}) {
@@ -797,7 +1474,7 @@
             }
 
             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 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);
 
@@ -841,8 +1518,16 @@
                 return true;
             }
 
-            const posted = this._post(this._visibilityWorker, payload);
+            const posted = this._postVisibility(payload);
             this._hitTestQueryPending = posted;
+            this._inFlightHitTestRequestSeq = posted ? payload.seq : 0;
+            this._inFlightHitTestPayload = posted ? { ...payload } : null;
+            if (posted) {
+                this._hitTestQueryStartedAt = monotonicNow();
+                this._armHitTestQueryTimer(payload.seq);
+            } else if (this._visibilityBackend === 'native') {
+                this._activateLegacyVisibilityFallback('native hit-test query post failed');
+            }
             return posted;
         }
 
@@ -853,8 +1538,16 @@
 
             const payload = this._deferredHitTestPayload;
             this._deferredHitTestPayload = null;
-            const posted = this._post(this._visibilityWorker, payload);
+            const posted = this._postVisibility(payload);
             this._hitTestQueryPending = posted;
+            this._inFlightHitTestRequestSeq = posted ? Number(payload.seq || 0) : 0;
+            this._inFlightHitTestPayload = posted ? { ...payload } : null;
+            if (posted) {
+                this._hitTestQueryStartedAt = monotonicNow();
+                this._armHitTestQueryTimer(payload.seq);
+            } else if (this._visibilityBackend === 'native') {
+                this._activateLegacyVisibilityFallback('deferred native hit-test query post failed');
+            }
         }
 
         getCachedHitTestCandidateIds(module = this.module, options = {}) {
@@ -903,12 +1596,18 @@
             };
 
             return new Promise((resolve) => {
-                this._pendingSelectionResolvers.set(payload.seq, resolve);
-                const posted = this._post(this._visibilityWorker, payload);
+                const pending = { resolve, payload: { ...payload }, timer: null, startedAt: monotonicNow() };
+                this._pendingSelectionResolvers.set(payload.seq, pending);
+                const posted = this._postVisibility(payload);
                 if (!posted) {
                     this._pendingSelectionResolvers.delete(payload.seq);
                     resolve(null);
+                    if (this._visibilityBackend === 'native') {
+                        this._activateLegacyVisibilityFallback('native selection query post failed');
+                    }
+                    return;
                 }
+                this._armSelectionQueryTimer(payload.seq, pending);
             });
         }
 
@@ -982,12 +1681,25 @@
             };
 
             return new Promise((resolve) => {
-                this._pendingSearchResolvers.set(seq, resolve);
-                const posted = this._post(this._searchWorker, payload);
+                const pending = { resolve, timer: null };
+                this._pendingSearchResolvers.set(seq, pending);
+                const posted = this._postSearch(payload);
                 if (!posted) {
                     this._pendingSearchResolvers.delete(seq);
                     resolve(null);
+                    return;
                 }
+                pending.timer = setTimeout(() => {
+                    if (!this._pendingSearchResolvers.has(seq)) return;
+                    this._pendingSearchResolvers.delete(seq);
+                    resolve(null);
+                    window.MindCanvasTrace?.emit?.('logicWorker.searchTimeout', {
+                        boardId,
+                        seq,
+                        boardRevision: this._searchRevision,
+                        timeoutMs: SEARCH_QUERY_TIMEOUT_MS
+                    });
+                }, SEARCH_QUERY_TIMEOUT_MS);
             });
         }
     }