@mindexec/cli 0.2.478 → 0.2.480

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

@@ -1,895 +1,895 @@
-'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 visibilityChanged = enteredIds.length > 0 || exitedIds.length > 0;
-    const canReusePriorityIds =
-        visibilityChanged !== true &&
-        Array.isArray(runtime.lastPriorityIds) &&
-        runtime.lastPriorityIds.length === nextVisibleIds.size;
-    const priorityIds = canReusePriorityIds
-        ? runtime.lastPriorityIds
-        : (usedIncrementalPanVisibility
-            ? buildIncrementalPriorityIds(nextVisibleIds, enteredIds, camX, camY)
-            : buildPriorityIds(nextVisibleIds, camX, camY));
-
-    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 =
-        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: canReusePriorityIds ? undefined : 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'
-});
+'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 visibilityChanged = enteredIds.length > 0 || exitedIds.length > 0;
+    const canReusePriorityIds =
+        visibilityChanged !== true &&
+        Array.isArray(runtime.lastPriorityIds) &&
+        runtime.lastPriorityIds.length === nextVisibleIds.size;
+    const priorityIds = canReusePriorityIds
+        ? runtime.lastPriorityIds
+        : (usedIncrementalPanVisibility
+            ? buildIncrementalPriorityIds(nextVisibleIds, enteredIds, camX, camY)
+            : buildPriorityIds(nextVisibleIds, camX, camY));
+
+    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 =
+        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: canReusePriorityIds ? undefined : 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'
+});