@mindexec/cli 0.2.339 → 0.2.341

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

@@ -1,890 +0,0 @@
-'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'
-});