@mindexec/cli 0.2.0

package/wwwroot/_content/MindExecution.Shared/js/mind-map-visibility-worker.js

@@ -0,0 +1,890 @@
+'use strict';
+
+const FULL_RES_VISIBILITY_EXIT_MARGIN_SCALE = 1.8;
+const MAX_DIRECT_GRID_LOOKUPS = 4096;
+const DEFAULT_HIT_TEST_CELL_RADIUS = 1;
+const MAX_HIT_TEST_CELL_RADIUS = 3;
+
+function createState() {
+    return {
+        boardId: '',
+        cellSize: 500,
+        nodes: new Map(),
+        spatialGrid: new Map(),
+        lastVisibleIds: new Set(),
+        lastPriorityIds: [],
+        lastVisibilityRect: null,
+        lastNodeCount: 0,
+        lastResultSeq: 0
+    };
+}
+
+let runtime = createState();
+
+function normalizeBoardId(boardId) {
+    return String(boardId ?? '').trim();
+}
+
+function normalizeNodeSnapshot(node) {
+    if (!node || typeof node !== 'object') {
+        return null;
+    }
+
+    const id = String(node.id || '').trim();
+    if (!id) {
+        return null;
+    }
+
+    const minX = Number(node.minX || 0);
+    const maxX = Number(node.maxX || minX);
+    const minY = Number(node.minY || 0);
+    const maxY = Number(node.maxY || minY);
+
+    return {
+        id,
+        contentType: String(node.contentType || '').trim().toLowerCase(),
+        textLike: node.textLike === true,
+        x: Number(node.x || minX),
+        y: Number(node.y || maxY),
+        z: Number(node.z || 0),
+        width: Math.max(1, Number(node.width || (maxX - minX) || 1)),
+        height: Math.max(1, Number(node.height || (maxY - minY) || 1)),
+        minX,
+        maxX,
+        minY,
+        maxY,
+        cellKeys: Array.isArray(node.cellKeys)
+            ? node.cellKeys.map((key) => String(key || '').trim()).filter(Boolean)
+            : []
+    };
+}
+
+function clearState(boardId, cellSize) {
+    runtime = createState();
+    runtime.boardId = normalizeBoardId(boardId);
+    runtime.cellSize = Math.max(1, Number(cellSize || 500));
+}
+
+function removeNodeFromGrid(nodeId, node) {
+    const normalizedId = String(nodeId || '').trim();
+    if (!normalizedId || !node?.cellKeys) {
+        return;
+    }
+
+    for (let i = 0; i < node.cellKeys.length; i++) {
+        const key = node.cellKeys[i];
+        const cell = runtime.spatialGrid.get(key);
+        if (!cell) {
+            continue;
+        }
+
+        cell.delete(normalizedId);
+        if (cell.size === 0) {
+            runtime.spatialGrid.delete(key);
+        }
+    }
+}
+
+function upsertNode(node) {
+    const normalizedNode = normalizeNodeSnapshot(node);
+    if (!normalizedNode) {
+        return;
+    }
+
+    const existing = runtime.nodes.get(normalizedNode.id);
+    if (existing) {
+        removeNodeFromGrid(normalizedNode.id, existing);
+    }
+
+    runtime.nodes.set(normalizedNode.id, normalizedNode);
+    for (let i = 0; i < normalizedNode.cellKeys.length; i++) {
+        const key = normalizedNode.cellKeys[i];
+        let cell = runtime.spatialGrid.get(key);
+        if (!cell) {
+            cell = new Set();
+            runtime.spatialGrid.set(key, cell);
+        }
+        cell.add(normalizedNode.id);
+    }
+}
+
+function removeNode(nodeId) {
+    const normalizedId = String(nodeId || '').trim();
+    if (!normalizedId) {
+        return;
+    }
+
+    const existing = runtime.nodes.get(normalizedId);
+    if (!existing) {
+        return;
+    }
+
+    removeNodeFromGrid(normalizedId, existing);
+    runtime.nodes.delete(normalizedId);
+    runtime.lastVisibleIds.delete(normalizedId);
+}
+
+function rebuildBoard(boardId, cellSize, nodes) {
+    clearState(boardId, cellSize);
+    const sourceNodes = Array.isArray(nodes) ? nodes : [];
+    for (let i = 0; i < sourceNodes.length; i++) {
+        upsertNode(sourceNodes[i]);
+    }
+}
+
+function getVisibilityMarginPolicy(cameraZ, isPanning = false, isCtrlWheelVerticalScrolling = false) {
+    let cullingMarginPx = 3000;
+    let maxMarginCells = 6;
+    let useCoarseVisibility = false;
+
+    if (cameraZ < 4500) {
+        cullingMarginPx = 1000;
+        maxMarginCells = 4;
+    } else if (cameraZ < 12000) {
+        cullingMarginPx = 2200;
+        maxMarginCells = 5;
+    } else if (cameraZ < 30000) {
+        cullingMarginPx = 900;
+        maxMarginCells = 2;
+    } else {
+        cullingMarginPx = 240;
+        maxMarginCells = 1;
+        useCoarseVisibility = isPanning !== true;
+    }
+
+    if (isPanning === true) {
+        if (cameraZ < 4500) {
+            cullingMarginPx += 500;
+            maxMarginCells += 1;
+        } else if (cameraZ < 12000) {
+            cullingMarginPx += 700;
+            maxMarginCells += 1;
+        } else if (cameraZ < 30000) {
+            cullingMarginPx += 600;
+            maxMarginCells += 1;
+        } else {
+            cullingMarginPx += 320;
+            maxMarginCells += 1;
+        }
+    }
+
+    if (isCtrlWheelVerticalScrolling && cameraZ < 12000) {
+        cullingMarginPx += (cameraZ < 4500) ? 700 : 900;
+        maxMarginCells += 2;
+    }
+
+    return {
+        cullingMarginPx,
+        maxMarginCells,
+        useCoarseVisibility
+    };
+}
+
+function describeCellRange(rect, cellSize) {
+    if (!rect) {
+        return null;
+    }
+
+    const left = Number(rect.left);
+    const right = Number(rect.right);
+    const bottom = Number(rect.bottom);
+    const top = Number(rect.top);
+    if (!Number.isFinite(left) || !Number.isFinite(right) || !Number.isFinite(bottom) || !Number.isFinite(top)) {
+        return null;
+    }
+    if (right < left || top < bottom) {
+        return null;
+    }
+
+    const startCellX = Math.floor(left / cellSize);
+    const endCellX = Math.floor(right / cellSize);
+    const startCellY = Math.floor(bottom / cellSize);
+    const endCellY = Math.floor(top / cellSize);
+    const spanX = Math.max(0, endCellX - startCellX + 1);
+    const spanY = Math.max(0, endCellY - startCellY + 1);
+
+    return {
+        startCellX,
+        endCellX,
+        startCellY,
+        endCellY,
+        spanX,
+        spanY,
+        directGridLookups: spanX * spanY
+    };
+}
+
+function intersectsRect(node, rect) {
+    if (!node || !rect) {
+        return false;
+    }
+
+    return !(
+        node.maxX < rect.left ||
+        node.minX > rect.right ||
+        node.maxY < rect.bottom ||
+        node.minY > rect.top
+    );
+}
+
+function collectCandidates(range) {
+    const candidateIds = new Set();
+    let usedPopulatedCellScan = false;
+
+    if (!range) {
+        runtime.nodes.forEach((_, nodeId) => candidateIds.add(nodeId));
+        return {
+            candidateIds,
+            usedPopulatedCellScan,
+            directGridLookups: 0,
+            gridSpanX: 0,
+            gridSpanY: 0
+        };
+    }
+
+    if (range.directGridLookups > MAX_DIRECT_GRID_LOOKUPS) {
+        usedPopulatedCellScan = true;
+        runtime.spatialGrid.forEach((nodeIds, key) => {
+            const separatorIndex = key.indexOf(':');
+            if (separatorIndex <= 0) {
+                return;
+            }
+
+            const cx = Number(key.slice(0, separatorIndex));
+            const cy = Number(key.slice(separatorIndex + 1));
+            if (!Number.isFinite(cx) || !Number.isFinite(cy)) {
+                return;
+            }
+
+            if (cx >= range.startCellX && cx <= range.endCellX && cy >= range.startCellY && cy <= range.endCellY) {
+                nodeIds.forEach((nodeId) => candidateIds.add(nodeId));
+            }
+        });
+    } else {
+        for (let cx = range.startCellX; cx <= range.endCellX; cx++) {
+            for (let cy = range.startCellY; cy <= range.endCellY; cy++) {
+                const cell = runtime.spatialGrid.get(`${cx}:${cy}`);
+                if (!cell) {
+                    continue;
+                }
+                cell.forEach((nodeId) => candidateIds.add(nodeId));
+            }
+        }
+    }
+
+    runtime.lastVisibleIds.forEach((nodeId) => {
+        if (runtime.nodes.has(nodeId)) {
+            candidateIds.add(nodeId);
+        }
+    });
+
+    return {
+        candidateIds,
+        usedPopulatedCellScan,
+        directGridLookups: range.directGridLookups,
+        gridSpanX: range.spanX,
+        gridSpanY: range.spanY
+    };
+}
+
+function buildCellKeySetFromRange(range, targetSet) {
+    if (!range || !targetSet) {
+        return;
+    }
+
+    for (let cx = range.startCellX; cx <= range.endCellX; cx++) {
+        for (let cy = range.startCellY; cy <= range.endCellY; cy++) {
+            targetSet.add(`${cx}:${cy}`);
+        }
+    }
+}
+
+function addCandidatesFromCellKeySet(cellKeys, candidateIds, skipPreviouslyVisible = false) {
+    if (!cellKeys || !candidateIds || cellKeys.size === 0) {
+        return;
+    }
+
+    cellKeys.forEach((key) => {
+        const nodeIds = runtime.spatialGrid.get(key);
+        if (!nodeIds) {
+            return;
+        }
+
+        nodeIds.forEach((nodeId) => {
+            if (skipPreviouslyVisible && runtime.lastVisibleIds.has(nodeId)) {
+                return;
+            }
+
+            candidateIds.add(nodeId);
+        });
+    });
+}
+
+function normalizeHitTestCellRadius(cellRadius) {
+    const normalized = Math.round(Number(cellRadius || DEFAULT_HIT_TEST_CELL_RADIUS));
+    if (!Number.isFinite(normalized)) {
+        return DEFAULT_HIT_TEST_CELL_RADIUS;
+    }
+
+    return Math.max(0, Math.min(MAX_HIT_TEST_CELL_RADIUS, normalized));
+}
+
+function collectHitTestCandidateIds(centerCellX, centerCellY, cellRadius) {
+    const candidateIds = new Set();
+    const normalizedCellRadius = normalizeHitTestCellRadius(cellRadius);
+    let cellLookups = 0;
+
+    for (let offsetX = -normalizedCellRadius; offsetX <= normalizedCellRadius; offsetX++) {
+        for (let offsetY = -normalizedCellRadius; offsetY <= normalizedCellRadius; offsetY++) {
+            cellLookups++;
+            const cell = runtime.spatialGrid.get(`${centerCellX + offsetX}:${centerCellY + offsetY}`);
+            if (!cell) {
+                continue;
+            }
+
+            cell.forEach((nodeId) => candidateIds.add(nodeId));
+        }
+    }
+
+    return {
+        candidateIds,
+        cellLookups,
+        cellRadius: normalizedCellRadius
+    };
+}
+
+function normalizeSelectionRect(rect) {
+    if (!rect || typeof rect !== 'object') {
+        return null;
+    }
+
+    const left = Number(rect.left);
+    const right = Number(rect.right);
+    const bottom = Number(rect.bottom);
+    const top = Number(rect.top);
+    if (!Number.isFinite(left) || !Number.isFinite(right) || !Number.isFinite(bottom) || !Number.isFinite(top)) {
+        return null;
+    }
+
+    return {
+        left: Math.min(left, right),
+        right: Math.max(left, right),
+        bottom: Math.min(bottom, top),
+        top: Math.max(bottom, top)
+    };
+}
+
+function buildPriorityIds(visibleIds, camX, camY) {
+    const buffer = [];
+    visibleIds.forEach((nodeId) => {
+        const node = runtime.nodes.get(nodeId);
+        if (!node) {
+            return;
+        }
+
+        const dx = Number(node.x || 0) - camX;
+        const dy = Number(node.y || 0) - camY;
+        const distSq = (dx * dx) + (dy * dy);
+        const textPriority = node.textLike === true ? 0 : 1;
+        const mediaPriority = node.contentType === 'image' ? 0 : 1;
+        buffer.push({ nodeId, textPriority, mediaPriority, distSq });
+    });
+
+    buffer.sort((a, b) => {
+        if (a.textPriority !== b.textPriority) {
+            return a.textPriority - b.textPriority;
+        }
+        if (a.mediaPriority !== b.mediaPriority) {
+            return a.mediaPriority - b.mediaPriority;
+        }
+        return a.distSq - b.distSq;
+    });
+
+    return buffer.map((entry) => entry.nodeId);
+}
+
+function buildIncrementalPriorityIds(nextVisibleIds, enteredIds, camX, camY) {
+    const priorityIds = [];
+    const used = new Set();
+
+    if (Array.isArray(runtime.lastPriorityIds)) {
+        for (let i = 0; i < runtime.lastPriorityIds.length; i++) {
+            const nodeId = String(runtime.lastPriorityIds[i] || '').trim();
+            if (!nodeId || used.has(nodeId) || !nextVisibleIds.has(nodeId)) {
+                continue;
+            }
+
+            priorityIds.push(nodeId);
+            used.add(nodeId);
+        }
+    }
+
+    const enteredSet = new Set();
+    if (Array.isArray(enteredIds)) {
+        for (let i = 0; i < enteredIds.length; i++) {
+            const nodeId = String(enteredIds[i] || '').trim();
+            if (nodeId && nextVisibleIds.has(nodeId) && !used.has(nodeId)) {
+                enteredSet.add(nodeId);
+            }
+        }
+    }
+
+    if (enteredSet.size > 0) {
+        const enteredPriorityIds = buildPriorityIds(enteredSet, camX, camY);
+        for (let i = 0; i < enteredPriorityIds.length; i++) {
+            const nodeId = enteredPriorityIds[i];
+            if (!used.has(nodeId)) {
+                priorityIds.push(nodeId);
+                used.add(nodeId);
+            }
+        }
+    }
+
+    if (priorityIds.length !== nextVisibleIds.size) {
+        return buildPriorityIds(nextVisibleIds, camX, camY);
+    }
+
+    return priorityIds;
+}
+
+function handleVisibilityQuery(message) {
+    const boardId = normalizeBoardId(message.boardId);
+    if (!boardId || boardId !== runtime.boardId) {
+        return;
+    }
+
+    const t0 = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+
+    const camera = message.camera || {};
+    const state = message.state || {};
+    const seq = Number(message.seq || 0);
+    const previousResultSeq = Math.max(0, Math.floor(Number(runtime.lastResultSeq || 0)));
+    const mainLastAppliedSeq = Math.max(0, Math.floor(Number(message.mainLastAppliedSeq || 0)));
+    const cellSize = Math.max(1, Number(message.cellSize || runtime.cellSize || 500));
+    const camX = Number(camera.x || 0);
+    const camY = Number(camera.y || 0);
+    const camZ = Number(camera.z || 0);
+    const camNear = Number(camera.near || 0);
+    const camFar = Number(camera.far || Number.MAX_SAFE_INTEGER);
+    const viewportW = Math.max(1, Number(camera.viewportW || 1));
+    const viewportH = Math.max(1, Number(camera.viewportH || 1));
+    const aspect = Math.max(0.1, Number(camera.aspect || 1));
+    const fov = Number(camera.fov || 45);
+    const isPanning = state.isPanning === true;
+    const isZooming = state.isZooming === true;
+    const isFullResMode = state.isFullResMode === true;
+    const isCtrlWheelVerticalScrolling = state.isCtrlWheelVerticalScrolling === true;
+
+    const marginPolicy = getVisibilityMarginPolicy(camZ, isPanning, isCtrlWheelVerticalScrolling);
+    let marginWorld = 0;
+    let verticalLeadMarginTopWorld = 0;
+    let verticalLeadMarginBottomWorld = 0;
+    let horizontalLeadMarginLeftWorld = 0;
+    let horizontalLeadMarginRightWorld = 0;
+
+    const vfov = (fov * Math.PI) / 180;
+    const viewHeight = 2 * Math.tan(vfov / 2) * Math.max(1, camZ);
+    const viewWidth = viewHeight * aspect;
+    const worldPerPxX = viewWidth / viewportW;
+    const worldPerPxY = viewHeight / viewportH;
+    const rawMarginWorld = marginPolicy.cullingMarginPx * Math.max(worldPerPxX, worldPerPxY);
+    marginWorld = Math.min(rawMarginWorld, cellSize * marginPolicy.maxMarginCells);
+
+    if (isCtrlWheelVerticalScrolling && camZ < 12000) {
+        const directionalLeadWorld = Math.min(
+            rawMarginWorld * 0.8,
+            cellSize * Math.max(1, marginPolicy.maxMarginCells - 1)
+        );
+        const lastCtrlWheelDeltaY = Number(state.lastCtrlWheelDeltaY || 0);
+        if (lastCtrlWheelDeltaY < -0.01) {
+            verticalLeadMarginTopWorld = directionalLeadWorld;
+        } else if (lastCtrlWheelDeltaY > 0.01) {
+            verticalLeadMarginBottomWorld = directionalLeadWorld;
+        } else {
+            verticalLeadMarginTopWorld = directionalLeadWorld * 0.5;
+            verticalLeadMarginBottomWorld = directionalLeadWorld * 0.5;
+        }
+    }
+
+    if (isPanning && camZ < 12000) {
+        const panLeadWorld = Math.min(
+            rawMarginWorld * (camZ < 4500 ? 1.35 : 1.1),
+            cellSize * Math.max(1, marginPolicy.maxMarginCells)
+        );
+        const panDx = Number(state.lastPanWorldDeltaX || 0);
+        const panDy = Number(state.lastPanWorldDeltaY || 0);
+        if (panDx > 0.01) {
+            horizontalLeadMarginRightWorld = panLeadWorld;
+        } else if (panDx < -0.01) {
+            horizontalLeadMarginLeftWorld = panLeadWorld;
+        }
+        if (panDy > 0.01) {
+            verticalLeadMarginTopWorld = Math.max(verticalLeadMarginTopWorld, panLeadWorld);
+        } else if (panDy < -0.01) {
+            verticalLeadMarginBottomWorld = Math.max(verticalLeadMarginBottomWorld, panLeadWorld);
+        }
+    }
+
+    const halfVisibleW = viewWidth / 2;
+    const halfVisibleH = viewHeight / 2;
+    const viewportLeft = camX - halfVisibleW;
+    const viewportRight = camX + halfVisibleW;
+    const viewportBottom = camY - halfVisibleH;
+    const viewportTop = camY + halfVisibleH;
+    const enterMarginWorld = marginWorld;
+    const exitMarginWorld = marginWorld * FULL_RES_VISIBILITY_EXIT_MARGIN_SCALE;
+
+    const currentEnterRect = {
+        left: viewportLeft - (enterMarginWorld + horizontalLeadMarginLeftWorld),
+        right: viewportRight + (enterMarginWorld + horizontalLeadMarginRightWorld),
+        bottom: viewportBottom - (enterMarginWorld + verticalLeadMarginBottomWorld),
+        top: viewportTop + (enterMarginWorld + verticalLeadMarginTopWorld)
+    };
+    const currentPreserveRect = {
+        left: viewportLeft - (exitMarginWorld + horizontalLeadMarginLeftWorld),
+        right: viewportRight + (exitMarginWorld + horizontalLeadMarginRightWorld),
+        bottom: viewportBottom - (exitMarginWorld + verticalLeadMarginBottomWorld),
+        top: viewportTop + (exitMarginWorld + verticalLeadMarginTopWorld)
+    };
+
+    const previousVisibilityRect = runtime.lastVisibilityRect || null;
+    const currentRange = describeCellRange(currentEnterRect, cellSize);
+    let candidateIds = new Set();
+    let usedPopulatedCellScan = false;
+    let directGridLookups = Number(currentRange?.directGridLookups || 0);
+    let gridSpanX = Number(currentRange?.spanX || 0);
+    let gridSpanY = Number(currentRange?.spanY || 0);
+    const previousVisibleCount = runtime.lastVisibleIds.size;
+    const nextVisibleIds = new Set();
+    let usedIncrementalPanVisibility = false;
+    let incrementalPanBandCount = 0;
+    let incrementalPanCellLookups = 0;
+    const canAttemptIncrementalFullResPan =
+        isFullResMode === true &&
+        isPanning === true &&
+        isZooming !== true &&
+        state.isWindowResizing !== true &&
+        state.isResizing !== true &&
+        previousVisibilityRect?.mode === 'full-res' &&
+        runtime.lastNodeCount === runtime.nodes.size &&
+        Math.abs(Number(previousVisibilityRect?.cameraZ || 0) - camZ) < 0.01 &&
+        runtime.lastVisibleIds.size > 0;
+
+    if (canAttemptIncrementalFullResPan && currentRange) {
+        const prevRect = previousVisibilityRect;
+        const epsilon = 0.01;
+        const incrementalBands = [];
+
+        if (currentEnterRect.left < Number(prevRect.left) - epsilon) {
+            incrementalBands.push({
+                left: currentEnterRect.left,
+                right: Math.min(currentEnterRect.right, Number(prevRect.left)),
+                bottom: currentEnterRect.bottom,
+                top: currentEnterRect.top
+            });
+        }
+        if (currentEnterRect.right > Number(prevRect.right) + epsilon) {
+            incrementalBands.push({
+                left: Math.max(currentEnterRect.left, Number(prevRect.right)),
+                right: currentEnterRect.right,
+                bottom: currentEnterRect.bottom,
+                top: currentEnterRect.top
+            });
+        }
+        if (currentEnterRect.bottom < Number(prevRect.bottom) - epsilon) {
+            incrementalBands.push({
+                left: currentEnterRect.left,
+                right: currentEnterRect.right,
+                bottom: currentEnterRect.bottom,
+                top: Math.min(currentEnterRect.top, Number(prevRect.bottom))
+            });
+        }
+        if (currentEnterRect.top > Number(prevRect.top) + epsilon) {
+            incrementalBands.push({
+                left: currentEnterRect.left,
+                right: currentEnterRect.right,
+                bottom: Math.max(currentEnterRect.bottom, Number(prevRect.top)),
+                top: currentEnterRect.top
+            });
+        }
+
+        const incrementalCellKeys = new Set();
+        for (let i = 0; i < incrementalBands.length; i++) {
+            const bandRange = describeCellRange(incrementalBands[i], cellSize);
+            if (!bandRange || bandRange.directGridLookups <= 0) {
+                continue;
+            }
+
+            incrementalPanBandCount++;
+            buildCellKeySetFromRange(bandRange, incrementalCellKeys);
+        }
+
+        if (incrementalPanBandCount > 0 &&
+            incrementalCellKeys.size > 0 &&
+            incrementalCellKeys.size < directGridLookups) {
+            usedIncrementalPanVisibility = true;
+            incrementalPanCellLookups = incrementalCellKeys.size;
+
+            runtime.lastVisibleIds.forEach((nodeId) => {
+                if (runtime.nodes.has(nodeId)) {
+                    nextVisibleIds.add(nodeId);
+                }
+            });
+            addCandidatesFromCellKeySet(incrementalCellKeys, candidateIds, true);
+        }
+    }
+
+    if (!usedIncrementalPanVisibility) {
+        const result = collectCandidates(currentRange);
+        candidateIds = result.candidateIds;
+        usedPopulatedCellScan = result.usedPopulatedCellScan;
+        directGridLookups = result.directGridLookups;
+        gridSpanX = result.gridSpanX;
+        gridSpanY = result.gridSpanY;
+    }
+
+    candidateIds.forEach((nodeId) => {
+        const node = runtime.nodes.get(nodeId);
+        if (!node) {
+            return;
+        }
+
+        const depth = camZ - node.z;
+        if (depth <= camNear || depth >= camFar) {
+            return;
+        }
+
+        const baseMarginWorld = runtime.lastVisibleIds.has(nodeId)
+            ? exitMarginWorld
+            : enterMarginWorld;
+        const leftBound = viewportLeft - (baseMarginWorld + horizontalLeadMarginLeftWorld);
+        const rightBound = viewportRight + (baseMarginWorld + horizontalLeadMarginRightWorld);
+        const bottomBound = viewportBottom - (baseMarginWorld + verticalLeadMarginBottomWorld);
+        const topBound = viewportTop + (baseMarginWorld + verticalLeadMarginTopWorld);
+
+        const isVisible = !(
+            node.maxX < leftBound ||
+            node.minX > rightBound ||
+            node.maxY < bottomBound ||
+            node.minY > topBound
+        );
+
+        if (isVisible) {
+            nextVisibleIds.add(nodeId);
+        }
+    });
+
+    const enteredIds = [];
+    nextVisibleIds.forEach((nodeId) => {
+        if (!runtime.lastVisibleIds.has(nodeId)) {
+            enteredIds.push(nodeId);
+        }
+    });
+
+    const exitedIds = [];
+    runtime.lastVisibleIds.forEach((nodeId) => {
+        if (!usedIncrementalPanVisibility && !nextVisibleIds.has(nodeId)) {
+            exitedIds.push(nodeId);
+        }
+    });
+
+    const priorityIds = usedIncrementalPanVisibility
+        ? buildIncrementalPriorityIds(nextVisibleIds, enteredIds, camX, camY)
+        : buildPriorityIds(nextVisibleIds, camX, camY);
+    const visibilityChanged = enteredIds.length > 0 || exitedIds.length > 0;
+
+    runtime.lastVisibleIds = nextVisibleIds;
+    runtime.lastPriorityIds = priorityIds;
+    runtime.lastVisibilityRect = {
+        left: currentEnterRect.left,
+        right: currentEnterRect.right,
+        bottom: currentEnterRect.bottom,
+        top: currentEnterRect.top,
+        mode: isFullResMode === true ? 'full-res' : 'lod',
+        cameraZ: camZ
+    };
+    runtime.lastNodeCount = runtime.nodes.size;
+    runtime.lastResultSeq = seq;
+
+    const t1 = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+
+    const canOmitFullVisibleIds =
+        usedIncrementalPanVisibility === true &&
+        mainLastAppliedSeq > 0 &&
+        mainLastAppliedSeq === previousResultSeq &&
+        seq === previousResultSeq + 1;
+
+    self.postMessage({
+        type: 'VISIBILITY_RESULT',
+        boardId,
+        seq,
+        visibleIds: canOmitFullVisibleIds ? undefined : Array.from(nextVisibleIds),
+        visibleCount: Number(nextVisibleIds.size || 0),
+        enteredIds,
+        exitedIds,
+        priorityIds,
+        visibilityChanged,
+        viewportRect: runtime.lastVisibilityRect,
+        lastVisibilityNodeCount: runtime.lastNodeCount,
+        fullResVisibilityReconcilePending: usedIncrementalPanVisibility === true,
+        profile: {
+            durationMs: Number(Math.max(0, t1 - t0).toFixed(2)),
+            cameraZ: Number((camZ || 0).toFixed(2)),
+            useCoarseVisibility: marginPolicy.useCoarseVisibility === true,
+            marginWorld: Number((marginWorld || 0).toFixed(2)),
+            gridSpanX: Number(gridSpanX || 0),
+            gridSpanY: Number(gridSpanY || 0),
+            directGridLookups: Number(directGridLookups || 0),
+            usedPopulatedCellScan: usedPopulatedCellScan === true,
+            incrementalPanMode: usedIncrementalPanVisibility === true,
+            incrementalPanBandCount,
+            incrementalPanCellLookups,
+            omittedFullVisibleIds: canOmitFullVisibleIds === true,
+            candidateCount: Number(candidateIds.size || 0),
+            processedCount: Number(candidateIds.size || 0),
+            prevVisibleCount: Number(previousVisibleCount || 0),
+            nextVisibleCount: Number(nextVisibleIds.size || 0),
+            visibilityChanged: visibilityChanged === true
+        }
+    });
+}
+
+function handleHitTestQuery(message) {
+    const boardId = normalizeBoardId(message.boardId);
+    if (!boardId || boardId !== runtime.boardId) {
+        return;
+    }
+
+    const seq = Number(message.seq || 0);
+    const cellX = Math.floor(Number(message.cellX || 0));
+    const cellY = Math.floor(Number(message.cellY || 0));
+    const t0 = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+    const { candidateIds, cellLookups, cellRadius } = collectHitTestCandidateIds(
+        cellX,
+        cellY,
+        message.cellRadius
+    );
+    const t1 = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+
+    self.postMessage({
+        type: 'HIT_TEST_RESULT',
+        boardId,
+        seq,
+        cellX,
+        cellY,
+        cellRadius,
+        rangeKey: `${cellX}:${cellY}:${cellRadius}`,
+        candidateIds: Array.from(candidateIds),
+        profile: {
+            durationMs: Number(Math.max(0, t1 - t0).toFixed(2)),
+            cellLookups,
+            candidateCount: Number(candidateIds.size || 0),
+            spatialGridCellCount: Number(runtime.spatialGrid.size || 0)
+        }
+    });
+}
+
+function handleSelectionQuery(message) {
+    const boardId = normalizeBoardId(message.boardId);
+    if (!boardId || boardId !== runtime.boardId) {
+        return;
+    }
+
+    const rect = normalizeSelectionRect(message.selectionRect);
+    if (!rect) {
+        return;
+    }
+
+    const seq = Number(message.seq || 0);
+    const t0 = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+    const range = describeCellRange(rect, Math.max(1, Number(message.cellSize || runtime.cellSize || 500)));
+    const { candidateIds, usedPopulatedCellScan, directGridLookups, gridSpanX, gridSpanY } = collectCandidates(range);
+    const selectedIds = [];
+
+    candidateIds.forEach((nodeId) => {
+        const node = runtime.nodes.get(nodeId);
+        if (!node) {
+            return;
+        }
+
+        if (node.minX >= rect.left &&
+            node.maxX <= rect.right &&
+            node.minY >= rect.bottom &&
+            node.maxY <= rect.top) {
+            selectedIds.push(nodeId);
+        }
+    });
+
+    const t1 = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+
+    self.postMessage({
+        type: 'SELECTION_QUERY_RESULT',
+        boardId,
+        seq,
+        selectedIds,
+        selectionRect: rect,
+        profile: {
+            durationMs: Number(Math.max(0, t1 - t0).toFixed(2)),
+            candidateCount: Number(candidateIds.size || 0),
+            selectedCount: Number(selectedIds.length || 0),
+            gridSpanX: Number(gridSpanX || 0),
+            gridSpanY: Number(gridSpanY || 0),
+            directGridLookups: Number(directGridLookups || 0),
+            usedPopulatedCellScan: usedPopulatedCellScan === true
+        }
+    });
+}
+
+self.onmessage = function (event) {
+    const message = event?.data || null;
+    if (!message || typeof message !== 'object') {
+        return;
+    }
+
+    switch (message.type) {
+        case 'RESET_BOARD':
+            clearState(message.boardId, message.cellSize);
+            break;
+        case 'REBUILD_BOARD':
+            rebuildBoard(message.boardId, message.cellSize, message.nodes);
+            break;
+        case 'UPSERT_NODE':
+            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+                upsertNode(message.node);
+            }
+            break;
+        case 'REMOVE_NODE':
+            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+                removeNode(message.nodeId);
+            }
+            break;
+        case 'VISIBILITY_QUERY':
+            handleVisibilityQuery(message);
+            break;
+        case 'HIT_TEST_QUERY':
+            handleHitTestQuery(message);
+            break;
+        case 'SELECTION_QUERY':
+            handleSelectionQuery(message);
+            break;
+        default:
+            break;
+    }
+};
+
+self.postMessage({
+    type: 'READY',
+    worker: 'visibility'
+});