@rezi-ui/core 0.1.0-alpha.9 → 0.1.0-beta.1

package/dist/app/widgetRenderer/mouseRouting.js

@@ -0,0 +1,1357 @@
+import { ZR_MOD_CTRL, ZR_MOD_SHIFT } from "../../keybindings/keyCodes.js";
+import { computeDropdownWindow } from "../../layout/dropdownGeometry.js";
+import { measureTextCells } from "../../layout/textMeasure.js";
+import { hitTestLayers } from "../../runtime/layers.js";
+import { routeVirtualListWheel, routeWheel } from "../../runtime/router.js";
+import { flattenVisibleFilePickerNodes } from "../../widgets/filePicker.js";
+import { applyFilters } from "../../widgets/logsConsole.js";
+import { computePanelCellSizes, handleDividerDrag, sizesToPercentages, } from "../../widgets/splitPane.js";
+import { computeSelection, distributeColumnWidths } from "../../widgets/table.js";
+import { TOAST_HEIGHT, getToastActionFocusId } from "../../widgets/toast.js";
+import { flattenTree } from "../../widgets/tree.js";
+import { clampScrollTop, computeVisibleRange, getItemHeight, getItemOffset, getTotalHeight, resolveVirtualListItemHeightSpec, } from "../../widgets/virtualList.js";
+import { fileNodeGetChildren, fileNodeGetKey, fileNodeHasChildren, makeFileNodeFlatCache, makeFilePickerFlatCache, readFileNodeFlatCache, readFilePickerFlatCache, } from "./fileNodeCache.js";
+import { computeFilePickerMouseSelection, getFilePickerActiveKey } from "./filePickerRouting.js";
+const NODE_ENV = globalThis.process?.env?.NODE_ENV ??
+    "development";
+const DEV_MODE = NODE_ENV !== "production";
+function warnDev(message) {
+    if (!DEV_MODE)
+        return;
+    const c = globalThis.console;
+    c?.warn?.(message);
+}
+function describeThrown(v) {
+    if (v instanceof Error)
+        return v.message;
+    try {
+        return String(v);
+    }
+    catch {
+        return "[unstringifiable thrown value]";
+    }
+}
+const ROUTE_RENDER = Object.freeze({ needsRender: true });
+const ROUTE_NO_RENDER = Object.freeze({ needsRender: false });
+const EMPTY_STRING_ARRAY = Object.freeze([]);
+function invokeCallbackSafely(callback, ...args) {
+    if (typeof callback !== "function")
+        return false;
+    try {
+        callback(...args);
+        return true;
+    }
+    catch (e) {
+        const message = describeThrown(e);
+        warnDev(`[rezi] widget callback threw: ${message}`);
+        return false;
+    }
+}
+function clampIndexScrollTopForRows(scrollTop, totalRows, viewportRows) {
+    const maxScrollTop = Math.max(0, totalRows - viewportRows);
+    if (!Number.isFinite(scrollTop) || scrollTop <= 0)
+        return 0;
+    if (scrollTop >= maxScrollTop)
+        return maxScrollTop;
+    return Math.trunc(scrollTop);
+}
+export function routeDropdownMouse(event, ctx) {
+    if (event.kind !== "mouse")
+        return null;
+    const topLayerId = ctx.layerStack.length > 0 ? (ctx.layerStack[ctx.layerStack.length - 1] ?? null) : null;
+    const topDropdownId = ctx.dropdownStack.length > 0 ? (ctx.dropdownStack[ctx.dropdownStack.length - 1] ?? null) : null;
+    if (!topDropdownId || topLayerId !== `dropdown:${topDropdownId}`)
+        return null;
+    const dropdown = ctx.dropdownById.get(topDropdownId);
+    const dropdownRect = dropdown ? ctx.computeDropdownRect(dropdown) : null;
+    if (!dropdown || !dropdownRect || dropdownRect.w <= 0 || dropdownRect.h <= 0)
+        return null;
+    const inside = event.x >= dropdownRect.x &&
+        event.x < dropdownRect.x + dropdownRect.w &&
+        event.y >= dropdownRect.y &&
+        event.y < dropdownRect.y + dropdownRect.h;
+    const contentX = dropdownRect.x + 1;
+    const contentY = dropdownRect.y + 1;
+    const contentW = Math.max(0, dropdownRect.w - 2);
+    const contentH = Math.max(0, dropdownRect.h - 2);
+    const window = computeDropdownWindow(dropdown.items.length, ctx.dropdownSelectedIndexById.get(topDropdownId) ?? 0, contentH, ctx.dropdownWindowStartById.get(topDropdownId) ?? 0);
+    const itemAreaW = window.overflow ? Math.max(0, contentW - 1) : contentW;
+    const inContent = event.x >= contentX &&
+        event.x < contentX + itemAreaW &&
+        event.y >= contentY &&
+        event.y < contentY + contentH;
+    const itemIndex = inContent ? window.startIndex + (event.y - contentY) : null;
+    const MOUSE_KIND_DOWN = 3;
+    const MOUSE_KIND_UP = 4;
+    if (event.mouseKind === MOUSE_KIND_DOWN) {
+        ctx.setPressedDropdown(null);
+        if (!inside) {
+            if (dropdown.onClose) {
+                try {
+                    dropdown.onClose();
+                }
+                catch (e) {
+                    const message = describeThrown(e);
+                    warnDev(`[rezi] onClose callback threw: ${message}`);
+                }
+            }
+            return ROUTE_RENDER;
+        }
+        if (itemIndex !== null && itemIndex >= 0 && itemIndex < dropdown.items.length) {
+            const item = dropdown.items[itemIndex];
+            if (item && !item.divider && item.disabled !== true) {
+                const prevSelected = ctx.dropdownSelectedIndexById.get(topDropdownId) ?? 0;
+                ctx.dropdownSelectedIndexById.set(topDropdownId, itemIndex);
+                ctx.dropdownWindowStartById.set(topDropdownId, computeDropdownWindow(dropdown.items.length, itemIndex, contentH, ctx.dropdownWindowStartById.get(topDropdownId) ?? 0).startIndex);
+                ctx.setPressedDropdown(Object.freeze({ id: topDropdownId, itemId: item.id }));
+                return Object.freeze({ needsRender: itemIndex !== prevSelected });
+            }
+        }
+        return ROUTE_NO_RENDER;
+    }
+    if (event.mouseKind === MOUSE_KIND_UP) {
+        const pressed = ctx.pressedDropdown;
+        ctx.setPressedDropdown(null);
+        if (pressed && pressed.id === topDropdownId && itemIndex !== null) {
+            const item = dropdown.items[itemIndex];
+            if (item && item.id === pressed.itemId && !item.divider && item.disabled !== true) {
+                if (dropdown.onSelect) {
+                    try {
+                        dropdown.onSelect(item);
+                    }
+                    catch (e) {
+                        const message = describeThrown(e);
+                        warnDev(`[rezi] onSelect callback threw: ${message}`);
+                    }
+                }
+                if (dropdown.onClose) {
+                    try {
+                        dropdown.onClose();
+                    }
+                    catch (e) {
+                        const message = describeThrown(e);
+                        warnDev(`[rezi] onClose callback threw: ${message}`);
+                    }
+                }
+                return ROUTE_RENDER;
+            }
+        }
+        return ROUTE_NO_RENDER;
+    }
+    return ROUTE_NO_RENDER;
+}
+export function routeLayerBackdropMouse(event, ctx) {
+    if (event.kind !== "mouse")
+        return null;
+    const hit = hitTestLayers(ctx.layerRegistry, event.x, event.y);
+    if (!hit.blocked)
+        return null;
+    const blocking = hit.blockingLayer;
+    if (blocking &&
+        event.mouseKind === 3 &&
+        (ctx.closeOnBackdropByLayerId.get(blocking.id) ?? false) === true) {
+        const cb = ctx.onCloseByLayerId.get(blocking.id);
+        if (cb) {
+            try {
+                cb();
+            }
+            catch (e) {
+                const message = describeThrown(e);
+                warnDev(`[rezi] onClose callback threw: ${message}`);
+            }
+            return ROUTE_RENDER;
+        }
+    }
+    return ROUTE_NO_RENDER;
+}
+export function routeSplitPaneMouse(event, ctx) {
+    if (event.kind !== "mouse")
+        return null;
+    const MOUSE_KIND_DOWN = 3;
+    const MOUSE_KIND_UP = 4;
+    const MOUSE_KIND_WHEEL = 5;
+    if (ctx.splitPaneDrag) {
+        if (event.mouseKind === MOUSE_KIND_UP) {
+            if (ctx.splitPaneDrag.didDrag) {
+                ctx.setSplitPaneLastDividerDown(null);
+            }
+            ctx.setSplitPaneDrag(null);
+            return ROUTE_RENDER;
+        }
+        if (event.mouseKind !== MOUSE_KIND_WHEEL) {
+            const drag = ctx.splitPaneDrag;
+            const pane = ctx.splitPaneById.get(drag.id);
+            if (pane) {
+                const delta = drag.direction === "horizontal" ? event.x - drag.startX : event.y - drag.startY;
+                const didDrag = drag.didDrag || delta !== 0;
+                if (didDrag && !drag.didDrag) {
+                    ctx.setSplitPaneDrag(Object.freeze({ ...drag, didDrag: true }));
+                }
+                if (didDrag) {
+                    ctx.setSplitPaneLastDividerDown(null);
+                }
+                const nextCellSizes = handleDividerDrag(drag.startCellSizes, drag.dividerIndex, delta, drag.minSizes, drag.maxSizes);
+                const nextSizes = drag.sizeMode === "percent" ? sizesToPercentages(nextCellSizes) : nextCellSizes;
+                invokeCallbackSafely(pane.onChange, Object.freeze(nextSizes.slice()));
+                return ROUTE_RENDER;
+            }
+            ctx.setSplitPaneLastDividerDown(null);
+            ctx.setSplitPaneDrag(null);
+            return ROUTE_RENDER;
+        }
+        return null;
+    }
+    if (event.mouseKind !== MOUSE_KIND_DOWN)
+        return null;
+    for (const [id, pane] of ctx.splitPaneById) {
+        const rect = ctx.rectById.get(id);
+        if (!rect || rect.w <= 0 || rect.h <= 0)
+            continue;
+        if (event.x < rect.x ||
+            event.x >= rect.x + rect.w ||
+            event.y < rect.y ||
+            event.y >= rect.y + rect.h) {
+            continue;
+        }
+        const childRects = ctx.splitPaneChildRectsById.get(id) ?? Object.freeze([]);
+        if (childRects.length < 2)
+            continue;
+        const dividerSize = Math.max(1, pane.dividerSize ?? 1);
+        const direction = pane.direction;
+        const sizeMode = pane.sizeMode ?? "percent";
+        const minSizes = pane.minSizes;
+        const maxSizes = pane.maxSizes;
+        const expand = 1;
+        for (let i = 0; i < childRects.length - 1; i++) {
+            const a = childRects[i];
+            const b = childRects[i + 1];
+            if (!a || !b)
+                continue;
+            if (direction === "horizontal") {
+                const x0 = b.x - dividerSize;
+                const hitX0 = x0 - expand;
+                const hitX1 = x0 + dividerSize + expand;
+                if (event.x >= hitX0 && event.x < hitX1) {
+                    if ((event.buttons & 1) === 0)
+                        continue;
+                    const prevDown = ctx.splitPaneLastDividerDown;
+                    const DOUBLE_CLICK_MS = 500;
+                    if (pane.collapsible === true && pane.onCollapse) {
+                        if (prevDown &&
+                            prevDown.id === id &&
+                            prevDown.dividerIndex === i &&
+                            event.timeMs - prevDown.timeMs <= DOUBLE_CLICK_MS) {
+                            ctx.setSplitPaneLastDividerDown(null);
+                            const targetIndex = event.x < x0 ? i : event.x >= x0 + dividerSize ? i + 1 : i;
+                            const isCollapsed = pane.collapsed?.includes(targetIndex) ?? false;
+                            invokeCallbackSafely(pane.onCollapse, targetIndex, !isCollapsed);
+                            return ROUTE_RENDER;
+                        }
+                        ctx.setSplitPaneLastDividerDown(Object.freeze({
+                            id,
+                            dividerIndex: i,
+                            timeMs: event.timeMs,
+                        }));
+                    }
+                    else {
+                        ctx.setSplitPaneLastDividerDown(null);
+                    }
+                    const availableCells = rect.w;
+                    const startCellSizes = computePanelCellSizes(childRects.length, pane.sizes, availableCells, sizeMode, dividerSize, minSizes, maxSizes).sizes;
+                    ctx.setSplitPaneDrag(Object.freeze({
+                        id,
+                        dividerIndex: i,
+                        direction,
+                        sizeMode,
+                        dividerSize,
+                        minSizes,
+                        maxSizes,
+                        startX: event.x,
+                        startY: event.y,
+                        startCellSizes,
+                        availableCells,
+                        didDrag: false,
+                    }));
+                    return ROUTE_RENDER;
+                }
+            }
+            else {
+                const y0 = b.y - dividerSize;
+                const hitY0 = y0 - expand;
+                const hitY1 = y0 + dividerSize + expand;
+                if (event.y >= hitY0 && event.y < hitY1) {
+                    if ((event.buttons & 1) === 0)
+                        continue;
+                    const prevDown = ctx.splitPaneLastDividerDown;
+                    const DOUBLE_CLICK_MS = 500;
+                    if (pane.collapsible === true && pane.onCollapse) {
+                        if (prevDown &&
+                            prevDown.id === id &&
+                            prevDown.dividerIndex === i &&
+                            event.timeMs - prevDown.timeMs <= DOUBLE_CLICK_MS) {
+                            ctx.setSplitPaneLastDividerDown(null);
+                            const targetIndex = event.y < y0 ? i : event.y >= y0 + dividerSize ? i + 1 : i;
+                            const isCollapsed = pane.collapsed?.includes(targetIndex) ?? false;
+                            invokeCallbackSafely(pane.onCollapse, targetIndex, !isCollapsed);
+                            return ROUTE_RENDER;
+                        }
+                        ctx.setSplitPaneLastDividerDown(Object.freeze({
+                            id,
+                            dividerIndex: i,
+                            timeMs: event.timeMs,
+                        }));
+                    }
+                    else {
+                        ctx.setSplitPaneLastDividerDown(null);
+                    }
+                    const availableCells = rect.h;
+                    const startCellSizes = computePanelCellSizes(childRects.length, pane.sizes, availableCells, sizeMode, dividerSize, minSizes, maxSizes).sizes;
+                    ctx.setSplitPaneDrag(Object.freeze({
+                        id,
+                        dividerIndex: i,
+                        direction,
+                        sizeMode,
+                        dividerSize,
+                        minSizes,
+                        maxSizes,
+                        startX: event.x,
+                        startY: event.y,
+                        startCellSizes,
+                        availableCells,
+                        didDrag: false,
+                    }));
+                    return ROUTE_RENDER;
+                }
+            }
+        }
+    }
+    return null;
+}
+export function routeToastMouseDown(event, ctx, prevActiveZoneId) {
+    if (event.kind !== "mouse" || event.mouseKind !== 3 || ctx.toastContainers.length <= 0)
+        return null;
+    for (let i = ctx.toastContainers.length - 1; i >= 0; i--) {
+        const tc = ctx.toastContainers[i];
+        if (!tc)
+            continue;
+        const rect = tc.rect;
+        if (rect.w <= 0 || rect.h <= 0)
+            continue;
+        if (event.x < rect.x ||
+            event.x >= rect.x + rect.w ||
+            event.y < rect.y ||
+            event.y >= rect.y + rect.h) {
+            continue;
+        }
+        const toasts = tc.props.toasts;
+        const maxVisible = tc.props.maxVisible ?? 5;
+        const position = tc.props.position ?? "bottom-right";
+        const maxByHeight = Math.floor(rect.h / TOAST_HEIGHT);
+        const visibleCount = Math.min(toasts.length, maxVisible, maxByHeight);
+        for (let t = 0; t < visibleCount; t++) {
+            const toast = toasts[t];
+            if (!toast)
+                continue;
+            const toastY = position.startsWith("top")
+                ? rect.y + t * TOAST_HEIGHT
+                : rect.y + rect.h - (t + 1) * TOAST_HEIGHT;
+            if (event.y < toastY || event.y >= toastY + TOAST_HEIGHT)
+                continue;
+            if (toast.action && event.y === toastY + 1 && rect.w >= 10) {
+                const label = `[${toast.action.label}]`;
+                const lw = measureTextCells(label);
+                const ax = rect.x + rect.w - 2 - lw;
+                if (ax > rect.x + 4 && event.x >= ax && event.x < ax + lw) {
+                    const nextFocusState = Object.freeze({
+                        ...ctx.focusState,
+                        focusedId: getToastActionFocusId(toast.id),
+                        activeZoneId: null,
+                    });
+                    ctx.setFocusState(nextFocusState);
+                    if (nextFocusState.activeZoneId !== prevActiveZoneId) {
+                        ctx.invokeFocusZoneCallbacks(prevActiveZoneId, nextFocusState.activeZoneId, ctx.zoneMetaById, ctx.zoneMetaById);
+                    }
+                    invokeCallbackSafely(toast.action.onAction);
+                    return ROUTE_RENDER;
+                }
+            }
+            invokeCallbackSafely(tc.props.onClose, toast.id);
+            return ROUTE_RENDER;
+        }
+    }
+    return null;
+}
+function hitToolApprovalAction(rect, dialog, x, y) {
+    const buttonY = rect.y + rect.h - 2;
+    if (y !== buttonY)
+        return null;
+    const allowX = rect.x + 2;
+    if (x >= allowX && x < allowX + "[Allow]".length)
+        return "allow";
+    const denyX = rect.x + 12;
+    if (x >= denyX && x < denyX + "[Deny]".length)
+        return "deny";
+    if (dialog.onAllowForSession) {
+        const sessionX = rect.x + 21;
+        if (x >= sessionX && x < sessionX + "[Allow Session]".length)
+            return "allowSession";
+    }
+    return null;
+}
+export function routeToolApprovalDialogMouseClick(event, ctx) {
+    if (event.kind !== "mouse" || (event.mouseKind !== 3 && event.mouseKind !== 4))
+        return false;
+    const targetId = ctx.mouseTargetId;
+    const dialog = targetId !== null ? ctx.toolApprovalDialogById.get(targetId) : undefined;
+    const rect = targetId !== null ? ctx.rectById.get(targetId) : undefined;
+    const action = dialog && rect && dialog.open === true
+        ? hitToolApprovalAction(rect, dialog, event.x, event.y)
+        : null;
+    if (event.mouseKind === 3) {
+        const pressed = ctx.pressedToolApproval;
+        ctx.setPressedToolApproval(null);
+        if (pressed)
+            ctx.requestRender();
+        if (!targetId || !dialog || !rect || action === null)
+            return false;
+        ctx.focusedActionById.set(targetId, action);
+        ctx.setPressedToolApproval(Object.freeze({ id: targetId, action }));
+        return true;
+    }
+    const pressed = ctx.pressedToolApproval;
+    ctx.setPressedToolApproval(null);
+    if (!pressed || !targetId || pressed.id !== targetId || action !== pressed.action || !dialog) {
+        if (pressed)
+            ctx.requestRender();
+        return false;
+    }
+    if (action === "allowSession" && dialog.onAllowForSession) {
+        invokeCallbackSafely(dialog.onAllowForSession);
+        invokeCallbackSafely(dialog.onClose);
+        return true;
+    }
+    if (action === "allow" || action === "deny") {
+        invokeCallbackSafely(dialog.onPress, action);
+        invokeCallbackSafely(dialog.onClose);
+        return true;
+    }
+    return false;
+}
+export function routeVirtualListMouseClick(event, ctx) {
+    if (event.kind !== "mouse" || (event.mouseKind !== 3 && event.mouseKind !== 4))
+        return false;
+    const targetId = ctx.mouseTargetId;
+    let localNeedsRender = false;
+    if (targetId !== null) {
+        const vlist = ctx.virtualListById.get(targetId);
+        const rect = ctx.rectById.get(targetId);
+        if (vlist && rect) {
+            const state = ctx.virtualListStore.get(targetId);
+            const itemHeight = resolveVirtualListItemHeightSpec(vlist);
+            const measuredHeights = vlist.estimateItemHeight !== undefined &&
+                state.measuredHeights !== undefined &&
+                state.measuredItemCount === vlist.items.length
+                ? state.measuredHeights
+                : undefined;
+            const localY = event.y - rect.y;
+            const inBounds = localY >= 0 && localY < rect.h;
+            const computeIndex = () => {
+                if (!inBounds)
+                    return null;
+                const yInContent = state.scrollTop + localY;
+                if (yInContent < 0)
+                    return null;
+                if (vlist.items.length === 0)
+                    return null;
+                if (typeof itemHeight === "number" && measuredHeights === undefined) {
+                    const h = itemHeight;
+                    if (h <= 0)
+                        return null;
+                    return Math.floor(yInContent / h);
+                }
+                const { itemOffsets } = computeVisibleRange(vlist.items, itemHeight, 0, Number.MAX_SAFE_INTEGER, 0, measuredHeights);
+                let lo = 0;
+                let hi = vlist.items.length - 1;
+                while (lo <= hi) {
+                    const mid = (lo + hi) >>> 1;
+                    const start = itemOffsets[mid] ?? 0;
+                    const end = itemOffsets[mid + 1] ?? start;
+                    if (yInContent < start) {
+                        hi = mid - 1;
+                    }
+                    else if (yInContent >= end) {
+                        lo = mid + 1;
+                    }
+                    else {
+                        return mid;
+                    }
+                }
+                return null;
+            };
+            if (event.mouseKind === 3) {
+                const idx0 = computeIndex();
+                if (idx0 !== null) {
+                    const idx = Math.max(0, Math.min(vlist.items.length - 1, idx0));
+                    const prev = state.selectedIndex;
+                    ctx.virtualListStore.set(targetId, { selectedIndex: idx });
+                    ctx.setPressedVirtualList(Object.freeze({ id: targetId, index: idx }));
+                    if (idx !== prev)
+                        localNeedsRender = true;
+                }
+                else {
+                    ctx.setPressedVirtualList(null);
+                }
+            }
+            else {
+                const idx0 = computeIndex();
+                const pressed = ctx.pressedVirtualList;
+                ctx.setPressedVirtualList(null);
+                if (idx0 !== null && pressed && pressed.id === targetId) {
+                    const idx = Math.max(0, Math.min(vlist.items.length - 1, idx0));
+                    if (idx === pressed.index) {
+                        const item = vlist.items[idx];
+                        if (item !== undefined && typeof vlist.onSelect === "function") {
+                            invokeCallbackSafely(vlist.onSelect, item, idx);
+                            localNeedsRender = true;
+                        }
+                    }
+                }
+            }
+        }
+        else if (event.mouseKind === 4) {
+            ctx.setPressedVirtualList(null);
+        }
+    }
+    else if (event.mouseKind === 4) {
+        ctx.setPressedVirtualList(null);
+    }
+    return localNeedsRender;
+}
+export function routeTableMouseClick(event, ctx) {
+    if (event.kind !== "mouse" || (event.mouseKind !== 3 && event.mouseKind !== 4))
+        return false;
+    const targetId = ctx.mouseTargetId;
+    let localNeedsRender = false;
+    if (targetId !== null) {
+        const table = ctx.tableById.get(targetId);
+        const rect = ctx.rectById.get(targetId);
+        if (table && rect) {
+            const tableCache = ctx.tableRenderCacheById.get(table.id);
+            const rowKeys = tableCache?.rowKeys ?? table.data.map((row, i) => table.getRowKey(row, i));
+            const rowKeyToIndex = tableCache?.rowKeyToIndex;
+            const selection = (table.selection ??
+                ctx.emptyStringArray ??
+                EMPTY_STRING_ARRAY);
+            const selectionMode = table.selectionMode ?? "none";
+            const state = ctx.tableStore.get(table.id);
+            const border = table.border === "none" ? "none" : "single";
+            const t = border === "none" ? 0 : 1;
+            const innerX = rect.x + t;
+            const innerY = rect.y + t;
+            const innerW = Math.max(0, rect.w - t * 2);
+            const innerH = Math.max(0, rect.h - t * 2);
+            const headerHeight = table.showHeader === false ? 0 : (table.headerHeight ?? 1);
+            const rowHeight = table.rowHeight ?? 1;
+            const safeRowHeight = rowHeight > 0 ? rowHeight : 1;
+            const bodyY = innerY + headerHeight;
+            const bodyH = Math.max(0, innerH - headerHeight);
+            const virtualized = table.virtualized !== false;
+            const effectiveScrollTop = virtualized ? state.scrollTop : 0;
+            const inHeader = headerHeight > 0 &&
+                innerW > 0 &&
+                event.x >= innerX &&
+                event.x < innerX + innerW &&
+                event.y >= innerY &&
+                event.y < innerY + headerHeight;
+            const inBody = bodyH > 0 &&
+                innerW > 0 &&
+                event.x >= innerX &&
+                event.x < innerX + innerW &&
+                event.y >= bodyY &&
+                event.y < bodyY + bodyH;
+            const computeColumnIndex = () => {
+                if (!inHeader || innerW <= 0)
+                    return null;
+                const { widths } = distributeColumnWidths(table.columns, innerW);
+                let xCursor = innerX;
+                for (let c = 0; c < widths.length; c++) {
+                    const w = widths[c] ?? 0;
+                    if (w <= 0)
+                        continue;
+                    if (event.x >= xCursor && event.x < xCursor + w)
+                        return c;
+                    xCursor += w;
+                }
+                return null;
+            };
+            const computeRowIndex = () => {
+                if (!inBody)
+                    return null;
+                if (table.data.length === 0)
+                    return null;
+                const localY = event.y - bodyY;
+                const yInContent = effectiveScrollTop + localY;
+                if (yInContent < 0)
+                    return null;
+                const idx0 = Math.floor(yInContent / safeRowHeight);
+                if (idx0 < 0 || idx0 >= table.data.length)
+                    return null;
+                return idx0;
+            };
+            if (event.mouseKind === 3) {
+                ctx.setPressedTable(null);
+                ctx.setPressedTableHeader(null);
+                const colIndex = computeColumnIndex();
+                if (colIndex !== null) {
+                    ctx.setLastTableClick(null);
+                    const prevRow = state.focusedRowIndex;
+                    const prevCol = state.focusedColumnIndex;
+                    ctx.tableStore.set(table.id, { focusedRowIndex: -1, focusedColumnIndex: colIndex });
+                    ctx.setPressedTableHeader(Object.freeze({ id: table.id, columnIndex: colIndex }));
+                    if (prevRow !== -1 || prevCol !== colIndex)
+                        localNeedsRender = true;
+                    ctx.setPressedTable(null);
+                }
+                else {
+                    const rowIndex = computeRowIndex();
+                    if (rowIndex !== null) {
+                        const rowKey = rowKeys[rowIndex];
+                        if (rowKey === undefined) {
+                            ctx.setPressedTable(null);
+                            ctx.setPressedTableHeader(null);
+                            ctx.setLastTableClick(null);
+                        }
+                        else {
+                            const hasShift = (event.mods & ZR_MOD_SHIFT) !== 0;
+                            const hasCtrl = (event.mods & ZR_MOD_CTRL) !== 0;
+                            const res = computeSelection(selection, rowKey, selectionMode, { shift: hasShift, ctrl: hasCtrl }, rowKeys, state.lastClickedKey, rowKeyToIndex);
+                            const prevRow = state.focusedRowIndex;
+                            ctx.tableStore.set(table.id, {
+                                focusedRowIndex: rowIndex,
+                                lastClickedKey: rowKey,
+                            });
+                            if (rowIndex !== prevRow)
+                                localNeedsRender = true;
+                            if (res.changed && typeof table.onSelectionChange === "function") {
+                                invokeCallbackSafely(table.onSelectionChange, res.selection);
+                                localNeedsRender = true;
+                            }
+                            ctx.setPressedTable(Object.freeze({ id: table.id, rowIndex }));
+                        }
+                    }
+                    else {
+                        ctx.setPressedTable(null);
+                        ctx.setPressedTableHeader(null);
+                        ctx.setLastTableClick(null);
+                    }
+                }
+            }
+            else {
+                const pressedRow = ctx.pressedTable;
+                const pressedHeader = ctx.pressedTableHeader;
+                ctx.setPressedTable(null);
+                ctx.setPressedTableHeader(null);
+                if (pressedHeader && pressedHeader.id === table.id) {
+                    ctx.setLastTableClick(null);
+                    const colIndex = computeColumnIndex();
+                    if (colIndex !== null && colIndex === pressedHeader.columnIndex) {
+                        const col = table.columns[colIndex];
+                        if (col && col.sortable === true && typeof table.onSort === "function") {
+                            const nextDirection = table.sortColumn === col.key && table.sortDirection === "asc" ? "desc" : "asc";
+                            invokeCallbackSafely(table.onSort, col.key, nextDirection);
+                            localNeedsRender = true;
+                        }
+                    }
+                }
+                if (pressedRow && pressedRow.id === table.id) {
+                    const rowIndex = computeRowIndex();
+                    if (rowIndex !== null && rowIndex === pressedRow.rowIndex) {
+                        const DOUBLE_PRESS_MS = 500;
+                        const last = ctx.lastTableClick;
+                        const dt = last ? event.timeMs - last.timeMs : Number.POSITIVE_INFINITY;
+                        const isDouble = last &&
+                            last.id === table.id &&
+                            last.rowIndex === rowIndex &&
+                            dt >= 0 &&
+                            dt <= DOUBLE_PRESS_MS;
+                        const row = table.data[rowIndex];
+                        if (row !== undefined) {
+                            if (isDouble && typeof table.onRowDoublePress === "function") {
+                                invokeCallbackSafely(table.onRowDoublePress, row, rowIndex);
+                                ctx.setLastTableClick(null);
+                            }
+                            else if (typeof table.onRowPress === "function") {
+                                invokeCallbackSafely(table.onRowPress, row, rowIndex);
+                                ctx.setLastTableClick(Object.freeze({
+                                    id: table.id,
+                                    rowIndex,
+                                    timeMs: event.timeMs,
+                                }));
+                            }
+                            else {
+                                ctx.setLastTableClick(Object.freeze({
+                                    id: table.id,
+                                    rowIndex,
+                                    timeMs: event.timeMs,
+                                }));
+                            }
+                            localNeedsRender = true;
+                        }
+                        else {
+                            ctx.setLastTableClick(null);
+                        }
+                    }
+                    else {
+                        ctx.setLastTableClick(null);
+                    }
+                }
+            }
+        }
+        else if (event.mouseKind === 4) {
+            ctx.setPressedTable(null);
+            ctx.setPressedTableHeader(null);
+        }
+    }
+    else if (event.mouseKind === 4) {
+        ctx.setPressedTable(null);
+        ctx.setPressedTableHeader(null);
+    }
+    return localNeedsRender;
+}
+export function routeFilePickerMouseClick(event, ctx) {
+    if (event.kind !== "mouse" || (event.mouseKind !== 3 && event.mouseKind !== 4))
+        return false;
+    const targetId = ctx.mouseTargetId;
+    let localNeedsRender = false;
+    if (targetId !== null) {
+        const fp = ctx.filePickerById.get(targetId);
+        const rect = ctx.rectById.get(targetId);
+        if (fp && rect) {
+            const state = ctx.treeStore.get(fp.id);
+            const flatNodes = readFilePickerFlatCache(state, fp.data, fp.expandedPaths, fp.filter, fp.showHidden) ??
+                (() => {
+                    const next = flattenVisibleFilePickerNodes(fp.data, fp.expandedPaths, fp.filter, fp.showHidden);
+                    ctx.treeStore.set(fp.id, {
+                        flatCache: makeFilePickerFlatCache(fp.data, fp.expandedPaths, fp.filter, fp.showHidden, next),
+                    });
+                    return next;
+                })();
+            const computeNodeIndex = () => {
+                const localY = event.y - rect.y;
+                if (localY < 0 || localY >= rect.h)
+                    return null;
+                if (flatNodes.length === 0)
+                    return null;
+                const effectiveScrollTop = clampIndexScrollTopForRows(state.scrollTop, flatNodes.length, rect.h);
+                const idx = effectiveScrollTop + localY;
+                if (idx < 0 || idx >= flatNodes.length)
+                    return null;
+                return idx;
+            };
+            if (event.mouseKind === 3) {
+                ctx.setPressedFilePicker(null);
+                const RIGHT_BUTTON = 1 << 2;
+                if ((event.buttons & RIGHT_BUTTON) !== 0) {
+                    // No right-click behavior for file picker.
+                }
+                else {
+                    const nodeIndex = computeNodeIndex();
+                    if (nodeIndex !== null) {
+                        const fn = flatNodes[nodeIndex];
+                        if (fn) {
+                            const activeKey = getFilePickerActiveKey(state, fp, null);
+                            if (fp.multiSelect === true && typeof fp.onSelectionChange === "function") {
+                                const selection = computeFilePickerMouseSelection(fp.selection, fn.key, flatNodes, {
+                                    shift: (event.mods & ZR_MOD_SHIFT) !== 0,
+                                    ctrl: (event.mods & ZR_MOD_CTRL) !== 0,
+                                }, activeKey);
+                                if (selection.changed) {
+                                    invokeCallbackSafely(fp.onSelectionChange, selection.selection);
+                                }
+                            }
+                            invokeCallbackSafely(fp.onSelect, fn.key);
+                            ctx.treeStore.set(fp.id, { focusedKey: fn.key });
+                            ctx.setPressedFilePicker(Object.freeze({
+                                id: fp.id,
+                                nodeIndex,
+                                nodeKey: fn.key,
+                            }));
+                            localNeedsRender = true;
+                        }
+                    }
+                    else {
+                        ctx.setPressedFilePicker(null);
+                        ctx.setLastFilePickerClick(null);
+                    }
+                }
+            }
+            else {
+                const pressed = ctx.pressedFilePicker;
+                ctx.setPressedFilePicker(null);
+                if (pressed && pressed.id === fp.id) {
+                    const nodeIndex = computeNodeIndex();
+                    if (nodeIndex !== null && nodeIndex === pressed.nodeIndex) {
+                        const fn = flatNodes[nodeIndex];
+                        if (!fn || fn.key !== pressed.nodeKey) {
+                            ctx.setLastFilePickerClick(null);
+                        }
+                        else {
+                            const DOUBLE_PRESS_MS = 500;
+                            const last = ctx.lastFilePickerClick;
+                            const dt = last ? event.timeMs - last.timeMs : Number.POSITIVE_INFINITY;
+                            const isDouble = last &&
+                                last.id === fp.id &&
+                                last.nodeIndex === nodeIndex &&
+                                last.nodeKey === fn.key &&
+                                dt >= 0 &&
+                                dt <= DOUBLE_PRESS_MS;
+                            if (isDouble) {
+                                if (fn.hasChildren) {
+                                    invokeCallbackSafely(fp.onChange, fn.key, !fp.expandedPaths.includes(fn.key));
+                                }
+                                else if (fn.node.type !== "directory") {
+                                    invokeCallbackSafely(fp.onPress, fn.key);
+                                }
+                                ctx.setLastFilePickerClick(null);
+                                localNeedsRender = true;
+                            }
+                            else {
+                                ctx.setLastFilePickerClick(Object.freeze({
+                                    id: fp.id,
+                                    nodeIndex,
+                                    nodeKey: fn.key,
+                                    timeMs: event.timeMs,
+                                }));
+                                localNeedsRender = true;
+                            }
+                        }
+                    }
+                    else {
+                        ctx.setLastFilePickerClick(null);
+                    }
+                }
+            }
+        }
+        else if (event.mouseKind === 4) {
+            ctx.setPressedFilePicker(null);
+        }
+    }
+    else if (event.mouseKind === 4) {
+        ctx.setPressedFilePicker(null);
+    }
+    return localNeedsRender;
+}
+export function routeFileTreeExplorerMouseClick(event, ctx) {
+    if (event.kind !== "mouse" || (event.mouseKind !== 3 && event.mouseKind !== 4))
+        return false;
+    const targetId = ctx.mouseTargetId;
+    let localNeedsRender = false;
+    if (targetId !== null) {
+        const fte = ctx.fileTreeExplorerById.get(targetId);
+        const rect = ctx.rectById.get(targetId);
+        if (fte && rect) {
+            const state = ctx.treeStore.get(fte.id);
+            const flatNodes = readFileNodeFlatCache(state, fte.data, fte.expanded) ??
+                (() => {
+                    const next = flattenTree(fte.data, fileNodeGetKey, fileNodeGetChildren, fileNodeHasChildren, fte.expanded);
+                    ctx.treeStore.set(fte.id, {
+                        flatCache: makeFileNodeFlatCache(fte.data, fte.expanded, next),
+                    });
+                    return next;
+                })();
+            const computeNodeIndex = () => {
+                const localY = event.y - rect.y;
+                if (localY < 0 || localY >= rect.h)
+                    return null;
+                if (flatNodes.length === 0)
+                    return null;
+                const effectiveScrollTop = clampIndexScrollTopForRows(state.scrollTop, flatNodes.length, rect.h);
+                const idx = effectiveScrollTop + localY;
+                if (idx < 0 || idx >= flatNodes.length)
+                    return null;
+                return idx;
+            };
+            if (event.mouseKind === 3) {
+                ctx.setPressedFileTree(null);
+                const RIGHT_BUTTON = 1 << 2;
+                if ((event.buttons & RIGHT_BUTTON) !== 0) {
+                    // Right-click is handled by the context menu block.
+                }
+                else {
+                    const nodeIndex = computeNodeIndex();
+                    if (nodeIndex !== null) {
+                        const fn = flatNodes[nodeIndex];
+                        if (fn) {
+                            invokeCallbackSafely(fte.onSelect, fn.node);
+                            ctx.treeStore.set(fte.id, { focusedKey: fn.key });
+                            ctx.setPressedFileTree(Object.freeze({
+                                id: fte.id,
+                                nodeIndex,
+                                nodeKey: fn.key,
+                            }));
+                            localNeedsRender = true;
+                        }
+                    }
+                    else {
+                        ctx.setPressedFileTree(null);
+                        ctx.setLastFileTreeClick(null);
+                    }
+                }
+            }
+            else {
+                const pressedFT = ctx.pressedFileTree;
+                ctx.setPressedFileTree(null);
+                if (pressedFT && pressedFT.id === fte.id) {
+                    const nodeIndex = computeNodeIndex();
+                    if (nodeIndex !== null && nodeIndex === pressedFT.nodeIndex) {
+                        const fn = flatNodes[nodeIndex];
+                        if (!fn || fn.key !== pressedFT.nodeKey) {
+                            ctx.setLastFileTreeClick(null);
+                        }
+                        else {
+                            const DOUBLE_PRESS_MS = 500;
+                            const last = ctx.lastFileTreeClick;
+                            const dt = last ? event.timeMs - last.timeMs : Number.POSITIVE_INFINITY;
+                            const isDouble = last &&
+                                last.id === fte.id &&
+                                last.nodeIndex === nodeIndex &&
+                                last.nodeKey === fn.key &&
+                                dt >= 0 &&
+                                dt <= DOUBLE_PRESS_MS;
+                            if (isDouble) {
+                                if (fn.node.type === "directory") {
+                                    invokeCallbackSafely(fte.onChange, fn.node, !fte.expanded.includes(fn.key));
+                                }
+                                invokeCallbackSafely(fte.onPress, fn.node);
+                                ctx.setLastFileTreeClick(null);
+                            }
+                            else {
+                                ctx.setLastFileTreeClick(Object.freeze({
+                                    id: fte.id,
+                                    nodeIndex,
+                                    nodeKey: fn.key,
+                                    timeMs: event.timeMs,
+                                }));
+                            }
+                            localNeedsRender = true;
+                        }
+                    }
+                    else {
+                        ctx.setLastFileTreeClick(null);
+                    }
+                }
+            }
+        }
+        else if (event.mouseKind === 4) {
+            ctx.setPressedFileTree(null);
+        }
+    }
+    else if (event.mouseKind === 4) {
+        ctx.setPressedFileTree(null);
+    }
+    return localNeedsRender;
+}
+export function routeTreeMouseClick(event, ctx) {
+    if (event.kind !== "mouse" || (event.mouseKind !== 3 && event.mouseKind !== 4))
+        return false;
+    const targetId = ctx.mouseTargetId;
+    let localNeedsRender = false;
+    if (targetId !== null) {
+        const tree = ctx.treeById.get(targetId);
+        const rect = ctx.rectById.get(targetId);
+        if (tree && rect) {
+            const state = ctx.treeStore.get(tree.id);
+            const expandedSet = state.expandedSetRef === tree.expanded && state.expandedSet
+                ? state.expandedSet
+                : new Set(tree.expanded);
+            if (state.expandedSetRef !== tree.expanded) {
+                ctx.treeStore.set(tree.id, { expandedSetRef: tree.expanded, expandedSet });
+            }
+            const loaded = ctx.loadedTreeChildrenByTreeId.get(tree.id);
+            const getChildrenRaw = tree.getChildren;
+            const getKey = tree.getKey;
+            const getChildren = loaded
+                ? (n) => {
+                    const k = getKey(n);
+                    const cached = loaded.get(k);
+                    return cached ?? getChildrenRaw?.(n);
+                }
+                : getChildrenRaw;
+            const cached = state.flatCache;
+            const canReuseFlatCache = cached &&
+                cached.kind === "tree" &&
+                cached.dataRef === tree.data &&
+                cached.expandedRef === tree.expanded &&
+                cached.getKeyRef === tree.getKey &&
+                cached.getChildrenRef === tree.getChildren &&
+                cached.hasChildrenRef === tree.hasChildren &&
+                cached.loadedRef === loaded;
+            const flatNodes = canReuseFlatCache
+                ? cached.flatNodes
+                : flattenTree(tree.data, getKey, getChildren, tree.hasChildren, tree.expanded, expandedSet);
+            if (!canReuseFlatCache) {
+                ctx.treeStore.set(tree.id, {
+                    flatCache: Object.freeze({
+                        kind: "tree",
+                        dataRef: tree.data,
+                        expandedRef: tree.expanded,
+                        loadedRef: loaded,
+                        getKeyRef: tree.getKey,
+                        getChildrenRef: tree.getChildren,
+                        hasChildrenRef: tree.hasChildren,
+                        flatNodes: flatNodes,
+                    }),
+                });
+            }
+            const computeNodeIndex = () => {
+                const localY = event.y - rect.y;
+                if (localY < 0 || localY >= rect.h)
+                    return null;
+                if (flatNodes.length === 0)
+                    return null;
+                const effectiveScrollTop = clampIndexScrollTopForRows(state.scrollTop, flatNodes.length, rect.h);
+                const idx = effectiveScrollTop + localY;
+                if (idx < 0 || idx >= flatNodes.length)
+                    return null;
+                return idx;
+            };
+            if (event.mouseKind === 3) {
+                ctx.setPressedTree(null);
+                const RIGHT_BUTTON = 1 << 2;
+                if ((event.buttons & RIGHT_BUTTON) !== 0) {
+                    // No right-click behavior for generic tree.
+                }
+                else {
+                    const nodeIndex = computeNodeIndex();
+                    if (nodeIndex !== null) {
+                        const fn = flatNodes[nodeIndex];
+                        if (fn) {
+                            if (tree.onSelect)
+                                invokeCallbackSafely(tree.onSelect, fn.node);
+                            ctx.treeStore.set(tree.id, { focusedKey: fn.key });
+                            ctx.setPressedTree(Object.freeze({
+                                id: tree.id,
+                                nodeIndex,
+                                nodeKey: fn.key,
+                            }));
+                            localNeedsRender = true;
+                        }
+                    }
+                    else {
+                        ctx.setPressedTree(null);
+                        ctx.setLastTreeClick(null);
+                    }
+                }
+            }
+            else {
+                const pressedTree = ctx.pressedTree;
+                ctx.setPressedTree(null);
+                if (pressedTree && pressedTree.id === tree.id) {
+                    const nodeIndex = computeNodeIndex();
+                    if (nodeIndex !== null && nodeIndex === pressedTree.nodeIndex) {
+                        const fn = flatNodes[nodeIndex];
+                        if (!fn || fn.key !== pressedTree.nodeKey) {
+                            ctx.setLastTreeClick(null);
+                        }
+                        else {
+                            const DOUBLE_PRESS_MS = 500;
+                            const last = ctx.lastTreeClick;
+                            const dt = last ? event.timeMs - last.timeMs : Number.POSITIVE_INFINITY;
+                            const isDouble = last &&
+                                last.id === tree.id &&
+                                last.nodeIndex === nodeIndex &&
+                                last.nodeKey === fn.key &&
+                                dt >= 0 &&
+                                dt <= DOUBLE_PRESS_MS;
+                            if (isDouble) {
+                                if (fn.hasChildren) {
+                                    invokeCallbackSafely(tree.onChange, fn.node, !tree.expanded.includes(fn.key));
+                                }
+                                if (tree.onPress)
+                                    invokeCallbackSafely(tree.onPress, fn.node);
+                                ctx.setLastTreeClick(null);
+                            }
+                            else {
+                                ctx.setLastTreeClick(Object.freeze({
+                                    id: tree.id,
+                                    nodeIndex,
+                                    nodeKey: fn.key,
+                                    timeMs: event.timeMs,
+                                }));
+                            }
+                            localNeedsRender = true;
+                        }
+                    }
+                    else {
+                        ctx.setLastTreeClick(null);
+                    }
+                }
+            }
+        }
+        else if (event.mouseKind === 4) {
+            ctx.setPressedTree(null);
+        }
+    }
+    else if (event.mouseKind === 4) {
+        ctx.setPressedTree(null);
+    }
+    return localNeedsRender;
+}
+export function routeFileTreeExplorerContextMenuMouse(event, ctx) {
+    if (event.kind !== "mouse" || event.mouseKind !== 3)
+        return false;
+    const targetId = ctx.mouseTargetId;
+    if (targetId === null)
+        return false;
+    const fte = ctx.fileTreeExplorerById.get(targetId);
+    const rect = ctx.rectById.get(targetId);
+    if (!fte || !rect || typeof fte.onContextMenu !== "function")
+        return false;
+    const RIGHT_BUTTON = 1 << 2;
+    if ((event.buttons & RIGHT_BUTTON) === 0)
+        return false;
+    const localY = event.y - rect.y;
+    const inBounds = localY >= 0 && localY < rect.h;
+    if (!inBounds)
+        return false;
+    const state = ctx.treeStore.get(fte.id);
+    const flatNodes = readFileNodeFlatCache(state, fte.data, fte.expanded) ??
+        (() => {
+            const next = flattenTree(fte.data, fileNodeGetKey, fileNodeGetChildren, fileNodeHasChildren, fte.expanded);
+            ctx.treeStore.set(fte.id, {
+                flatCache: makeFileNodeFlatCache(fte.data, fte.expanded, next),
+            });
+            return next;
+        })();
+    const effectiveScrollTop = clampIndexScrollTopForRows(state.scrollTop, flatNodes.length, rect.h);
+    const idx = effectiveScrollTop + localY;
+    const fn = flatNodes[idx];
+    if (!fn)
+        return false;
+    invokeCallbackSafely(fte.onContextMenu, fn.node);
+    return true;
+}
+export function routeMouseWheel(event, ctx) {
+    if (event.kind !== "mouse" || event.mouseKind !== 5)
+        return null;
+    const topModalLayer = ctx.layerRegistry.getTopmostModal();
+    if (topModalLayer) {
+        const hit = hitTestLayers(ctx.layerRegistry, event.x, event.y);
+        if (hit.blocked)
+            return ROUTE_NO_RENDER;
+    }
+    const allowFocusFallback = topModalLayer === undefined;
+    const targetId = ctx.mouseTargetId ?? (allowFocusFallback ? ctx.focusedId : null);
+    if (targetId !== null) {
+        const vlist = ctx.virtualListById.get(targetId);
+        if (vlist) {
+            const state = ctx.virtualListStore.get(vlist.id);
+            const itemHeight = resolveVirtualListItemHeightSpec(vlist);
+            const measuredHeights = vlist.estimateItemHeight !== undefined &&
+                state.measuredHeights !== undefined &&
+                state.measuredItemCount === vlist.items.length
+                ? state.measuredHeights
+                : undefined;
+            const totalHeight = getTotalHeight(vlist.items, itemHeight, measuredHeights);
+            const r = routeVirtualListWheel(event, {
+                scrollTop: state.scrollTop,
+                totalHeight,
+                viewportHeight: state.viewportHeight,
+                scrollDirection: vlist.scrollDirection ?? "traditional",
+            });
+            if (r.nextScrollTop !== undefined) {
+                let stickyFollowActive;
+                const rawEnsureVisibleIndex = vlist.ensureVisibleIndex;
+                if (typeof rawEnsureVisibleIndex === "number" &&
+                    Number.isFinite(rawEnsureVisibleIndex) &&
+                    vlist.ensureVisibleMode === "sticky") {
+                    if (vlist.items.length === 0) {
+                        stickyFollowActive = true;
+                    }
+                    else {
+                        const followIndex = Math.max(0, Math.min(vlist.items.length - 1, Math.trunc(rawEnsureVisibleIndex)));
+                        const clampedScrollTop = clampScrollTop(r.nextScrollTop, totalHeight, state.viewportHeight);
+                        const maxScrollTop = clampScrollTop(totalHeight, totalHeight, state.viewportHeight);
+                        const followsTail = followIndex >= vlist.items.length - 1;
+                        if (followsTail && maxScrollTop - clampedScrollTop <= 1) {
+                            stickyFollowActive = true;
+                        }
+                        else {
+                            const offset = getItemOffset(vlist.items, itemHeight, followIndex, measuredHeights);
+                            const height = getItemHeight(vlist.items, itemHeight, followIndex, measuredHeights);
+                            const viewportBottom = clampedScrollTop + state.viewportHeight;
+                            const itemBottom = offset + height;
+                            stickyFollowActive = viewportBottom >= itemBottom - 1;
+                        }
+                    }
+                }
+                ctx.virtualListStore.set(vlist.id, {
+                    scrollTop: r.nextScrollTop,
+                    ...(stickyFollowActive === undefined ? {} : { stickyFollowActive }),
+                });
+                if (typeof vlist.onScroll === "function") {
+                    const overscan = vlist.overscan ?? 3;
+                    const { startIndex, endIndex } = computeVisibleRange(vlist.items, itemHeight, r.nextScrollTop, state.viewportHeight, overscan, measuredHeights);
+                    invokeCallbackSafely(vlist.onScroll, r.nextScrollTop, [startIndex, endIndex]);
+                }
+                return ROUTE_RENDER;
+            }
+        }
+        const table = ctx.tableById.get(targetId);
+        if (table && table.virtualized !== false) {
+            const state = ctx.tableStore.get(table.id);
+            const rect = ctx.rectById.get(table.id) ?? null;
+            const border = table.border === "none" ? "none" : "single";
+            const t = border === "none" ? 0 : 1;
+            const innerW = rect ? Math.max(0, rect.w - t * 2) : 0;
+            const innerH = rect ? Math.max(0, rect.h - t * 2) : 0;
+            const headerHeight = table.showHeader === false ? 0 : (table.headerHeight ?? 1);
+            const bodyH = Math.max(0, innerH - headerHeight);
+            const rowHeight = table.rowHeight ?? 1;
+            const safeRowHeight = rowHeight > 0 ? rowHeight : 1;
+            const totalHeight = table.data.length * safeRowHeight;
+            const r = routeWheel(event, {
+                scrollX: 0,
+                scrollY: state.scrollTop,
+                contentWidth: innerW,
+                contentHeight: totalHeight,
+                viewportWidth: innerW,
+                viewportHeight: bodyH,
+            });
+            if (r.nextScrollY !== undefined) {
+                ctx.tableStore.set(table.id, { scrollTop: r.nextScrollY });
+                return ROUTE_RENDER;
+            }
+        }
+    }
+    const candidateIds = allowFocusFallback
+        ? [ctx.mouseTargetId, ctx.focusedId]
+        : [ctx.mouseTargetId];
+    for (const candidateId of candidateIds) {
+        if (candidateId === null)
+            continue;
+        const fte = ctx.fileTreeExplorerById.get(candidateId);
+        if (fte) {
+            const state = ctx.treeStore.get(fte.id);
+            const rect = ctx.rectById.get(fte.id) ?? null;
+            const flatNodes = readFileNodeFlatCache(state, fte.data, fte.expanded) ??
+                (() => {
+                    const next = flattenTree(fte.data, fileNodeGetKey, fileNodeGetChildren, fileNodeHasChildren, fte.expanded);
+                    ctx.treeStore.set(fte.id, {
+                        flatCache: makeFileNodeFlatCache(fte.data, fte.expanded, next),
+                    });
+                    return next;
+                })();
+            const viewportWidth = rect?.w ?? 0;
+            const viewportHeight = rect?.h ?? 0;
+            const r = routeWheel(event, {
+                scrollX: 0,
+                scrollY: state.scrollTop,
+                contentWidth: viewportWidth,
+                contentHeight: flatNodes.length,
+                viewportWidth,
+                viewportHeight,
+            });
+            if (r.nextScrollY !== undefined) {
+                ctx.treeStore.set(fte.id, { scrollTop: r.nextScrollY });
+                return ROUTE_RENDER;
+            }
+            break;
+        }
+        const editor = ctx.codeEditorById.get(candidateId);
+        if (editor) {
+            const rect = ctx.rectById.get(editor.id) ?? null;
+            const lineNumWidth = ctx.codeEditorRenderCacheById.get(editor.id)?.lineNumWidth ??
+                (editor.lineNumbers === false ? 0 : Math.max(4, String(editor.lines.length).length + 1));
+            const viewportWidth = rect ? Math.max(1, rect.w - lineNumWidth) : 1;
+            const viewportHeight = rect ? Math.max(1, rect.h) : 1;
+            let contentWidth = 1;
+            for (const line of editor.lines) {
+                const lineWidth = measureTextCells(line);
+                if (lineWidth > contentWidth)
+                    contentWidth = lineWidth;
+            }
+            const r = routeWheel(event, {
+                scrollX: editor.scrollLeft,
+                scrollY: editor.scrollTop,
+                contentWidth,
+                contentHeight: editor.lines.length,
+                viewportWidth,
+                viewportHeight,
+            });
+            if (r.nextScrollY !== undefined || r.nextScrollX !== undefined) {
+                invokeCallbackSafely(editor.onScroll, r.nextScrollY ?? editor.scrollTop, r.nextScrollX ?? editor.scrollLeft);
+                return ROUTE_RENDER;
+            }
+            break;
+        }
+        const logs = ctx.logsConsoleById.get(candidateId);
+        if (logs) {
+            const rect = ctx.rectById.get(logs.id) ?? null;
+            const viewportWidth = rect ? Math.max(1, rect.w) : 1;
+            const viewportHeight = rect ? Math.max(1, rect.h) : 1;
+            const cached = ctx.logsConsoleRenderCacheById.get(logs.id);
+            const filteredLen = cached?.filtered.length ??
+                applyFilters(logs.entries, logs.levelFilter, logs.sourceFilter, logs.searchQuery).length;
+            const r = routeWheel(event, {
+                scrollX: 0,
+                scrollY: logs.scrollTop,
+                contentWidth: viewportWidth,
+                contentHeight: filteredLen,
+                viewportWidth,
+                viewportHeight,
+            });
+            if (r.nextScrollY !== undefined) {
+                invokeCallbackSafely(logs.onScroll, r.nextScrollY);
+                return ROUTE_RENDER;
+            }
+            break;
+        }
+        const diff = ctx.diffViewerById.get(candidateId);
+        if (diff) {
+            const rect = ctx.rectById.get(diff.id) ?? null;
+            const viewportWidth = rect ? Math.max(1, rect.w) : 1;
+            const viewportHeight = rect ? Math.max(1, rect.h) : 1;
+            let totalLines = 0;
+            for (const h of diff.diff.hunks) {
+                if (!h)
+                    continue;
+                totalLines += 1 + h.lines.length;
+            }
+            const r = routeWheel(event, {
+                scrollX: 0,
+                scrollY: diff.scrollTop,
+                contentWidth: viewportWidth,
+                contentHeight: totalLines,
+                viewportWidth,
+                viewportHeight,
+            });
+            if (r.nextScrollY !== undefined) {
+                invokeCallbackSafely(diff.onScroll, r.nextScrollY);
+                return ROUTE_RENDER;
+            }
+            break;
+        }
+    }
+    const scrollTargets = ctx.findScrollableAncestors(ctx.mouseTargetAnyId);
+    for (const scrollTarget of scrollTargets) {
+        const { nodeId, meta } = scrollTarget;
+        const r = routeWheel(event, {
+            scrollX: meta.scrollX,
+            scrollY: meta.scrollY,
+            contentWidth: meta.contentWidth,
+            contentHeight: meta.contentHeight,
+            viewportWidth: meta.viewportWidth,
+            viewportHeight: meta.viewportHeight,
+        });
+        if (r.nextScrollX !== undefined || r.nextScrollY !== undefined) {
+            ctx.scrollOverrides.set(nodeId, {
+                scrollX: r.nextScrollX ?? meta.scrollX,
+                scrollY: r.nextScrollY ?? meta.scrollY,
+            });
+            return ROUTE_RENDER;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=mouseRouting.js.map