mtrl-addons 0.5.6 → 0.7.0

package/dist/core/viewport/index.js

@@ -0,0 +1,3715 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/viewport/index.ts
+var exports_viewport = {};
+__export(exports_viewport, {
+  withVirtual: () => withVirtual,
+  withScrolling: () => withScrolling,
+  withScrollbar: () => withScrollbar,
+  withRendering: () => withRendering,
+  withPlaceholders: () => withPlaceholders,
+  withEvents: () => withEvents,
+  withCollection: () => withCollection,
+  withBase: () => withBase,
+  createViewport: () => createViewport,
+  VIEWPORT_CONSTANTS: () => VIEWPORT_CONSTANTS
+});
+module.exports = __toCommonJS(exports_viewport);
+
+// src/core/viewport/viewport.ts
+var import_mtrl4 = require("mtrl");
+
+// src/core/viewport/features/utils.ts
+function wrapInitialize(component, featureInit) {
+  const originalInitialize = component.viewport.initialize;
+  component.viewport.initialize = () => {
+    const result = originalInitialize();
+    if (result !== false) {
+      featureInit();
+    }
+    return result;
+  };
+}
+function wrapDestroy(component, cleanup) {
+  if ("destroy" in component && typeof component.destroy === "function") {
+    const originalDestroy = component.destroy;
+    component.destroy = () => {
+      cleanup();
+      originalDestroy?.();
+    };
+  }
+}
+function getViewportState(component) {
+  return component.viewport.state;
+}
+function isPlaceholder(item) {
+  return item && typeof item === "object" && (item._placeholder === true || item["_placeholder"] === true);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function storeFeatureFunction(component, name, fn) {
+  component[name] = fn;
+}
+
+// src/core/viewport/features/base.ts
+var withBase = (config = {}) => {
+  return (component) => {
+    const { className = "mtrl-viewport", orientation = "vertical" } = config;
+    wrapInitialize(component, () => {
+      const element = component.element;
+      if (!element)
+        return;
+      let viewportElement = element.querySelector(".mtrl-viewport");
+      if (!viewportElement) {
+        viewportElement = document.createElement("div");
+        viewportElement.className = className;
+        viewportElement.style.cssText = `
+          position: relative;
+          width: 100%;
+          height: 100%;
+          overflow: hidden;
+        `;
+        viewportElement.setAttribute("data-orientation", orientation);
+        const itemsContainer = document.createElement("div");
+        itemsContainer.className = "mtrl-viewport-items";
+        itemsContainer.style.cssText = `
+          position: relative;
+          width: 100%;
+        `;
+        viewportElement.appendChild(itemsContainer);
+        element.appendChild(viewportElement);
+        const state = getViewportState(component);
+        if (state) {
+          state.viewportElement = viewportElement;
+          state.itemsContainer = itemsContainer;
+        }
+        component.viewportElement = viewportElement;
+        component.itemsContainer = itemsContainer;
+      }
+    });
+    return component;
+  };
+};
+
+// src/core/viewport/constants.ts
+var VIEWPORT_CONSTANTS = {
+  VIRTUAL_SCROLL: {
+    DEFAULT_ITEM_SIZE: 48,
+    OVERSCAN_BUFFER: 2,
+    SCROLL_SENSITIVITY: 0.7,
+    MAX_VIRTUAL_SIZE: 100 * 1000 * 1000,
+    AUTO_DETECT_ITEM_SIZE: true
+  },
+  SCROLLING: {
+    OVERSCAN: 1
+  },
+  RENDERING: {
+    DEFAULT_MAX_POOL_SIZE: 100,
+    CLASSES: {
+      ITEM: "viewport-item"
+    }
+  },
+  LOADING: {
+    CANCEL_THRESHOLD: 25,
+    MAX_CONCURRENT_REQUESTS: 1,
+    DEFAULT_RANGE_SIZE: 20,
+    DEBOUNCE_LOADING: 150,
+    MIN_RANGE_SIZE: 10,
+    MAX_RANGE_SIZE: 100,
+    REQUEST_TIMEOUT: 5000,
+    RETRY_ATTEMPTS: 2,
+    RETRY_DELAY: 1000
+  },
+  REQUEST_QUEUE: {
+    ENABLED: true,
+    MAX_QUEUE_SIZE: 1,
+    MAX_ACTIVE_REQUESTS: 2
+  },
+  PLACEHOLDER: {
+    MASK_CHARACTER: "X",
+    CLASS: "viewport-item--placeholder",
+    MAX_SAMPLE_SIZE: 20,
+    PLACEHOLDER_FLAG: "_placeholder",
+    RANDOM_LENGTH_VARIANCE: true
+  },
+  SPEED_TRACKING: {
+    DECELERATION_FACTOR: 0.85
+  },
+  MOMENTUM: {
+    ENABLED: false,
+    DECELERATION_FACTOR: 0.95,
+    MIN_VELOCITY: 0.1,
+    MIN_DURATION: 750,
+    MIN_VELOCITY_THRESHOLD: 0.4,
+    FRAME_TIME: 16
+  },
+  INITIAL_LOAD: {
+    STRATEGY: "placeholders",
+    VIEWPORT_MULTIPLIER: 1.5,
+    MIN_ITEMS: 10,
+    MAX_ITEMS: 100,
+    PLACEHOLDER_COUNT: 20,
+    SHOW_LOADING_STATE: true,
+    LOADING_DELAY: 100
+  },
+  SELECTION: {
+    SELECTED_CLASS: "viewport-item--selected"
+  },
+  SCROLLBAR: {
+    CLASSES: {
+      SCROLLBAR: "viewport__scrollbar",
+      SCROLLBAR_TRACK: "viewport__scrollbar-track",
+      SCROLLBAR_THUMB: "viewport__scrollbar-thumb",
+      SCROLLBAR_VISIBLE: "viewport__scrollbar--visible",
+      SCROLLBAR_DRAGGING: "viewport__scrollbar--dragging",
+      SCROLLBAR_THUMB_DRAGGING: "viewport__scrollbar-thumb--dragging"
+    }
+  },
+  ORIENTATION: {
+    DEFAULT_ORIENTATION: "vertical",
+    DEFAULT_CROSS_AXIS_ALIGNMENT: "stretch",
+    REVERSE_DIRECTION: false
+  },
+  PAGINATION: {
+    DEFAULT_STRATEGY: "offset",
+    DEFAULT_LIMIT: 20,
+    STRATEGIES: {
+      PAGE: "page",
+      OFFSET: "offset",
+      CURSOR: "cursor"
+    },
+    CURSOR_CLEANUP_INTERVAL: 60000,
+    MAX_CURSOR_MAP_SIZE: 1000,
+    CURSOR_SCROLL_MARGIN_MULTIPLIER: 3,
+    CURSOR_MIN_VIRTUAL_SIZE_MULTIPLIER: 3
+  }
+};
+
+// src/core/viewport/features/virtual.ts
+var withVirtual = (config = {}) => {
+  return (component) => {
+    const {
+      itemSize,
+      overscan = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.OVERSCAN_BUFFER,
+      orientation = "vertical",
+      autoDetectItemSize = itemSize === undefined ? VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.AUTO_DETECT_ITEM_SIZE : false,
+      debug = false,
+      initialScrollIndex = 0
+    } = config;
+    const initialItemSize = itemSize || VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.DEFAULT_ITEM_SIZE;
+    const MAX_VIRTUAL_SIZE = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.MAX_VIRTUAL_SIZE;
+    let viewportState;
+    let hasCalculatedItemSize = false;
+    let hasRecalculatedScrollForCompression = false;
+    let resizeObserver = null;
+    let lastScrollPosition = -1;
+    let lastVisibleRange = null;
+    let lastActualVisibleRange = null;
+    component.on?.("reload:start", () => {
+      hasCalculatedItemSize = false;
+      hasRecalculatedScrollForCompression = false;
+      lastScrollPosition = -1;
+      lastVisibleRange = null;
+      lastActualVisibleRange = null;
+      if (viewportState) {
+        viewportState.totalItems = 0;
+        viewportState.virtualTotalSize = 0;
+        viewportState.visibleRange = { start: 0, end: 0 };
+        delete viewportState.targetScrollIndex;
+      }
+    });
+    wrapInitialize(component, () => {
+      viewportState = getViewportState(component);
+      if (!viewportState)
+        return;
+      Object.assign(viewportState, {
+        itemSize: initialItemSize,
+        overscan,
+        containerSize: viewportState.viewportElement?.[orientation === "horizontal" ? "offsetWidth" : "offsetHeight"] || 600
+      });
+      updateTotalVirtualSize(viewportState.totalItems);
+      let initialScrollPosition = viewportState.scrollPosition || 0;
+      if (initialScrollIndex > 0) {
+        viewportState.targetScrollIndex = initialScrollIndex;
+        initialScrollPosition = initialScrollIndex * (viewportState.itemSize || initialItemSize);
+        viewportState.scrollPosition = initialScrollPosition;
+        setTimeout(() => {
+          component.emit?.("viewport:scroll-position-sync", {
+            position: initialScrollPosition,
+            source: "initial-scroll-index"
+          });
+        }, 0);
+      }
+      updateVisibleRange(initialScrollPosition);
+      requestAnimationFrame(() => {
+        updateContainerSize();
+      });
+      if (viewportState.viewportElement && typeof ResizeObserver !== "undefined") {
+        resizeObserver = new ResizeObserver((entries) => {
+          for (const entry of entries) {
+            const size = orientation === "horizontal" ? entry.contentRect.width : entry.contentRect.height;
+            if (size > 0 && size !== viewportState?.containerSize) {
+              updateContainerSize();
+            }
+          }
+        });
+        resizeObserver.observe(viewportState.viewportElement);
+      }
+    });
+    const getCompressionRatio = () => {
+      if (!viewportState?.virtualTotalSize)
+        return 1;
+      const actualSize = viewportState.totalItems * viewportState.itemSize;
+      return actualSize <= MAX_VIRTUAL_SIZE ? 1 : MAX_VIRTUAL_SIZE / actualSize;
+    };
+    const log = (message, data) => {
+      if (debug)
+        console.log(`[Virtual] ${message}`, data);
+    };
+    const calculateVisibleRange = (scrollPosition) => {
+      if (!viewportState) {
+        console.warn("[Virtual] No viewport state, returning empty range");
+        return { start: 0, end: 0 };
+      }
+      const { containerSize, totalItems } = viewportState;
+      if (!containerSize || containerSize <= 0 || !totalItems || totalItems <= 0) {
+        if (initialScrollIndex > 0) {
+          const visibleCount2 = Math.ceil((containerSize || 600) / (viewportState.itemSize || initialItemSize));
+          const start2 = Math.max(0, initialScrollIndex - overscan);
+          const end2 = initialScrollIndex + visibleCount2 + overscan;
+          return { start: start2, end: end2 };
+        }
+        log(`Invalid state: container=${containerSize}, items=${totalItems}`);
+        return { start: 0, end: 0 };
+      }
+      const virtualSize = viewportState.virtualTotalSize || totalItems * viewportState.itemSize;
+      const visibleCount = Math.ceil(containerSize / viewportState.itemSize);
+      const compressionRatio2 = getCompressionRatio();
+      let start, end;
+      const targetScrollIndex = viewportState.targetScrollIndex;
+      if (compressionRatio2 < 1) {
+        if (targetScrollIndex !== undefined && targetScrollIndex > 0) {
+          start = Math.max(0, targetScrollIndex - overscan);
+          end = Math.min(totalItems - 1, targetScrollIndex + visibleCount + overscan);
+          delete viewportState.targetScrollIndex;
+        } else {
+          const scrollRatio = scrollPosition / virtualSize;
+          const exactIndex = scrollRatio * totalItems;
+          start = Math.floor(exactIndex);
+          end = Math.ceil(exactIndex) + visibleCount;
+        }
+        const maxScroll = virtualSize - containerSize;
+        const distanceFromBottom = maxScroll - scrollPosition;
+        if (distanceFromBottom <= containerSize && distanceFromBottom >= -1) {
+          const itemsAtBottom = Math.floor(containerSize / viewportState.itemSize);
+          const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);
+          const interpolation = Math.max(0, Math.min(1, 1 - distanceFromBottom / containerSize));
+          start = Math.floor(start + (firstVisibleAtBottom - start) * interpolation);
+          end = distanceFromBottom <= 1 ? totalItems - 1 : Math.min(totalItems - 1, start + visibleCount + overscan);
+          log("Near bottom calculation:", {
+            distanceFromBottom,
+            interpolation,
+            start,
+            end,
+            scrollPosition,
+            totalItems
+          });
+        }
+        start = Math.max(0, start - overscan);
+        end = Math.min(totalItems - 1, end + overscan);
+      } else {
+        start = Math.max(0, Math.floor(scrollPosition / viewportState.itemSize) - overscan);
+        end = Math.min(totalItems - 1, start + visibleCount + overscan * 2);
+      }
+      if (isNaN(start) || isNaN(end)) {
+        console.error("[Virtual] NaN in range calculation:", {
+          scrollPosition,
+          containerSize,
+          totalItems,
+          itemSize: viewportState.itemSize,
+          compressionRatio: compressionRatio2
+        });
+        return { start: 0, end: 0 };
+      }
+      return { start, end };
+    };
+    const calculateActualVisibleRange = (scrollPosition) => {
+      if (!viewportState)
+        return { start: 0, end: 0 };
+      const { containerSize, totalItems } = viewportState;
+      if (!containerSize || !totalItems)
+        return { start: 0, end: 0 };
+      const itemSize2 = viewportState.itemSize;
+      const visibleCount = Math.ceil(containerSize / itemSize2);
+      const actualSize = totalItems * itemSize2;
+      const virtualSize = viewportState.virtualTotalSize || actualSize;
+      const compressionRatio2 = actualSize > 0 ? virtualSize / actualSize : 1;
+      let start, end;
+      if (compressionRatio2 < 1) {
+        const scrollRatio = scrollPosition / virtualSize;
+        start = Math.floor(scrollRatio * totalItems);
+        end = Math.min(totalItems - 1, start + visibleCount - 1);
+        const maxScroll = virtualSize - containerSize;
+        const distanceFromBottom = maxScroll - scrollPosition;
+        if (distanceFromBottom <= containerSize && distanceFromBottom >= -1) {
+          const itemsAtBottom = Math.floor(containerSize / itemSize2);
+          const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);
+          const interpolation = Math.max(0, Math.min(1, 1 - distanceFromBottom / containerSize));
+          start = Math.floor(start + (firstVisibleAtBottom - start) * interpolation);
+          end = distanceFromBottom <= 1 ? totalItems - 1 : Math.min(totalItems - 1, start + visibleCount - 1);
+        }
+      } else {
+        start = Math.floor(scrollPosition / itemSize2);
+        end = Math.min(totalItems - 1, start + visibleCount - 1);
+      }
+      start = Math.max(0, start);
+      end = Math.max(start, end);
+      return { start, end };
+    };
+    const updateVisibleRange = (scrollPosition) => {
+      if (!viewportState)
+        return;
+      if (lastScrollPosition >= 0 && Math.abs(scrollPosition - lastScrollPosition) < 1) {
+        return;
+      }
+      lastScrollPosition = scrollPosition;
+      viewportState.visibleRange = calculateVisibleRange(scrollPosition);
+      const actualVisibleRange = calculateActualVisibleRange(scrollPosition);
+      if (lastVisibleRange && lastActualVisibleRange && lastVisibleRange.start === viewportState.visibleRange.start && lastVisibleRange.end === viewportState.visibleRange.end && lastActualVisibleRange.start === actualVisibleRange.start && lastActualVisibleRange.end === actualVisibleRange.end) {
+        return;
+      }
+      lastVisibleRange = { ...viewportState.visibleRange };
+      lastActualVisibleRange = { ...actualVisibleRange };
+      component.emit?.("viewport:range-changed", {
+        range: viewportState.visibleRange,
+        visibleRange: actualVisibleRange,
+        scrollPosition
+      });
+    };
+    const updateTotalVirtualSize = (totalItems) => {
+      if (!viewportState)
+        return;
+      const oldSize = viewportState.virtualTotalSize;
+      viewportState.totalItems = totalItems;
+      const actualSize = totalItems * viewportState.itemSize;
+      let totalPadding = 0;
+      if (viewportState.itemsContainer) {
+        const computedStyle = window.getComputedStyle(viewportState.itemsContainer);
+        const paddingTop = parseFloat(computedStyle.paddingTop) || 0;
+        const paddingBottom = parseFloat(computedStyle.paddingBottom) || 0;
+        totalPadding = paddingTop + paddingBottom;
+      }
+      viewportState.virtualTotalSize = Math.min(actualSize + totalPadding, MAX_VIRTUAL_SIZE);
+      component.emit?.("viewport:virtual-size-changed", {
+        totalVirtualSize: viewportState.virtualTotalSize,
+        totalItems,
+        compressionRatio: getCompressionRatio()
+      });
+    };
+    const updateContainerSize = () => {
+      if (!viewportState || !viewportState.viewportElement)
+        return;
+      const size = viewportState.viewportElement[viewportState.orientation === "horizontal" ? "offsetWidth" : "offsetHeight"];
+      if (size !== viewportState.containerSize) {
+        viewportState.containerSize = size;
+        updateVisibleRange(viewportState.scrollPosition || 0);
+        updateTotalVirtualSize(viewportState.totalItems);
+        component.emit?.("viewport:container-size-changed", {
+          containerSize: size
+        });
+      }
+    };
+    component.viewport.getVisibleRange = () => viewportState?.visibleRange || calculateVisibleRange(viewportState?.scrollPosition || 0);
+    component.on?.("viewport:scroll", (data) => updateVisibleRange(data.position));
+    component.on?.("viewport:items-changed", (data) => {
+      if (data.totalItems !== undefined) {
+        updateTotalVirtualSize(data.totalItems);
+        updateVisibleRange(viewportState?.scrollPosition || 0);
+      }
+    });
+    component.on?.("viewport:total-items-changed", (data) => {
+      if (data.total === undefined)
+        return;
+      if (initialScrollIndex > 0 && !hasRecalculatedScrollForCompression && data.total > 0) {
+        const actualTotalSize = data.total * viewportState.itemSize;
+        const isCompressed = actualTotalSize > MAX_VIRTUAL_SIZE;
+        if (isCompressed) {
+          const ratio = initialScrollIndex / data.total;
+          const compressedPosition = ratio * MAX_VIRTUAL_SIZE;
+          viewportState.scrollPosition = compressedPosition;
+          component.emit?.("viewport:scroll-position-sync", {
+            position: compressedPosition,
+            source: "compression-recalculation"
+          });
+          delete viewportState.targetScrollIndex;
+        }
+        hasRecalculatedScrollForCompression = true;
+      }
+      updateTotalVirtualSize(data.total);
+      updateVisibleRange(viewportState?.scrollPosition || 0);
+      component.viewport?.renderItems?.();
+    });
+    component.on?.("viewport:container-size-changed", (data) => {
+      if (viewportState && data.containerSize !== viewportState.containerSize) {
+        viewportState.containerSize = data.containerSize;
+        updateTotalVirtualSize(viewportState.totalItems);
+        updateVisibleRange(viewportState.scrollPosition || 0);
+      }
+    });
+    component.on?.("collection:range-loaded", (data) => {
+      if (data.total !== undefined && data.total !== viewportState?.totalItems) {
+        updateTotalVirtualSize(data.total);
+      }
+      lastScrollPosition = -1;
+      updateVisibleRange(viewportState?.scrollPosition || 0);
+      component.viewport?.renderItems?.();
+    });
+    if (autoDetectItemSize) {
+      component.on?.("viewport:items-rendered", (data) => {
+        if (!hasCalculatedItemSize && data.elements?.length > 0 && viewportState) {
+          const sizes = [];
+          const sizeProperty = orientation === "horizontal" ? "offsetWidth" : "offsetHeight";
+          data.elements.forEach((element) => {
+            const size = element[sizeProperty];
+            if (size > 0) {
+              sizes.push(size);
+            }
+          });
+          if (sizes.length > 0) {
+            const avgSize = Math.round(sizes.reduce((sum, size) => sum + size, 0) / sizes.length);
+            const previousItemSize = viewportState.itemSize;
+            viewportState.itemSize = avgSize;
+            if (initialScrollIndex > 0 && avgSize !== previousItemSize) {
+              const newScrollPosition = initialScrollIndex * avgSize;
+              viewportState.scrollPosition = newScrollPosition;
+              component.emit?.("viewport:scroll-position-sync", {
+                position: newScrollPosition,
+                source: "item-size-detected"
+              });
+            }
+            updateTotalVirtualSize(viewportState.totalItems);
+            updateVisibleRange(viewportState.scrollPosition || 0);
+            component.viewport?.renderItems?.();
+            component.emit?.("viewport:item-size-detected", {
+              previousSize: initialItemSize,
+              detectedSize: avgSize
+            });
+            hasCalculatedItemSize = true;
+          }
+        }
+      });
+    }
+    wrapDestroy(component, () => {
+      if (resizeObserver) {
+        resizeObserver.disconnect();
+        resizeObserver = null;
+      }
+    });
+    const compressionRatio = getCompressionRatio();
+    component.virtual = {
+      calculateVisibleRange,
+      updateTotalVirtualSize,
+      getTotalVirtualSize: () => viewportState?.virtualTotalSize || 0,
+      getContainerSize: () => viewportState?.containerSize || 0,
+      updateContainerSize: (size) => {
+        if (viewportState) {
+          viewportState.containerSize = size;
+          updateVisibleRange(viewportState.scrollPosition || 0);
+        }
+      },
+      getItemSize: () => viewportState?.itemSize || initialItemSize,
+      calculateIndexFromPosition: (position) => Math.floor(position / ((viewportState?.itemSize || initialItemSize) * compressionRatio)),
+      calculatePositionForIndex: (index) => index * (viewportState?.itemSize || initialItemSize) * compressionRatio
+    };
+    return component;
+  };
+};
+
+// src/core/viewport/features/scrolling.ts
+var import_mtrl = require("mtrl");
+var createSpeedTracker = () => ({
+  velocity: 0,
+  lastPosition: 0,
+  lastTime: Date.now(),
+  direction: "forward",
+  samples: []
+});
+var updateSpeedTracker = (tracker, newPosition, previousPosition) => {
+  const now = Date.now();
+  const timeDelta = now - tracker.lastTime;
+  if (timeDelta === 0)
+    return tracker;
+  const positionDelta = newPosition - previousPosition;
+  const instantVelocity = positionDelta / timeDelta;
+  const samples = [...tracker.samples, { position: newPosition, time: now }];
+  const recentSamples = samples.filter((s) => now - s.time < 100);
+  let avgVelocity = instantVelocity;
+  if (recentSamples.length > 1) {
+    const oldestSample = recentSamples[0];
+    const totalDistance = newPosition - oldestSample.position;
+    const totalTime = now - oldestSample.time;
+    avgVelocity = totalTime > 0 ? totalDistance / totalTime : instantVelocity;
+  }
+  return {
+    velocity: avgVelocity,
+    lastPosition: newPosition,
+    lastTime: now,
+    direction: positionDelta >= 0 ? "forward" : "backward",
+    samples: recentSamples
+  };
+};
+var withScrolling = (config = {}) => {
+  return (component) => {
+    const {
+      orientation = "vertical",
+      sensitivity = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.SCROLL_SENSITIVITY,
+      smoothing = false,
+      idleTimeout = 100,
+      stopOnClick = true
+    } = config;
+    let scrollPosition = 0;
+    let totalVirtualSize = 0;
+    let containerSize = 0;
+    let isScrolling = false;
+    let isScrolledFromTop = false;
+    let lastScrollTime = 0;
+    const removeScrolledClass = () => {
+      const viewportEl = component.viewportElement || component._scrollingViewportElement;
+      if (viewportEl) {
+        const vlistContainer = viewportEl.closest(`.${import_mtrl.PREFIX}-vlist`);
+        if (vlistContainer) {
+          vlistContainer.classList.remove(`${import_mtrl.PREFIX}-vlist--scrolled`);
+        }
+      }
+    };
+    component.on?.("reload:start", () => {
+      scrollPosition = 0;
+      totalVirtualSize = 0;
+      isScrolling = false;
+      isScrolledFromTop = false;
+      lastScrollTime = 0;
+      speedTracker = createSpeedTracker();
+      hasEmittedIdle = false;
+      anchorPosition = null;
+      anchorTime = 0;
+      lastWheelTime = 0;
+      anchorInitialDelta = 0;
+      anchorLastDelta = 0;
+      anchorMinDelta = Infinity;
+      consecutiveIncreases = 0;
+      sustainedHighCount = 0;
+      renderScheduled = false;
+      pendingScrollData = null;
+      if (idleTimeoutId) {
+        clearTimeout(idleTimeoutId);
+        idleTimeoutId = null;
+      }
+      stopIdleDetection();
+      removeScrolledClass();
+    });
+    component.on?.("cleared", () => {
+      scrollPosition = 0;
+      totalVirtualSize = 0;
+      isScrolledFromTop = false;
+      removeScrolledClass();
+    });
+    let speedTracker = createSpeedTracker();
+    let idleTimeoutId = null;
+    let idleCheckFrame = null;
+    let lastIdleCheckPosition = 0;
+    let hasEmittedIdle = false;
+    let anchorPosition = null;
+    let anchorTime = 0;
+    let lastWheelTime = 0;
+    let anchorInitialDelta = 0;
+    let anchorLastDelta = 0;
+    let anchorMinDelta = Infinity;
+    let consecutiveIncreases = 0;
+    let sustainedHighCount = 0;
+    let renderScheduled = false;
+    let pendingScrollData = null;
+    const SCROLLED_THRESHOLD = 1;
+    const updateScrolledState = (viewportElement, position) => {
+      const shouldBeScrolled = position > SCROLLED_THRESHOLD;
+      if (shouldBeScrolled !== isScrolledFromTop) {
+        isScrolledFromTop = shouldBeScrolled;
+        const vlistContainer = viewportElement.closest(`.${import_mtrl.PREFIX}-vlist`);
+        if (vlistContainer) {
+          vlistContainer.classList.toggle(`${import_mtrl.PREFIX}-vlist--scrolled`, shouldBeScrolled);
+        }
+      }
+    };
+    let viewportState;
+    wrapInitialize(component, () => {
+      viewportState = getViewportState(component);
+      if (viewportState) {
+        totalVirtualSize = viewportState.virtualTotalSize || 0;
+        containerSize = viewportState.containerSize || 0;
+        if (viewportState.scrollPosition > 0) {
+          scrollPosition = viewportState.scrollPosition;
+        }
+      }
+      component.on?.("viewport:virtual-size-changed", (data) => {
+        updateScrollBounds(data.totalVirtualSize, containerSize);
+      });
+      component.on?.("viewport:scroll-position-sync", (data) => {
+        if (data.position !== undefined && data.position !== scrollPosition) {
+          scrollPosition = data.position;
+          totalVirtualSize = viewportState?.virtualTotalSize || totalVirtualSize;
+          containerSize = viewportState?.containerSize || containerSize;
+        }
+      });
+      component.on?.("viewport:container-size-changed", (data) => {
+        if (data.containerSize) {
+          containerSize = data.containerSize;
+          updateScrollBounds(totalVirtualSize, containerSize);
+        }
+      });
+      const viewportElement = viewportState?.viewportElement || component.viewportElement;
+      if (viewportElement) {
+        viewportElement.addEventListener("wheel", handleWheel, {
+          passive: false
+        });
+        updateScrolledState(viewportElement, scrollPosition);
+        if (stopOnClick) {
+          viewportElement.addEventListener("mousedown", handleMouseDown);
+        }
+        component._scrollingViewportElement = viewportElement;
+        component._scrollingStopOnClick = stopOnClick;
+      } else {
+        console.warn(`[Scrolling] No viewport element found for wheel events`);
+      }
+    });
+    const startIdleDetection = () => {
+      if (idleCheckFrame !== null) {
+        cancelAnimationFrame(idleCheckFrame);
+        idleCheckFrame = null;
+      }
+      hasEmittedIdle = false;
+      const checkIdle = () => {
+        if (scrollPosition === lastIdleCheckPosition) {
+          if (!hasEmittedIdle && (speedTracker.velocity > 0 || isScrolling)) {
+            hasEmittedIdle = true;
+            setVelocityToZero();
+          }
+        } else {
+          hasEmittedIdle = false;
+        }
+        lastIdleCheckPosition = scrollPosition;
+        idleCheckFrame = requestAnimationFrame(checkIdle);
+      };
+      idleCheckFrame = requestAnimationFrame(checkIdle);
+    };
+    const stopIdleDetection = () => {
+      if (idleCheckFrame) {
+        cancelAnimationFrame(idleCheckFrame);
+        idleCheckFrame = null;
+      }
+    };
+    const setVelocityToZero = () => {
+      stopIdleDetection();
+      speedTracker = createSpeedTracker();
+      isScrolling = false;
+      component.emit?.("viewport:velocity-changed", {
+        velocity: 0,
+        direction: speedTracker.direction
+      });
+      component.emit?.("viewport:idle", {
+        position: scrollPosition,
+        lastScrollTime
+      });
+    };
+    const updateContainerPosition = () => {
+      if (!viewportState || !viewportState.itemsContainer)
+        return;
+    };
+    const handleMouseDown = (_e) => {
+      anchorPosition = scrollPosition;
+      anchorTime = Date.now();
+      anchorInitialDelta = 0;
+      anchorLastDelta = 0;
+      anchorMinDelta = Infinity;
+      consecutiveIncreases = 0;
+      sustainedHighCount = 0;
+      if (isScrolling || speedTracker.velocity > 0) {
+        setVelocityToZero();
+      }
+      const momentumState = component.viewport.momentumState;
+      if (momentumState?.stopMomentum) {
+        momentumState.stopMomentum();
+      }
+    };
+    const handleWheel = (event) => {
+      event.preventDefault();
+      const delta = orientation === "vertical" ? event.deltaY : event.deltaX;
+      const scrollDelta = delta * sensitivity;
+      const now = Date.now();
+      const timeSinceLastWheel = now - lastWheelTime;
+      lastWheelTime = now;
+      if (anchorPosition !== null) {
+        const timeSinceAnchor = now - anchorTime;
+        const wheelDeltaMagnitude = Math.abs(scrollDelta);
+        if (anchorInitialDelta === 0) {
+          anchorInitialDelta = wheelDeltaMagnitude;
+          anchorLastDelta = wheelDeltaMagnitude;
+          anchorMinDelta = wheelDeltaMagnitude;
+        }
+        anchorMinDelta = Math.min(anchorMinDelta, wheelDeltaMagnitude);
+        const isBatchedEvent = wheelDeltaMagnitude > anchorLastDelta * 1.8 && wheelDeltaMagnitude < anchorLastDelta * 2.2;
+        if (!isBatchedEvent && wheelDeltaMagnitude > anchorLastDelta * 1.01) {
+          consecutiveIncreases++;
+        } else if (wheelDeltaMagnitude < anchorLastDelta * 0.99) {
+          consecutiveIncreases = 0;
+        }
+        if (!isBatchedEvent && wheelDeltaMagnitude > anchorMinDelta * 1.05) {
+          sustainedHighCount++;
+        } else {
+          sustainedHighCount = 0;
+        }
+        const sustainedIncrease = consecutiveIncreases >= 3;
+        const sustainedHigh = sustainedHighCount >= 5;
+        const significantIncrease = !isBatchedEvent && wheelDeltaMagnitude > anchorMinDelta * 1.15 && wheelDeltaMagnitude > anchorLastDelta * 1.08;
+        const deltaIncreasing = sustainedIncrease || sustainedHigh || significantIncrease;
+        const hasWheelGap = timeSinceLastWheel > 200;
+        const deltaDecayed = wheelDeltaMagnitude < anchorInitialDelta * 0.3;
+        const isLowDelta = wheelDeltaMagnitude < 30;
+        if (hasWheelGap) {
+          anchorPosition = null;
+        } else if (deltaIncreasing && timeSinceAnchor > 100) {
+          anchorPosition = null;
+        } else if (isLowDelta) {
+          anchorPosition = null;
+        } else if (deltaDecayed && timeSinceAnchor > 300) {
+          anchorPosition = null;
+        } else {
+          if (scrollPosition !== anchorPosition) {
+            scrollPosition = anchorPosition;
+            if (viewportState) {
+              viewportState.scrollPosition = scrollPosition;
+            }
+            component.viewport.renderItems();
+          }
+          anchorLastDelta = wheelDeltaMagnitude;
+          return;
+        }
+        anchorLastDelta = wheelDeltaMagnitude;
+      }
+      const previousPosition = scrollPosition;
+      const maxScroll = Math.max(0, totalVirtualSize - containerSize);
+      let newPosition = scrollPosition + scrollDelta;
+      if (smoothing) {
+        const smoothingFactor = 0.3;
+        newPosition = scrollPosition + scrollDelta * smoothingFactor;
+      }
+      newPosition = clamp(newPosition, 0, maxScroll);
+      if (newPosition !== scrollPosition) {
+        scrollPosition = newPosition;
+        const now2 = Date.now();
+        if (!isScrolling) {
+          isScrolling = true;
+          stopIdleDetection();
+          startIdleDetection();
+        }
+        lastScrollTime = now2;
+        speedTracker = updateSpeedTracker(speedTracker, scrollPosition, previousPosition);
+        if (viewportState) {
+          viewportState.scrollPosition = scrollPosition;
+          viewportState.velocity = speedTracker.velocity;
+          viewportState.scrollDirection = speedTracker.direction;
+        }
+        const viewportEl = viewportState?.viewportElement || component.viewportElement;
+        if (viewportEl) {
+          updateScrolledState(viewportEl, scrollPosition);
+        }
+        pendingScrollData = {
+          position: scrollPosition,
+          direction: speedTracker.direction,
+          previousPosition
+        };
+        if (!renderScheduled) {
+          renderScheduled = true;
+          requestAnimationFrame(() => {
+            renderScheduled = false;
+            if (pendingScrollData) {
+              component.emit?.("viewport:scroll", {
+                position: pendingScrollData.position,
+                direction: pendingScrollData.direction,
+                previousPosition: pendingScrollData.previousPosition
+              });
+              component.emit?.("viewport:velocity-changed", {
+                velocity: speedTracker.velocity,
+                direction: speedTracker.direction
+              });
+              component.viewport.renderItems();
+              pendingScrollData = null;
+            }
+          });
+        }
+      }
+    };
+    const scrollToPosition = (position, source) => {
+      const maxScroll = Math.max(0, totalVirtualSize - containerSize);
+      const clampedPosition = clamp(position, 0, maxScroll);
+      if (clampedPosition !== scrollPosition) {
+        const previousPosition = scrollPosition;
+        scrollPosition = clampedPosition;
+        speedTracker = updateSpeedTracker(speedTracker, scrollPosition, previousPosition);
+        if (viewportState) {
+          viewportState.scrollPosition = scrollPosition;
+          viewportState.velocity = speedTracker.velocity;
+          viewportState.scrollDirection = speedTracker.direction;
+        }
+        const direction = clampedPosition > previousPosition ? "forward" : "backward";
+        const viewportEl = viewportState?.viewportElement || component.viewportElement;
+        if (viewportEl) {
+          updateScrolledState(viewportEl, scrollPosition);
+        }
+        component.emit?.("viewport:scroll", {
+          position: scrollPosition,
+          direction,
+          previousPosition
+        });
+        component.emit?.("viewport:velocity-changed", {
+          velocity: speedTracker.velocity,
+          direction: speedTracker.direction
+        });
+        if (!isScrolling) {
+          isScrolling = true;
+          startIdleDetection();
+        }
+        lastScrollTime = Date.now();
+        component.viewport.renderItems();
+      } else {}
+    };
+    const scrollToIndex = (index, alignment = "start") => {
+      if (!viewportState) {
+        return;
+      }
+      const itemSize = viewportState.itemSize || 50;
+      const totalItems = viewportState.totalItems || 0;
+      const actualTotalSize = totalItems * itemSize;
+      const MAX_VIRTUAL_SIZE = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.MAX_VIRTUAL_SIZE;
+      const isCompressed = actualTotalSize > MAX_VIRTUAL_SIZE;
+      let targetPosition;
+      if (isCompressed) {
+        const ratio = index / totalItems;
+        targetPosition = ratio * Math.min(actualTotalSize, MAX_VIRTUAL_SIZE);
+      } else {
+        targetPosition = index * itemSize;
+      }
+      switch (alignment) {
+        case "center":
+          targetPosition -= containerSize / 2 - itemSize / 2;
+          break;
+        case "end":
+          targetPosition -= containerSize - itemSize;
+          break;
+      }
+      scrollToPosition(targetPosition, "scrollToIndex");
+    };
+    const scrollToPage = (page, limit = 20, alignment = "start") => {
+      if (typeof alignment !== "string" || !["start", "center", "end"].includes(alignment)) {
+        console.warn(`[Scrolling] Invalid alignment "${alignment}", using "start"`);
+        alignment = "start";
+      }
+      const viewportConfig = component.config;
+      const isCursorMode = viewportConfig?.pagination?.strategy === "cursor";
+      if (isCursorMode) {
+        const collection = component.viewport.collection;
+        if (collection) {
+          const highestLoadedPage = Math.floor(collection.getLoadedRanges().size);
+          if (page > highestLoadedPage + 1) {
+            const maxPagesToLoad = 10;
+            const targetPage = Math.min(page, highestLoadedPage + maxPagesToLoad);
+            console.warn(`[Scrolling] Cannot jump directly to page ${page} in cursor mode. ` + `Pages must be loaded sequentially. Current highest page: ${highestLoadedPage}. ` + `Will load up to page ${targetPage}`);
+            const targetOffset = (targetPage - 1) * limit;
+            const currentOffset = highestLoadedPage * limit;
+            const lastLoadedIndex = highestLoadedPage * limit;
+            scrollToIndex(lastLoadedIndex, alignment);
+            return;
+          }
+        }
+      }
+      const index = (page - 1) * limit;
+      scrollToIndex(index, alignment);
+    };
+    const updateScrollBounds = (newTotalSize, newContainerSize) => {
+      totalVirtualSize = newTotalSize;
+      containerSize = newContainerSize;
+      if (viewportState) {
+        viewportState.virtualTotalSize = newTotalSize;
+        viewportState.containerSize = newContainerSize;
+      }
+      const totalItems = viewportState?.totalItems || 0;
+      if (totalItems <= 0) {
+        return;
+      }
+      const maxScroll = Math.max(0, totalVirtualSize - containerSize);
+      if (scrollPosition > maxScroll) {
+        scrollToPosition(maxScroll);
+      }
+    };
+    const originalScrollToIndex = component.viewport.scrollToIndex;
+    component.viewport.scrollToIndex = (index, alignment) => {
+      scrollToIndex(index, alignment);
+      originalScrollToIndex?.(index, alignment);
+    };
+    component.viewport.scrollToPage = (page, limit, alignment) => {
+      scrollToPage(page, limit, alignment);
+    };
+    const originalScrollToPosition = component.viewport.scrollToPosition;
+    component.viewport.scrollToPosition = (position) => {
+      scrollToPosition(position, "api");
+      originalScrollToPosition?.(position);
+    };
+    const originalGetScrollPosition = component.viewport.getScrollPosition;
+    component.viewport.getScrollPosition = () => {
+      return scrollPosition;
+    };
+    if ("destroy" in component && typeof component.destroy === "function") {
+      const originalDestroy = component.destroy;
+      component.destroy = () => {
+        const viewportElement = component._scrollingViewportElement;
+        if (viewportElement) {
+          viewportElement.removeEventListener("wheel", handleWheel);
+          if (component._scrollingStopOnClick) {
+            viewportElement.removeEventListener("mousedown", handleMouseDown);
+          }
+        }
+        if (idleTimeoutId) {
+          clearTimeout(idleTimeoutId);
+        }
+        stopIdleDetection();
+        originalDestroy?.();
+      };
+    }
+    const scrollBy = (delta) => {
+      const previousPosition = scrollPosition;
+      const maxScroll = Math.max(0, totalVirtualSize - containerSize);
+      const newPosition = clamp(scrollPosition + delta, 0, maxScroll);
+      if (newPosition !== previousPosition) {
+        scrollPosition = newPosition;
+        speedTracker = updateSpeedTracker(speedTracker, scrollPosition, previousPosition);
+        if (viewportState) {
+          viewportState.scrollPosition = scrollPosition;
+          viewportState.velocity = speedTracker.velocity;
+        }
+        const viewportEl = viewportState?.viewportElement || component.viewportElement;
+        if (viewportEl) {
+          updateScrolledState(viewportEl, scrollPosition);
+        }
+        component.emit?.("viewport:scroll", {
+          position: scrollPosition,
+          velocity: speedTracker.velocity,
+          direction: speedTracker.direction
+        });
+        component.viewport.renderItems?.();
+        if (!isScrolling) {
+          isScrolling = true;
+          startIdleDetection();
+        }
+        lastScrollTime = Date.now();
+      }
+    };
+    component.viewport.scrollingState = {
+      setVelocityToZero
+    };
+    component.viewport.scrollBy = scrollBy;
+    component.viewport.getVelocity = () => speedTracker.velocity;
+    component.scrolling = {
+      handleWheel,
+      scrollToPosition,
+      scrollToIndex,
+      scrollToPage,
+      scrollBy,
+      getScrollPosition: () => scrollPosition,
+      updateScrollBounds,
+      getVelocity: () => speedTracker.velocity,
+      getDirection: () => speedTracker.direction,
+      isScrolling: () => isScrolling
+    };
+    return component;
+  };
+};
+
+// src/core/viewport/features/momentum.ts
+var withMomentum = (config = {}) => {
+  return (component) => {
+    const {
+      enabled = VIEWPORT_CONSTANTS.MOMENTUM.ENABLED,
+      deceleration = VIEWPORT_CONSTANTS.MOMENTUM.DECELERATION_FACTOR,
+      minVelocity = VIEWPORT_CONSTANTS.MOMENTUM.MIN_VELOCITY,
+      minDuration = VIEWPORT_CONSTANTS.MOMENTUM.MIN_DURATION,
+      minVelocityThreshold = VIEWPORT_CONSTANTS.MOMENTUM.MIN_VELOCITY_THRESHOLD,
+      stopOnClick = true
+    } = config;
+    let momentumAnimationId = null;
+    let isTouching = false;
+    let isMouseDragging = false;
+    let lastTouchPosition = 0;
+    let lastMousePosition = 0;
+    let touchStartTime = 0;
+    let viewportState;
+    let scrollingState;
+    let isEnabled = enabled;
+    const originalInitialize = component.viewport.initialize;
+    component.viewport.initialize = () => {
+      const result = originalInitialize();
+      if (result === false) {
+        return false;
+      }
+      viewportState = component.viewport.state;
+      scrollingState = component.viewport.scrollingState;
+      return result;
+    };
+    const stopMomentum = () => {
+      if (momentumAnimationId) {
+        cancelAnimationFrame(momentumAnimationId);
+        momentumAnimationId = null;
+        if (scrollingState) {
+          scrollingState.setVelocityToZero?.();
+        }
+      }
+    };
+    const startMomentum = (initialVelocity) => {
+      if (momentumAnimationId) {
+        cancelAnimationFrame(momentumAnimationId);
+      }
+      let velocity = initialVelocity;
+      const animate = () => {
+        velocity *= deceleration;
+        if (Math.abs(velocity) < minVelocity) {
+          momentumAnimationId = null;
+          if (scrollingState) {
+            scrollingState.setVelocityToZero?.();
+          }
+          return;
+        }
+        const frameDelta = velocity * VIEWPORT_CONSTANTS.MOMENTUM.FRAME_TIME;
+        if (component.viewport.scrollBy) {
+          component.viewport.scrollBy(frameDelta);
+          momentumAnimationId = requestAnimationFrame(animate);
+        } else {
+          momentumAnimationId = null;
+        }
+      };
+      momentumAnimationId = requestAnimationFrame(animate);
+    };
+    const handleTouchStart = (e) => {
+      isTouching = true;
+      const touch = e.touches[0];
+      const orientation = viewportState?.orientation || "vertical";
+      lastTouchPosition = orientation === "vertical" ? touch.clientY : touch.clientX;
+      touchStartTime = Date.now();
+      if (momentumAnimationId) {
+        cancelAnimationFrame(momentumAnimationId);
+        momentumAnimationId = null;
+      }
+    };
+    const handleTouchMove = (e) => {
+      if (!isTouching)
+        return;
+      e.preventDefault();
+      const touch = e.touches[0];
+      const orientation = viewportState?.orientation || "vertical";
+      const currentPosition = orientation === "vertical" ? touch.clientY : touch.clientX;
+      const delta = lastTouchPosition - currentPosition;
+      lastTouchPosition = currentPosition;
+      if (component.viewport.scrollBy) {
+        component.viewport.scrollBy(delta);
+      }
+    };
+    const handleTouchEnd = () => {
+      if (!isTouching)
+        return;
+      isTouching = false;
+      const touchEndTime = Date.now();
+      const touchDuration = touchEndTime - touchStartTime;
+      const velocity = component.viewport.getVelocity?.() || 0;
+      if (touchDuration < minDuration && Math.abs(velocity) > minVelocityThreshold) {
+        startMomentum(velocity);
+      }
+    };
+    const handleClick = (_e) => {
+      stopMomentum();
+    };
+    const handleMouseDown = (e) => {
+      isMouseDragging = true;
+      const orientation = viewportState?.orientation || "vertical";
+      lastMousePosition = orientation === "vertical" ? e.clientY : e.clientX;
+      touchStartTime = Date.now();
+      stopMomentum();
+      e.preventDefault();
+    };
+    const handleMouseMove = (e) => {
+      if (!isMouseDragging)
+        return;
+      const orientation = viewportState?.orientation || "vertical";
+      const currentPosition = orientation === "vertical" ? e.clientY : e.clientX;
+      const delta = lastMousePosition - currentPosition;
+      lastMousePosition = currentPosition;
+      if (component.viewport.scrollBy) {
+        component.viewport.scrollBy(delta);
+      }
+    };
+    const handleMouseUp = () => {
+      if (!isMouseDragging)
+        return;
+      isMouseDragging = false;
+      const mouseUpTime = Date.now();
+      const dragDuration = mouseUpTime - touchStartTime;
+      const velocity = component.viewport.getVelocity?.() || 0;
+      if (dragDuration < minDuration && Math.abs(velocity) > minVelocityThreshold) {
+        startMomentum(velocity);
+      }
+    };
+    const originalInit = component.viewport.initialize;
+    component.viewport.initialize = () => {
+      const result = originalInit();
+      if (result === false) {
+        return false;
+      }
+      const viewportElement = component.viewportElement || component.viewport.state?.viewportElement;
+      if (viewportElement) {
+        viewportElement.addEventListener("touchstart", handleTouchStart, {
+          passive: true
+        });
+        viewportElement.addEventListener("touchmove", handleTouchMove, {
+          passive: false
+        });
+        viewportElement.addEventListener("touchend", handleTouchEnd, {
+          passive: true
+        });
+        viewportElement.addEventListener("mousedown", handleMouseDown);
+        viewportElement.addEventListener("mousemove", handleMouseMove);
+        viewportElement.addEventListener("mouseup", handleMouseUp);
+        viewportElement.addEventListener("mouseleave", handleMouseUp);
+        if (stopOnClick) {
+          viewportElement.addEventListener("click", handleClick);
+        }
+        component._momentumViewportElement = viewportElement;
+        component._momentumStopOnClick = stopOnClick;
+      }
+    };
+    if ("destroy" in component && typeof component.destroy === "function") {
+      const originalDestroy = component.destroy;
+      component.destroy = () => {
+        const viewportElement = component._momentumViewportElement;
+        if (viewportElement) {
+          viewportElement.removeEventListener("touchstart", handleTouchStart);
+          viewportElement.removeEventListener("touchmove", handleTouchMove);
+          viewportElement.removeEventListener("touchend", handleTouchEnd);
+          viewportElement.removeEventListener("mousedown", handleMouseDown);
+          viewportElement.removeEventListener("mousemove", handleMouseMove);
+          viewportElement.removeEventListener("mouseup", handleMouseUp);
+          viewportElement.removeEventListener("mouseleave", handleMouseUp);
+          if (component._momentumStopOnClick) {
+            viewportElement.removeEventListener("click", handleClick);
+          }
+        }
+        stopMomentum();
+        originalDestroy();
+      };
+    }
+    component.viewport.momentumState = {
+      stopMomentum
+    };
+    return component;
+  };
+};
+
+// src/core/viewport/features/scrollbar.ts
+var import_mtrl2 = require("mtrl");
+function withScrollbar(config = {}) {
+  return (component) => {
+    const {
+      enabled = true,
+      autoHide = true,
+      thumbMinHeight = 25,
+      borderRadius = 4,
+      fadeTimeout = 1000
+    } = config;
+    if (!enabled) {
+      return {
+        ...component,
+        scrollbar: {
+          show: () => {},
+          hide: () => {},
+          updateBounds: () => {},
+          updatePosition: () => {}
+        }
+      };
+    }
+    let viewportElement = null;
+    let scrollbarTrack = null;
+    let scrollbarThumb = null;
+    let isInitialized = false;
+    let isDragging = false;
+    let dragStartY = 0;
+    let dragStartScrollPosition = 0;
+    let hideTimeout = null;
+    let totalVirtualSize = 0;
+    let containerSize = 0;
+    let thumbHeight = 0;
+    let animationFrameId = null;
+    let lastRequestedScrollPosition = null;
+    let isCursorMode = false;
+    let loadedItemsCount = 0;
+    const createScrollbarElements = () => {
+      if (!viewportElement)
+        return;
+      scrollbarTrack = document.createElement("div");
+      import_mtrl2.addClass(scrollbarTrack, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR);
+      scrollbarTrack.style.cssText = `
+        position: absolute;
+        top: 0;
+        right: 0;
+        height: 100%;
+        z-index: 10;
+      `;
+      scrollbarThumb = document.createElement("div");
+      import_mtrl2.addClass(scrollbarThumb, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_THUMB);
+      scrollbarTrack.appendChild(scrollbarThumb);
+      viewportElement.appendChild(scrollbarTrack);
+    };
+    const show = () => {
+      if (!scrollbarTrack || totalVirtualSize <= containerSize)
+        return;
+      if (hideTimeout) {
+        clearTimeout(hideTimeout);
+        hideTimeout = null;
+      }
+      import_mtrl2.addClass(scrollbarTrack, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_VISIBLE);
+      if (autoHide && !isDragging) {
+        hideTimeout = setTimeout(hide, fadeTimeout);
+      }
+    };
+    const hide = () => {
+      if (!scrollbarTrack || isDragging)
+        return;
+      import_mtrl2.removeClass(scrollbarTrack, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_VISIBLE);
+    };
+    const updateBounds = (newTotalSize, newContainerSize) => {
+      totalVirtualSize = newTotalSize;
+      containerSize = newContainerSize;
+      if (!scrollbarTrack || !scrollbarThumb)
+        return;
+      const needsScrollbar = totalVirtualSize > containerSize;
+      scrollbarTrack.style.display = needsScrollbar ? "block" : "none";
+      if (needsScrollbar) {
+        let scrollRatio;
+        if (isCursorMode && loadedItemsCount > 0) {
+          const estimatedTotal = totalVirtualSize > 0 ? totalVirtualSize : loadedItemsCount * 2;
+          scrollRatio = containerSize / Math.max(estimatedTotal, loadedItemsCount + containerSize);
+        } else {
+          scrollRatio = containerSize / totalVirtualSize;
+        }
+        thumbHeight = Math.max(thumbMinHeight, scrollRatio * containerSize);
+        scrollbarThumb.style.height = `${thumbHeight}px`;
+        updatePosition(component.viewport?.getScrollPosition() || 0);
+      }
+    };
+    const updatePosition = (scrollPos) => {
+      if (!scrollbarThumb || !scrollbarTrack)
+        return;
+      const scrollableDistance = totalVirtualSize - containerSize;
+      if (scrollableDistance <= 0)
+        return;
+      const scrollRatio = Math.min(1, Math.max(0, scrollPos / scrollableDistance));
+      const maxThumbPosition = scrollbarTrack.clientHeight - scrollbarThumb.clientHeight;
+      const thumbPosition = scrollRatio * maxThumbPosition;
+      scrollbarThumb.style.transform = `translateY(${thumbPosition}px)`;
+    };
+    const handleTrackClick = (e) => {
+      if (!scrollbarTrack || !scrollbarThumb || e.target === scrollbarThumb)
+        return;
+      const trackRect = scrollbarTrack.getBoundingClientRect();
+      const clickY = e.clientY - trackRect.top;
+      const thumbCenterY = clickY - thumbHeight / 2;
+      const maxThumbPosition = containerSize - thumbHeight;
+      const thumbPosition = Math.max(0, Math.min(thumbCenterY, maxThumbPosition));
+      const scrollRatio = thumbPosition / maxThumbPosition;
+      const targetScrollPosition = scrollRatio * (totalVirtualSize - containerSize);
+      component.viewport?.scrollToPosition(targetScrollPosition);
+    };
+    const handleThumbMouseDown = (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      isDragging = true;
+      dragStartY = e.clientY;
+      dragStartScrollPosition = component.viewport?.getScrollPosition() || 0;
+      if (scrollbarTrack) {
+        import_mtrl2.addClass(scrollbarTrack, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_DRAGGING);
+      }
+      component.emit?.("viewport:drag-start", {
+        source: "scrollbar",
+        startPosition: dragStartScrollPosition
+      });
+      document.addEventListener("mousemove", handleMouseMove);
+      document.addEventListener("mouseup", handleMouseUp);
+    };
+    const handleMouseMove = (e) => {
+      if (!isDragging || !scrollbarTrack || !scrollbarThumb)
+        return;
+      const deltaY = e.clientY - dragStartY;
+      const trackHeight = scrollbarTrack.clientHeight;
+      const thumbHeight2 = scrollbarThumb.clientHeight;
+      const maxThumbTravel = trackHeight - thumbHeight2;
+      if (maxThumbTravel <= 0)
+        return;
+      const deltaRatio = deltaY / maxThumbTravel;
+      const dragStartScrollRatio = dragStartScrollPosition / (totalVirtualSize - containerSize);
+      const newScrollRatio = Math.max(0, Math.min(1, dragStartScrollRatio + deltaRatio));
+      const thumbPosition = newScrollRatio * maxThumbTravel;
+      scrollbarThumb.style.transform = `translateY(${thumbPosition}px)`;
+      const newPosition = newScrollRatio * (totalVirtualSize - containerSize);
+      lastRequestedScrollPosition = newPosition;
+      if (animationFrameId === null && component.viewport) {
+        animationFrameId = requestAnimationFrame(() => {
+          if (lastRequestedScrollPosition !== null && component.viewport) {
+            component.viewport.scrollToPosition(lastRequestedScrollPosition);
+          }
+          animationFrameId = null;
+        });
+      }
+    };
+    const handleMouseUp = () => {
+      isDragging = false;
+      if (animationFrameId !== null) {
+        cancelAnimationFrame(animationFrameId);
+        animationFrameId = null;
+      }
+      if (lastRequestedScrollPosition !== null && component.viewport) {
+        component.viewport.scrollToPosition(lastRequestedScrollPosition);
+        lastRequestedScrollPosition = null;
+      }
+      if (scrollbarTrack) {
+        import_mtrl2.removeClass(scrollbarTrack, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_DRAGGING);
+      }
+      component.emit?.("viewport:drag-end", {
+        source: "scrollbar",
+        endPosition: component.viewport?.getScrollPosition() || 0
+      });
+      hide();
+      document.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("mouseup", handleMouseUp);
+    };
+    const initialize = () => {
+      if (isInitialized)
+        return;
+      viewportElement = component.element?.querySelector(`.${import_mtrl2.PREFIX}-viewport`);
+      if (!viewportElement) {
+        console.warn("[Scrollbar] No viewport element found");
+        return;
+      }
+      if (viewportElement.querySelector(`.${import_mtrl2.PREFIX}-${VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR}`))
+        return;
+      createScrollbarElements();
+      isInitialized = true;
+      if (scrollbarTrack && viewportElement) {
+        scrollbarTrack.addEventListener("click", handleTrackClick);
+        if (scrollbarThumb) {
+          scrollbarThumb.addEventListener("mousedown", handleThumbMouseDown);
+        }
+        viewportElement.addEventListener("mouseenter", show, { passive: true });
+        viewportElement.addEventListener("mouseleave", () => {
+          if (!isDragging)
+            hide();
+        }, { passive: true });
+      }
+      if (component.viewport) {
+        const info = component.viewport.getViewportInfo();
+        totalVirtualSize = info.totalVirtualSize;
+        containerSize = info.containerSize;
+        const collection = component.collection;
+        const viewportConfig = component.config;
+        isCursorMode = viewportConfig?.pagination?.strategy === "cursor";
+        updateBounds(totalVirtualSize, containerSize);
+        updatePosition(component.viewport.getScrollPosition());
+      }
+      component.on?.("viewport:scroll", (data) => {
+        if (!isDragging) {
+          updatePosition(data.position);
+          show();
+        }
+      });
+      component.on?.("viewport:virtual-size-changed", (data) => {
+        totalVirtualSize = data.totalVirtualSize;
+        updateBounds(data.totalVirtualSize, containerSize);
+      });
+      component.on?.("viewport:container-size-changed", (data) => {
+        containerSize = data.containerSize;
+        updateBounds(totalVirtualSize, data.containerSize);
+      });
+      component.on?.("viewport:items-changed", (data) => {
+        if (isCursorMode) {
+          loadedItemsCount = data.loadedCount || 0;
+          updateBounds(totalVirtualSize, containerSize);
+        }
+      });
+      component.on?.("viewport:total-items-changed", (data) => {
+        if (isCursorMode && data.total) {
+          console.log(`[Scrollbar] Cursor mode: updating bounds for new total ${data.total}`);
+          updateBounds(totalVirtualSize, containerSize);
+        }
+      });
+    };
+    storeFeatureFunction(component, "_scrollbarInitialize", initialize);
+    wrapInitialize(component, initialize);
+    const destroy = () => {
+      if (scrollbarTrack) {
+        scrollbarTrack.remove();
+        scrollbarTrack = null;
+      }
+      scrollbarThumb = null;
+      viewportElement = null;
+      isInitialized = false;
+      if (hideTimeout) {
+        clearTimeout(hideTimeout);
+        hideTimeout = null;
+      }
+      document.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("mouseup", handleMouseUp);
+    };
+    storeFeatureFunction(component, "_scrollbarDestroy", destroy);
+    wrapDestroy(component, destroy);
+    return {
+      ...component,
+      scrollbar: { show, hide, updateBounds, updatePosition }
+    };
+  };
+}
+
+// src/core/viewport/features/collection.ts
+function withCollection(config = {}) {
+  return (component) => {
+    const {
+      collection,
+      rangeSize = VIEWPORT_CONSTANTS.LOADING.DEFAULT_RANGE_SIZE,
+      strategy = "offset",
+      transform,
+      cancelLoadThreshold = VIEWPORT_CONSTANTS.LOADING.CANCEL_THRESHOLD,
+      maxConcurrentRequests = VIEWPORT_CONSTANTS.LOADING.MAX_CONCURRENT_REQUESTS,
+      enableRequestQueue = VIEWPORT_CONSTANTS.REQUEST_QUEUE.ENABLED,
+      maxQueueSize = VIEWPORT_CONSTANTS.REQUEST_QUEUE.MAX_QUEUE_SIZE,
+      loadOnDragEnd = true,
+      initialScrollIndex = 0,
+      selectId,
+      autoLoad = true,
+      autoSelectFirst = false,
+      maxCachedItems = 1000,
+      evictionBuffer = 150
+    } = config;
+    let hasCompletedInitialPositionLoad = false;
+    const hasInitialScrollIndex = initialScrollIndex > 0;
+    let hasManuallyLoaded = false;
+    let reloadInProgress = false;
+    let reloadTargetRange = null;
+    let currentVelocity = 0;
+    let activeLoadCount = 0;
+    let completedLoads = 0;
+    let failedLoads = 0;
+    let cancelledLoads = 0;
+    let isDragging = false;
+    const MAX_CACHED_ITEMS = maxCachedItems;
+    const EVICTION_BUFFER = evictionBuffer;
+    let cachedItemCount = 0;
+    const logMemoryStats = (caller) => {
+      const loadedRangeCount = loadedRanges.size;
+      const pendingRangeCount = pendingRanges.size;
+      const abortControllerCount = abortControllers.size;
+    };
+    const evictDistantItems = (visibleStart, visibleEnd) => {
+      if (cachedItemCount <= MAX_CACHED_ITEMS) {
+        return;
+      }
+      const keepStart = Math.max(0, visibleStart - EVICTION_BUFFER);
+      const keepEnd = visibleEnd + EVICTION_BUFFER;
+      const keepRangeStart = Math.floor(keepStart / rangeSize);
+      const keepRangeEnd = Math.floor(keepEnd / rangeSize);
+      let evictedCount = 0;
+      const rangesToRemove = new Set;
+      loadedRanges.forEach((rangeId) => {
+        if (rangeId < keepRangeStart || rangeId > keepRangeEnd) {
+          rangesToRemove.add(rangeId);
+          const rangeStart = rangeId * rangeSize;
+          const rangeEnd = rangeStart + rangeSize;
+          for (let i = rangeStart;i < rangeEnd; i++) {
+            if (items[i] !== undefined) {
+              delete items[i];
+              evictedCount++;
+            }
+          }
+        }
+      });
+      rangesToRemove.forEach((rangeId) => {
+        loadedRanges.delete(rangeId);
+        pendingRanges.delete(rangeId);
+        activeRequests.delete(rangeId);
+        const controller = abortControllers.get(rangeId);
+        if (controller) {
+          controller.abort();
+          abortControllers.delete(rangeId);
+        }
+      });
+      if (evictedCount > 0) {
+        cachedItemCount -= evictedCount;
+        component.emit?.("collection:items-evicted", {
+          keepStart,
+          keepEnd,
+          evictedCount
+        });
+      }
+    };
+    const activeLoadRanges = new Set;
+    let loadRequestQueue = [];
+    const abortControllers = new Map;
+    let items = [];
+    let totalItems = 0;
+    let loadedRanges = new Set;
+    let pendingRanges = new Set;
+    let failedRanges = new Map;
+    let activeRequests = new Map;
+    let currentCursor = null;
+    let cursorMap = new Map;
+    let pageToOffsetMap = new Map;
+    let highestLoadedPage = 0;
+    let discoveredTotal = null;
+    let hasReachedEnd = false;
+    component.items = items;
+    const getRangeId = (offset, limit) => {
+      return Math.floor(offset / rangeSize);
+    };
+    const getRangeKey = (range) => {
+      return `${range.start}-${range.end}`;
+    };
+    const canLoad = () => {
+      return currentVelocity <= cancelLoadThreshold;
+    };
+    const processQueue = () => {
+      if (!enableRequestQueue || loadRequestQueue.length === 0)
+        return;
+      loadRequestQueue.sort((a, b) => {
+        const priorityOrder = { high: 0, normal: 1, low: 2 };
+        const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+        return priorityDiff !== 0 ? priorityDiff : a.timestamp - b.timestamp;
+      });
+      while (loadRequestQueue.length > 0 && activeLoadCount < maxConcurrentRequests) {
+        const request = loadRequestQueue.shift();
+        if (request) {
+          executeQueuedLoad(request);
+        }
+      }
+    };
+    const executeQueuedLoad = (request) => {
+      activeLoadCount++;
+      activeLoadRanges.add(getRangeKey(request.range));
+      loadMissingRangesInternal(request.range, request.caller).then(() => {
+        request.resolve();
+        completedLoads++;
+      }).catch((error) => {
+        request.reject(error);
+        failedLoads++;
+      }).finally(() => {
+        activeLoadCount--;
+        activeLoadRanges.delete(getRangeKey(request.range));
+        processQueue();
+      });
+    };
+    const transformItems = (rawItems) => {
+      if (!transform)
+        return rawItems;
+      return rawItems.map(transform);
+    };
+    const loadRange = async (offset, limit, caller) => {
+      if (!collection) {
+        console.warn("[Collection] No collection adapter configured");
+        return [];
+      }
+      const rangeId = getRangeId(offset, limit);
+      if (loadedRanges.has(rangeId)) {
+        return items.slice(offset, offset + limit);
+      }
+      if (pendingRanges.has(rangeId)) {
+        const existingRequest = activeRequests.get(rangeId);
+        if (existingRequest) {
+          return existingRequest;
+        }
+      }
+      pendingRanges.add(rangeId);
+      const abortController = new AbortController;
+      abortControllers.set(rangeId, abortController);
+      const requestPromise = (async () => {
+        try {
+          const page = Math.floor(offset / limit) + 1;
+          let params;
+          if (strategy === "cursor") {
+            if (page === 1) {
+              params = { limit };
+            } else {
+              const prevPageCursor = cursorMap.get(page - 1);
+              if (!prevPageCursor) {
+                console.warn(`[Collection] Cannot load page ${page} without cursor for page ${page - 1}`);
+                throw new Error(`Sequential loading required - missing cursor for page ${page - 1}`);
+              }
+              params = { cursor: prevPageCursor, limit };
+            }
+          } else if (strategy === "page") {
+            params = { page, limit };
+          } else {
+            params = { offset, limit };
+          }
+          const selfRef = component._selfRef;
+          const self = selfRef?.current ?? {};
+          if (typeof self._searchQuery === "function") {
+            const searchQuery = self._searchQuery();
+            if (searchQuery) {
+              params.search = searchQuery;
+            }
+          }
+          if (typeof self._filters === "function") {
+            const filters = self._filters();
+            if (filters && Object.keys(filters).length > 0) {
+              params.filters = filters;
+            }
+          }
+          const response = await collection.read({
+            ...params,
+            signal: abortController.signal
+          });
+          const rawItems = response.data || response.items || response;
+          const meta = response.meta || {};
+          const responseCursor = meta.cursor || meta.nextCursor;
+          if (strategy === "cursor" && responseCursor) {
+            currentCursor = responseCursor;
+            cursorMap.set(page, responseCursor);
+            pageToOffsetMap.set(page, offset);
+            highestLoadedPage = Math.max(highestLoadedPage, page);
+          }
+          if (strategy === "cursor" && meta.hasNext === false) {
+            hasReachedEnd = true;
+          }
+          if (meta.total !== undefined) {
+            discoveredTotal = meta.total;
+          }
+          const transformedItems = transformItems(rawItems);
+          let newItemsAdded = 0;
+          transformedItems.forEach((item, index) => {
+            if (items[offset + index] === undefined) {
+              newItemsAdded++;
+            }
+            items[offset + index] = item;
+          });
+          cachedItemCount += newItemsAdded;
+          let newTotal = discoveredTotal ?? totalItems;
+          if (offset === 0 && transformedItems.length === 0) {
+            newTotal = 0;
+            discoveredTotal = 0;
+          }
+          if (strategy === "cursor") {
+            const loadedItemsCount = cachedItemCount;
+            const marginItems = hasReachedEnd ? 0 : rangeSize * VIEWPORT_CONSTANTS.PAGINATION.CURSOR_SCROLL_MARGIN_MULTIPLIER;
+            const minVirtualItems = rangeSize * VIEWPORT_CONSTANTS.PAGINATION.CURSOR_MIN_VIRTUAL_SIZE_MULTIPLIER;
+            newTotal = Math.max(loadedItemsCount + marginItems, minVirtualItems);
+            if (newTotal > totalItems) {
+              totalItems = newTotal;
+              setTotalItems(newTotal);
+            }
+          } else {
+            newTotal = discoveredTotal ?? totalItems;
+          }
+          if (newTotal !== totalItems) {
+            totalItems = newTotal;
+            setTotalItems(newTotal);
+          }
+          component.items = items;
+          component.emit?.("viewport:items-changed", {
+            totalItems: newTotal,
+            loadedCount: cachedItemCount
+          });
+          const viewportState = component.viewport.state;
+          if (viewportState) {
+            viewportState.totalItems = newTotal ?? items.length;
+          }
+          const itemsActuallyStored = transformedItems.length > 0 && transformedItems.every((_, idx) => items[offset + idx] !== undefined);
+          if (itemsActuallyStored) {
+            loadedRanges.add(rangeId);
+          }
+          pendingRanges.delete(rangeId);
+          failedRanges.delete(rangeId);
+          if (completedLoads % 5 === 0) {
+            logMemoryStats(`load:${completedLoads}`);
+          }
+          component.emit?.("viewport:range-loaded", {
+            offset,
+            limit,
+            items: transformedItems,
+            total: newTotal
+          });
+          component.emit?.("collection:range-loaded", {
+            offset,
+            limit,
+            items: transformedItems,
+            total: newTotal,
+            rangeId,
+            itemsInMemory: items.filter((item) => item !== undefined).length,
+            cursor: strategy === "cursor" ? currentCursor : undefined
+          });
+          component.viewport?.updateViewport?.();
+          return transformedItems;
+        } catch (error) {
+          const isAbortError = error.name === "AbortError" || error.message === "Failed to fetch" && abortController.signal.aborted;
+          if (isAbortError) {
+            pendingRanges.delete(rangeId);
+            cancelledLoads++;
+            return [];
+          }
+          pendingRanges.delete(rangeId);
+          failedLoads++;
+          const attempts = (failedRanges.get(rangeId)?.attempts || 0) + 1;
+          failedRanges.set(rangeId, {
+            attempts,
+            lastError: error,
+            timestamp: Date.now()
+          });
+          component.emit?.("viewport:range-error", {
+            offset,
+            limit,
+            error,
+            attempts
+          });
+          throw error;
+        } finally {
+          activeRequests.delete(rangeId);
+          abortControllers.delete(rangeId);
+        }
+      })();
+      activeRequests.set(rangeId, requestPromise);
+      return requestPromise;
+    };
+    const loadMissingRangesInternal = async (range, caller) => {
+      if (!collection)
+        return;
+      if (strategy === "cursor") {
+        const startPage = Math.floor(range.start / rangeSize) + 1;
+        const endPage = Math.floor(range.end / rangeSize) + 1;
+        const maxPagesToLoad = 10;
+        const currentHighestPage = highestLoadedPage || 0;
+        const limitedEndPage = Math.min(endPage, currentHighestPage + maxPagesToLoad);
+        for (let page = startPage;page <= limitedEndPage; page++) {
+          const rangeId = page - 1;
+          const offset = rangeId * rangeSize;
+          if (pendingRanges.has(rangeId)) {
+            return;
+          }
+          if (!loadedRanges.has(rangeId) && !pendingRanges.has(rangeId)) {
+            if (page > 1) {
+              let canLoad2 = true;
+              for (let prevPage = 1;prevPage < page; prevPage++) {
+                const prevRangeId = prevPage - 1;
+                if (!loadedRanges.has(prevRangeId)) {
+                  canLoad2 = false;
+                  if (!pendingRanges.has(prevRangeId)) {
+                    try {
+                      await loadRange(prevRangeId * rangeSize, rangeSize);
+                    } catch (error) {
+                      console.error(`[Collection] Failed to load prerequisite page ${prevPage}:`, error);
+                      return;
+                    }
+                  }
+                  break;
+                }
+              }
+              if (!canLoad2) {
+                continue;
+              }
+            }
+            try {
+              await loadRange(offset, rangeSize);
+            } catch (error) {
+              console.error(`[Collection] Failed to load page ${page}:`, error);
+              break;
+            }
+          }
+        }
+        if (endPage > limitedEndPage) {}
+        return;
+      }
+      const startRange = Math.floor(range.start / rangeSize);
+      const endRange = Math.floor(range.end / rangeSize);
+      const rangesToLoad = [];
+      const visibleStart = range.start;
+      const visibleEnd = range.end;
+      let hasMissingData = false;
+      if (totalItems === 0 || items.length === 0) {
+        hasMissingData = true;
+      } else {
+        for (let i = visibleStart;i <= visibleEnd && i < totalItems; i++) {
+          if (items[i] === undefined) {
+            hasMissingData = true;
+            break;
+          }
+        }
+      }
+      if (hasMissingData) {
+        for (let rangeId = startRange;rangeId <= endRange; rangeId++) {
+          if (pendingRanges.has(rangeId)) {
+            continue;
+          }
+          if (totalItems === 0) {
+            loadedRanges.delete(rangeId);
+            rangesToLoad.push(rangeId);
+            continue;
+          }
+          const rangeStart = rangeId * rangeSize;
+          const rangeEnd = Math.min(rangeStart + rangeSize, totalItems);
+          let rangeMissingData = false;
+          for (let i = rangeStart;i < rangeEnd; i++) {
+            if (i >= visibleStart && i <= visibleEnd && items[i] === undefined) {
+              rangeMissingData = true;
+              break;
+            }
+          }
+          if (rangeMissingData) {
+            loadedRanges.delete(rangeId);
+            rangesToLoad.push(rangeId);
+          }
+        }
+      }
+      if (rangesToLoad.length === 0) {
+        if (loadRequestQueue.length > 0 && activeLoadCount < maxConcurrentRequests) {
+          processQueue();
+        }
+        return;
+      }
+      const promises = rangesToLoad.map((rangeId) => loadRange(rangeId * rangeSize, rangeSize));
+      await Promise.allSettled(promises);
+    };
+    const loadMissingRanges = (range, caller) => {
+      return new Promise((resolve, reject) => {
+        const rangeKey = getRangeKey(range);
+        if (activeLoadRanges.has(rangeKey)) {
+          resolve();
+          return;
+        }
+        if (isDragging && currentVelocity < 0.5 && currentVelocity > 0) {
+          cancelledLoads++;
+          resolve();
+          return;
+        }
+        if (!canLoad()) {
+          cancelledLoads++;
+          resolve();
+          return;
+        }
+        if (activeLoadCount < maxConcurrentRequests) {
+          executeQueuedLoad({
+            range,
+            priority: "normal",
+            timestamp: Date.now(),
+            resolve,
+            reject,
+            caller
+          });
+        } else if (enableRequestQueue && loadRequestQueue.length < maxQueueSize) {
+          loadRequestQueue.push({
+            range,
+            priority: "normal",
+            timestamp: Date.now(),
+            resolve,
+            reject,
+            caller
+          });
+        } else {
+          if (caller === "viewport:idle" || caller === "viewport:range-changed") {
+            loadRequestQueue.forEach((r) => {
+              cancelledLoads++;
+              r.resolve();
+            });
+            loadRequestQueue.length = 0;
+            loadRequestQueue.push({
+              range,
+              priority: "high",
+              timestamp: Date.now(),
+              resolve,
+              reject,
+              caller
+            });
+          } else {
+            if (loadRequestQueue.length >= maxQueueSize) {
+              const removed = loadRequestQueue.splice(0, loadRequestQueue.length - maxQueueSize);
+              removed.forEach((r) => {
+                cancelledLoads++;
+                r.resolve();
+              });
+            }
+            resolve();
+          }
+        }
+      });
+    };
+    const retryFailedRange = async (rangeId) => {
+      failedRanges.delete(rangeId);
+      const offset = rangeId * rangeSize;
+      return loadRange(offset, rangeSize);
+    };
+    const setTotalItems = (total) => {
+      totalItems = total;
+      const viewportState = component.viewport.state;
+      if (viewportState) {
+        viewportState.totalItems = total;
+      }
+      component.emit?.("viewport:total-items-changed", { total });
+    };
+    const originalInitialize = component.viewport.initialize;
+    component.viewport.initialize = () => {
+      const result = originalInitialize();
+      if (result === false) {
+        return false;
+      }
+      if (component.totalItems) {
+        totalItems = component.totalItems;
+      }
+      component.on?.("viewport:drag-start", () => {
+        isDragging = true;
+      });
+      component.on?.("viewport:drag-end", () => {
+        isDragging = false;
+        if (loadOnDragEnd) {
+          processQueue();
+        }
+      });
+      component.on?.("viewport:range-changed", async (data) => {
+        const range = data.range || data;
+        if (!autoLoad && !hasManuallyLoaded) {
+          return;
+        }
+        const { start, end } = range;
+        if (typeof start !== "number" || typeof end !== "number") {
+          console.warn("[Collection] Invalid range in viewport:range-changed event:", data);
+          return;
+        }
+        if (hasInitialScrollIndex && !hasCompletedInitialPositionLoad) {
+          const page1EndIndex = rangeSize - 1;
+          if (start === 0 && end <= page1EndIndex) {
+            return;
+          }
+        }
+        if (reloadInProgress && reloadTargetRange) {
+          const page1EndIndex = rangeSize - 1;
+          if (start === 0 && end <= page1EndIndex) {
+            if (reloadTargetRange.start > page1EndIndex) {
+              return;
+            }
+          }
+        }
+        loadMissingRanges({ start, end }, "viewport:range-changed");
+        evictDistantItems(start, end);
+        if (strategy === "cursor" && !hasReachedEnd) {
+          const loadedItemsCount = cachedItemCount;
+          const marginItems = rangeSize * VIEWPORT_CONSTANTS.PAGINATION.CURSOR_SCROLL_MARGIN_MULTIPLIER;
+          const minVirtualItems = rangeSize * VIEWPORT_CONSTANTS.PAGINATION.CURSOR_MIN_VIRTUAL_SIZE_MULTIPLIER;
+          const dynamicTotal = Math.max(loadedItemsCount + marginItems, minVirtualItems);
+          if (dynamicTotal !== totalItems) {
+            setTotalItems(dynamicTotal);
+          }
+        }
+      });
+      component.on?.("viewport:velocity-changed", (data) => {
+        const previousVelocity = currentVelocity;
+        currentVelocity = Math.abs(data.velocity || 0);
+        if (previousVelocity > cancelLoadThreshold && currentVelocity <= cancelLoadThreshold) {
+          processQueue();
+        }
+      });
+      component.on?.("viewport:idle", async (data) => {
+        currentVelocity = 0;
+        if (isDragging) {
+          isDragging = false;
+        }
+        const viewportState = component.viewport.state;
+        const visibleRange = viewportState?.visibleRange;
+        if (visibleRange) {
+          const buffer = rangeSize * 2;
+          loadRequestQueue = loadRequestQueue.filter((request) => {
+            const requestEnd = request.range.end;
+            const requestStart = request.range.start;
+            const isRelevant = requestEnd >= visibleRange.start - buffer && requestStart <= visibleRange.end + buffer;
+            if (!isRelevant) {
+              request.resolve();
+            }
+            return isRelevant;
+          });
+          await loadMissingRanges(visibleRange, "viewport:idle");
+        }
+        processQueue();
+      });
+      component.on?.("item:removed", (data) => {
+        if (discoveredTotal !== null && discoveredTotal > 0) {
+          discoveredTotal = discoveredTotal - 1;
+        }
+      });
+      if (collection && autoLoad) {
+        if (initialScrollIndex > 0 || selectId !== undefined && selectId !== null) {
+          const visibleRange = component.viewport?.getVisibleRange?.();
+          if (visibleRange && (visibleRange.start > 0 || visibleRange.end > 0)) {
+            loadMissingRanges(visibleRange, "initial-position").then(() => {
+              hasCompletedInitialPositionLoad = true;
+              if (selectId !== undefined) {
+                component.emit?.("collection:initial-load-complete", {
+                  selectId,
+                  initialScrollIndex
+                });
+              }
+            }).catch((error) => {
+              console.error("[Collection] Failed to load initial position data:", error);
+              hasCompletedInitialPositionLoad = true;
+            });
+          } else {
+            const overscan = 2;
+            const estimatedVisibleCount = Math.ceil(600 / 50);
+            const start = Math.max(0, initialScrollIndex - overscan);
+            const end = initialScrollIndex + estimatedVisibleCount + overscan;
+            loadMissingRanges({ start, end }, "initial-position-fallback").then(() => {
+              hasCompletedInitialPositionLoad = true;
+              if (selectId !== undefined) {
+                component.emit?.("collection:initial-load-complete", {
+                  selectId,
+                  initialScrollIndex
+                });
+              }
+            }).catch((error) => {
+              console.error("[Collection] Failed to load initial position data (fallback):", error);
+              hasCompletedInitialPositionLoad = true;
+            });
+          }
+          return;
+        }
+        loadRange(0, rangeSize, "initialize-page1").then(() => {
+          if (autoSelectFirst && items.length > 0) {
+            const firstItem = items[0];
+            const firstId = firstItem?._id || firstItem?.id;
+            if (firstId !== undefined) {
+              component.emit?.("collection:initial-load-complete", {
+                selectId: firstId,
+                initialScrollIndex: 0
+              });
+            }
+          }
+        }).catch((error) => {
+          console.error("[Collection] Failed to load initial data:", error);
+        });
+      }
+      return result;
+    };
+    const reset = () => {
+      logMemoryStats("reset:before");
+      abortControllers.forEach((controller) => {
+        try {
+          controller.abort();
+        } catch (e) {}
+      });
+      abortControllers.clear();
+      items.length = 0;
+      loadRequestQueue.length = 0;
+      loadedRanges.clear();
+      pendingRanges.clear();
+      failedRanges.clear();
+      activeLoadRanges.clear();
+      activeRequests.clear();
+      cursorMap.clear();
+      pageToOffsetMap.clear();
+      totalItems = 0;
+      currentCursor = null;
+      highestLoadedPage = 0;
+      discoveredTotal = null;
+      hasReachedEnd = false;
+      hasCompletedInitialPositionLoad = false;
+      hasManuallyLoaded = false;
+      cachedItemCount = 0;
+      activeLoadCount = 0;
+      completedLoads = 0;
+      failedLoads = 0;
+      cancelledLoads = 0;
+      component.items = items;
+      component.totalItems = 0;
+      logMemoryStats("reset:after");
+      component.emit?.("collection:reset");
+    };
+    const clearQueue = () => {
+      loadRequestQueue.forEach((request) => {
+        request.resolve();
+      });
+      loadRequestQueue.length = 0;
+    };
+    const setManuallyLoaded = () => {
+      hasManuallyLoaded = true;
+    };
+    const setReloadInProgress = (inProgress, targetRange) => {
+      reloadInProgress = inProgress;
+      reloadTargetRange = targetRange || null;
+    };
+    component.viewport.collection = {
+      loadRange: (offset, limit) => loadRange(offset, limit),
+      loadMissingRanges: (range, caller) => loadMissingRanges(range, caller || "viewport.collection"),
+      getLoadedRanges: () => loadedRanges,
+      getPendingRanges: () => pendingRanges,
+      clearFailedRanges: () => failedRanges.clear(),
+      clearQueue,
+      setManuallyLoaded,
+      setReloadInProgress,
+      retryFailedRange,
+      setTotalItems,
+      getTotalItems: () => totalItems,
+      getCurrentCursor: () => currentCursor,
+      getCursorForPage: (page) => cursorMap.get(page) || null,
+      reset
+    };
+    component.collection = {
+      items,
+      getItems: () => items,
+      getItem: (index) => items[index],
+      loadRange,
+      loadMissingRanges: (range, caller) => loadMissingRanges(range, caller || "component.collection"),
+      getLoadingStats: () => ({
+        pendingRequests: activeLoadCount,
+        completedRequests: completedLoads,
+        failedRequests: failedLoads,
+        cancelledRequests: cancelledLoads,
+        currentVelocity,
+        canLoad: canLoad(),
+        queuedRequests: loadRequestQueue.length
+      }),
+      getTotalItems: () => totalItems,
+      setTotalItems,
+      getCurrentCursor: () => currentCursor,
+      getCursorForPage: (page) => cursorMap.get(page) || null,
+      reset
+    };
+    component.items = items;
+    const destroy = () => {
+      logMemoryStats("destroy:before");
+      abortControllers.forEach((controller) => {
+        try {
+          controller.abort();
+        } catch (e) {}
+      });
+      abortControllers.clear();
+      items.length = 0;
+      loadRequestQueue.length = 0;
+      loadedRanges.clear();
+      pendingRanges.clear();
+      failedRanges.clear();
+      activeLoadRanges.clear();
+      activeRequests.clear();
+      cursorMap.clear();
+      pageToOffsetMap.clear();
+      totalItems = 0;
+      currentCursor = null;
+      highestLoadedPage = 0;
+      discoveredTotal = null;
+      hasReachedEnd = false;
+      if (component.items === items) {
+        component.items = [];
+      }
+      logMemoryStats("destroy:after");
+    };
+    wrapDestroy(component, destroy);
+    return {
+      ...component,
+      collection: {
+        items,
+        getItems: () => items,
+        getItem: (index) => items[index],
+        loadRange,
+        loadMissingRanges: (range, caller) => loadMissingRanges(range, caller || "return.collection"),
+        getLoadedRanges: () => loadedRanges,
+        getPendingRanges: () => pendingRanges,
+        clearFailedRanges: () => failedRanges.clear(),
+        clearQueue,
+        setManuallyLoaded,
+        setReloadInProgress,
+        retryFailedRange,
+        setTotalItems,
+        getTotalItems: () => totalItems,
+        getCurrentCursor: () => currentCursor,
+        getCursorForPage: (page) => cursorMap.get(page) || null,
+        reset
+      }
+    };
+  };
+}
+
+// src/core/viewport/features/placeholders.ts
+function withPlaceholders(config = {}) {
+  return (component) => {
+    const {
+      enabled = true,
+      analyzeFirstLoad = true,
+      maskCharacter = VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER,
+      randomLengthVariance = VIEWPORT_CONSTANTS.PLACEHOLDER.RANDOM_LENGTH_VARIANCE
+    } = config;
+    let fieldStructures = null;
+    let hasAnalyzed = false;
+    let placeholderIdCounter = 0;
+    const analyzeDataStructure = (items) => {
+      if (!enabled || hasAnalyzed || !items.length) {
+        return;
+      }
+      const structures = new Map;
+      const sampleSize = Math.min(items.length, VIEWPORT_CONSTANTS.PLACEHOLDER.MAX_SAMPLE_SIZE);
+      const fieldStats = new Map;
+      for (let i = 0;i < sampleSize; i++) {
+        const item = items[i];
+        if (!item || typeof item !== "object")
+          continue;
+        Object.keys(item).forEach((field) => {
+          if (field.startsWith("_") || field === VIEWPORT_CONSTANTS.PLACEHOLDER.PLACEHOLDER_FLAG) {
+            return;
+          }
+          const value = String(item[field] || "");
+          const length = value.length;
+          if (!fieldStats.has(field)) {
+            fieldStats.set(field, []);
+          }
+          fieldStats.get(field).push(length);
+        });
+      }
+      fieldStats.forEach((lengths, field) => {
+        if (lengths.length === 0)
+          return;
+        const minLength = Math.min(...lengths);
+        const maxLength = Math.max(...lengths);
+        const avgLength = Math.round(lengths.reduce((sum, len) => sum + len, 0) / lengths.length);
+        structures.set(field, {
+          minLength,
+          maxLength,
+          avgLength
+        });
+      });
+      fieldStructures = structures;
+      hasAnalyzed = true;
+      component.emit?.("viewport:placeholders-structure-analyzed", {
+        structure: Object.fromEntries(structures)
+      });
+    };
+    const generatePlaceholderItem = (index) => {
+      const placeholder = {
+        id: `placeholder-${placeholderIdCounter++}`,
+        [VIEWPORT_CONSTANTS.PLACEHOLDER.PLACEHOLDER_FLAG]: true,
+        _index: index
+      };
+      if (!fieldStructures || fieldStructures.size === 0) {
+        placeholder.label = maskCharacter.repeat(10);
+        return placeholder;
+      }
+      fieldStructures.forEach((structure, field) => {
+        let length;
+        if (randomLengthVariance && structure.minLength !== structure.maxLength) {
+          length = Math.floor(Math.random() * (structure.maxLength - structure.minLength + 1) + structure.minLength);
+        } else {
+          length = structure.avgLength;
+        }
+        if (randomLengthVariance && Math.random() < 0.3) {
+          length = Math.max(1, length + Math.floor(Math.random() * 3) - 1);
+        }
+        placeholder[field] = maskCharacter.repeat(length);
+      });
+      return placeholder;
+    };
+    const generatePlaceholderItems = (range) => {
+      const items = [];
+      for (let i = range.start;i <= range.end; i++) {
+        items.push(generatePlaceholderItem(i));
+      }
+      return items;
+    };
+    const showPlaceholders = (range) => {
+      if (!enabled)
+        return;
+      const placeholders = generatePlaceholderItems(range);
+      if (component.items) {
+        for (let i = 0;i < placeholders.length; i++) {
+          const index = range.start + i;
+          if (!component.items[index]) {
+            component.items[index] = placeholders[i];
+          }
+        }
+      }
+      console.log(`\uD83D\uDD04 [PLACEHOLDERS] Showing ${placeholders.length} placeholders for range ${range.start}-${range.end}`);
+      component.emit?.("viewport:placeholders-shown", {
+        range,
+        count: placeholders.length
+      });
+    };
+    const isPlaceholder2 = (item) => {
+      return item && typeof item === "object" && item[VIEWPORT_CONSTANTS.PLACEHOLDER.PLACEHOLDER_FLAG] === true;
+    };
+    const replacePlaceholders = (items, offset) => {
+      if (!component.items)
+        return;
+      let replacedCount = 0;
+      for (let i = 0;i < items.length; i++) {
+        const index = offset + i;
+        const currentItem = component.items[index];
+        if (isPlaceholder2(currentItem)) {
+          component.items[index] = items[i];
+          replacedCount++;
+        }
+      }
+      if (replacedCount > 0) {
+        console.log(`✨ [PLACEHOLDERS] Replaced ${replacedCount} placeholders at offset ${offset}`);
+        component.emit?.("viewport:placeholders-replaced", {
+          offset,
+          count: replacedCount
+        });
+      }
+    };
+    const clear = () => {
+      fieldStructures = null;
+      hasAnalyzed = false;
+      placeholderIdCounter = 0;
+    };
+    const initialize = () => {
+      if (!enabled)
+        return;
+      if (analyzeFirstLoad) {
+        const handleRangeLoaded = (data) => {
+          if (!hasAnalyzed && data.items && data.items.length > 0) {
+            analyzeDataStructure(data.items);
+          }
+          replacePlaceholders(data.items, data.offset);
+        };
+        component.on?.("viewport:range-loaded", handleRangeLoaded);
+      }
+      const totalItems = component.collection?.getTotalItems() || 0;
+      if (totalItems > 0) {
+        const initialRange = {
+          start: 0,
+          end: Math.min(VIEWPORT_CONSTANTS.PLACEHOLDER.MAX_SAMPLE_SIZE - 1, totalItems - 1)
+        };
+        showPlaceholders(initialRange);
+      }
+    };
+    const destroy = () => {
+      clear();
+    };
+    component._placeholdersInitialize = initialize;
+    component._placeholdersDestroy = destroy;
+    return {
+      ...component,
+      placeholders: {
+        analyzeDataStructure,
+        hasAnalyzedStructure: () => hasAnalyzed,
+        generatePlaceholderItem,
+        generatePlaceholderItems,
+        showPlaceholders,
+        isPlaceholder: isPlaceholder2,
+        replacePlaceholders,
+        clear
+      }
+    };
+  };
+}
+
+// src/core/viewport/features/rendering.ts
+var import_mtrl3 = require("mtrl");
+
+// src/core/layout/schema.ts
+class FragmentPool {
+  pool = [];
+  maxSize = 8;
+  get() {
+    return this.pool.pop() || document.createDocumentFragment();
+  }
+  release(fragment) {
+    if (this.pool.length < this.maxSize && fragment.childNodes.length === 0) {
+      this.pool.push(fragment);
+    }
+  }
+  clear() {
+    this.pool.length = 0;
+  }
+}
+var fragmentPool = new FragmentPool;
+var classCache = new Map;
+var PREFIX3 = "mtrl";
+var PREFIX_WITH_DASH = `${PREFIX3}-`;
+function getCachedClassName(type, property, value) {
+  const key = `${type}-${property}-${value}`;
+  if (!classCache.has(key)) {
+    if (type === "item") {
+      classCache.set(key, property === "" ? `layout__item--${value}` : `layout__item--${property}-${value}`);
+    } else {
+      if (property === "align") {
+        classCache.set(key, `layout--${type}-${value}`);
+      } else {
+        classCache.set(key, `layout--${type}-${property}-${value}`);
+      }
+    }
+  }
+  return classCache.get(key);
+}
+function isComponent(value) {
+  return value && typeof value === "object" && "element" in value;
+}
+function createFragment() {
+  return fragmentPool.get();
+}
+function releaseFragment(fragment) {
+  fragmentPool.release(fragment);
+}
+function processClassNames(options, skipPrefix = false) {
+  if (!options)
+    return options;
+  const hasRawClass = options.rawClass;
+  const hasRegularClass = options.class || options.className;
+  if (!hasRawClass && !hasRegularClass)
+    return options;
+  if (hasRawClass && !hasRegularClass && skipPrefix) {
+    const processed2 = { ...options };
+    delete processed2.rawClass;
+    if (typeof hasRawClass === "string") {
+      processed2.class = hasRawClass;
+    } else {
+      processed2.class = hasRawClass.join(" ");
+    }
+    return processed2;
+  }
+  const processed = { ...options };
+  let finalClasses = "";
+  if (!skipPrefix && hasRegularClass) {
+    let prefixedString = "";
+    if (processed.class) {
+      prefixedString += Array.isArray(processed.class) ? processed.class.join(" ") : processed.class;
+    }
+    if (processed.className) {
+      prefixedString += (prefixedString ? " " : "") + processed.className;
+    }
+    if (prefixedString) {
+      finalClasses = prefixedString.split(/\s+/).filter(Boolean).map((cls) => cls.startsWith(PREFIX_WITH_DASH) ? cls : PREFIX_WITH_DASH + cls).join(" ");
+    }
+  }
+  if (hasRawClass) {
+    const rawString = Array.isArray(hasRawClass) ? hasRawClass.filter(Boolean).join(" ") : hasRawClass;
+    finalClasses += (finalClasses ? " " : "") + rawString;
+  }
+  if (finalClasses) {
+    processed.class = finalClasses;
+  }
+  delete processed.className;
+  delete processed.rawClass;
+  return processed;
+}
+function extractParameters(schema, startIndex, defaultCreator) {
+  const items = schema.slice(startIndex, startIndex + 3);
+  let creator, name, options;
+  let consumed = 1;
+  const [first, second, third] = items;
+  if (typeof first === "function") {
+    creator = first;
+    if (typeof second === "string") {
+      name = second;
+      consumed = 2;
+      if (isObject(third)) {
+        options = third;
+        consumed = 3;
+      }
+    } else if (isObject(second)) {
+      options = second;
+      consumed = 2;
+    }
+  } else if (typeof first === "string") {
+    creator = defaultCreator;
+    name = first;
+    if (isObject(second)) {
+      options = second;
+      consumed = 2;
+    }
+  } else if (isObject(first)) {
+    creator = defaultCreator;
+    options = first;
+  }
+  return {
+    creator: creator || defaultCreator,
+    name,
+    options: options || {},
+    consumed
+  };
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createElement(options = {}) {
+  const tag = options.tag || "div";
+  const element = document.createElement(tag);
+  if (options.class) {
+    element.className = options.class;
+  }
+  if (options.style) {
+    if (typeof options.style === "string") {
+      element.setAttribute("style", options.style);
+    } else if (typeof options.style === "object") {
+      Object.assign(element.style, options.style);
+    }
+  }
+  if (options.textContent) {
+    element.textContent = options.textContent;
+  }
+  if (options.text) {
+    element.textContent = options.text;
+  }
+  return element;
+}
+function addClass2(element, className) {
+  if (element && className) {
+    element.classList.add(className);
+  }
+}
+function hasClass(element, className) {
+  return element && element.classList.contains(className);
+}
+function createComponentInstance(Component, options = {}) {
+  try {
+    const {
+      layout: layoutConfig,
+      layoutItem: layoutItemConfig,
+      style: styleConfig,
+      attributes: attributesConfig,
+      events: eventsConfig,
+      event,
+      ...cleanOptions
+    } = options;
+    const finalEventsConfig = eventsConfig || event;
+    if (styleConfig && typeof styleConfig === "string") {
+      cleanOptions.style = styleConfig;
+    }
+    const isClass = typeof Component === "function" && Object.getOwnPropertyDescriptor(Component, "prototype")?.writable === false;
+    const component = isClass ? new Component(cleanOptions) : Component(cleanOptions);
+    if (component) {
+      const element = component.element || (component instanceof HTMLElement ? component : null);
+      if (element) {
+        if (layoutConfig)
+          applyLayoutClasses(element, layoutConfig);
+        if (layoutItemConfig)
+          applyLayoutItemClasses(element, layoutItemConfig);
+        if (styleConfig && typeof styleConfig === "object") {
+          Object.assign(element.style, styleConfig);
+        }
+        if (attributesConfig && typeof attributesConfig === "object") {
+          for (const [key, value] of Object.entries(attributesConfig)) {
+            if (value !== undefined && value !== null) {
+              element.setAttribute(key, value.toString());
+            }
+          }
+        }
+        if (finalEventsConfig && typeof finalEventsConfig === "object") {
+          if (Array.isArray(finalEventsConfig)) {
+            for (const eventDef of finalEventsConfig) {
+              if (Array.isArray(eventDef) && eventDef.length >= 2) {
+                const [eventName, handler] = eventDef;
+                if (typeof eventName === "string" && typeof handler === "function") {
+                  element.addEventListener(eventName, handler);
+                }
+              }
+            }
+          } else {
+            for (const [eventName, handler] of Object.entries(finalEventsConfig)) {
+              if (typeof handler === "function") {
+                element.addEventListener(eventName, handler);
+              }
+            }
+          }
+        }
+      }
+    }
+    return component;
+  } catch (error) {
+    console.error("Error creating component instance:", error);
+    return document.createElement("div");
+  }
+}
+function applyLayoutClasses(element, layoutConfig) {
+  if (!element || !layoutConfig)
+    return;
+  if (layoutConfig.type) {
+    addClass2(element, `${PREFIX_WITH_DASH}layout--${layoutConfig.type}`);
+  }
+  const layoutType = layoutConfig.type || getLayoutType(element);
+  if (layoutType) {
+    if (layoutConfig.gap !== undefined) {
+      addClass2(element, PREFIX_WITH_DASH + getCachedClassName(layoutType, "gap", layoutConfig.gap));
+    }
+    if (layoutConfig.align) {
+      addClass2(element, PREFIX_WITH_DASH + getCachedClassName(layoutType, "align", layoutConfig.align));
+    }
+    if (layoutConfig.justify) {
+      addClass2(element, PREFIX_WITH_DASH + getCachedClassName(layoutType, "justify", layoutConfig.justify));
+    }
+  }
+  if (layoutConfig.type === "grid" || getLayoutType(element) === "grid") {
+    if (typeof layoutConfig.columns === "number") {
+      addClass2(element, PREFIX_WITH_DASH + getCachedClassName("grid", "cols", layoutConfig.columns));
+    } else if (layoutConfig.columns === "auto-fill") {
+      addClass2(element, PREFIX_WITH_DASH + getCachedClassName("grid", "fill", "auto"));
+    } else if (layoutConfig.columns === "auto-fit") {
+      addClass2(element, PREFIX_WITH_DASH + getCachedClassName("grid", "cols", "auto-fit"));
+    }
+    if (layoutConfig.dense)
+      addClass2(element, `${PREFIX_WITH_DASH}layout--grid-dense`);
+    if (layoutConfig.autoHeight)
+      addClass2(element, `${PREFIX_WITH_DASH}layout--grid-auto-height`);
+  }
+  if (layoutConfig.type === "row" || getLayoutType(element) === "row") {
+    if (layoutConfig.wrap === false || layoutConfig.wrap === "nowrap") {
+      addClass2(element, `${PREFIX_WITH_DASH}layout--row-nowrap`);
+    } else if (layoutConfig.wrap === "reverse") {
+      addClass2(element, `${PREFIX_WITH_DASH}layout--row-wrap-reverse`);
+    }
+    if (layoutConfig.mobileStack)
+      addClass2(element, `${PREFIX_WITH_DASH}layout--row-mobile-stack`);
+    if (layoutConfig.mobileScroll)
+      addClass2(element, `${PREFIX_WITH_DASH}layout--row-mobile-scroll`);
+  }
+  if (layoutConfig.class) {
+    layoutConfig.class.split(" ").filter(Boolean).forEach((cls) => element.classList.add(cls));
+  }
+}
+function applyLayoutItemClasses(element, itemConfig) {
+  if (!element || !itemConfig)
+    return;
+  addClass2(element, `${PREFIX_WITH_DASH}layout__item`);
+  if (itemConfig.width && itemConfig.width >= 1 && itemConfig.width <= 12) {
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "", itemConfig.width));
+  }
+  if (itemConfig.sm)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "sm", itemConfig.sm));
+  if (itemConfig.md)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "md", itemConfig.md));
+  if (itemConfig.lg)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "lg", itemConfig.lg));
+  if (itemConfig.xl)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "xl", itemConfig.xl));
+  if (itemConfig.span)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "span", itemConfig.span));
+  if (itemConfig.rowSpan)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "row-span", itemConfig.rowSpan));
+  if (itemConfig.order)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "order", itemConfig.order));
+  if (itemConfig.align)
+    addClass2(element, PREFIX_WITH_DASH + getCachedClassName("item", "self", itemConfig.align));
+  if (itemConfig.auto)
+    addClass2(element, `${PREFIX_WITH_DASH}layout__item--auto`);
+}
+function getLayoutType(element) {
+  return hasClass(element, `${PREFIX_WITH_DASH}layout--stack`) ? "stack" : hasClass(element, `${PREFIX_WITH_DASH}layout--row`) ? "row" : hasClass(element, `${PREFIX_WITH_DASH}layout--grid`) ? "grid" : "";
+}
+function processArraySchema(schema, parentElement = null, level = 0, options = {}) {
+  level++;
+  const layout = {};
+  const components = [];
+  const fragment = createFragment();
+  let component = null;
+  if (!Array.isArray(schema)) {
+    return createLayoutResult(layout);
+  }
+  const defaultCreator = options.creator || createElement;
+  for (let i = 0;i < schema.length; i++) {
+    const item = schema[i];
+    if (!item)
+      continue;
+    if (Array.isArray(item)) {
+      const container = component || parentElement;
+      const result = processArraySchema(item, container, level, options);
+      if (Array.isArray(result.layout.components)) {
+        components.push(...result.layout.components);
+        delete result.layout.components;
+      }
+      Object.assign(layout, result.layout);
+      continue;
+    }
+    const {
+      creator,
+      name,
+      options: itemOptions,
+      consumed
+    } = extractParameters(schema, i, defaultCreator);
+    if (!creator) {
+      console.warn("Skipping unsupported item type:", item);
+      continue;
+    }
+    if (creator === createElement && !("tag" in itemOptions)) {
+      itemOptions.tag = "div";
+    }
+    i += consumed - 1;
+    const shouldApplyPrefix = "prefix" in itemOptions ? itemOptions.prefix : options.prefix !== false;
+    const processedOptions = shouldApplyPrefix || itemOptions.rawClass ? processClassNames(itemOptions, !shouldApplyPrefix) : itemOptions;
+    if (name && !("name" in processedOptions) && !(creator === createElement || creator.isElement)) {
+      processedOptions.name = name;
+    }
+    component = createComponentInstance(creator, processedOptions);
+    const element = isComponent(component) ? component.element : component;
+    if (level === 1)
+      layout.element = element;
+    if (name) {
+      layout[name] = component;
+      components.push([name, component]);
+    }
+    if (component) {
+      if ("insert" in component && typeof component.insert === "function") {
+        component.insert(fragment);
+      } else {
+        fragment.appendChild(element);
+      }
+      if (parentElement) {
+        component._container = parentElement;
+        if ("onInserted" in component && typeof component.onInserted === "function") {
+          component.onInserted(parentElement);
+        }
+      }
+    }
+  }
+  if (parentElement && fragment.hasChildNodes()) {
+    const wrapper = isComponent(parentElement) ? parentElement.element : parentElement;
+    wrapper.appendChild(fragment);
+  }
+  releaseFragment(fragment);
+  layout.components = components;
+  return createLayoutResult(layout);
+}
+function processObjectSchema(schema, parentElement = null, options = {}) {
+  const layout = {};
+  const defaultCreator = options.creator || createElement;
+  if (schema.element && !parentElement) {
+    const elementDef = schema.element;
+    const createElementFn = elementDef.creator || defaultCreator;
+    const elementOptions = elementDef.options || {};
+    const processedOptions = options.prefix !== false ? processClassNames(elementOptions) : { ...elementOptions };
+    const rootComponent = createComponentInstance(createElementFn, processedOptions);
+    layout.element = rootComponent;
+    if (elementDef.name)
+      layout[elementDef.name] = rootComponent;
+    if (elementDef.children) {
+      const rootElement = isComponent(rootComponent) ? rootComponent.element : rootComponent;
+      const childResult = processObjectSchema(elementDef.children, rootElement, options);
+      Object.assign(layout, childResult.layout);
+    }
+    return createLayoutResult(layout);
+  }
+  const fragment = parentElement ? createFragment() : null;
+  for (const key in schema) {
+    const def = schema[key];
+    if (!def)
+      continue;
+    const elementCreator = def.creator || defaultCreator;
+    const elementOptions = def.options || {};
+    const shouldApplyPrefix = "prefix" in elementOptions ? elementOptions.prefix : options.prefix !== false;
+    const processedOptions = shouldApplyPrefix ? processClassNames(elementOptions) : { ...elementOptions };
+    if (!def.name && key !== "element") {
+      def.name = key;
+    }
+    const created = createComponentInstance(elementCreator, processedOptions);
+    layout[key] = created;
+    if (def.name && def.name !== key)
+      layout[def.name] = created;
+    const element = isComponent(created) ? created.element : created;
+    if (fragment)
+      fragment.appendChild(element);
+    if (def.children) {
+      const childResult = processObjectSchema(def.children, element, options);
+      Object.assign(layout, childResult.layout);
+    }
+  }
+  if (parentElement && fragment) {
+    const parentDom = isComponent(parentElement) ? parentElement.element : parentElement;
+    parentDom.appendChild(fragment);
+    releaseFragment(fragment);
+  }
+  return createLayoutResult(layout);
+}
+function flattenLayout(layout) {
+  const flattened = {};
+  if (!layout || typeof layout !== "object")
+    return flattened;
+  for (const key in layout) {
+    const value = layout[key];
+    if (value && typeof value !== "function" && (value instanceof HTMLElement || typeof SVGElement !== "undefined" && value instanceof SVGElement || isComponent(value))) {
+      flattened[key] = value;
+    }
+  }
+  return flattened;
+}
+function createLayoutResult(layout) {
+  const flattenedComponents = flattenLayout(layout);
+  return {
+    layout,
+    element: layout.element,
+    component: flattenedComponents,
+    get(name) {
+      return layout[name] ?? null;
+    },
+    getAll() {
+      return flattenedComponents;
+    },
+    destroy() {
+      const destroyed = new Set;
+      const destroyComponent = (component) => {
+        if (!component || destroyed.has(component))
+          return;
+        if (component instanceof HTMLElement || typeof component !== "object")
+          return;
+        if (typeof component.destroy === "function") {
+          destroyed.add(component);
+          try {
+            component.destroy();
+          } catch (e) {}
+        }
+      };
+      if (Array.isArray(layout.components)) {
+        for (const [name, component] of layout.components) {
+          destroyComponent(component);
+        }
+      }
+      for (const key in layout) {
+        if (key === "element" || key === "components")
+          continue;
+        destroyComponent(layout[key]);
+      }
+      if (Array.isArray(layout.components)) {
+        layout.components.length = 0;
+      }
+      if (layout.element) {
+        const element = isComponent(layout.element) ? layout.element.element : layout.element;
+        if (element && element.parentNode) {
+          element.parentNode.removeChild(element);
+        }
+      }
+      for (const key in layout) {
+        delete layout[key];
+      }
+    }
+  };
+}
+function createLayout(schema, parentElement = null, options = {}) {
+  if (typeof schema === "function") {
+    schema = schema();
+  }
+  if (typeof schema === "string") {
+    const template = document.createElement("template");
+    template.innerHTML = schema.trim();
+    const fragment = template.content;
+    if (parentElement && fragment.hasChildNodes()) {
+      parentElement.appendChild(fragment);
+    }
+    const layout = { element: fragment.firstElementChild };
+    return createLayoutResult(layout);
+  }
+  if (Array.isArray(schema) && schema.length >= 3 && typeof schema[0] === "function" && typeof schema[1] === "string" && isObject(schema[2])) {
+    return processArraySchema(schema, parentElement, 0, options);
+  }
+  return Array.isArray(schema) ? processArraySchema(schema, parentElement, 0, options) : processObjectSchema(schema, parentElement, options);
+}
+// src/core/viewport/features/rendering.ts
+var withRendering = (config = {}) => {
+  return (component) => {
+    const {
+      template,
+      overscan = 5,
+      measureItems = false,
+      enableRecycling = true,
+      maxPoolSize = VIEWPORT_CONSTANTS.RENDERING.DEFAULT_MAX_POOL_SIZE,
+      maintainDomOrder = true
+    } = config;
+    const getCollectionItems = () => {
+      return component.collection?.items || component.items || [];
+    };
+    const renderedElements = new Map;
+    const elementPool = [];
+    const poolStats = { created: 0, recycled: 0, poolSize: 0, released: 0 };
+    const layoutResults = new WeakMap;
+    const templateParser = document.createElement("template");
+    let viewportState = null;
+    let currentVisibleRange = { start: 0, end: 0 };
+    let lastRenderTime = 0;
+    let isRemovingItem = false;
+    const getPooledElement = () => {
+      if (enableRecycling && elementPool.length > 0) {
+        poolStats.recycled++;
+        return elementPool.pop();
+      }
+      const element = document.createElement("div");
+      element.className = "mtrl-viewport-item";
+      poolStats.created++;
+      return element;
+    };
+    const releaseElement = (element) => {
+      poolStats.released++;
+      const layoutResult = layoutResults.get(element);
+      if (layoutResult && typeof layoutResult.destroy === "function") {
+        try {
+          layoutResult.destroy();
+        } catch (e) {}
+        layoutResults.delete(element);
+      }
+      if (!enableRecycling) {
+        element.remove();
+        return;
+      }
+      element.className = "mtrl-viewport-item";
+      element.removeAttribute("data-index");
+      element.style.cssText = "";
+      element.innerHTML = "";
+      if (element.parentNode) {
+        element.parentNode.removeChild(element);
+      }
+      if (elementPool.length < maxPoolSize) {
+        elementPool.push(element);
+        poolStats.poolSize = elementPool.length;
+      }
+    };
+    wrapInitialize(component, () => {
+      viewportState = getViewportState(component);
+      if (viewportState?.itemsContainer && viewportState.virtualTotalSize > 0) {
+        viewportState.itemsContainer.style.height = `${viewportState.virtualTotalSize}px`;
+      }
+      component.on?.("item:update-request", (data) => {
+        const { index, item, previousItem } = data;
+        const existingElement = renderedElements.get(index);
+        const wasVisible = !!existingElement;
+        const wasSelected = existingElement ? import_mtrl3.hasClass(existingElement, VIEWPORT_CONSTANTS.SELECTION.SELECTED_CLASS) || import_mtrl3.hasClass(existingElement, "mtrl-viewport-item--selected") : false;
+        if (existingElement && existingElement.parentNode) {
+          const newElement = renderItem(item, index);
+          if (newElement) {
+            Object.assign(newElement.style, {
+              position: existingElement.style.position,
+              transform: existingElement.style.transform,
+              width: existingElement.style.width
+            });
+            if (wasSelected) {
+              import_mtrl3.addClass(newElement, VIEWPORT_CONSTANTS.SELECTION.SELECTED_CLASS);
+              import_mtrl3.addClass(newElement, "mtrl-viewport-item--selected");
+            }
+            import_mtrl3.addClass(newElement, "viewport-item--updated");
+            const innerItem = newElement.firstElementChild;
+            if (innerItem) {
+              import_mtrl3.addClass(innerItem, "item--updated");
+            }
+            existingElement.parentNode.replaceChild(newElement, existingElement);
+            renderedElements.set(index, newElement);
+            releaseElement(existingElement);
+            setTimeout(() => {
+              import_mtrl3.removeClass(newElement, "viewport-item--updated");
+              if (innerItem) {
+                import_mtrl3.removeClass(innerItem, "item--updated");
+              }
+            }, 500);
+          }
+        }
+        component.emit?.("item:updated", {
+          item,
+          index,
+          previousItem,
+          wasVisible,
+          wasSelected
+        });
+      });
+      component.on?.("item:remove-request", (data) => {
+        const { index, item } = data;
+        isRemovingItem = true;
+        const existingElement = renderedElements.get(index);
+        if (existingElement && existingElement.parentNode) {
+          releaseElement(existingElement);
+        }
+        renderedElements.delete(index);
+        const renderedKeys = Array.from(renderedElements.keys()).sort((a, b) => a - b);
+        const newRenderedElements = new Map;
+        for (const key of renderedKeys) {
+          if (key > index) {
+            const element = renderedElements.get(key);
+            if (element) {
+              element.dataset.index = String(key - 1);
+              newRenderedElements.set(key - 1, element);
+            }
+          } else if (key < index) {
+            const element = renderedElements.get(key);
+            if (element) {
+              newRenderedElements.set(key, element);
+            }
+          }
+        }
+        renderedElements.clear();
+        for (const [key, element] of newRenderedElements) {
+          renderedElements.set(key, element);
+        }
+        if (viewportState && viewportState.totalItems > 0) {
+          viewportState.totalItems--;
+        }
+        currentVisibleRange = { start: -1, end: -1 };
+        component.emit?.("item:removed", {
+          item,
+          index
+        });
+        renderItems();
+        isRemovingItem = false;
+      });
+      component.on?.("items:add-request", (data) => {
+        const { items: newItems, position, previousCount } = data;
+        if (!newItems || newItems.length === 0)
+          return;
+        const itemsAdded = newItems.length;
+        if (position === "start") {
+          const renderedKeys = Array.from(renderedElements.keys()).sort((a, b) => b - a);
+          const newRenderedElements = new Map;
+          for (const key of renderedKeys) {
+            const element = renderedElements.get(key);
+            const newIndex = key + itemsAdded;
+            element.setAttribute("data-index", String(newIndex));
+            newRenderedElements.set(newIndex, element);
+          }
+          renderedElements.clear();
+          newRenderedElements.forEach((el, idx) => renderedElements.set(idx, el));
+        }
+        if (viewportState) {
+          viewportState.totalItems = (viewportState.totalItems || 0) + itemsAdded;
+        }
+        currentVisibleRange = { start: -1, end: -1 };
+        const collection = component.viewport?.collection;
+        if (collection?.getLoadedRanges) {
+          const loadedRanges = collection.getLoadedRanges();
+          loadedRanges.clear();
+        }
+        renderItems();
+        component.emit?.("items:render-complete", {
+          items: newItems,
+          position,
+          total: viewportState?.totalItems || 0
+        });
+      });
+      component.on?.("collection:items-evicted", (data) => {
+        const { keepStart, keepEnd } = data;
+        renderedElements.forEach((element, index) => {
+          if (index < keepStart || index > keepEnd) {
+            releaseElement(element);
+            renderedElements.delete(index);
+          }
+        });
+      });
+      component.on?.("reload:start", () => {
+        currentVisibleRange = { start: -1, end: -1 };
+        lastRenderTime = 0;
+        isRemovingItem = false;
+        elementPool.length = 0;
+        poolStats.poolSize = 0;
+      });
+      component.on?.("collection:reset", () => {
+        renderedElements.forEach((element) => {
+          releaseElement(element);
+        });
+        renderedElements.clear();
+        currentVisibleRange = { start: -1, end: -1 };
+      });
+      component.on?.("viewport:clear-pool", () => {
+        elementPool.length = 0;
+        poolStats.poolSize = 0;
+        lastRenderTime = 0;
+      });
+      component.on?.("collection:range-loaded", (data) => {
+        if (!data.items?.length)
+          return;
+        const placeholders = component.placeholders;
+        if (placeholders && !placeholders.hasAnalyzedStructure()) {
+          placeholders.analyzeDataStructure(data.items);
+        }
+        data.items.forEach((item, i) => {
+          const index = data.offset + i;
+          const element = renderedElements.get(index);
+          const isPlaceholderElement = element?.classList.contains(VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS) || element?.classList.contains(`mtrl-${VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS}`);
+          if (isPlaceholderElement) {
+            const newElement = renderItem(item, index);
+            if (newElement) {
+              import_mtrl3.removeClass(newElement, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);
+              if (newElement.firstElementChild) {
+                import_mtrl3.removeClass(newElement.firstElementChild, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);
+              }
+              import_mtrl3.addClass(newElement, "viewport-item--replaced");
+              if (element) {
+                Object.assign(newElement.style, {
+                  position: element.style.position,
+                  transform: element.style.transform,
+                  width: element.style.width
+                });
+                element.parentNode?.replaceChild(newElement, element);
+              }
+              renderedElements.set(index, newElement);
+              if (element) {
+                releaseElement(element);
+              }
+              setTimeout(() => {
+                import_mtrl3.removeClass(newElement, "viewport-item--replaced");
+              }, 300);
+            } else {
+              if (element) {
+                releaseElement(element);
+              }
+              renderedElements.delete(index);
+            }
+          }
+        });
+        const { visibleRange } = viewportState || {};
+        if (visibleRange) {
+          const renderStart = Math.max(0, visibleRange.start - overscan);
+          const renderEnd = Math.min(viewportState?.totalItems ?? 0 - 1, visibleRange.end + overscan);
+          const loadedStart = data.offset;
+          const loadedEnd = data.offset + data.items.length - 1;
+          const needsRender = loadedStart <= renderEnd && loadedEnd >= renderStart && renderedElements.size < renderEnd - renderStart + 1;
+          if (needsRender)
+            renderItems();
+        }
+      });
+      component.on?.("viewport:range-changed", renderItems);
+      component.on?.("viewport:scroll", updateItemPositions);
+      component.on?.("viewport:virtual-size-changed", (data) => {
+        if (viewportState?.itemsContainer && data.totalVirtualSize !== undefined) {
+          viewportState.itemsContainer.style.height = `${data.totalVirtualSize}px`;
+        }
+      });
+    });
+    const getDefaultTemplate = () => (item, index) => {
+      return [
+        {
+          tag: "div",
+          class: "viewport-item",
+          text: typeof item === "object" ? item.name || item.label || item.text || `Item ${index}` : String(item)
+        }
+      ];
+    };
+    const processLayoutSchema = (schema, item, index) => {
+      if (typeof schema === "string") {
+        return schema.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+          if (key === "index")
+            return String(index);
+          if (key === "item")
+            return String(item);
+          const value = key.split(".").reduce((obj, prop) => {
+            return obj?.[prop.trim()];
+          }, item);
+          return value !== undefined ? String(value) : match;
+        });
+      }
+      if (Array.isArray(schema)) {
+        return schema.map((child) => processLayoutSchema(child, item, index));
+      }
+      if (typeof schema === "object" && schema !== null) {
+        const processed = {};
+        for (const [key, value] of Object.entries(schema)) {
+          processed[key] = processLayoutSchema(value, item, index);
+        }
+        return processed;
+      }
+      return schema;
+    };
+    const calculateItemPosition = (index, scrollPosition, totalItems, itemSize, virtualTotalSize, containerSize, targetScrollIndex) => {
+      const actualTotalSize = totalItems * itemSize;
+      const isCompressed = actualTotalSize > virtualTotalSize && virtualTotalSize > 0;
+      if (targetScrollIndex !== undefined && targetScrollIndex > 0) {
+        return (index - targetScrollIndex) * itemSize;
+      }
+      if (!isCompressed || totalItems === 0) {
+        return index * itemSize - scrollPosition;
+      }
+      const maxScrollPosition = virtualTotalSize - containerSize;
+      const distanceFromBottom = maxScrollPosition - scrollPosition;
+      const nearBottomThreshold = containerSize;
+      if (distanceFromBottom <= nearBottomThreshold && distanceFromBottom >= -1) {
+        const itemsAtBottom = Math.floor(containerSize / itemSize);
+        const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);
+        const scrollRatio2 = scrollPosition / virtualTotalSize;
+        const exactScrollIndex = scrollRatio2 * totalItems;
+        const interpolation = Math.max(0, Math.min(1, 1 - distanceFromBottom / nearBottomThreshold));
+        const bottomPosition = (index - firstVisibleAtBottom) * itemSize;
+        const normalPosition = (index - exactScrollIndex) * itemSize;
+        return normalPosition + (bottomPosition - normalPosition) * interpolation;
+      }
+      const scrollRatio = scrollPosition / virtualTotalSize;
+      return (index - scrollRatio * totalItems) * itemSize;
+    };
+    const renderItem = (item, index) => {
+      const itemTemplate = template || getDefaultTemplate();
+      try {
+        const result = itemTemplate(item, index);
+        let element;
+        if (Array.isArray(result) || typeof result === "object" && result !== null && !(result instanceof HTMLElement)) {
+          const processedSchema = processLayoutSchema(result, item, index);
+          const layoutResult = createLayout(processedSchema);
+          element = layoutResult.element;
+          if (element && element.nodeType === 1) {
+            layoutResults.set(element, layoutResult);
+          } else {
+            element = getPooledElement();
+            if (layoutResult.element) {
+              element.appendChild(layoutResult.element);
+              layoutResults.set(element, layoutResult);
+            }
+          }
+        } else if (typeof result === "string") {
+          templateParser.innerHTML = result;
+          const content = templateParser.content;
+          if (content.children.length === 1) {
+            element = content.firstElementChild;
+            content.removeChild(element);
+            import_mtrl3.addClass(element, "mtrl-viewport-item");
+            if (isPlaceholder(item)) {
+              import_mtrl3.addClass(element, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);
+            }
+          } else {
+            element = getPooledElement();
+            while (content.firstChild) {
+              element.appendChild(content.firstChild);
+            }
+          }
+        } else if (result instanceof HTMLElement) {
+          element = getPooledElement();
+          element.appendChild(result);
+        } else {
+          console.warn(`[Rendering] Invalid template result for item ${index}`);
+          return null;
+        }
+        if (!import_mtrl3.hasClass(element, "viewport-item"))
+          import_mtrl3.addClass(element, "viewport-item");
+        if (isPlaceholder(item)) {
+          import_mtrl3.addClass(element, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);
+        }
+        element.dataset.index = String(index);
+        const itemId = item?._id || item?.id;
+        if (itemId !== undefined && itemId !== null) {
+          element.dataset.id = String(itemId);
+        }
+        return element;
+      } catch (error) {
+        console.error(`[Rendering] Error rendering item ${index}:`, error);
+        return null;
+      }
+    };
+    const updateItemPositions = () => {
+      if (!viewportState || renderedElements.size === 0)
+        return;
+      const {
+        scrollPosition,
+        itemSize,
+        totalItems,
+        virtualTotalSize,
+        containerSize
+      } = viewportState;
+      const actualTotalSize = totalItems * itemSize;
+      const isCompressed = actualTotalSize > virtualTotalSize && virtualTotalSize > 0;
+      const sortedIndices = Array.from(renderedElements.keys()).sort((a, b) => a - b);
+      if (!sortedIndices.length)
+        return;
+      const firstIndex = sortedIndices[0];
+      let currentPosition = 0;
+      if (isCompressed) {
+        const maxScroll = virtualTotalSize - containerSize;
+        const distanceFromBottom = maxScroll - scrollPosition;
+        if (distanceFromBottom <= containerSize && distanceFromBottom >= -1) {
+          const itemsAtBottom = Math.floor(containerSize / itemSize);
+          const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);
+          const scrollRatio = scrollPosition / virtualTotalSize;
+          const exactScrollIndex = scrollRatio * totalItems;
+          const interpolation = Math.max(0, Math.min(1, 1 - distanceFromBottom / containerSize));
+          const bottomPos = (firstIndex - firstVisibleAtBottom) * itemSize;
+          const normalPos = (firstIndex - exactScrollIndex) * itemSize;
+          currentPosition = normalPos + (bottomPos - normalPos) * interpolation;
+        } else {
+          const scrollRatio = scrollPosition / virtualTotalSize;
+          currentPosition = (firstIndex - scrollRatio * totalItems) * itemSize;
+        }
+      } else {
+        currentPosition = firstIndex * itemSize - scrollPosition;
+      }
+      sortedIndices.forEach((index) => {
+        const element = renderedElements.get(index);
+        if (element) {
+          element.style.transform = `translateY(${Math.round(currentPosition)}px)`;
+          currentPosition += itemSize;
+        }
+      });
+    };
+    const renderItems = () => {
+      if (!viewportState?.itemsContainer) {
+        return;
+      }
+      const {
+        visibleRange,
+        itemsContainer,
+        totalItems,
+        itemSize,
+        scrollPosition,
+        containerSize,
+        virtualTotalSize
+      } = viewportState;
+      if (!visibleRange || totalItems <= 0 || visibleRange.start < 0 || visibleRange.start >= totalItems || visibleRange.end < visibleRange.start || isNaN(visibleRange.start) || isNaN(visibleRange.end)) {
+        if (totalItems <= 0 && renderedElements.size > 0) {
+          Array.from(renderedElements.entries()).forEach(([index, element]) => {
+            if (element.parentNode)
+              releaseElement(element);
+            renderedElements.delete(index);
+          });
+          currentVisibleRange = { start: -1, end: -1 };
+        }
+        return;
+      }
+      if (visibleRange.start === currentVisibleRange.start && visibleRange.end === currentVisibleRange.end && renderedElements.size > 0) {
+        updateItemPositions();
+        return;
+      }
+      lastRenderTime = Date.now();
+      const renderStart = Math.max(0, visibleRange.start - overscan);
+      const renderEnd = Math.min(totalItems - 1, visibleRange.end + overscan);
+      const toRemove = Array.from(renderedElements.entries()).filter(([index]) => index < renderStart || index > renderEnd);
+      toRemove.forEach(([index, element]) => {
+        if (element.parentNode)
+          releaseElement(element);
+        renderedElements.delete(index);
+      });
+      const items = getCollectionItems();
+      const missingItems = [];
+      const newElements = [];
+      for (let i = renderStart;i <= renderEnd; i++) {
+        if (i < 0 || i >= totalItems || renderedElements.has(i))
+          continue;
+        let item = items[i];
+        if (!item) {
+          missingItems.push(i);
+          const placeholders = component.placeholders;
+          item = placeholders?.generatePlaceholderItem(i) || {
+            _placeholder: true,
+            index: i,
+            id: `placeholder-${i}`,
+            name: VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER.repeat(15),
+            text: VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER.repeat(25),
+            description: VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER.repeat(40)
+          };
+        }
+        const element = renderItem(item, i);
+        if (element) {
+          const targetScrollIndex = viewportState?.targetScrollIndex;
+          const position = calculateItemPosition(i, scrollPosition, totalItems, itemSize, virtualTotalSize, containerSize, targetScrollIndex);
+          Object.assign(element.style, {
+            position: "absolute",
+            transform: `translateY(${position}px)`,
+            width: "100%"
+          });
+          if (maintainDomOrder) {
+            newElements.push([i, element]);
+          } else {
+            itemsContainer.appendChild(element);
+          }
+          renderedElements.set(i, element);
+        }
+      }
+      if (maintainDomOrder && newElements.length > 0) {
+        newElements.sort(([a], [b]) => a - b);
+        const existingChildren = Array.from(itemsContainer.children);
+        let newIdx = 0;
+        let existingIdx = 0;
+        while (newIdx < newElements.length) {
+          const [newIndex, newElement] = newElements[newIdx];
+          while (existingIdx < existingChildren.length && parseInt(existingChildren[existingIdx].dataset.index || "-1", 10) < newIndex) {
+            existingIdx++;
+          }
+          if (existingIdx < existingChildren.length) {
+            itemsContainer.insertBefore(newElement, existingChildren[existingIdx]);
+          } else {
+            itemsContainer.appendChild(newElement);
+          }
+          newIdx++;
+        }
+      }
+      if (missingItems.length > 0 && component.viewport?.collection?.loadMissingRanges) {
+        component.viewport.collection.loadMissingRanges({
+          start: Math.min(...missingItems),
+          end: Math.max(...missingItems)
+        }, "rendering:missing-items");
+      }
+      currentVisibleRange = visibleRange;
+      const renderedElementsArray = Array.from(renderedElements.values());
+      component.emit?.("viewport:items-rendered", {
+        elements: renderedElementsArray,
+        range: visibleRange
+      });
+      component.emit?.("viewport:rendered", {
+        range: visibleRange,
+        renderedCount: renderedElements.size
+      });
+      updateItemPositions();
+      if (renderedElements.size === 0 && totalItems > 0 && component.viewport?.collection) {
+        component.viewport.collection.loadMissingRanges(visibleRange, "rendering:no-items");
+      }
+    };
+    const originalRenderItems = component.viewport.renderItems;
+    component.viewport.renderItems = () => {
+      renderItems();
+      originalRenderItems?.();
+    };
+    wrapDestroy(component, () => {
+      renderedElements.forEach((element) => {
+        releaseElement(element);
+      });
+      renderedElements.clear();
+      elementPool.length = 0;
+      currentVisibleRange = { start: -1, end: -1 };
+      viewportState = null;
+      lastRenderTime = 0;
+      poolStats.created = 0;
+      poolStats.recycled = 0;
+      poolStats.poolSize = 0;
+    });
+    return component;
+  };
+};
+
+// src/core/viewport/features/events.ts
+var withEvents = (config = {}) => {
+  return (component) => {
+    const { debug = false } = config;
+    const listeners = new Map;
+    const emit = (event, data) => {
+      const eventListeners = listeners.get(event);
+      if (eventListeners) {
+        eventListeners.forEach((listener) => {
+          try {
+            listener(data);
+          } catch (error) {
+            console.error(`[Events] Error in listener for ${event}:`, error);
+          }
+        });
+      }
+    };
+    const on = (event, handler) => {
+      if (!listeners.has(event)) {
+        listeners.set(event, new Set);
+      }
+      listeners.get(event).add(handler);
+      return () => {
+        const eventListeners = listeners.get(event);
+        if (eventListeners) {
+          eventListeners.delete(handler);
+          if (eventListeners.size === 0) {
+            listeners.delete(event);
+          }
+        }
+      };
+    };
+    const once = (event, handler) => {
+      const wrappedHandler = (data) => {
+        handler(data);
+        off(event, wrappedHandler);
+      };
+      return on(event, wrappedHandler);
+    };
+    const off = (event, handler) => {
+      const eventListeners = listeners.get(event);
+      if (eventListeners) {
+        eventListeners.delete(handler);
+        if (eventListeners.size === 0) {
+          listeners.delete(event);
+        }
+      }
+    };
+    const clear = (event) => {
+      if (event) {
+        listeners.delete(event);
+      } else {
+        listeners.clear();
+      }
+    };
+    component.emit = emit;
+    component.on = on;
+    component.once = once;
+    component.off = off;
+    component.viewport.events = {
+      emit,
+      on,
+      once,
+      off,
+      clear,
+      getListenerCount: (event) => {
+        if (event) {
+          return listeners.get(event)?.size || 0;
+        }
+        let total = 0;
+        listeners.forEach((set) => total += set.size);
+        return total;
+      }
+    };
+    if ("destroy" in component && typeof component.destroy === "function") {
+      const originalDestroy = component.destroy;
+      component.destroy = () => {
+        clear();
+        originalDestroy?.();
+      };
+    }
+    return component;
+  };
+};
+
+// src/core/viewport/viewport.ts
+var createViewport = (config = {}) => {
+  return (component) => {
+    let isInitialized = false;
+    const state = {
+      scrollPosition: 0,
+      totalItems: component.totalItems || 0,
+      itemSize: config.virtual?.itemSize || 50,
+      containerSize: 0,
+      virtualTotalSize: 0,
+      visibleRange: { start: 0, end: 0 },
+      itemsContainer: null,
+      velocity: 0,
+      scrollDirection: "forward"
+    };
+    const viewportAPI = {
+      initialize: () => {
+        if (isInitialized) {
+          return false;
+        }
+        isInitialized = true;
+        if (component.element) {
+          state.containerSize = config.scrolling?.orientation === "horizontal" ? component.element.offsetWidth : component.element.offsetHeight;
+        }
+        state.virtualTotalSize = state.totalItems * state.itemSize;
+        state.visibleRange = calculateVisibleRange(state.scrollPosition);
+      },
+      destroy: () => {},
+      updateViewport: () => {},
+      isInitialized: () => isInitialized,
+      resetInitialization: () => {
+        isInitialized = false;
+      },
+      _shouldInit: () => !isInitialized,
+      scrollToIndex: (index, alignment) => {},
+      scrollToPosition: (position) => {},
+      getScrollPosition: () => state.scrollPosition,
+      getVisibleRange: () => state.visibleRange,
+      getViewportInfo: () => ({
+        containerSize: state.containerSize,
+        totalVirtualSize: state.virtualTotalSize,
+        visibleRange: state.visibleRange,
+        virtualScrollPosition: state.scrollPosition
+      }),
+      renderItems: () => {},
+      state
+    };
+    const calculateVisibleRange = (scrollPos) => {
+      const itemSize = state.itemSize;
+      const start = Math.floor(scrollPos / itemSize);
+      const visibleCount = Math.ceil(state.containerSize / itemSize);
+      const end = Math.min(start + visibleCount, state.totalItems - 1);
+      return { start: Math.max(0, start), end: Math.max(0, end) };
+    };
+    const baseComponent = {
+      ...component,
+      viewport: viewportAPI
+    };
+    const enhancers = [];
+    enhancers.push(withEvents({
+      debug: config.debug
+    }));
+    enhancers.push(withBase({
+      className: config.className,
+      orientation: config.scrolling?.orientation
+    }));
+    enhancers.push(withVirtual({
+      itemSize: config.virtual?.itemSize,
+      overscan: config.virtual?.overscan,
+      orientation: config.scrolling?.orientation,
+      autoDetectItemSize: config.virtual?.autoDetectItemSize,
+      initialScrollIndex: config.initialScrollIndex
+    }));
+    enhancers.push(withScrolling({
+      orientation: config.scrolling?.orientation,
+      sensitivity: config.scrolling?.sensitivity,
+      smoothing: config.scrolling?.animation,
+      stopOnClick: config.scrolling?.stopOnClick
+    }));
+    enhancers.push(withMomentum({
+      enabled: true,
+      stopOnClick: config.scrolling?.stopOnClick,
+      deceleration: config.scrolling?.momentum?.deceleration,
+      minVelocity: config.scrolling?.momentum?.minVelocity,
+      minDuration: config.scrolling?.momentum?.maxDuration,
+      minVelocityThreshold: config.scrolling?.momentum?.velocityThreshold
+    }));
+    if (config.scrollbar?.enabled !== false) {
+      enhancers.push(withScrollbar({
+        enabled: true,
+        autoHide: config.scrollbar?.autoHide
+      }));
+    }
+    if (config.collection?.adapter) {
+      enhancers.push(withCollection({
+        collection: config.collection.adapter,
+        rangeSize: config.pagination?.limit,
+        strategy: config.pagination?.strategy,
+        transform: config.collection?.transform,
+        cancelLoadThreshold: config.performance?.cancelLoadThreshold,
+        maxConcurrentRequests: config.performance?.maxConcurrentRequests,
+        enableRequestQueue: config.performance?.enableRequestQueue !== false,
+        initialScrollIndex: config.initialScrollIndex,
+        selectId: config.selectId,
+        autoLoad: config.autoLoad !== false,
+        autoSelectFirst: config.autoSelectFirst,
+        maxCachedItems: config.cache?.maxItems,
+        evictionBuffer: config.cache?.evictionBuffer
+      }));
+    }
+    if (config.collection?.adapter && config.placeholders?.enabled !== false) {
+      enhancers.push(withPlaceholders({
+        enabled: true,
+        analyzeFirstLoad: config.placeholders?.analyzeFirstLoad ?? true,
+        maskCharacter: config.placeholders?.maskCharacter
+      }));
+    }
+    enhancers.push(withRendering({
+      template: config.template,
+      overscan: config.virtual?.overscan,
+      maintainDomOrder: config.rendering?.maintainDomOrder
+    }));
+    const enhance = import_mtrl4.pipe(...enhancers);
+    const enhanced = enhance(baseComponent);
+    if (enhanced.element) {
+      enhanced.viewport.initialize();
+    }
+    return enhanced;
+  };
+};
+
+//# debugId=BD481E0A015C99EC64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/core/viewport/viewport.ts", "../../../src/core/viewport/features/utils.ts", "../../../src/core/viewport/features/base.ts", "../../../src/core/viewport/constants.ts", "../../../src/core/viewport/features/virtual.ts", "../../../src/core/viewport/features/scrolling.ts", "../../../src/core/viewport/features/momentum.ts", "../../../src/core/viewport/features/scrollbar.ts", "../../../src/core/viewport/features/collection.ts", "../../../src/core/viewport/features/placeholders.ts", "../../../src/core/viewport/features/rendering.ts", "../../../src/core/layout/schema.ts", "../../../src/core/viewport/features/events.ts"],
  "sourcesContent": [
    "/**\n * Viewport - Core virtual scrolling engine\n */\n\nimport type {\n  ViewportConfig,\n  ViewportContext,\n  ViewportComponent,\n  ItemRange,\n  ViewportInfo,\n} from \"./types\";\nimport { pipe } from \"mtrl\";\nimport { withBase } from \"./features/base\";\nimport { withVirtual } from \"./features/virtual\";\nimport { withScrolling } from \"./features/scrolling\";\nimport { withMomentum } from \"./features/momentum\";\nimport { withScrollbar } from \"./features/scrollbar\";\nimport { withCollection } from \"./features/collection\";\nimport { withPlaceholders } from \"./features/placeholders\";\nimport { withRendering } from \"./features/rendering\";\nimport { withEvents } from \"./features/events\";\n\n// Internal viewport state\ninterface ViewportState {\n  scrollPosition: number;\n  totalItems: number;\n  itemSize: number;\n  containerSize: number;\n  virtualTotalSize: number;\n  visibleRange: ItemRange;\n  itemsContainer: HTMLElement | null;\n  velocity: number;\n  scrollDirection: \"forward\" | \"backward\";\n}\n\n/**\n * Creates a viewport-enhanced component using composition\n *\n * @param config - Viewport configuration\n * @returns Function that enhances a component with viewport capabilities\n */\nexport const createViewport = (config: ViewportConfig = {}) => {\n  return <T extends ViewportContext>(component: T): T & ViewportComponent => {\n    // Track if viewport has been initialized to prevent multiple initializations\n    let isInitialized = false;\n\n    // No normalization needed - we'll use the nested structure directly\n\n    // Create shared viewport state\n    const state: ViewportState = {\n      scrollPosition: 0,\n      totalItems: component.totalItems || 0,\n      itemSize: config.virtual?.itemSize || 50,\n      containerSize: 0,\n      virtualTotalSize: 0,\n      visibleRange: { start: 0, end: 0 },\n      itemsContainer: null,\n      velocity: 0,\n      scrollDirection: \"forward\",\n    };\n\n    // Create base viewport API\n    const viewportAPI = {\n      // Core API\n      initialize: () => {\n        // Prevent multiple initializations\n        if (isInitialized) {\n          return false;\n        }\n        isInitialized = true;\n\n        // console.log(\"[Viewport] Initializing with state:\", {\n        //   element: !!component.element,\n        //   totalItems: component.totalItems,\n        //   itemSize: config.virtual?.itemSize,\n        // });\n\n        // Initialize container size\n        if (component.element) {\n          state.containerSize =\n            config.scrolling?.orientation === \"horizontal\"\n              ? component.element.offsetWidth\n              : component.element.offsetHeight;\n\n          // console.log(\"[Viewport] Container size:\", state.containerSize);\n        }\n\n        // Calculate initial virtual size\n        state.virtualTotalSize = state.totalItems * state.itemSize;\n\n        // Calculate initial visible range\n        state.visibleRange = calculateVisibleRange(state.scrollPosition);\n\n        // console.log(\"[Viewport] Initial state:\", {\n        //   containerSize: state.containerSize,\n        //   virtualTotalSize: state.virtualTotalSize,\n        //   visibleRange: state.visibleRange,\n        // });\n      },\n\n      destroy: () => {\n        // Cleanup will be handled by features\n      },\n\n      updateViewport: () => {\n        // Will be implemented by rendering feature\n      },\n\n      // Check if already initialized\n      isInitialized: () => isInitialized,\n\n      // Reset initialization state (for reload functionality)\n      resetInitialization: () => {\n        isInitialized = false;\n      },\n\n      // Allow features to check if init should proceed\n      _shouldInit: () => !isInitialized,\n\n      // Scrolling API (will be overridden by scrolling feature)\n      scrollToIndex: (\n        index: number,\n        alignment?: \"start\" | \"center\" | \"end\",\n      ) => {\n        // Placeholder - will be implemented by scrolling feature\n      },\n\n      scrollToPosition: (position: number) => {\n        // Will be implemented by scrolling feature\n      },\n\n      getScrollPosition: () => state.scrollPosition,\n\n      // Info API\n      getVisibleRange: () => state.visibleRange,\n\n      getViewportInfo: (): ViewportInfo => ({\n        containerSize: state.containerSize,\n        totalVirtualSize: state.virtualTotalSize,\n        visibleRange: state.visibleRange,\n        virtualScrollPosition: state.scrollPosition,\n      }),\n\n      // Rendering API\n      renderItems: () => {\n        // Will be implemented by rendering feature\n      },\n\n      // Internal state (for features to access)\n      state,\n    };\n\n    // Helper function to calculate visible range\n    const calculateVisibleRange = (scrollPos: number): ItemRange => {\n      const itemSize = state.itemSize;\n      const start = Math.floor(scrollPos / itemSize);\n      const visibleCount = Math.ceil(state.containerSize / itemSize);\n      const end = Math.min(start + visibleCount, state.totalItems - 1);\n\n      return { start: Math.max(0, start), end: Math.max(0, end) };\n    };\n\n    // Add viewport API to component\n    const baseComponent = {\n      ...component,\n      viewport: viewportAPI,\n    };\n\n    // Build the enhancement pipeline\n    const enhancers: Array<(c: any) => any> = [];\n\n    // Events system (always first - provides communication for other features)\n    enhancers.push(\n      withEvents({\n        debug: config.debug,\n      }),\n    );\n\n    // Base setup (creates DOM structure)\n    enhancers.push(\n      withBase({\n        className: config.className,\n        orientation: config.scrolling?.orientation,\n      }),\n    );\n\n    // Virtual scrolling (required for most features)\n    enhancers.push(\n      withVirtual({\n        itemSize: config.virtual?.itemSize,\n        overscan: config.virtual?.overscan,\n        orientation: config.scrolling?.orientation,\n        autoDetectItemSize: config.virtual?.autoDetectItemSize,\n        initialScrollIndex: (config as any).initialScrollIndex,\n      }),\n    );\n\n    // Scrolling behavior\n    enhancers.push(\n      withScrolling({\n        orientation: config.scrolling?.orientation,\n        sensitivity: config.scrolling?.sensitivity,\n        smoothing: config.scrolling?.animation,\n        stopOnClick: config.scrolling?.stopOnClick,\n      }),\n    );\n\n    // Momentum scrolling (touch/drag support for mobile)\n    enhancers.push(\n      withMomentum({\n        enabled: true,\n        stopOnClick: config.scrolling?.stopOnClick,\n        deceleration: config.scrolling?.momentum?.deceleration,\n        minVelocity: config.scrolling?.momentum?.minVelocity,\n        minDuration: config.scrolling?.momentum?.maxDuration,\n        minVelocityThreshold: config.scrolling?.momentum?.velocityThreshold,\n      }),\n    );\n\n    // Scrollbar (optional)\n    if (config.scrollbar?.enabled !== false) {\n      enhancers.push(\n        withScrollbar({\n          enabled: true,\n          autoHide: config.scrollbar?.autoHide,\n        }),\n      );\n    }\n\n    // Add collection if configured\n    if (config.collection?.adapter) {\n      enhancers.push(\n        withCollection({\n          collection: config.collection.adapter,\n          rangeSize: config.pagination?.limit,\n          strategy: config.pagination?.strategy as\n            | \"offset\"\n            | \"page\"\n            | \"cursor\"\n            | undefined,\n          transform: config.collection?.transform,\n          cancelLoadThreshold: config.performance?.cancelLoadThreshold,\n          maxConcurrentRequests: config.performance?.maxConcurrentRequests,\n          enableRequestQueue: config.performance?.enableRequestQueue !== false,\n          initialScrollIndex: (config as any).initialScrollIndex,\n          selectId: (config as any).selectId,\n          autoLoad: (config as any).autoLoad !== false,\n          autoSelectFirst: (config as any).autoSelectFirst,\n          maxCachedItems: config.cache?.maxItems,\n          evictionBuffer: config.cache?.evictionBuffer,\n        }),\n      );\n    }\n\n    // Placeholders (optional, requires collection)\n    if (config.collection?.adapter && config.placeholders?.enabled !== false) {\n      enhancers.push(\n        withPlaceholders({\n          enabled: true,\n          analyzeFirstLoad: config.placeholders?.analyzeFirstLoad ?? true,\n          maskCharacter: config.placeholders?.maskCharacter,\n        }),\n      );\n    }\n\n    // Rendering (always last to have access to all features)\n    enhancers.push(\n      withRendering({\n        template: config.template,\n        overscan: config.virtual?.overscan,\n        maintainDomOrder: config.rendering?.maintainDomOrder,\n      }),\n    );\n\n    // Compose all enhancers\n    const enhance = pipe(...enhancers);\n\n    // Apply enhancements\n    const enhanced = enhance(baseComponent);\n\n    // Auto-initialize if element is provided\n    if (enhanced.element) {\n      enhanced.viewport.initialize();\n    }\n\n    return enhanced as T & ViewportComponent;\n  };\n};\n",
    "// src/core/viewport/features/utils.ts\n\n/**\n * Shared utilities for viewport features\n * Eliminates code duplication across features\n */\n\nimport type { ViewportContext, ViewportComponent } from \"../types\";\n\n/**\n * Wraps viewport initialization with feature-specific logic\n * Eliminates the repeated initialization hook pattern\n */\nexport function wrapInitialize<T extends ViewportContext & ViewportComponent>(\n  component: T,\n  featureInit: () => void,\n): void {\n  const originalInitialize = component.viewport.initialize;\n  component.viewport.initialize = () => {\n    // Check if already initialized (returns false if already done)\n    const result = originalInitialize();\n    // Only run feature init if base init actually ran (didn't return false)\n    if (result !== false) {\n      featureInit();\n    }\n    // Propagate the result through the chain so outer wrappers know to skip\n    return result;\n  };\n}\n\n/**\n * Wraps component destroy with cleanup logic\n * Eliminates the repeated destroy hook pattern\n */\nexport function wrapDestroy<T extends Record<string, any>>(\n  component: T,\n  cleanup: () => void,\n): void {\n  if (\"destroy\" in component && typeof component.destroy === \"function\") {\n    const originalDestroy = component.destroy;\n    (component as any).destroy = () => {\n      cleanup();\n      originalDestroy?.();\n    };\n  }\n}\n\n/**\n * Gets viewport state with proper typing\n * Eliminates repeated (component.viewport as any).state\n */\nexport function getViewportState(component: ViewportComponent): any {\n  return (component.viewport as any).state;\n}\n\n/**\n * Checks if an item is a placeholder\n * Eliminates duplicated placeholder detection logic\n */\nexport function isPlaceholder(item: any): boolean {\n  return (\n    item &&\n    typeof item === \"object\" &&\n    (item._placeholder === true || item[\"_placeholder\"] === true) // Support both access patterns\n  );\n}\n\n/**\n * Creates a range key for deduplication\n * Used by multiple features for tracking ranges\n */\nexport function getRangeKey(range: { start: number; end: number }): string {\n  return `${range.start}-${range.end}`;\n}\n\n/**\n * Clamps a value between min and max\n * Used by multiple features for boundary checking\n */\nexport function clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\n/**\n * Stores a function reference on the component for later access\n * Eliminates pattern like (component as any)._featureFunction = fn\n */\nexport function storeFeatureFunction<T extends Record<string, any>>(\n  component: T,\n  name: string,\n  fn: Function,\n): void {\n  (component as any)[name] = fn;\n}\n",
    "// src/core/viewport/features/base.ts\n\n/**\n * Base Viewport Feature - Sets up core viewport structure\n * Provides the foundation for other viewport features\n */\n\nimport type { ViewportContext, ViewportComponent } from \"../types\";\nimport { wrapInitialize, getViewportState } from \"./utils\";\n\nexport interface BaseConfig {\n  className?: string;\n  orientation?: \"vertical\" | \"horizontal\";\n}\n\n/**\n * Base feature for viewport\n * Sets up the DOM structure and core styles\n */\nexport const withBase = (config: BaseConfig = {}) => {\n  return <T extends ViewportContext & ViewportComponent>(component: T): T => {\n    const { className = \"mtrl-viewport\", orientation = \"vertical\" } = config;\n\n    // Use the shared wrapper utility\n    wrapInitialize(component, () => {\n      const element = component.element;\n      if (!element) return;\n\n      // Create viewport structure\n      let viewportElement = element.querySelector(\n        \".mtrl-viewport\"\n      ) as HTMLElement;\n\n      if (!viewportElement) {\n        viewportElement = document.createElement(\"div\");\n        viewportElement.className = className;\n        viewportElement.style.cssText = `\n          position: relative;\n          width: 100%;\n          height: 100%;\n          overflow: hidden;\n        `;\n\n        // Set orientation\n        viewportElement.setAttribute(\"data-orientation\", orientation);\n\n        // Create items container\n        const itemsContainer = document.createElement(\"div\");\n        itemsContainer.className = \"mtrl-viewport-items\";\n        itemsContainer.style.cssText = `\n          position: relative;\n          width: 100%;\n        `;\n\n        viewportElement.appendChild(itemsContainer);\n        element.appendChild(viewportElement);\n\n        // Update viewport state with containers using utility\n        const state = getViewportState(component);\n        if (state) {\n          state.viewportElement = viewportElement;\n          state.itemsContainer = itemsContainer;\n        }\n\n        // Store references on component\n        (component as any).viewportElement = viewportElement;\n        (component as any).itemsContainer = itemsContainer;\n      }\n    });\n\n    return component;\n  };\n};\n",
    "// src/core/viewport/constants.ts\n\n/**\n * Viewport Constants\n * Centralized constants for all viewport functionality\n * Consolidated from viewport, viewport/features, and list-manager constants\n */\n\nexport const VIEWPORT_CONSTANTS = {\n  // Virtual scrolling defaults\n  VIRTUAL_SCROLL: {\n    DEFAULT_ITEM_SIZE: 48,\n    OVERSCAN_BUFFER: 2,\n    SCROLL_SENSITIVITY: 0.7,\n    MAX_VIRTUAL_SIZE: 100 * 1000 * 1000, // 100M pixels - modern browsers can handle this\n    AUTO_DETECT_ITEM_SIZE: true, // Enable automatic item size detection\n  },\n\n  // Scrolling settings\n  SCROLLING: {\n    OVERSCAN: 1, // From features/constants\n  },\n\n  // Rendering settings\n  RENDERING: {\n    // Element recycling\n    DEFAULT_MAX_POOL_SIZE: 100,\n    CLASSES: {\n      ITEM: \"viewport-item\",\n    },\n  },\n\n  // Loading settings\n  LOADING: {\n    CANCEL_THRESHOLD: 25, // px/ms - velocity above which loads cancel\n    MAX_CONCURRENT_REQUESTS: 1, // Parallel requests allowed\n    DEFAULT_RANGE_SIZE: 20, // Items per request\n    DEBOUNCE_LOADING: 150, // Debounce delay (ms)\n    MIN_RANGE_SIZE: 10, // Minimum items per load\n    MAX_RANGE_SIZE: 100, // Maximum items per load\n    REQUEST_TIMEOUT: 5000, // Request timeout (ms)\n    RETRY_ATTEMPTS: 2, // Failed request retries\n    RETRY_DELAY: 1000, // Delay between retries (ms)\n  },\n\n  // Request queue configuration (from features/constants)\n  REQUEST_QUEUE: {\n    ENABLED: true, // Enable request queuing\n    MAX_QUEUE_SIZE: 1, // Max queued requests\n    MAX_ACTIVE_REQUESTS: 2, // Max concurrent active requests\n  },\n\n  // Placeholder settings\n  PLACEHOLDER: {\n    MASK_CHARACTER: \"X\", // Updated from list-manager\n    CLASS: \"viewport-item--placeholder\",\n    MAX_SAMPLE_SIZE: 20,\n    PLACEHOLDER_FLAG: \"_placeholder\",\n    RANDOM_LENGTH_VARIANCE: true,\n  },\n\n  // Speed tracking (from list-manager)\n  SPEED_TRACKING: {\n    // Velocity calculation\n    DECELERATION_FACTOR: 0.85, // velocity decay per frame\n  },\n\n  // Momentum settings\n  MOMENTUM: {\n    ENABLED: false, // Enable momentum by default\n    DECELERATION_FACTOR: 0.95, // How quickly velocity decreases per frame (higher = longer coast)\n    MIN_VELOCITY: 0.1, // Minimum velocity before stopping (px/ms)\n    MIN_DURATION: 750, // Maximum gesture duration to trigger momentum (ms)\n    MIN_VELOCITY_THRESHOLD: 0.4, // Minimum velocity to trigger momentum (px/ms)\n    FRAME_TIME: 16, // Assumed frame time for calculations (ms)\n  },\n\n  // Initial load configuration (from list-manager)\n  INITIAL_LOAD: {\n    STRATEGY: \"placeholders\", // \"placeholders\" | \"direct\" | \"progressive\"\n    VIEWPORT_MULTIPLIER: 1.5, // load 1.5x viewport capacity\n    MIN_ITEMS: 10,\n    MAX_ITEMS: 100,\n    PLACEHOLDER_COUNT: 20, // default placeholder count\n    SHOW_LOADING_STATE: true,\n    LOADING_DELAY: 100, // ms - delay before showing loading state\n  },\n\n  // Selection settings\n  SELECTION: {\n    SELECTED_CLASS: \"viewport-item--selected\",\n  },\n\n  // Scrollbar settings (from list-manager)\n  SCROLLBAR: {\n    // CSS classes\n    CLASSES: {\n      SCROLLBAR: \"viewport__scrollbar\",\n      SCROLLBAR_TRACK: \"viewport__scrollbar-track\",\n      SCROLLBAR_THUMB: \"viewport__scrollbar-thumb\",\n      SCROLLBAR_VISIBLE: \"viewport__scrollbar--visible\",\n      SCROLLBAR_DRAGGING: \"viewport__scrollbar--dragging\",\n      SCROLLBAR_THUMB_DRAGGING: \"viewport__scrollbar-thumb--dragging\",\n    },\n  },\n\n  // Orientation (from list-manager)\n  ORIENTATION: {\n    DEFAULT_ORIENTATION: \"vertical\",\n    DEFAULT_CROSS_AXIS_ALIGNMENT: \"stretch\",\n    REVERSE_DIRECTION: false,\n  },\n\n  PAGINATION: {\n    DEFAULT_STRATEGY: \"offset\" as \"offset\" | \"page\" | \"cursor\",\n    DEFAULT_LIMIT: 20,\n    STRATEGIES: {\n      PAGE: \"page\" as const,\n      OFFSET: \"offset\" as const,\n      CURSOR: \"cursor\" as const,\n    },\n    CURSOR_CLEANUP_INTERVAL: 60000, // Clean up old cursors every minute\n    MAX_CURSOR_MAP_SIZE: 1000, // Maximum number of cursors to keep in memory\n    // Cursor-specific virtual sizing\n    CURSOR_SCROLL_MARGIN_MULTIPLIER: 3, // Multiply rangeSize by this for scroll margin\n    CURSOR_MIN_VIRTUAL_SIZE_MULTIPLIER: 3, // Minimum virtual size as multiplier of rangeSize\n  },\n};\n\n/**\n * Type for overriding constants at runtime\n */\nexport type ViewportConstants = typeof VIEWPORT_CONSTANTS;\n\n/**\n * Helper function to merge user constants with defaults\n */\nexport function mergeConstants(\n  userConstants: Partial<ViewportConstants> = {},\n): ViewportConstants {\n  return {\n    ...VIEWPORT_CONSTANTS,\n    ...userConstants,\n  };\n}\n",
    "/**\n * Virtual Feature - Core virtual scrolling calculations\n * Handles visible range calculation and total virtual size management\n */\n\nimport type { ViewportContext, ViewportComponent } from \"../types\";\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\nimport { wrapInitialize, wrapDestroy, getViewportState } from \"./utils\";\n\nexport interface VirtualConfig {\n  itemSize?: number;\n  overscan?: number;\n  orientation?: \"vertical\" | \"horizontal\";\n  autoDetectItemSize?: boolean;\n  debug?: boolean;\n  initialScrollIndex?: number;\n}\n\n/**\n * Virtual scrolling feature for viewport\n * Handles visible range calculations with compression for large datasets\n */\nexport const withVirtual = (config: VirtualConfig = {}) => {\n  return <T extends ViewportContext & ViewportComponent>(component: T): T => {\n    const {\n      itemSize,\n      overscan = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.OVERSCAN_BUFFER,\n      orientation = \"vertical\",\n      autoDetectItemSize = itemSize === undefined\n        ? VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.AUTO_DETECT_ITEM_SIZE\n        : false,\n      debug = false,\n      initialScrollIndex = 0,\n    } = config;\n\n    // Use provided itemSize or default, but mark if we should auto-detect\n    const initialItemSize =\n      itemSize || VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.DEFAULT_ITEM_SIZE;\n\n    const MAX_VIRTUAL_SIZE = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.MAX_VIRTUAL_SIZE;\n    let viewportState: any;\n    let hasCalculatedItemSize = false;\n    let hasRecalculatedScrollForCompression = false; // Track if we've recalculated scroll position for compression\n    let resizeObserver: ResizeObserver | null = null;\n\n    // Cache variables for range calculations (declared here, initialized later)\n    let lastScrollPosition = -1;\n    let lastVisibleRange: { start: number; end: number } | null = null;\n    let lastActualVisibleRange: { start: number; end: number } | null = null;\n\n    // Listen for reload:start to reset feature-specific state\n    // NOTE: We do NOT reset scrollPosition here - the caller (reload or reloadAt)\n    // is responsible for setting the scroll position. This prevents race conditions\n    // where reloadAt sets a position but we reset it to 0 before the load completes.\n    component.on?.(\"reload:start\", () => {\n      hasCalculatedItemSize = false;\n      hasRecalculatedScrollForCompression = false;\n      // Reset cache\n      lastScrollPosition = -1;\n      lastVisibleRange = null;\n      lastActualVisibleRange = null;\n      // Reset viewportState if it exists, but preserve scrollPosition\n      // The caller (reload/reloadAt) is responsible for setting scrollPosition\n      if (viewportState) {\n        // Don't reset scrollPosition - caller controls it\n        // viewportState.scrollPosition = 0;\n        viewportState.totalItems = 0;\n        viewportState.virtualTotalSize = 0;\n        viewportState.visibleRange = { start: 0, end: 0 };\n        delete (viewportState as any).targetScrollIndex;\n      }\n    });\n\n    // Initialize using shared wrapper\n    wrapInitialize(component, () => {\n      viewportState = getViewportState(component);\n      if (!viewportState) return;\n\n      Object.assign(viewportState, {\n        itemSize: initialItemSize,\n        overscan,\n        containerSize:\n          viewportState.viewportElement?.[\n            orientation === \"horizontal\" ? \"offsetWidth\" : \"offsetHeight\"\n          ] || 600,\n      });\n\n      updateTotalVirtualSize(viewportState.totalItems);\n\n      // If we have an initial scroll index, calculate initial scroll position\n      // Note: We store the initialScrollIndex to use directly in range calculations\n      // because scroll position may be compressed for large lists\n      let initialScrollPosition = viewportState.scrollPosition || 0;\n\n      if (initialScrollIndex > 0) {\n        // Store the target index for use in range calculations\n        (viewportState as any).targetScrollIndex = initialScrollIndex;\n\n        // Calculate scroll position (may be compressed for large lists)\n        initialScrollPosition =\n          initialScrollIndex * (viewportState.itemSize || initialItemSize);\n        viewportState.scrollPosition = initialScrollPosition;\n\n        // Notify scrolling feature to sync its local scroll position\n        // Use setTimeout to ensure scrolling feature has initialized\n        setTimeout(() => {\n          component.emit?.(\"viewport:scroll-position-sync\", {\n            position: initialScrollPosition,\n            source: \"initial-scroll-index\",\n          });\n        }, 0);\n      }\n\n      updateVisibleRange(initialScrollPosition);\n\n      // Ensure container size is measured after DOM is ready\n      requestAnimationFrame(() => {\n        updateContainerSize();\n      });\n\n      // Set up ResizeObserver to handle viewport container resize\n      if (\n        viewportState.viewportElement &&\n        typeof ResizeObserver !== \"undefined\"\n      ) {\n        resizeObserver = new ResizeObserver((entries) => {\n          for (const entry of entries) {\n            // Use contentBoxSize if available, otherwise fall back to contentRect\n            const size =\n              orientation === \"horizontal\"\n                ? entry.contentRect.width\n                : entry.contentRect.height;\n\n            if (size > 0 && size !== viewportState?.containerSize) {\n              updateContainerSize();\n            }\n          }\n        });\n        resizeObserver.observe(viewportState.viewportElement);\n      }\n    });\n\n    // Helper functions\n    const getCompressionRatio = (): number => {\n      if (!viewportState?.virtualTotalSize) return 1;\n      const actualSize = viewportState.totalItems * viewportState.itemSize;\n      return actualSize <= MAX_VIRTUAL_SIZE ? 1 : MAX_VIRTUAL_SIZE / actualSize;\n    };\n\n    const log = (message: string, data?: any) => {\n      if (debug) console.log(`[Virtual] ${message}`, data);\n    };\n\n    // Calculate visible range\n    const calculateVisibleRange = (\n      scrollPosition: number,\n    ): { start: number; end: number } => {\n      if (!viewportState) {\n        console.warn(\"[Virtual] No viewport state, returning empty range\");\n        return { start: 0, end: 0 };\n      }\n\n      const { containerSize, totalItems } = viewportState;\n\n      // Early returns for invalid states\n      if (\n        !containerSize ||\n        containerSize <= 0 ||\n        !totalItems ||\n        totalItems <= 0\n      ) {\n        // If we have an initialScrollIndex, use it to calculate the range\n        // even when totalItems is 0 (not yet loaded from API)\n        if (initialScrollIndex > 0) {\n          const visibleCount = Math.ceil(\n            (containerSize || 600) /\n              (viewportState.itemSize || initialItemSize),\n          );\n          const start = Math.max(0, initialScrollIndex - overscan);\n          const end = initialScrollIndex + visibleCount + overscan;\n          return { start, end };\n        }\n        log(`Invalid state: container=${containerSize}, items=${totalItems}`);\n        return { start: 0, end: 0 };\n      }\n\n      const virtualSize =\n        viewportState.virtualTotalSize || totalItems * viewportState.itemSize;\n      const visibleCount = Math.ceil(containerSize / viewportState.itemSize);\n      const compressionRatio = getCompressionRatio();\n\n      let start: number, end: number;\n\n      // Check if we have a target scroll index (for initialScrollIndex with compression)\n      const targetScrollIndex = (viewportState as any).targetScrollIndex;\n\n      if (compressionRatio < 1) {\n        // Compressed space calculation\n        // If we have a targetScrollIndex, use it directly instead of calculating from scroll position\n        // This ensures we show the correct items even when virtual space is compressed\n        if (targetScrollIndex !== undefined && targetScrollIndex > 0) {\n          start = Math.max(0, targetScrollIndex - overscan);\n          end = Math.min(\n            totalItems - 1,\n            targetScrollIndex + visibleCount + overscan,\n          );\n          // Clear targetScrollIndex after first use so normal scrolling works\n          delete (viewportState as any).targetScrollIndex;\n        } else {\n          const scrollRatio = scrollPosition / virtualSize;\n          const exactIndex = scrollRatio * totalItems;\n          start = Math.floor(exactIndex);\n          end = Math.ceil(exactIndex) + visibleCount;\n        }\n\n        // Near-bottom handling\n        const maxScroll = virtualSize - containerSize;\n        const distanceFromBottom = maxScroll - scrollPosition;\n\n        if (distanceFromBottom <= containerSize && distanceFromBottom >= -1) {\n          const itemsAtBottom = Math.floor(\n            containerSize / viewportState.itemSize,\n          );\n          const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);\n          const interpolation = Math.max(\n            0,\n            Math.min(1, 1 - distanceFromBottom / containerSize),\n          );\n\n          start = Math.floor(\n            start + (firstVisibleAtBottom - start) * interpolation,\n          );\n          end =\n            distanceFromBottom <= 1\n              ? totalItems - 1\n              : Math.min(totalItems - 1, start + visibleCount + overscan);\n\n          log(\"Near bottom calculation:\", {\n            distanceFromBottom,\n            interpolation,\n            start,\n            end,\n            scrollPosition,\n            totalItems,\n          });\n        }\n\n        // Apply overscan\n        start = Math.max(0, start - overscan);\n        end = Math.min(totalItems - 1, end + overscan);\n      } else {\n        // Direct calculation\n        start = Math.max(\n          0,\n          Math.floor(scrollPosition / viewportState.itemSize) - overscan,\n        );\n        end = Math.min(totalItems - 1, start + visibleCount + overscan * 2);\n      }\n\n      // Validate output\n      if (isNaN(start) || isNaN(end)) {\n        console.error(\"[Virtual] NaN in range calculation:\", {\n          scrollPosition,\n          containerSize,\n          totalItems,\n          itemSize: viewportState.itemSize,\n          compressionRatio,\n        });\n        return { start: 0, end: 0 };\n      }\n\n      // Strategic log for last range\n      // if (end >= totalItems - 10) {\n      //   console.log(\n      //     `[Virtual] Near end range: ${start}-${end}, totalItems=${totalItems}, lastItemPos=${\n      //       end * viewportState.itemSize\n      //     }px, virtualSize=${viewportState.virtualTotalSize}px`\n      //   );\n      // }\n\n      return { start, end };\n    };\n\n    // Calculate actual visible range (without overscan buffer)\n    const calculateActualVisibleRange = (scrollPosition: number) => {\n      if (!viewportState) return { start: 0, end: 0 };\n\n      const { containerSize, totalItems } = viewportState;\n\n      if (!containerSize || !totalItems) return { start: 0, end: 0 };\n\n      const itemSize = viewportState.itemSize;\n      const visibleCount = Math.ceil(containerSize / itemSize);\n      const actualSize = totalItems * itemSize;\n      const virtualSize = viewportState.virtualTotalSize || actualSize;\n      // compressionRatio < 1 means list is compressed (virtualSize < actualSize)\n      const compressionRatio = actualSize > 0 ? virtualSize / actualSize : 1;\n\n      let start: number, end: number;\n\n      if (compressionRatio < 1) {\n        // Compressed space - calculate based on scroll ratio\n        const scrollRatio = scrollPosition / virtualSize;\n        start = Math.floor(scrollRatio * totalItems);\n        end = Math.min(totalItems - 1, start + visibleCount - 1);\n\n        // Near-bottom handling - ensure we show the actual last items at bottom\n        const maxScroll = virtualSize - containerSize;\n        const distanceFromBottom = maxScroll - scrollPosition;\n\n        if (distanceFromBottom <= containerSize && distanceFromBottom >= -1) {\n          const itemsAtBottom = Math.floor(containerSize / itemSize);\n          const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);\n          const interpolation = Math.max(\n            0,\n            Math.min(1, 1 - distanceFromBottom / containerSize),\n          );\n\n          start = Math.floor(\n            start + (firstVisibleAtBottom - start) * interpolation,\n          );\n          end =\n            distanceFromBottom <= 1\n              ? totalItems - 1\n              : Math.min(totalItems - 1, start + visibleCount - 1);\n        }\n      } else {\n        // Direct calculation\n        start = Math.floor(scrollPosition / itemSize);\n        end = Math.min(totalItems - 1, start + visibleCount - 1);\n      }\n\n      // Ensure valid range\n      start = Math.max(0, start);\n      end = Math.max(start, end);\n\n      return { start, end };\n    };\n\n    // Update functions\n    const updateVisibleRange = (scrollPosition: number) => {\n      if (!viewportState) return;\n\n      // Skip if scroll position hasn't changed significantly (within 1px)\n      if (\n        lastScrollPosition >= 0 &&\n        Math.abs(scrollPosition - lastScrollPosition) < 1\n      ) {\n        return;\n      }\n\n      lastScrollPosition = scrollPosition;\n      viewportState.visibleRange = calculateVisibleRange(scrollPosition);\n\n      // Calculate actual visible range (without overscan) for UI display\n      const actualVisibleRange = calculateActualVisibleRange(scrollPosition);\n\n      // Skip emit if ranges haven't changed\n      if (\n        lastVisibleRange &&\n        lastActualVisibleRange &&\n        lastVisibleRange.start === viewportState.visibleRange.start &&\n        lastVisibleRange.end === viewportState.visibleRange.end &&\n        lastActualVisibleRange.start === actualVisibleRange.start &&\n        lastActualVisibleRange.end === actualVisibleRange.end\n      ) {\n        return;\n      }\n\n      lastVisibleRange = { ...viewportState.visibleRange };\n      lastActualVisibleRange = { ...actualVisibleRange };\n\n      component.emit?.(\"viewport:range-changed\", {\n        range: viewportState.visibleRange,\n        visibleRange: actualVisibleRange,\n        scrollPosition,\n      });\n    };\n\n    // Update total virtual size\n    const updateTotalVirtualSize = (totalItems: number) => {\n      if (!viewportState) return;\n\n      const oldSize = viewportState.virtualTotalSize;\n      viewportState.totalItems = totalItems;\n      const actualSize = totalItems * viewportState.itemSize;\n\n      // Get padding from the items container if available\n      let totalPadding = 0;\n      if (viewportState.itemsContainer) {\n        const computedStyle = window.getComputedStyle(\n          viewportState.itemsContainer,\n        );\n        const paddingTop = parseFloat(computedStyle.paddingTop) || 0;\n        const paddingBottom = parseFloat(computedStyle.paddingBottom) || 0;\n        totalPadding = paddingTop + paddingBottom;\n      }\n\n      // Include padding in the virtual size\n      viewportState.virtualTotalSize = Math.min(\n        actualSize + totalPadding,\n        MAX_VIRTUAL_SIZE,\n      );\n\n      // Strategic log for debugging gap issue\n      // console.log(\n      //   `[Virtual] Total size update: items=${totalItems}, itemSize=${viewportState.itemSize}px, padding=${totalPadding}px, virtualSize=${viewportState.virtualTotalSize}px (was ${oldSize}px)`\n      // );\n\n      component.emit?.(\"viewport:virtual-size-changed\", {\n        totalVirtualSize: viewportState.virtualTotalSize,\n        totalItems: totalItems,\n        compressionRatio: getCompressionRatio(),\n      });\n    };\n\n    // Update container size\n    const updateContainerSize = () => {\n      if (!viewportState || !viewportState.viewportElement) return;\n\n      const size =\n        viewportState.viewportElement[\n          viewportState.orientation === \"horizontal\"\n            ? \"offsetWidth\"\n            : \"offsetHeight\"\n        ];\n\n      // Log the actual measurement\n      // console.log(\n      //   `[Virtual] Container size measured: ${size}px from viewport element`\n      // );\n\n      if (size !== viewportState.containerSize) {\n        viewportState.containerSize = size;\n        updateVisibleRange(viewportState.scrollPosition || 0);\n        updateTotalVirtualSize(viewportState.totalItems); // Also update virtual size\n        component.emit?.(\"viewport:container-size-changed\", {\n          containerSize: size,\n        });\n      }\n    };\n\n    // Override viewport methods\n    component.viewport.getVisibleRange = () =>\n      viewportState?.visibleRange ||\n      calculateVisibleRange(viewportState?.scrollPosition || 0);\n\n    // Event listeners\n    component.on?.(\"viewport:scroll\", (data: any) =>\n      updateVisibleRange(data.position),\n    );\n\n    component.on?.(\"viewport:items-changed\", (data: any) => {\n      if (data.totalItems !== undefined) {\n        updateTotalVirtualSize(data.totalItems);\n        updateVisibleRange(viewportState?.scrollPosition || 0);\n      }\n    });\n\n    // Listen for total items changes (important for cursor pagination)\n    // Note: setTotalItems() updates viewportState.totalItems BEFORE emitting this event,\n    // so we can't rely on viewportState.totalItems to detect the first total.\n    // Instead we use the hasRecalculatedScrollForCompression flag.\n    component.on?.(\"viewport:total-items-changed\", (data: any) => {\n      if (data.total === undefined) return;\n\n      // FIX: When we first receive totalItems with initialScrollIndex and compression,\n      // recalculate scroll position to account for compression.\n      // Without this, initialScrollIndex calculates position as index * itemSize,\n      // but rendering uses compressed space, causing items to appear off-screen.\n      //\n      // We check this BEFORE updateTotalVirtualSize because we need to recalculate\n      // scroll position based on the new total, and the flag ensures we only do this once.\n      if (\n        initialScrollIndex > 0 &&\n        !hasRecalculatedScrollForCompression &&\n        data.total > 0\n      ) {\n        const actualTotalSize = data.total * viewportState.itemSize;\n        const isCompressed = actualTotalSize > MAX_VIRTUAL_SIZE;\n\n        if (isCompressed) {\n          // Recalculate scroll position using compression-aware formula\n          // Same formula used in scrollToIndex\n          const ratio = initialScrollIndex / data.total;\n          const compressedPosition = ratio * MAX_VIRTUAL_SIZE;\n\n          viewportState.scrollPosition = compressedPosition;\n\n          // Notify scrolling feature to sync its local scroll position\n          component.emit?.(\"viewport:scroll-position-sync\", {\n            position: compressedPosition,\n            source: \"compression-recalculation\",\n          });\n\n          // Clear targetScrollIndex since we've now correctly calculated the scroll position\n          // The normal compressed scrolling formula will now work correctly\n          delete (viewportState as any).targetScrollIndex;\n        }\n\n        // Mark as done even if not compressed - we only want to do this check once\n        hasRecalculatedScrollForCompression = true;\n      }\n\n      updateTotalVirtualSize(data.total);\n      updateVisibleRange(viewportState?.scrollPosition || 0);\n\n      // Trigger a render to update the view\n      component.viewport?.renderItems?.();\n    });\n\n    // Listen for container size changes to recalculate virtual size\n    component.on?.(\"viewport:container-size-changed\", (data: any) => {\n      if (viewportState && data.containerSize !== viewportState.containerSize) {\n        viewportState.containerSize = data.containerSize;\n        // Recalculate virtual size with new container size\n        updateTotalVirtualSize(viewportState.totalItems);\n        updateVisibleRange(viewportState.scrollPosition || 0);\n      }\n    });\n\n    component.on?.(\"collection:range-loaded\", (data: any) => {\n      if (\n        data.total !== undefined &&\n        data.total !== viewportState?.totalItems\n      ) {\n        updateTotalVirtualSize(data.total);\n      }\n\n      // Force visible range recalculation after data loads\n      // This is critical: totalItems may have been updated by collection.setTotalItems()\n      // which bypasses updateTotalVirtualSize, so lastScrollPosition wasn't reset.\n      // We must recalculate to ensure visibleRange reflects the new totalItems.\n      lastScrollPosition = -1;\n\n      updateVisibleRange(viewportState?.scrollPosition || 0);\n      component.viewport?.renderItems?.();\n    });\n\n    // Listen for first items rendered to calculate item size (if auto-detection is enabled)\n    if (autoDetectItemSize) {\n      component.on?.(\"viewport:items-rendered\", (data: any) => {\n        if (\n          !hasCalculatedItemSize &&\n          data.elements?.length > 0 &&\n          viewportState\n        ) {\n          // Calculate average item size from first rendered batch\n          const sizes: number[] = [];\n          const sizeProperty =\n            orientation === \"horizontal\" ? \"offsetWidth\" : \"offsetHeight\";\n\n          data.elements.forEach((element: HTMLElement) => {\n            const size = element[sizeProperty];\n            if (size > 0) {\n              sizes.push(size);\n            }\n          });\n\n          if (sizes.length > 0) {\n            const avgSize = Math.round(\n              sizes.reduce((sum, size) => sum + size, 0) / sizes.length,\n            );\n            const previousItemSize = viewportState.itemSize;\n            viewportState.itemSize = avgSize;\n\n            // If we have an initialScrollIndex, recalculate scroll position\n            // based on the newly detected item size\n            if (initialScrollIndex > 0 && avgSize !== previousItemSize) {\n              const newScrollPosition = initialScrollIndex * avgSize;\n              viewportState.scrollPosition = newScrollPosition;\n\n              // Notify scrolling feature to sync its local scroll position\n              component.emit?.(\"viewport:scroll-position-sync\", {\n                position: newScrollPosition,\n                source: \"item-size-detected\",\n              });\n            }\n\n            // Recalculate everything with new size\n            updateTotalVirtualSize(viewportState.totalItems);\n            updateVisibleRange(viewportState.scrollPosition || 0);\n\n            // Re-render to adjust positions\n            component.viewport?.renderItems?.();\n\n            // Emit event for size change\n            component.emit?.(\"viewport:item-size-detected\", {\n              previousSize: initialItemSize,\n              detectedSize: avgSize,\n            });\n\n            hasCalculatedItemSize = true;\n          }\n        }\n      });\n    }\n\n    // Clean up ResizeObserver on destroy\n    wrapDestroy(component, () => {\n      if (resizeObserver) {\n        resizeObserver.disconnect();\n        resizeObserver = null;\n      }\n    });\n\n    // Expose virtual API\n    const compressionRatio = getCompressionRatio();\n    (component as any).virtual = {\n      calculateVisibleRange,\n      updateTotalVirtualSize,\n      getTotalVirtualSize: () => viewportState?.virtualTotalSize || 0,\n      getContainerSize: () => viewportState?.containerSize || 0,\n      updateContainerSize: (size: number) => {\n        if (viewportState) {\n          viewportState.containerSize = size;\n          updateVisibleRange(viewportState.scrollPosition || 0);\n        }\n      },\n      getItemSize: () => viewportState?.itemSize || initialItemSize,\n      calculateIndexFromPosition: (position: number) =>\n        Math.floor(\n          position /\n            ((viewportState?.itemSize || initialItemSize) * compressionRatio),\n        ),\n      calculatePositionForIndex: (index: number) =>\n        index * (viewportState?.itemSize || initialItemSize) * compressionRatio,\n    };\n\n    return component;\n  };\n};\n",
    "/**\n * Scrolling Feature - Virtual scrolling with integrated velocity tracking\n * Handles wheel events, touch/mouse events, scroll position management, velocity measurement, and momentum scrolling\n */\n\nimport { PREFIX } from \"mtrl\";\nimport type { ViewportContext, ViewportComponent } from \"../types\";\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\nimport { wrapInitialize, getViewportState, clamp } from \"./utils\";\n\nexport interface ScrollingConfig {\n  orientation?: \"vertical\" | \"horizontal\";\n  sensitivity?: number;\n  smoothing?: boolean;\n  idleTimeout?: number;\n  /** Stop scrolling when clicking on the viewport (default: true) */\n  stopOnClick?: boolean;\n}\n\n// Speed tracker interface\ninterface SpeedTracker {\n  velocity: number;\n  lastPosition: number;\n  lastTime: number;\n  direction: \"forward\" | \"backward\";\n  samples: Array<{ position: number; time: number }>;\n}\n\n/**\n * Creates a new speed tracker\n */\nconst createSpeedTracker = (): SpeedTracker => ({\n  velocity: 0,\n  lastPosition: 0,\n  lastTime: Date.now(),\n  direction: \"forward\",\n  samples: [],\n});\n\n/**\n * Updates speed tracker with new position\n */\nconst updateSpeedTracker = (\n  tracker: SpeedTracker,\n  newPosition: number,\n  previousPosition: number,\n): SpeedTracker => {\n  const now = Date.now();\n  const timeDelta = now - tracker.lastTime;\n\n  if (timeDelta === 0) return tracker;\n\n  const positionDelta = newPosition - previousPosition;\n  // Keep velocity signed (positive = forward/down, negative = backward/up)\n  const instantVelocity = positionDelta / timeDelta;\n\n  // Add new sample\n  const samples = [...tracker.samples, { position: newPosition, time: now }];\n\n  // Keep only recent samples (last 100ms)\n  const recentSamples = samples.filter((s) => now - s.time < 100);\n\n  // Calculate average velocity from recent samples (preserving sign/direction)\n  let avgVelocity = instantVelocity;\n  if (recentSamples.length > 1) {\n    const oldestSample = recentSamples[0];\n    const totalDistance = newPosition - oldestSample.position; // Signed distance\n    const totalTime = now - oldestSample.time;\n    avgVelocity = totalTime > 0 ? totalDistance / totalTime : instantVelocity;\n  }\n\n  return {\n    velocity: avgVelocity,\n    lastPosition: newPosition,\n    lastTime: now,\n    direction: positionDelta >= 0 ? \"forward\" : \"backward\",\n    samples: recentSamples,\n  };\n};\n\n/**\n * Scrolling feature for viewport\n * Handles wheel events, velocity tracking, and idle detection\n */\nexport const withScrolling = (config: ScrollingConfig = {}) => {\n  return <T extends ViewportContext & ViewportComponent>(component: T): T => {\n    const {\n      orientation = \"vertical\",\n      sensitivity = VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.SCROLL_SENSITIVITY,\n      smoothing = false,\n      idleTimeout = 100, // Default idle timeout in ms\n      stopOnClick = true, // Stop scrolling on click by default\n    } = config;\n\n    // State\n    let scrollPosition = 0;\n    let totalVirtualSize = 0;\n    let containerSize = 0;\n    let isScrolling = false;\n    let isScrolledFromTop = false; // Track if scrolled away from top\n    let lastScrollTime = 0;\n\n    /**\n     * Helper to remove the --scrolled class from the vlist container\n     */\n    const removeScrolledClass = () => {\n      const viewportEl =\n        (component as any).viewportElement ||\n        (component as any)._scrollingViewportElement;\n      if (viewportEl) {\n        const vlistContainer = viewportEl.closest(`.${PREFIX}-vlist`);\n        if (vlistContainer) {\n          vlistContainer.classList.remove(`${PREFIX}-vlist--scrolled`);\n        }\n      }\n    };\n\n    // Listen for reload:start to reset feature-specific state\n    component.on?.(\"reload:start\", () => {\n      scrollPosition = 0;\n      totalVirtualSize = 0;\n      isScrolling = false;\n      isScrolledFromTop = false;\n      lastScrollTime = 0;\n      speedTracker = createSpeedTracker();\n      hasEmittedIdle = false;\n      anchorPosition = null;\n      anchorTime = 0;\n      lastWheelTime = 0;\n      anchorInitialDelta = 0;\n      anchorLastDelta = 0;\n      anchorMinDelta = Infinity;\n      consecutiveIncreases = 0;\n      sustainedHighCount = 0;\n      renderScheduled = false;\n      pendingScrollData = null;\n\n      // Clear any pending timeouts\n      if (idleTimeoutId) {\n        clearTimeout(idleTimeoutId);\n        idleTimeoutId = null;\n      }\n      stopIdleDetection();\n\n      // Remove --scrolled class from DOM since we're resetting to top\n      removeScrolledClass();\n    });\n\n    // Listen for cleared event (from vlist.clear()) to reset scrolled state\n    component.on?.(\"cleared\", () => {\n      scrollPosition = 0;\n      totalVirtualSize = 0;\n      isScrolledFromTop = false;\n      removeScrolledClass();\n    });\n    let speedTracker = createSpeedTracker();\n    let idleTimeoutId: number | null = null;\n    let idleCheckFrame: number | null = null;\n    let lastIdleCheckPosition = 0;\n    let hasEmittedIdle = false; // Track if we've already emitted idle\n    let anchorPosition: number | null = null; // Anchor position to maintain on click (for stopOnClick)\n    let anchorTime = 0; // Timestamp when anchor was set\n    let lastWheelTime = 0; // Timestamp of last wheel event (for detecting gaps)\n    let anchorInitialDelta = 0; // Initial wheel delta when anchor was set (to detect decay)\n    let anchorLastDelta = 0; // Previous wheel delta (to detect increasing delta = new scroll)\n    let anchorMinDelta = Infinity; // Minimum delta seen since anchor (to detect reacceleration)\n    let consecutiveIncreases = 0; // Count of consecutive delta increases (to detect sustained new scrolling)\n    let sustainedHighCount = 0; // Count of events where delta is significantly above minimum (sustained new scrolling)\n\n    // RAF-based render throttling - prevents wasted renders during fast scrolling\n    let renderScheduled = false;\n    let pendingScrollData: {\n      position: number;\n      direction: \"forward\" | \"backward\";\n      previousPosition: number;\n    } | null = null;\n\n    // console.log(`[Scrolling] Initial state - position: ${scrollPosition}`);\n\n    // Threshold for considering the list \"scrolled\" (in pixels)\n    const SCROLLED_THRESHOLD = 1;\n\n    /**\n     * Updates the scrolled state class on the vlist container\n     * Adds --scrolled modifier when list is not at the top\n     */\n    const updateScrolledState = (\n      viewportElement: HTMLElement,\n      position: number,\n    ) => {\n      const shouldBeScrolled = position > SCROLLED_THRESHOLD;\n      if (shouldBeScrolled !== isScrolledFromTop) {\n        isScrolledFromTop = shouldBeScrolled;\n        // Find the vlist container (parent of viewport)\n        const vlistContainer = viewportElement.closest(`.${PREFIX}-vlist`);\n        if (vlistContainer) {\n          vlistContainer.classList.toggle(\n            `${PREFIX}-vlist--scrolled`,\n            shouldBeScrolled,\n          );\n        }\n      }\n    };\n\n    // Get viewport state\n    let viewportState: any;\n\n    // Use shared initialization wrapper\n    wrapInitialize(component, () => {\n      viewportState = getViewportState(component);\n\n      // Initialize state values\n      if (viewportState) {\n        totalVirtualSize = viewportState.virtualTotalSize || 0;\n        containerSize = viewportState.containerSize || 0;\n        // Sync scrollPosition from viewportState (important for initialScrollIndex)\n        if (viewportState.scrollPosition > 0) {\n          scrollPosition = viewportState.scrollPosition;\n        }\n      }\n\n      // Listen for virtual size changes\n      component.on?.(\"viewport:virtual-size-changed\", (data: any) => {\n        // console.log(\"[Scrolling] Virtual size changed:\", data);\n        updateScrollBounds(data.totalVirtualSize, containerSize);\n      });\n\n      // Listen for scroll position changes from other features (e.g., virtual.ts after item size detection)\n      component.on?.(\"viewport:scroll-position-sync\", (data: any) => {\n        if (data.position !== undefined && data.position !== scrollPosition) {\n          scrollPosition = data.position;\n          // Also update local tracking vars\n          totalVirtualSize =\n            viewportState?.virtualTotalSize || totalVirtualSize;\n          containerSize = viewportState?.containerSize || containerSize;\n        }\n      });\n\n      // Listen for container size changes\n      component.on?.(\"viewport:container-size-changed\", (data: any) => {\n        if (data.containerSize) {\n          containerSize = data.containerSize;\n          updateScrollBounds(totalVirtualSize, containerSize);\n        }\n      });\n\n      // Attach wheel event listener to viewport element\n      const viewportElement =\n        viewportState?.viewportElement || (component as any).viewportElement;\n      if (viewportElement) {\n        // console.log(`[Scrolling] Attaching wheel event to viewport element`);\n        viewportElement.addEventListener(\"wheel\", handleWheel, {\n          passive: false,\n        });\n\n        // Initialize scrolled state based on current scroll position\n        updateScrolledState(viewportElement, scrollPosition);\n\n        // Add mousedown listener to stop scrolling on click\n        if (stopOnClick) {\n          viewportElement.addEventListener(\"mousedown\", handleMouseDown);\n        }\n\n        // Store reference for cleanup\n        (component as any)._scrollingViewportElement = viewportElement;\n        (component as any)._scrollingStopOnClick = stopOnClick;\n      } else {\n        console.warn(`[Scrolling] No viewport element found for wheel events`);\n      }\n    });\n\n    // Use clamp from utils\n\n    // Start idle detection\n    const startIdleDetection = () => {\n      // console.log(\"[Scrolling] Starting idle detection\");\n\n      // Stop any existing idle detection first\n      if (idleCheckFrame !== null) {\n        cancelAnimationFrame(idleCheckFrame);\n        idleCheckFrame = null;\n      }\n\n      hasEmittedIdle = false; // Reset idle emission flag\n      const checkIdle = () => {\n        if (scrollPosition === lastIdleCheckPosition) {\n          // Position hasn't changed - we're idle\n          if (!hasEmittedIdle && (speedTracker.velocity > 0 || isScrolling)) {\n            // console.log(\n            //   \"[Scrolling] Idle detected - position stable, setting velocity to zero\"\n            // );\n            hasEmittedIdle = true; // Mark that we've emitted idle\n            setVelocityToZero();\n          }\n        } else {\n          // Position changed, reset the flag\n          hasEmittedIdle = false;\n        }\n        lastIdleCheckPosition = scrollPosition;\n        idleCheckFrame = requestAnimationFrame(checkIdle);\n      };\n      idleCheckFrame = requestAnimationFrame(checkIdle);\n    };\n\n    // Stop idle detection\n    const stopIdleDetection = () => {\n      if (idleCheckFrame) {\n        // console.log(\"[Scrolling] Stopping idle detection\");\n        cancelAnimationFrame(idleCheckFrame);\n        idleCheckFrame = null;\n      }\n    };\n\n    // Set velocity to zero and emit idle event\n    const setVelocityToZero = () => {\n      // Stop idle detection since we're now idle\n      stopIdleDetection();\n\n      speedTracker = createSpeedTracker();\n      isScrolling = false; // Reset scrolling state\n\n      // Emit velocity change\n      component.emit?.(\"viewport:velocity-changed\", {\n        velocity: 0,\n        direction: speedTracker.direction,\n      });\n\n      // Emit idle state\n      component.emit?.(\"viewport:idle\", {\n        position: scrollPosition,\n        lastScrollTime,\n      });\n    };\n    // Update container position\n    const updateContainerPosition = () => {\n      if (!viewportState || !viewportState.itemsContainer) return;\n\n      // Items container doesn't move - items inside it are positioned\n      // This is handled by the rendering feature\n    };\n\n    // Handle mousedown to stop scrolling on click\n    const handleMouseDown = (_e: MouseEvent) => {\n      // Anchor the current scroll position - any wheel events will be forced back to this position\n      // This elegantly handles mouse wheels with physical inertia (like Logitech free-spin)\n      anchorPosition = scrollPosition;\n      anchorTime = Date.now();\n      anchorInitialDelta = 0; // Will be set by first wheel event\n      anchorLastDelta = 0;\n      anchorMinDelta = Infinity;\n      consecutiveIncreases = 0;\n      sustainedHighCount = 0;\n\n      // Only stop if we're currently scrolling\n      if (isScrolling || speedTracker.velocity > 0) {\n        setVelocityToZero();\n      }\n      // Also stop momentum animation if active\n      const momentumState = (component.viewport as any).momentumState;\n      if (momentumState?.stopMomentum) {\n        momentumState.stopMomentum();\n      }\n    };\n\n    // Handle wheel event\n    const handleWheel = (event: WheelEvent) => {\n      event.preventDefault();\n\n      const delta = orientation === \"vertical\" ? event.deltaY : event.deltaX;\n      const scrollDelta = delta * sensitivity;\n\n      const now = Date.now();\n      const timeSinceLastWheel = now - lastWheelTime;\n      lastWheelTime = now;\n\n      // If we have an anchor position (user clicked to stop scrolling),\n      // check if this is intentional new scrolling or residual wheel inertia\n      if (anchorPosition !== null) {\n        const timeSinceAnchor = now - anchorTime;\n        const wheelDeltaMagnitude = Math.abs(scrollDelta);\n\n        // Track initial delta to detect when inertia has decayed\n        if (anchorInitialDelta === 0) {\n          anchorInitialDelta = wheelDeltaMagnitude;\n          anchorLastDelta = wheelDeltaMagnitude;\n          anchorMinDelta = wheelDeltaMagnitude;\n        }\n\n        // Track minimum delta to detect reacceleration (user started scrolling again)\n        anchorMinDelta = Math.min(anchorMinDelta, wheelDeltaMagnitude);\n\n        // Detect if delta is increasing (user started new scroll)\n        // Inertia only decays, so increasing delta = intentional new scrolling\n        // BUT: filter out batched events where delta is ~2x the last (browser batching, not real increase)\n        const isBatchedEvent =\n          wheelDeltaMagnitude > anchorLastDelta * 1.8 &&\n          wheelDeltaMagnitude < anchorLastDelta * 2.2;\n\n        // Track consecutive increases - sustained increases indicate new scrolling\n        // Use 1% threshold to catch gradual acceleration\n        if (!isBatchedEvent && wheelDeltaMagnitude > anchorLastDelta * 1.01) {\n          consecutiveIncreases++;\n        } else if (wheelDeltaMagnitude < anchorLastDelta * 0.99) {\n          // Delta decreasing - reset counter\n          consecutiveIncreases = 0;\n        }\n        // If delta is roughly the same (within 1%), don't change the counter\n\n        // Track sustained high delta (delta significantly above minimum for multiple events)\n        // This catches when user starts scrolling but delta plateaus instead of strictly increasing\n        if (!isBatchedEvent && wheelDeltaMagnitude > anchorMinDelta * 1.05) {\n          sustainedHighCount++;\n        } else {\n          sustainedHighCount = 0;\n        }\n\n        // Release if: 3+ consecutive increases, OR sustained high delta, OR significant single increase\n        const sustainedIncrease = consecutiveIncreases >= 3;\n        const sustainedHigh = sustainedHighCount >= 5; // 5+ events at 5%+ above minimum\n        const significantIncrease =\n          !isBatchedEvent &&\n          wheelDeltaMagnitude > anchorMinDelta * 1.15 && // 15% increase from minimum\n          wheelDeltaMagnitude > anchorLastDelta * 1.08; // and 8% increasing from last\n        const deltaIncreasing =\n          sustainedIncrease || sustainedHigh || significantIncrease;\n\n        // Release anchor if:\n        // 1. There was a gap in wheel events (> 200ms) - user stopped and started new scroll\n        // 2. Delta is increasing from minimum - user started scrolling again during inertia\n        // 3. Delta has decayed significantly (< 30% of initial) - inertia is winding down\n        // 4. Low absolute delta (< 30) - gentle intentional scroll\n        const hasWheelGap = timeSinceLastWheel > 200;\n        const deltaDecayed = wheelDeltaMagnitude < anchorInitialDelta * 0.3;\n        const isLowDelta = wheelDeltaMagnitude < 30;\n\n        if (hasWheelGap) {\n          // Time gap - user stopped and started new scroll\n          anchorPosition = null;\n        } else if (deltaIncreasing && timeSinceAnchor > 100) {\n          // Delta increasing - user started scrolling again\n          anchorPosition = null;\n        } else if (isLowDelta) {\n          // Very low delta - gentle intentional scroll\n          anchorPosition = null;\n        } else if (deltaDecayed && timeSinceAnchor > 300) {\n          // Delta has decayed and some time passed - inertia is done\n          anchorPosition = null;\n        } else {\n          // Still in inertia phase - stay anchored\n          if (scrollPosition !== anchorPosition) {\n            scrollPosition = anchorPosition;\n            if (viewportState) {\n              viewportState.scrollPosition = scrollPosition;\n            }\n            component.viewport.renderItems();\n          }\n          // Update last delta for next comparison\n          anchorLastDelta = wheelDeltaMagnitude;\n          return;\n        }\n\n        // Update last delta for next comparison\n        anchorLastDelta = wheelDeltaMagnitude;\n      }\n\n      const previousPosition = scrollPosition;\n      const maxScroll = Math.max(0, totalVirtualSize - containerSize);\n\n      let newPosition = scrollPosition + scrollDelta;\n\n      // Apply smoothing if enabled\n      if (smoothing) {\n        const smoothingFactor = 0.3;\n        newPosition = scrollPosition + scrollDelta * smoothingFactor;\n      }\n\n      newPosition = clamp(newPosition, 0, maxScroll);\n\n      if (newPosition !== scrollPosition) {\n        scrollPosition = newPosition;\n        const now = Date.now();\n\n        // Update scroll state\n        if (!isScrolling) {\n          isScrolling = true;\n          // Stop any existing idle detection before starting new one\n          stopIdleDetection();\n          startIdleDetection();\n        }\n        lastScrollTime = now;\n\n        // Update speed tracker\n        speedTracker = updateSpeedTracker(\n          speedTracker,\n          scrollPosition,\n          previousPosition,\n        );\n\n        // Update viewport state\n        if (viewportState) {\n          viewportState.scrollPosition = scrollPosition;\n          viewportState.velocity = speedTracker.velocity;\n          viewportState.scrollDirection = speedTracker.direction;\n        }\n\n        // Update scrolled state class\n        const viewportEl =\n          viewportState?.viewportElement || (component as any).viewportElement;\n        if (viewportEl) {\n          updateScrolledState(viewportEl, scrollPosition);\n        }\n\n        // Store pending scroll data for RAF-batched rendering\n        pendingScrollData = {\n          position: scrollPosition,\n          direction: speedTracker.direction,\n          previousPosition,\n        };\n\n        // Schedule render via RAF if not already scheduled\n        // This ensures we render at most once per frame, even during fast scrolling\n        if (!renderScheduled) {\n          renderScheduled = true;\n          requestAnimationFrame(() => {\n            renderScheduled = false;\n\n            // Use the latest scroll data (coalesces multiple wheel events)\n            if (pendingScrollData) {\n              // Emit events with the latest position\n              component.emit?.(\"viewport:scroll\", {\n                position: pendingScrollData.position,\n                direction: pendingScrollData.direction,\n                previousPosition: pendingScrollData.previousPosition,\n              });\n\n              component.emit?.(\"viewport:velocity-changed\", {\n                velocity: speedTracker.velocity,\n                direction: speedTracker.direction,\n              });\n\n              // Trigger render\n              component.viewport.renderItems();\n\n              pendingScrollData = null;\n            }\n          });\n        }\n      }\n    };\n\n    // Scroll to position\n    const scrollToPosition = (position: number, source?: string) => {\n      const maxScroll = Math.max(0, totalVirtualSize - containerSize);\n      const clampedPosition = clamp(position, 0, maxScroll);\n\n      if (clampedPosition !== scrollPosition) {\n        const previousPosition = scrollPosition;\n        scrollPosition = clampedPosition;\n\n        // Update speed tracker to calculate velocity\n        speedTracker = updateSpeedTracker(\n          speedTracker,\n          scrollPosition,\n          previousPosition,\n        );\n\n        // Update viewport state\n        if (viewportState) {\n          viewportState.scrollPosition = scrollPosition;\n          viewportState.velocity = speedTracker.velocity;\n          viewportState.scrollDirection = speedTracker.direction;\n        }\n\n        const direction =\n          clampedPosition > previousPosition ? \"forward\" : \"backward\";\n\n        // Update scrolled state class\n        const viewportEl =\n          viewportState?.viewportElement || (component as any).viewportElement;\n        if (viewportEl) {\n          updateScrolledState(viewportEl, scrollPosition);\n        }\n\n        // Emit scroll event\n        component.emit?.(\"viewport:scroll\", {\n          position: scrollPosition,\n          direction,\n          previousPosition,\n        });\n\n        // Emit velocity change event so collection can track it\n        component.emit?.(\"viewport:velocity-changed\", {\n          velocity: speedTracker.velocity,\n          direction: speedTracker.direction,\n        });\n\n        // Update scroll state and idle detection\n        if (!isScrolling) {\n          isScrolling = true;\n          startIdleDetection();\n        }\n        lastScrollTime = Date.now();\n\n        // Trigger render\n        component.viewport.renderItems();\n      } else {\n        // console.log(`[Scrolling] Position unchanged: ${scrollPosition}`);\n        // console.log(\n        //   `[Scrolling] Position unchanged: ${scrollPosition}, not resetting idle timeout`\n        // );\n      }\n    };\n\n    // Scroll to index\n    const scrollToIndex = (\n      index: number,\n      alignment: \"start\" | \"center\" | \"end\" = \"start\",\n    ) => {\n      // console.log(\n      //   `[Scrolling] scrollToIndex called: index=${index}, alignment=${alignment}`\n      // );\n      if (!viewportState) {\n        //console.log(`[Scrolling] scrollToIndex aborted: no viewport state`);\n        return;\n      }\n\n      const itemSize = viewportState.itemSize || 50;\n      const totalItems = viewportState.totalItems || 0;\n      const actualTotalSize = totalItems * itemSize;\n      const MAX_VIRTUAL_SIZE =\n        VIEWPORT_CONSTANTS.VIRTUAL_SCROLL.MAX_VIRTUAL_SIZE;\n      const isCompressed = actualTotalSize > MAX_VIRTUAL_SIZE;\n\n      let targetPosition: number;\n\n      if (isCompressed) {\n        // In compressed space, map index to virtual position\n        const ratio = index / totalItems;\n        targetPosition = ratio * Math.min(actualTotalSize, MAX_VIRTUAL_SIZE);\n      } else {\n        // Direct calculation when not compressed\n        targetPosition = index * itemSize;\n      }\n\n      // Adjust position based on alignment\n      switch (alignment) {\n        case \"center\":\n          targetPosition -= containerSize / 2 - itemSize / 2;\n          break;\n        case \"end\":\n          targetPosition -= containerSize - itemSize;\n          break;\n      }\n\n      // console.log(\n      //   `[Scrolling] Target position: ${targetPosition}, isCompressed: ${isCompressed}`\n      // );\n\n      // console.log(\n      //   `[Scrolling] ScrollToIndex: index=${index}, position=${targetPosition}, alignment=${alignment}`\n      // );\n\n      scrollToPosition(targetPosition, \"scrollToIndex\");\n    };\n\n    // Scroll to a specific page\n    const scrollToPage = (\n      page: number,\n      limit: number = 20,\n      alignment: \"start\" | \"center\" | \"end\" = \"start\",\n    ) => {\n      // Validate alignment parameter\n      if (\n        typeof alignment !== \"string\" ||\n        ![\"start\", \"center\", \"end\"].includes(alignment)\n      ) {\n        console.warn(\n          `[Scrolling] Invalid alignment \"${alignment}\", using \"start\"`,\n        );\n        alignment = \"start\";\n      }\n\n      // Check if we're in cursor mode\n      const viewportConfig = (component as any).config;\n      const isCursorMode = viewportConfig?.pagination?.strategy === \"cursor\";\n\n      if (isCursorMode) {\n        // In cursor mode, check if we can scroll to this page\n        const collection = (component.viewport as any).collection;\n        if (collection) {\n          const highestLoadedPage = Math.floor(\n            collection.getLoadedRanges().size,\n          );\n\n          if (page > highestLoadedPage + 1) {\n            // Limit how many pages we'll load at once to prevent excessive API calls\n            const maxPagesToLoad = 10; // Reasonable limit\n            const targetPage = Math.min(\n              page,\n              highestLoadedPage + maxPagesToLoad,\n            );\n\n            console.warn(\n              `[Scrolling] Cannot jump directly to page ${page} in cursor mode. ` +\n                `Pages must be loaded sequentially. Current highest page: ${highestLoadedPage}. ` +\n                `Will load up to page ${targetPage}`,\n            );\n\n            // Trigger sequential loading to the target page (limited)\n            const targetOffset = (targetPage - 1) * limit;\n            const currentOffset = highestLoadedPage * limit;\n\n            // Load pages sequentially up to the limited target\n            // console.log(\n            //   `[Scrolling] Initiating sequential load from page ${\n            //     highestLoadedPage + 1\n            //   } to ${targetPage}`,\n            // );\n\n            // Scroll to the last loaded position first\n            const lastLoadedIndex = highestLoadedPage * limit;\n            scrollToIndex(lastLoadedIndex, alignment);\n\n            // The collection feature will handle sequential loading\n            return;\n          }\n        }\n      }\n\n      // Convert page to index (page 1 = index 0)\n      const index = (page - 1) * limit;\n\n      // console.log(\n      //   `[Scrolling] ScrollToPage: page=${page}, limit=${limit}, targetIndex=${index}, alignment=${alignment}`\n      // );\n\n      // Just scroll to the index - let the normal rendering flow handle data loading and placeholders\n      scrollToIndex(index, alignment);\n    };\n\n    // Update scroll bounds\n    const updateScrollBounds = (\n      newTotalSize: number,\n      newContainerSize: number,\n    ) => {\n      totalVirtualSize = newTotalSize;\n      containerSize = newContainerSize;\n\n      if (viewportState) {\n        viewportState.virtualTotalSize = newTotalSize;\n        viewportState.containerSize = newContainerSize;\n      }\n\n      // Don't clamp scroll position until we have real data loaded\n      // This prevents resetting initialScrollIndex position before data arrives\n      // Check totalItems instead of totalVirtualSize since virtualSize can be non-zero from padding\n      const totalItems = viewportState?.totalItems || 0;\n      if (totalItems <= 0) {\n        return;\n      }\n\n      // Clamp current position to new bounds\n      const maxScroll = Math.max(0, totalVirtualSize - containerSize);\n      if (scrollPosition > maxScroll) {\n        scrollToPosition(maxScroll);\n      }\n    };\n\n    // Extend viewport API\n    const originalScrollToIndex = component.viewport.scrollToIndex;\n    component.viewport.scrollToIndex = (\n      index: number,\n      alignment?: \"start\" | \"center\" | \"end\",\n    ) => {\n      scrollToIndex(index, alignment);\n      originalScrollToIndex?.(index, alignment);\n    };\n\n    // Add scrollToPage to viewport API (new method, no original to preserve)\n    (component.viewport as any).scrollToPage = (\n      page: number,\n      limit?: number,\n      alignment?: \"start\" | \"center\" | \"end\",\n    ) => {\n      scrollToPage(page, limit, alignment);\n    };\n\n    const originalScrollToPosition = component.viewport.scrollToPosition;\n    component.viewport.scrollToPosition = (position: number) => {\n      scrollToPosition(position, \"api\");\n      originalScrollToPosition?.(position);\n    };\n\n    const originalGetScrollPosition = component.viewport.getScrollPosition;\n    component.viewport.getScrollPosition = () => {\n      return scrollPosition;\n    };\n\n    // Add wheel event listener on initialization\n    // This block is removed as per the edit hint.\n\n    // Clean up on destroy\n    if (\"destroy\" in component && typeof component.destroy === \"function\") {\n      const originalDestroy = component.destroy;\n      component.destroy = () => {\n        // Remove event listeners\n        const viewportElement = (component as any)._scrollingViewportElement;\n        if (viewportElement) {\n          viewportElement.removeEventListener(\"wheel\", handleWheel);\n          if ((component as any)._scrollingStopOnClick) {\n            viewportElement.removeEventListener(\"mousedown\", handleMouseDown);\n          }\n        }\n\n        // Clear timeouts\n        if (idleTimeoutId) {\n          clearTimeout(idleTimeoutId);\n        }\n\n        stopIdleDetection();\n        originalDestroy?.();\n      };\n    }\n\n    // Add scrollBy method\n    const scrollBy = (delta: number) => {\n      const previousPosition = scrollPosition;\n      const maxScroll = Math.max(0, totalVirtualSize - containerSize);\n      const newPosition = clamp(scrollPosition + delta, 0, maxScroll);\n\n      if (newPosition !== previousPosition) {\n        scrollPosition = newPosition;\n\n        // Update speed tracker\n        speedTracker = updateSpeedTracker(\n          speedTracker,\n          scrollPosition,\n          previousPosition,\n        );\n\n        // Update viewport state\n        if (viewportState) {\n          viewportState.scrollPosition = scrollPosition;\n          viewportState.velocity = speedTracker.velocity;\n        }\n\n        // Update scrolled state class\n        const viewportEl =\n          viewportState?.viewportElement || (component as any).viewportElement;\n        if (viewportEl) {\n          updateScrolledState(viewportEl, scrollPosition);\n        }\n\n        // Emit scroll event\n        component.emit?.(\"viewport:scroll\", {\n          position: scrollPosition,\n          velocity: speedTracker.velocity,\n          direction: speedTracker.direction,\n        });\n\n        // Trigger render\n        component.viewport.renderItems?.();\n\n        // Start idle detection if not scrolling\n        if (!isScrolling) {\n          isScrolling = true;\n          startIdleDetection();\n        }\n        lastScrollTime = Date.now();\n      }\n    };\n\n    // Expose scrolling state for other features\n    (component.viewport as any).scrollingState = {\n      setVelocityToZero,\n    };\n\n    // Add scrollBy to viewport API\n    component.viewport.scrollBy = scrollBy;\n    component.viewport.getVelocity = () => speedTracker.velocity;\n\n    // Expose scrolling API\n    (component as any).scrolling = {\n      handleWheel,\n      scrollToPosition,\n      scrollToIndex,\n      scrollToPage,\n      scrollBy,\n      getScrollPosition: () => scrollPosition,\n      updateScrollBounds,\n      getVelocity: () => speedTracker.velocity,\n      getDirection: () => speedTracker.direction,\n      isScrolling: () => isScrolling,\n    };\n\n    return component;\n  };\n};\n",
    "// src/core/viewport/features/momentum.ts\n\n/**\n * Momentum Feature - Adds inertial scrolling to viewport\n * Provides smooth deceleration after touch/mouse drag gestures\n */\n\nimport type { ViewportComponent, ViewportContext } from \"../types\";\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\n\ninterface MomentumConfig {\n  enabled?: boolean;\n  deceleration?: number;\n  minVelocity?: number;\n  minDuration?: number;\n  minVelocityThreshold?: number;\n  /** Stop momentum when clicking on the viewport (default: true) */\n  stopOnClick?: boolean;\n}\n\n/**\n * Adds momentum scrolling to viewport\n */\nexport const withMomentum = (config: MomentumConfig = {}) => {\n  return <T extends ViewportContext & ViewportComponent>(component: T): T => {\n    const {\n      enabled = VIEWPORT_CONSTANTS.MOMENTUM.ENABLED,\n      deceleration = VIEWPORT_CONSTANTS.MOMENTUM.DECELERATION_FACTOR,\n      minVelocity = VIEWPORT_CONSTANTS.MOMENTUM.MIN_VELOCITY,\n      minDuration = VIEWPORT_CONSTANTS.MOMENTUM.MIN_DURATION,\n      minVelocityThreshold = VIEWPORT_CONSTANTS.MOMENTUM.MIN_VELOCITY_THRESHOLD,\n      stopOnClick = true, // Stop momentum on click by default\n    } = config;\n\n    // Always apply the feature, but check isEnabled at runtime\n\n    // Momentum state\n    let momentumAnimationId: number | null = null;\n    let isTouching = false;\n    let isMouseDragging = false;\n    let lastTouchPosition = 0;\n    let lastMousePosition = 0;\n    let touchStartTime = 0;\n    let viewportState: any;\n    let scrollingState: any;\n    let isEnabled = enabled; // Track current enabled state\n\n    // Get references after initialization\n    const originalInitialize = component.viewport.initialize;\n    component.viewport.initialize = () => {\n      const result = originalInitialize();\n      // Skip if already initialized\n      if (result === false) {\n        return false;\n      }\n\n      // Get viewport and scrolling states\n      viewportState = (component.viewport as any).state;\n      scrollingState = (component.viewport as any).scrollingState;\n      return result;\n    };\n\n    // Stop momentum animation (can be called externally)\n    const stopMomentum = () => {\n      if (momentumAnimationId) {\n        cancelAnimationFrame(momentumAnimationId);\n        momentumAnimationId = null;\n        // Reset velocity in scrolling feature\n        if (scrollingState) {\n          scrollingState.setVelocityToZero?.();\n        }\n      }\n    };\n\n    // Start momentum animation\n    const startMomentum = (initialVelocity: number) => {\n      // Cancel any existing momentum\n      if (momentumAnimationId) {\n        cancelAnimationFrame(momentumAnimationId);\n      }\n\n      let velocity = initialVelocity;\n\n      const animate = () => {\n        // Apply deceleration\n        velocity *= deceleration;\n\n        // Stop if velocity is too small\n        if (Math.abs(velocity) < minVelocity) {\n          momentumAnimationId = null;\n          // Reset velocity in scrolling feature\n          if (scrollingState) {\n            scrollingState.setVelocityToZero?.();\n          }\n          return;\n        }\n\n        // Calculate scroll delta (velocity is in px/ms, so multiply by frame time)\n        const frameDelta = velocity * VIEWPORT_CONSTANTS.MOMENTUM.FRAME_TIME;\n\n        // Use scrolling feature's API to update position\n        if (component.viewport.scrollBy) {\n          component.viewport.scrollBy(frameDelta);\n\n          // Continue animation\n          momentumAnimationId = requestAnimationFrame(animate);\n        } else {\n          // No scrollBy method, stop momentum\n          momentumAnimationId = null;\n        }\n      };\n\n      momentumAnimationId = requestAnimationFrame(animate);\n    };\n\n    // Touch event handlers\n    const handleTouchStart = (e: TouchEvent) => {\n      isTouching = true;\n      const touch = e.touches[0];\n      const orientation = viewportState?.orientation || \"vertical\";\n      lastTouchPosition =\n        orientation === \"vertical\" ? touch.clientY : touch.clientX;\n      touchStartTime = Date.now();\n\n      // Cancel any ongoing momentum\n      if (momentumAnimationId) {\n        cancelAnimationFrame(momentumAnimationId);\n        momentumAnimationId = null;\n      }\n    };\n\n    const handleTouchMove = (e: TouchEvent) => {\n      if (!isTouching) return;\n\n      e.preventDefault(); // Prevent native scrolling\n\n      const touch = e.touches[0];\n      const orientation = viewportState?.orientation || \"vertical\";\n      const currentPosition =\n        orientation === \"vertical\" ? touch.clientY : touch.clientX;\n      const delta = lastTouchPosition - currentPosition; // Inverted for natural scrolling\n      lastTouchPosition = currentPosition;\n\n      // Use scrolling feature's API (1:1 touch-to-scroll for natural feel)\n      if (component.viewport.scrollBy) {\n        component.viewport.scrollBy(delta);\n      }\n    };\n\n    const handleTouchEnd = () => {\n      if (!isTouching) return;\n      isTouching = false;\n\n      const touchEndTime = Date.now();\n      const touchDuration = touchEndTime - touchStartTime;\n\n      // Get current velocity from scrolling feature\n      const velocity = component.viewport.getVelocity?.() || 0;\n\n      // Only start momentum if the touch was quick enough and we have velocity\n      if (\n        touchDuration < minDuration &&\n        Math.abs(velocity) > minVelocityThreshold\n      ) {\n        startMomentum(velocity);\n      }\n    };\n\n    // Handle click to stop momentum (without preventing selection)\n    const handleClick = (_e: MouseEvent) => {\n      stopMomentum();\n    };\n\n    // Mouse event handlers for desktop\n    const handleMouseDown = (e: MouseEvent) => {\n      isMouseDragging = true;\n      const orientation = viewportState?.orientation || \"vertical\";\n      lastMousePosition = orientation === \"vertical\" ? e.clientY : e.clientX;\n      touchStartTime = Date.now();\n\n      // Cancel any ongoing momentum\n      stopMomentum();\n\n      // Prevent text selection\n      e.preventDefault();\n    };\n\n    const handleMouseMove = (e: MouseEvent) => {\n      if (!isMouseDragging) return;\n\n      const orientation = viewportState?.orientation || \"vertical\";\n      const currentPosition =\n        orientation === \"vertical\" ? e.clientY : e.clientX;\n      const delta = lastMousePosition - currentPosition;\n      lastMousePosition = currentPosition;\n\n      // Use scrolling feature's API (1:1 drag-to-scroll for natural feel)\n      if (component.viewport.scrollBy) {\n        component.viewport.scrollBy(delta);\n      }\n    };\n\n    const handleMouseUp = () => {\n      if (!isMouseDragging) return;\n      isMouseDragging = false;\n\n      const mouseUpTime = Date.now();\n      const dragDuration = mouseUpTime - touchStartTime;\n\n      // Get current velocity from scrolling feature\n      const velocity = component.viewport.getVelocity?.() || 0;\n\n      // Start momentum for quick drags\n      if (\n        dragDuration < minDuration &&\n        Math.abs(velocity) > minVelocityThreshold\n      ) {\n        startMomentum(velocity);\n      }\n    };\n\n    // Override initialize to add event listeners\n    const originalInit = component.viewport.initialize;\n    component.viewport.initialize = () => {\n      const result = originalInit();\n      // Skip if already initialized\n      if (result === false) {\n        return false;\n      }\n\n      const viewportElement =\n        (component as any).viewportElement ||\n        (component.viewport as any).state?.viewportElement;\n\n      if (viewportElement) {\n        // Touch events\n        viewportElement.addEventListener(\"touchstart\", handleTouchStart, {\n          passive: true,\n        });\n        viewportElement.addEventListener(\"touchmove\", handleTouchMove, {\n          passive: false,\n        });\n        viewportElement.addEventListener(\"touchend\", handleTouchEnd, {\n          passive: true,\n        });\n\n        // Mouse events for desktop dragging\n        viewportElement.addEventListener(\"mousedown\", handleMouseDown);\n        viewportElement.addEventListener(\"mousemove\", handleMouseMove);\n        viewportElement.addEventListener(\"mouseup\", handleMouseUp);\n        viewportElement.addEventListener(\"mouseleave\", handleMouseUp);\n\n        // Add click listener to stop momentum on click (without blocking selection)\n        if (stopOnClick) {\n          viewportElement.addEventListener(\"click\", handleClick);\n        }\n\n        // Store reference for cleanup\n        (component as any)._momentumViewportElement = viewportElement;\n        (component as any)._momentumStopOnClick = stopOnClick;\n      }\n    };\n\n    // Clean up on destroy\n    if (\"destroy\" in component && typeof component.destroy === \"function\") {\n      const originalDestroy = component.destroy;\n      component.destroy = () => {\n        // Remove event listeners\n        const viewportElement = (component as any)._momentumViewportElement;\n        if (viewportElement) {\n          viewportElement.removeEventListener(\"touchstart\", handleTouchStart);\n          viewportElement.removeEventListener(\"touchmove\", handleTouchMove);\n          viewportElement.removeEventListener(\"touchend\", handleTouchEnd);\n          viewportElement.removeEventListener(\"mousedown\", handleMouseDown);\n          viewportElement.removeEventListener(\"mousemove\", handleMouseMove);\n          viewportElement.removeEventListener(\"mouseup\", handleMouseUp);\n          viewportElement.removeEventListener(\"mouseleave\", handleMouseUp);\n          if ((component as any)._momentumStopOnClick) {\n            viewportElement.removeEventListener(\"click\", handleClick);\n          }\n        }\n\n        // Cancel momentum animation\n        stopMomentum();\n\n        originalDestroy();\n      };\n    }\n\n    // Expose momentum state for other features\n    (component.viewport as any).momentumState = {\n      stopMomentum,\n    };\n\n    return component;\n  };\n};\n",
    "// src/core/viewport/features/scrollbar.ts\n\n/**\n * Scrollbar Feature - Custom scrollbar implementation\n * Provides visual scroll indication and drag-to-scroll functionality\n */\n\nimport type { ViewportContext, ViewportComponent } from \"../types\";\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\nimport { wrapInitialize, wrapDestroy, storeFeatureFunction } from \"./utils\";\nimport { PREFIX, addClass, removeClass } from \"mtrl\";\n\nexport interface ScrollbarConfig {\n  enabled?: boolean;\n  autoHide?: boolean;\n  thumbMinHeight?: number;\n  thumbColor?: string;\n  trackColor?: string;\n  borderRadius?: number;\n  fadeTimeout?: number;\n}\n\nexport interface ScrollbarComponent {\n  scrollbar: {\n    show: () => void;\n    hide: () => void;\n    updateBounds: (totalVirtualSize: number, containerSize: number) => void;\n    updatePosition: (scrollPosition: number) => void;\n  };\n}\n\n/**\n * Adds scrollbar functionality to viewport component\n */\nexport function withScrollbar(config: ScrollbarConfig = {}) {\n  return <T extends ViewportContext & ViewportComponent>(\n    component: T,\n  ): T & ScrollbarComponent => {\n    const {\n      enabled = true,\n      autoHide = true,\n      thumbMinHeight = 25,\n      borderRadius = 4,\n      fadeTimeout = 1000,\n    } = config;\n\n    // Return no-op if disabled\n    if (!enabled) {\n      return {\n        ...component,\n        scrollbar: {\n          show: () => {},\n          hide: () => {},\n          updateBounds: () => {},\n          updatePosition: () => {},\n        },\n      };\n    }\n\n    // State\n    let viewportElement: HTMLElement | null = null;\n    let scrollbarTrack: HTMLElement | null = null;\n    let scrollbarThumb: HTMLElement | null = null;\n    let isInitialized = false;\n    let isDragging = false;\n    let dragStartY = 0;\n    let dragStartScrollPosition = 0;\n    let hideTimeout: ReturnType<typeof setTimeout> | null = null;\n    let totalVirtualSize = 0;\n    let containerSize = 0;\n    let thumbHeight = 0;\n    let animationFrameId: number | null = null;\n    let lastRequestedScrollPosition: number | null = null;\n    let isCursorMode = false;\n    let loadedItemsCount = 0;\n\n    // Create scrollbar elements\n    const createScrollbarElements = () => {\n      if (!viewportElement) return;\n\n      scrollbarTrack = document.createElement(\"div\");\n      addClass(scrollbarTrack, VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR);\n      scrollbarTrack.style.cssText = `\n        position: absolute;\n        top: 0;\n        right: 0;\n        height: 100%;\n        z-index: 10;\n      `;\n\n      scrollbarThumb = document.createElement(\"div\");\n\n      addClass(\n        scrollbarThumb,\n        VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_THUMB,\n      );\n\n      scrollbarTrack.appendChild(scrollbarThumb);\n      viewportElement.appendChild(scrollbarTrack);\n    };\n\n    // Show/hide functions\n    const show = () => {\n      if (!scrollbarTrack || totalVirtualSize <= containerSize) return;\n\n      if (hideTimeout) {\n        clearTimeout(hideTimeout);\n        hideTimeout = null;\n      }\n\n      addClass(\n        scrollbarTrack,\n        VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_VISIBLE,\n      );\n\n      if (autoHide && !isDragging) {\n        hideTimeout = setTimeout(hide, fadeTimeout);\n      }\n    };\n\n    const hide = () => {\n      if (!scrollbarTrack || isDragging) return;\n      removeClass(\n        scrollbarTrack,\n        VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_VISIBLE,\n      );\n    };\n\n    // Update scrollbar bounds\n    const updateBounds = (newTotalSize: number, newContainerSize: number) => {\n      totalVirtualSize = newTotalSize;\n      containerSize = newContainerSize;\n\n      if (!scrollbarTrack || !scrollbarThumb) return;\n\n      const needsScrollbar = totalVirtualSize > containerSize;\n      // console.log(\n      //   `[Scrollbar] updateBounds: totalSize=${totalVirtualSize}, containerSize=${containerSize}, needsScrollbar=${needsScrollbar}`\n      // );\n      scrollbarTrack.style.display = needsScrollbar ? \"block\" : \"none\";\n\n      if (needsScrollbar) {\n        let scrollRatio: number;\n\n        if (isCursorMode && loadedItemsCount > 0) {\n          // For cursor mode, thumb size represents loaded content vs estimated total\n          // If we don't know total, use loaded items * 2 as estimate\n          const estimatedTotal =\n            totalVirtualSize > 0 ? totalVirtualSize : loadedItemsCount * 2;\n          scrollRatio =\n            containerSize /\n            Math.max(estimatedTotal, loadedItemsCount + containerSize);\n        } else {\n          // Normal calculation for offset/page strategies\n          scrollRatio = containerSize / totalVirtualSize;\n        }\n\n        thumbHeight = Math.max(thumbMinHeight, scrollRatio * containerSize);\n        scrollbarThumb.style.height = `${thumbHeight}px`;\n        updatePosition(component.viewport?.getScrollPosition() || 0);\n      }\n    };\n\n    // Update thumb position\n    const updatePosition = (scrollPos: number) => {\n      if (!scrollbarThumb || !scrollbarTrack) return;\n\n      const scrollableDistance = totalVirtualSize - containerSize;\n      if (scrollableDistance <= 0) return;\n\n      const scrollRatio = Math.min(\n        1,\n        Math.max(0, scrollPos / scrollableDistance),\n      );\n      const maxThumbPosition =\n        scrollbarTrack.clientHeight - scrollbarThumb.clientHeight;\n      const thumbPosition = scrollRatio * maxThumbPosition;\n\n      scrollbarThumb.style.transform = `translateY(${thumbPosition}px)`;\n    };\n\n    // Handle track click\n    const handleTrackClick = (e: MouseEvent) => {\n      if (!scrollbarTrack || !scrollbarThumb || e.target === scrollbarThumb)\n        return;\n\n      const trackRect = scrollbarTrack.getBoundingClientRect();\n      const clickY = e.clientY - trackRect.top;\n      const thumbCenterY = clickY - thumbHeight / 2;\n      const maxThumbPosition = containerSize - thumbHeight;\n      const thumbPosition = Math.max(\n        0,\n        Math.min(thumbCenterY, maxThumbPosition),\n      );\n      const scrollRatio = thumbPosition / maxThumbPosition;\n      const targetScrollPosition =\n        scrollRatio * (totalVirtualSize - containerSize);\n\n      component.viewport?.scrollToPosition(targetScrollPosition);\n    };\n\n    // Mouse event handlers\n    const handleThumbMouseDown = (e: MouseEvent) => {\n      e.preventDefault();\n      e.stopPropagation();\n\n      isDragging = true;\n      dragStartY = e.clientY;\n      dragStartScrollPosition = component.viewport?.getScrollPosition() || 0;\n\n      if (scrollbarTrack) {\n        addClass(\n          scrollbarTrack,\n          VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_DRAGGING,\n        );\n      }\n\n      // Emit drag start event to notify viewport\n      component.emit?.(\"viewport:drag-start\", {\n        source: \"scrollbar\",\n        startPosition: dragStartScrollPosition,\n      });\n\n      document.addEventListener(\"mousemove\", handleMouseMove);\n      document.addEventListener(\"mouseup\", handleMouseUp);\n    };\n\n    const handleMouseMove = (e: MouseEvent) => {\n      if (!isDragging || !scrollbarTrack || !scrollbarThumb) return;\n\n      const deltaY = e.clientY - dragStartY;\n      const trackHeight = scrollbarTrack.clientHeight;\n      const thumbHeight = scrollbarThumb.clientHeight;\n      const maxThumbTravel = trackHeight - thumbHeight;\n\n      if (maxThumbTravel <= 0) return;\n\n      const deltaRatio = deltaY / maxThumbTravel;\n      const dragStartScrollRatio =\n        dragStartScrollPosition / (totalVirtualSize - containerSize);\n      const newScrollRatio = Math.max(\n        0,\n        Math.min(1, dragStartScrollRatio + deltaRatio),\n      );\n\n      // Update thumb position immediately\n      const thumbPosition = newScrollRatio * maxThumbTravel;\n      scrollbarThumb.style.transform = `translateY(${thumbPosition}px)`;\n\n      // Calculate new scroll position\n      const newPosition = newScrollRatio * (totalVirtualSize - containerSize);\n      lastRequestedScrollPosition = newPosition;\n\n      // console.log(\n      //   `[Scrollbar] Mouse move: newPos=${newPosition.toFixed(\n      //     0\n      //   )}, animationFrameId=${animationFrameId}`\n      // );\n\n      // Throttle viewport updates\n      if (animationFrameId === null && component.viewport) {\n        animationFrameId = requestAnimationFrame(() => {\n          // console.log(\n          //   `[Scrollbar] RAF callback: scrolling to ${lastRequestedScrollPosition}`\n          // );\n          if (lastRequestedScrollPosition !== null && component.viewport) {\n            component.viewport.scrollToPosition(lastRequestedScrollPosition);\n          }\n          animationFrameId = null;\n        });\n      }\n    };\n\n    const handleMouseUp = () => {\n      isDragging = false;\n\n      if (animationFrameId !== null) {\n        cancelAnimationFrame(animationFrameId);\n        animationFrameId = null;\n      }\n\n      if (lastRequestedScrollPosition !== null && component.viewport) {\n        component.viewport.scrollToPosition(lastRequestedScrollPosition);\n        lastRequestedScrollPosition = null;\n      }\n\n      if (scrollbarTrack) {\n        removeClass(\n          scrollbarTrack,\n          VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR_DRAGGING,\n        );\n      }\n\n      // Emit drag end event\n      component.emit?.(\"viewport:drag-end\", {\n        source: \"scrollbar\",\n        endPosition: component.viewport?.getScrollPosition() || 0,\n      });\n\n      hide();\n\n      document.removeEventListener(\"mousemove\", handleMouseMove);\n      document.removeEventListener(\"mouseup\", handleMouseUp);\n    };\n\n    // Initialize function\n    const initialize = () => {\n      if (isInitialized) return;\n\n      viewportElement = component.element?.querySelector(\n        `.${PREFIX}-viewport`,\n      ) as HTMLElement;\n\n      if (!viewportElement) {\n        console.warn(\"[Scrollbar] No viewport element found\");\n        return;\n      }\n\n      if (\n        viewportElement.querySelector(\n          `.${PREFIX}-${VIEWPORT_CONSTANTS.SCROLLBAR.CLASSES.SCROLLBAR}`,\n        )\n      )\n        return;\n\n      createScrollbarElements();\n      isInitialized = true;\n\n      if (scrollbarTrack && viewportElement) {\n        scrollbarTrack.addEventListener(\"click\", handleTrackClick);\n\n        if (scrollbarThumb) {\n          scrollbarThumb.addEventListener(\"mousedown\", handleThumbMouseDown);\n        }\n\n        viewportElement.addEventListener(\"mouseenter\", show, { passive: true });\n        viewportElement.addEventListener(\n          \"mouseleave\",\n          () => {\n            if (!isDragging) hide();\n          },\n          { passive: true },\n        );\n      }\n\n      // Initialize with current viewport state\n      if (component.viewport) {\n        const info = component.viewport.getViewportInfo();\n        totalVirtualSize = info.totalVirtualSize;\n        containerSize = info.containerSize;\n\n        // Check if we're in cursor mode\n        const collection = (component as any).collection;\n        const viewportConfig = (component as any).config;\n        isCursorMode = viewportConfig?.pagination?.strategy === \"cursor\";\n\n        updateBounds(totalVirtualSize, containerSize);\n        updatePosition(component.viewport.getScrollPosition());\n      }\n\n      // Event listeners\n      component.on?.(\"viewport:scroll\", (data: any) => {\n        if (!isDragging) {\n          updatePosition(data.position);\n          show();\n        }\n      });\n\n      component.on?.(\"viewport:virtual-size-changed\", (data: any) => {\n        totalVirtualSize = data.totalVirtualSize;\n        updateBounds(data.totalVirtualSize, containerSize);\n      });\n\n      component.on?.(\"viewport:container-size-changed\", (data: any) => {\n        containerSize = data.containerSize;\n        updateBounds(totalVirtualSize, data.containerSize);\n      });\n\n      // Listen for items loaded to update scrollbar in cursor mode\n      component.on?.(\"viewport:items-changed\", (data: any) => {\n        if (isCursorMode) {\n          loadedItemsCount = data.loadedCount || 0;\n          updateBounds(totalVirtualSize, containerSize);\n        }\n      });\n\n      // Listen for total items changes (important for cursor mode)\n      component.on?.(\"viewport:total-items-changed\", (data: any) => {\n        if (isCursorMode && data.total) {\n          // In cursor mode, the total is dynamic\n          console.log(\n            `[Scrollbar] Cursor mode: updating bounds for new total ${data.total}`,\n          );\n          updateBounds(totalVirtualSize, containerSize);\n        }\n      });\n    };\n\n    // Store initialize function\n    storeFeatureFunction(component, \"_scrollbarInitialize\", initialize);\n\n    // Hook into viewport initialization\n    wrapInitialize(component, initialize);\n\n    // Cleanup\n    const destroy = () => {\n      if (scrollbarTrack) {\n        scrollbarTrack.remove();\n        scrollbarTrack = null;\n      }\n      scrollbarThumb = null;\n      viewportElement = null;\n      isInitialized = false;\n\n      if (hideTimeout) {\n        clearTimeout(hideTimeout);\n        hideTimeout = null;\n      }\n\n      document.removeEventListener(\"mousemove\", handleMouseMove);\n      document.removeEventListener(\"mouseup\", handleMouseUp);\n    };\n\n    storeFeatureFunction(component, \"_scrollbarDestroy\", destroy);\n    wrapDestroy(component, destroy);\n\n    // Return enhanced component\n    return {\n      ...component,\n      scrollbar: { show, hide, updateBounds, updatePosition },\n    };\n  };\n}\n",
    "// src/core/viewport/features/collection.ts\n\n/**\n * Collection Feature - Data management and range loading\n * Handles collection integration, pagination, and data fetching\n */\n\nimport type { ViewportContext, ViewportComponent } from \"../types\";\n\n/**\n * Mutable reference for late binding in functional composition.\n * Used by VList to allow collection (applied early) to access\n * search/filter features (applied later).\n */\ninterface SelfRef<T> {\n  current: T | null;\n}\n\n/**\n * Component with optional search/filter capabilities.\n * These are added by withSearch and withFilter features.\n */\ninterface SearchFilterCapable {\n  _searchQuery?: () => string;\n  _filters?: () => Record<string, unknown>;\n}\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\nimport { wrapDestroy } from \"./utils\";\n\nexport interface CollectionConfig {\n  collection?: any; // Collection adapter\n  rangeSize?: number; // Default range size for loading\n  strategy?: \"offset\" | \"page\" | \"cursor\"; // Loading strategy\n  transform?: (item: any) => any; // Item transformation function\n  cancelLoadThreshold?: number; // Velocity threshold for cancelling loads\n  maxConcurrentRequests?: number;\n  enableRequestQueue?: boolean;\n  maxQueueSize?: number;\n  loadOnDragEnd?: boolean; // Enable loading when drag ends (safety measure)\n  initialScrollIndex?: number; // Initial scroll position (0-based index)\n  selectId?: string | number; // ID of item to select after initial load completes\n  autoLoad?: boolean; // Whether to automatically load data on initialization (default: true)\n  autoSelectFirst?: boolean; // Automatically select first item after initial load (default: false)\n  /** Maximum items to keep in memory (default: 1000) */\n  maxCachedItems?: number;\n  /** Extra items to keep around visible range during eviction (default: 150) */\n  evictionBuffer?: number;\n}\n\nexport interface CollectionComponent {\n  collection: {\n    loadRange: (offset: number, limit: number) => Promise<any[]>;\n    loadMissingRanges: (\n      range: { start: number; end: number },\n      caller?: string,\n    ) => Promise<void>;\n    getLoadedRanges: () => Set<number>;\n    getPendingRanges: () => Set<number>;\n    clearFailedRanges: () => void;\n    clearQueue: () => void;\n    setManuallyLoaded: () => void;\n    setReloadInProgress: (\n      inProgress: boolean,\n      targetRange?: { start: number; end: number },\n    ) => void;\n    retryFailedRange: (rangeId: number) => Promise<any[]>;\n    setTotalItems: (total: number) => void;\n    getTotalItems: () => number;\n    // Cursor-specific methods\n    getCurrentCursor: () => string | null;\n    getCursorForPage: (page: number) => string | null;\n    // Reset method for reload functionality\n    reset: () => void;\n  };\n}\n\n/**\n * Adds collection functionality to viewport component\n */\nexport function withCollection(config: CollectionConfig = {}) {\n  return <T extends ViewportContext & ViewportComponent>(\n    component: T,\n  ): T & CollectionComponent => {\n    const {\n      collection,\n      rangeSize = VIEWPORT_CONSTANTS.LOADING.DEFAULT_RANGE_SIZE,\n      strategy = \"offset\",\n      transform,\n      cancelLoadThreshold = VIEWPORT_CONSTANTS.LOADING.CANCEL_THRESHOLD,\n      maxConcurrentRequests = VIEWPORT_CONSTANTS.LOADING\n        .MAX_CONCURRENT_REQUESTS,\n      enableRequestQueue = VIEWPORT_CONSTANTS.REQUEST_QUEUE.ENABLED,\n      maxQueueSize = VIEWPORT_CONSTANTS.REQUEST_QUEUE.MAX_QUEUE_SIZE,\n      loadOnDragEnd = true, // Default to true as safety measure\n      initialScrollIndex = 0, // Start from beginning by default\n      selectId, // ID of item to select after initial load\n      autoLoad = true, // Auto-load initial data by default\n      autoSelectFirst = false, // Automatically select first item after initial load\n      maxCachedItems = 1000, // Maximum items to keep in memory\n      evictionBuffer = 150, // Extra items to keep around visible range\n    } = config;\n\n    // Track if we've completed the initial load for initialScrollIndex\n    // This prevents the viewport:range-changed listener from loading page 1\n    let hasCompletedInitialPositionLoad = false;\n    const hasInitialScrollIndex = initialScrollIndex > 0;\n\n    // Track if data has been manually loaded (e.g., via reloadAt)\n    // This enables subsequent loads from viewport:range-changed even with autoLoad: false\n    let hasManuallyLoaded = false;\n\n    // Track if a reload is in progress (reloadAt sets this to prevent stale page 1 loads)\n    // This is set by reloadAt BEFORE it starts loading, and cleared when loading completes\n    let reloadInProgress = false;\n    let reloadTargetRange: { start: number; end: number } | null = null;\n\n    // console.log(\"[Viewport Collection] Initialized with config:\", {\n    //   strategy,\n    //   rangeSize,\n    //   initialScrollIndex,\n    // });\n\n    // Loading manager state\n    interface QueuedRequest {\n      range: { start: number; end: number };\n      priority: \"high\" | \"normal\" | \"low\";\n      timestamp: number;\n      resolve: () => void;\n      reject: (error: any) => void;\n      caller?: string;\n    }\n\n    // State tracking\n    let currentVelocity = 0;\n    let activeLoadCount = 0;\n    let completedLoads = 0;\n    let failedLoads = 0;\n    let cancelledLoads = 0;\n    let isDragging = false; // Track drag state\n\n    // Cache eviction configuration (from config)\n    const MAX_CACHED_ITEMS = maxCachedItems;\n    const EVICTION_BUFFER = evictionBuffer;\n\n    // Track actual item count efficiently (avoid O(n) sparse array iteration)\n    let cachedItemCount = 0;\n\n    // Memory diagnostics\n    const logMemoryStats = (caller: string) => {\n      const loadedRangeCount = loadedRanges.size;\n      const pendingRangeCount = pendingRanges.size;\n      const abortControllerCount = abortControllers.size;\n    };\n\n    /**\n     * Evict items far from the current visible range to prevent memory bloat\n     * Keeps items within EVICTION_BUFFER of the visible range\n     *\n     * PERFORMANCE: Uses loadedRanges to iterate only loaded data, not the entire\n     * sparse array. This is critical for large lists (1M+ items) where the\n     * items array is sparse and iterating items.length would be O(n).\n     */\n    const evictDistantItems = (visibleStart: number, visibleEnd: number) => {\n      // Only evict if we have more than MAX_CACHED_ITEMS\n      // Use cached count instead of O(n) items.filter(Boolean).length\n      if (cachedItemCount <= MAX_CACHED_ITEMS) {\n        return;\n      }\n\n      const keepStart = Math.max(0, visibleStart - EVICTION_BUFFER);\n      const keepEnd = visibleEnd + EVICTION_BUFFER;\n\n      // Calculate which ranges to keep based on visible area\n      const keepRangeStart = Math.floor(keepStart / rangeSize);\n      const keepRangeEnd = Math.floor(keepEnd / rangeSize);\n\n      let evictedCount = 0;\n      const rangesToRemove = new Set<number>();\n\n      // Iterate only over loaded ranges, not the entire sparse array\n      // This is O(loaded ranges) instead of O(total items)\n      loadedRanges.forEach((rangeId) => {\n        // Check if this range is outside the keep zone\n        if (rangeId < keepRangeStart || rangeId > keepRangeEnd) {\n          rangesToRemove.add(rangeId);\n\n          // Evict items in this range\n          const rangeStart = rangeId * rangeSize;\n          const rangeEnd = rangeStart + rangeSize;\n          for (let i = rangeStart; i < rangeEnd; i++) {\n            if (items[i] !== undefined) {\n              delete items[i];\n              evictedCount++;\n            }\n          }\n        }\n      });\n\n      // Remove all ranges that had items evicted\n      // This is critical: even if only part of a range was evicted,\n      // we must remove it from loadedRanges so it gets reloaded\n      // Also remove from pendingRanges - if a slow request completes for an evicted range,\n      // we don't want it to block future loads when user scrolls back\n      rangesToRemove.forEach((rangeId) => {\n        loadedRanges.delete(rangeId);\n        pendingRanges.delete(rangeId);\n        // Clean up active requests tracking\n        activeRequests.delete(rangeId);\n        // Also abort any in-flight request for this range to free up network resources\n        const controller = abortControllers.get(rangeId);\n        if (controller) {\n          controller.abort();\n          abortControllers.delete(rangeId);\n        }\n      });\n\n      if (evictedCount > 0) {\n        // Update cached item count\n        cachedItemCount -= evictedCount;\n\n        // Emit event for rendering to also clean up\n        component.emit?.(\"collection:items-evicted\", {\n          keepStart,\n          keepEnd,\n          evictedCount,\n        });\n      }\n    };\n\n    const activeLoadRanges = new Set<string>();\n    let loadRequestQueue: QueuedRequest[] = [];\n\n    // AbortController map for cancelling in-flight requests\n    const abortControllers = new Map<number, AbortController>();\n\n    // State\n    let items: any[] = [];\n    let totalItems = 0;\n    let loadedRanges = new Set<number>();\n    let pendingRanges = new Set<number>();\n    let failedRanges = new Map<\n      number,\n      {\n        attempts: number;\n        lastError: Error;\n        timestamp: number;\n      }\n    >();\n    let activeRequests = new Map<number, Promise<any[]>>();\n\n    // Cursor pagination state\n    let currentCursor: string | null = null;\n    let cursorMap = new Map<number, string>(); // Map page number to cursor\n    let pageToOffsetMap = new Map<number, number>(); // Map page to actual offset\n    let highestLoadedPage = 0;\n    let discoveredTotal: number | null = null; // Track discovered total from API\n    let hasReachedEnd = false; // Track if we've reached the end of data\n\n    // Share items array with component\n    component.items = items;\n\n    /**\n     * Get a unique ID for a range based on offset and the base range size\n     */\n    const getRangeId = (offset: number, limit: number): number => {\n      // Always use the base rangeSize for consistent IDs\n      // This ensures merged ranges can be tracked properly\n      return Math.floor(offset / rangeSize);\n    };\n\n    // Loading manager helpers\n    const getRangeKey = (range: { start: number; end: number }): string => {\n      return `${range.start}-${range.end}`;\n    };\n\n    const canLoad = (): boolean => {\n      return currentVelocity <= cancelLoadThreshold;\n    };\n\n    const processQueue = () => {\n      if (!enableRequestQueue || loadRequestQueue.length === 0) return;\n\n      // Sort queue by priority and timestamp\n      loadRequestQueue.sort((a, b) => {\n        const priorityOrder = { high: 0, normal: 1, low: 2 };\n        const priorityDiff =\n          priorityOrder[a.priority] - priorityOrder[b.priority];\n        return priorityDiff !== 0 ? priorityDiff : a.timestamp - b.timestamp;\n      });\n\n      // Process requests up to capacity\n      while (\n        loadRequestQueue.length > 0 &&\n        activeLoadCount < maxConcurrentRequests\n      ) {\n        const request = loadRequestQueue.shift();\n        if (request) {\n          executeQueuedLoad(request);\n        }\n      }\n    };\n\n    const executeQueuedLoad = (request: QueuedRequest) => {\n      activeLoadCount++;\n      activeLoadRanges.add(getRangeKey(request.range));\n\n      // Call the actual loadMissingRanges function\n      loadMissingRangesInternal(request.range, request.caller)\n        .then(() => {\n          request.resolve();\n          completedLoads++;\n        })\n        .catch((error: Error) => {\n          request.reject(error);\n          failedLoads++;\n        })\n        .finally(() => {\n          activeLoadCount--;\n          activeLoadRanges.delete(getRangeKey(request.range));\n          processQueue();\n        });\n    };\n\n    /**\n     * Transform items if transform function provided\n     */\n    const transformItems = (rawItems: any[]): any[] => {\n      if (!transform) return rawItems;\n      return rawItems.map(transform);\n    };\n\n    /**\n     * Load a range of data\n     */\n    const loadRange = async (\n      offset: number,\n      limit: number,\n      caller?: string,\n    ): Promise<any[]> => {\n      if (!collection) {\n        console.warn(\"[Collection] No collection adapter configured\");\n        return [];\n      }\n\n      const rangeId = getRangeId(offset, limit);\n      // console.log(`[Collection] Range ID: ${rangeId}`);\n\n      // Check if already loaded\n      if (loadedRanges.has(rangeId)) {\n        return items.slice(offset, offset + limit);\n      }\n\n      // Check if already pending\n      if (pendingRanges.has(rangeId)) {\n        const existingRequest = activeRequests.get(rangeId);\n        if (existingRequest) {\n          return existingRequest;\n        }\n      }\n\n      // Mark as pending\n      pendingRanges.add(rangeId);\n\n      // Create AbortController for this request\n      const abortController = new AbortController();\n      abortControllers.set(rangeId, abortController);\n\n      // Create request promise\n      const requestPromise = (async () => {\n        try {\n          // Call collection adapter with appropriate parameters\n          const page = Math.floor(offset / limit) + 1;\n          let params: any;\n\n          if (strategy === \"cursor\") {\n            // For cursor pagination\n            if (page === 1) {\n              // First page - no cursor\n              params = { limit };\n            } else {\n              // Check if we have cursor for previous page\n              const prevPageCursor = cursorMap.get(page - 1);\n              if (!prevPageCursor) {\n                // Can't load this page without previous cursor\n                console.warn(\n                  `[Collection] Cannot load page ${page} without cursor for page ${\n                    page - 1\n                  }`,\n                );\n                throw new Error(\n                  `Sequential loading required - missing cursor for page ${\n                    page - 1\n                  }`,\n                );\n              }\n              params = { cursor: prevPageCursor, limit };\n            }\n          } else if (strategy === \"page\") {\n            params = { page, limit };\n          } else {\n            // offset strategy\n            params = { offset, limit };\n          }\n\n          // Inject search query if component has withSearch feature\n          // Use _selfRef.current for late binding (search/filter features are added after viewport)\n          const selfRef = (\n            component as unknown as { _selfRef?: SelfRef<SearchFilterCapable> }\n          )._selfRef;\n          const self: Partial<SearchFilterCapable> = selfRef?.current ?? {};\n          if (typeof self._searchQuery === \"function\") {\n            const searchQuery = self._searchQuery();\n            if (searchQuery) {\n              params.search = searchQuery;\n            }\n          }\n\n          // Inject filters if component has withFilter feature\n          if (typeof self._filters === \"function\") {\n            const filters = self._filters();\n            if (filters && Object.keys(filters).length > 0) {\n              params.filters = filters;\n            }\n          }\n\n          // console.log(\n          //   `[Viewport Collection] Loading range offset=${offset}, limit=${limit}, strategy=${strategy}, calculated page=${page}, params:`,\n          //   JSON.stringify(params)\n          // );\n\n          // Pass abort signal to the adapter if it supports it\n          const response = await collection.read({\n            ...params,\n            signal: abortController.signal,\n          });\n\n          // Extract items and total\n          const rawItems = response.data || response.items || response;\n          const meta = response.meta || {};\n\n          // For cursor pagination, track the cursor (check both cursor and nextCursor)\n          const responseCursor = meta.cursor || meta.nextCursor;\n          if (strategy === \"cursor\" && responseCursor) {\n            currentCursor = responseCursor;\n            cursorMap.set(page, responseCursor);\n            pageToOffsetMap.set(page, offset);\n            highestLoadedPage = Math.max(highestLoadedPage, page);\n            // console.log(\n            //   `[Collection] Stored cursor for page ${page}: ${responseCursor}`,\n            // );\n          }\n\n          // Check if we've reached the end\n          if (strategy === \"cursor\" && meta.hasNext === false) {\n            hasReachedEnd = true;\n            // console.log(\n            //   `[Collection] Reached end of cursor pagination at page ${page}`,\n            // );\n          }\n\n          // Update discovered total if provided\n          // console.log(\n          //   `[Collection] meta.total: ${meta.total}, discoveredTotal before: ${discoveredTotal}`,\n          // );\n          if (meta.total !== undefined) {\n            discoveredTotal = meta.total;\n          }\n          // console.log(`[Collection] discoveredTotal after: ${discoveredTotal}`);\n\n          // Transform items\n          const transformedItems = transformItems(rawItems);\n\n          // Add items to array and track count efficiently\n          let newItemsAdded = 0;\n          transformedItems.forEach((item, index) => {\n            // Only count as new if slot was empty\n            if (items[offset + index] === undefined) {\n              newItemsAdded++;\n            }\n            items[offset + index] = item;\n          });\n          cachedItemCount += newItemsAdded;\n\n          // For cursor strategy, calculate dynamic total based on loaded data\n          // Use nullish coalescing (??) instead of || to handle discoveredTotal = 0 correctly\n          let newTotal = discoveredTotal ?? totalItems;\n\n          // CRITICAL FIX: When API returns 0 items on page 1 (offset 0), the list is empty.\n          // We must set totalItems to 0 regardless of meta.total being undefined.\n          // This handles the case where count=false is sent but the list is actually empty.\n          if (offset === 0 && transformedItems.length === 0) {\n            // console.log(\n            //   `[Collection] Empty result on page 1 - forcing totalItems to 0`,\n            // );\n            newTotal = 0;\n            discoveredTotal = 0;\n          }\n          // console.log(\n          //   `[Collection] newTotal initial: ${newTotal}, totalItems: ${totalItems}, strategy: ${strategy}`,\n          // );\n\n          if (strategy === \"cursor\") {\n            // Calculate total based on loaded items + margin\n            // Use cachedItemCount instead of O(n) filter operation\n            const loadedItemsCount = cachedItemCount;\n            const marginItems = hasReachedEnd\n              ? 0\n              : rangeSize *\n                VIEWPORT_CONSTANTS.PAGINATION.CURSOR_SCROLL_MARGIN_MULTIPLIER;\n            const minVirtualItems =\n              rangeSize *\n              VIEWPORT_CONSTANTS.PAGINATION.CURSOR_MIN_VIRTUAL_SIZE_MULTIPLIER;\n\n            // Dynamic total: loaded items + margin (unless we've reached the end)\n            newTotal = Math.max(\n              loadedItemsCount + marginItems,\n              minVirtualItems,\n            );\n\n            // console.log(\n            //   `[Collection] Cursor mode virtual size: loaded=${loadedItemsCount}, margin=${marginItems}, total=${newTotal}, hasReachedEnd=${hasReachedEnd}`,\n            // );\n\n            // Update total if it has grown\n            if (newTotal > totalItems) {\n              // console.log(\n              //   `[Collection] Updating cursor virtual size from ${totalItems} to ${newTotal}`,\n              // );\n              totalItems = newTotal;\n              setTotalItems(newTotal);\n            }\n          } else {\n            // For other strategies, use discovered total or current total\n            // Use nullish coalescing (??) instead of || to handle discoveredTotal = 0 correctly\n            newTotal = discoveredTotal ?? totalItems;\n          }\n\n          // Update state\n          // console.log(\n          //   `[Collection] Before state update: newTotal=${newTotal}, totalItems=${totalItems}, will update: ${newTotal !== totalItems}`,\n          // );\n          if (newTotal !== totalItems) {\n            // console.log(`[Collection] Calling setTotalItems(${newTotal})`);\n            totalItems = newTotal;\n            setTotalItems(newTotal);\n          }\n\n          // Update component items reference\n          component.items = items;\n\n          // Emit items changed event\n          component.emit?.(\"viewport:items-changed\", {\n            totalItems: newTotal,\n            loadedCount: cachedItemCount,\n          });\n\n          // Update viewport state\n          const viewportState = (component.viewport as any).state;\n          if (viewportState) {\n            // Use nullish coalescing (??) instead of || to handle newTotal = 0 correctly\n            viewportState.totalItems = newTotal ?? items.length;\n          }\n\n          // Verify items are actually still in the array before marking as loaded\n          // This prevents a race condition where eviction happens during async load:\n          // 1. Load starts for range A\n          // 2. User scrolls to range B\n          // 3. Eviction removes items from range A and removes from loadedRanges\n          // 4. Load for range A completes, would re-add to loadedRanges\n          // 5. User scrolls back to A, loadedRanges says loaded but items are gone\n          const itemsActuallyStored =\n            transformedItems.length > 0 &&\n            transformedItems.every(\n              (_, idx) => items[offset + idx] !== undefined,\n            );\n\n          if (itemsActuallyStored) {\n            // Mark as loaded only if items are actually present\n            loadedRanges.add(rangeId);\n          }\n          // Always clean up pending/failed state\n          pendingRanges.delete(rangeId);\n          failedRanges.delete(rangeId);\n\n          // console.log(\n          //   `[Collection] Range ${rangeId} loaded successfully with ${transformedItems.length} items`\n          // );\n\n          // Log memory stats periodically (every 5 loads)\n          if (completedLoads % 5 === 0) {\n            logMemoryStats(`load:${completedLoads}`);\n          }\n\n          // Emit events\n          component.emit?.(\"viewport:range-loaded\", {\n            offset,\n            limit,\n            items: transformedItems,\n            total: newTotal,\n          });\n\n          // Emit collection loaded event with more details\n          component.emit?.(\"collection:range-loaded\", {\n            offset,\n            limit,\n            items: transformedItems,\n            total: newTotal,\n            rangeId,\n            itemsInMemory: items.filter((item) => item !== undefined).length,\n            cursor: strategy === \"cursor\" ? currentCursor : undefined,\n          });\n\n          // Trigger viewport update\n          component.viewport?.updateViewport?.();\n\n          return transformedItems;\n        } catch (error) {\n          // Handle AbortError and \"Failed to fetch\" (which can occur on abort) gracefully\n          const isAbortError =\n            (error as Error).name === \"AbortError\" ||\n            ((error as Error).message === \"Failed to fetch\" &&\n              abortController.signal.aborted);\n\n          if (isAbortError) {\n            pendingRanges.delete(rangeId);\n            cancelledLoads++;\n            // Don't throw, just return empty array\n            return [];\n          }\n\n          // Handle other errors\n          pendingRanges.delete(rangeId);\n          failedLoads++;\n\n          const attempts = (failedRanges.get(rangeId)?.attempts || 0) + 1;\n          failedRanges.set(rangeId, {\n            attempts,\n            lastError: error as Error,\n            timestamp: Date.now(),\n          });\n\n          // Emit error event\n          component.emit?.(\"viewport:range-error\", {\n            offset,\n            limit,\n            error,\n            attempts,\n          });\n\n          throw error;\n        } finally {\n          activeRequests.delete(rangeId);\n          abortControllers.delete(rangeId);\n        }\n      })();\n\n      activeRequests.set(rangeId, requestPromise);\n      return requestPromise;\n    };\n\n    /**\n     * Load missing ranges from collection\n     */\n    const loadMissingRangesInternal = async (\n      // Note: caller is added by loadMissingRanges wrapper\n      range: {\n        start: number;\n        end: number;\n      },\n      caller?: string,\n    ): Promise<void> => {\n      if (!collection) return;\n\n      // For cursor pagination, we need to load sequentially\n      if (strategy === \"cursor\") {\n        const startPage = Math.floor(range.start / rangeSize) + 1;\n        const endPage = Math.floor(range.end / rangeSize) + 1;\n\n        // Limit how many pages we'll load at once\n        const maxPagesToLoad = 10;\n        const currentHighestPage = highestLoadedPage || 0;\n        const limitedEndPage = Math.min(\n          endPage,\n          currentHighestPage + maxPagesToLoad,\n        );\n\n        // console.log(\n        //   `[Collection] Cursor mode: need to load pages ${startPage} to ${endPage}, limited to ${limitedEndPage}`,\n        // );\n\n        // Check if we need to load pages sequentially\n        for (let page = startPage; page <= limitedEndPage; page++) {\n          const rangeId = page - 1; // Convert to 0-based rangeId\n          const offset = rangeId * rangeSize;\n\n          // Skip if already being loaded\n          if (pendingRanges.has(rangeId)) {\n            // Range already being loaded\n            return;\n          }\n\n          if (!loadedRanges.has(rangeId) && !pendingRanges.has(rangeId)) {\n            // For cursor pagination, we must load sequentially\n            // Check if we have all previous pages loaded\n            if (page > 1) {\n              let canLoad = true;\n              for (let prevPage = 1; prevPage < page; prevPage++) {\n                const prevRangeId = prevPage - 1;\n                if (!loadedRanges.has(prevRangeId)) {\n                  // console.log(\n                  //   `[Collection] Cannot load page ${page} - need to load page ${prevPage} first`,\n                  // );\n                  canLoad = false;\n\n                  // Try to load the missing page\n                  if (!pendingRanges.has(prevRangeId)) {\n                    try {\n                      await loadRange(prevRangeId * rangeSize, rangeSize);\n                    } catch (error) {\n                      console.error(\n                        `[Collection] Failed to load prerequisite page ${prevPage}:`,\n                        error,\n                      );\n                      return; // Stop trying to load further pages\n                    }\n                  }\n                  break;\n                }\n              }\n\n              if (!canLoad) {\n                continue; // Skip this page for now\n              }\n            }\n\n            try {\n              await loadRange(offset, rangeSize);\n            } catch (error) {\n              console.error(`[Collection] Failed to load page ${page}:`, error);\n              break; // Stop sequential loading on error\n            }\n          }\n        }\n\n        if (endPage > limitedEndPage) {\n          // console.log(\n          //   `[Collection] Stopped at page ${limitedEndPage} to prevent excessive loading (requested up to ${endPage})`,\n          // );\n        }\n\n        return;\n      }\n\n      // Original logic for offset/page strategies\n      // Calculate range boundaries\n      const startRange = Math.floor(range.start / rangeSize);\n      const endRange = Math.floor(range.end / rangeSize);\n\n      // Collect ranges that need loading\n      // We need to check if the VISIBLE indices have data, not just any data in a range\n      const rangesToLoad: number[] = [];\n\n      // Check each visible index to see if it has data\n      const visibleStart = range.start;\n      const visibleEnd = range.end;\n\n      // Find which indices in the visible range are missing data\n      // If totalItems is 0 or we have no items, we need to load (initial load case)\n      let hasMissingData = false;\n\n      if (totalItems === 0 || items.length === 0) {\n        // Initial load - we need to fetch data\n        hasMissingData = true;\n      } else {\n        // Check each visible index for missing data\n        for (let i = visibleStart; i <= visibleEnd && i < totalItems; i++) {\n          if (items[i] === undefined) {\n            hasMissingData = true;\n            break;\n          }\n        }\n      }\n\n      if (hasMissingData) {\n        // Find which ranges need to be loaded\n        for (let rangeId = startRange; rangeId <= endRange; rangeId++) {\n          if (pendingRanges.has(rangeId)) {\n            continue;\n          }\n\n          // If totalItems is 0, we're doing initial load - always load the range\n          if (totalItems === 0) {\n            loadedRanges.delete(rangeId);\n            rangesToLoad.push(rangeId);\n            continue;\n          }\n\n          // Check if this specific range has all its data\n          const rangeStart = rangeId * rangeSize;\n          const rangeEnd = Math.min(rangeStart + rangeSize, totalItems);\n          let rangeMissingData = false;\n\n          for (let i = rangeStart; i < rangeEnd; i++) {\n            // Only check indices that are in the visible range\n            if (\n              i >= visibleStart &&\n              i <= visibleEnd &&\n              items[i] === undefined\n            ) {\n              rangeMissingData = true;\n              break;\n            }\n          }\n\n          if (rangeMissingData) {\n            loadedRanges.delete(rangeId); // Clear stale loaded state\n            rangesToLoad.push(rangeId);\n          }\n        }\n      }\n\n      if (rangesToLoad.length === 0) {\n        // Check if there are queued requests we should process\n        if (\n          loadRequestQueue.length > 0 &&\n          activeLoadCount < maxConcurrentRequests\n        ) {\n          processQueue();\n        }\n        return;\n      }\n\n      // console.log(\n      //   `[Collection] Loading ${rangesToLoad.length} ranges: [${rangesToLoad.join(\", \")}]`,\n      // );\n\n      // Load ranges individually - no merging to avoid loading old ranges\n      const promises = rangesToLoad.map((rangeId) =>\n        loadRange(rangeId * rangeSize, rangeSize),\n      );\n      await Promise.allSettled(promises);\n    };\n\n    /**\n     * Velocity-aware wrapper for loadMissingRanges\n     */\n    const loadMissingRanges = (\n      range: {\n        start: number;\n        end: number;\n      },\n      caller?: string,\n    ): Promise<void> => {\n      return new Promise((resolve, reject) => {\n        const rangeKey = getRangeKey(range);\n\n        // Check if already loading\n        if (activeLoadRanges.has(rangeKey)) {\n          resolve();\n          return;\n        }\n\n        // Skip if dragging with low velocity (but not if we're idle)\n        if (isDragging && currentVelocity < 0.5 && currentVelocity > 0) {\n          cancelledLoads++;\n          resolve();\n          return;\n        }\n\n        // Check velocity - if too high, cancel the request entirely\n        if (!canLoad()) {\n          cancelledLoads++;\n          resolve();\n          return;\n        }\n\n        // Check capacity\n        if (activeLoadCount < maxConcurrentRequests) {\n          // Execute immediately\n          executeQueuedLoad({\n            range,\n            priority: \"normal\",\n            timestamp: Date.now(),\n            resolve,\n            reject,\n            caller,\n          });\n        } else if (\n          enableRequestQueue &&\n          loadRequestQueue.length < maxQueueSize\n        ) {\n          // Queue the request\n          loadRequestQueue.push({\n            range,\n            priority: \"normal\",\n            timestamp: Date.now(),\n            resolve,\n            reject,\n            caller,\n          });\n          // console.log(\n          //   `[LoadingManager] Queued request (at capacity), queue size: ${loadRequestQueue.length}`\n          // );\n        } else {\n          // Queue is full - but don't drop idle/range-changed requests, they're critical!\n          // Instead, clear old queued requests and add the new one\n          if (\n            caller === \"viewport:idle\" ||\n            caller === \"viewport:range-changed\"\n          ) {\n            // Clear old queued requests - they're for ranges user scrolled past\n            loadRequestQueue.forEach((r) => {\n              cancelledLoads++;\n              r.resolve();\n            });\n            loadRequestQueue.length = 0;\n            // Queue this priority request\n            loadRequestQueue.push({\n              range,\n              priority: \"high\",\n              timestamp: Date.now(),\n              resolve,\n              reject,\n              caller,\n            });\n          } else {\n            // Queue overflow - resolve to avoid errors\n            if (loadRequestQueue.length >= maxQueueSize) {\n              const removed = loadRequestQueue.splice(\n                0,\n                loadRequestQueue.length - maxQueueSize,\n              );\n              removed.forEach((r) => {\n                cancelledLoads++;\n                r.resolve();\n              });\n            }\n            resolve();\n          }\n        }\n      });\n    };\n\n    /**\n     * Retry a failed range\n     */\n    const retryFailedRange = async (rangeId: number): Promise<any[]> => {\n      failedRanges.delete(rangeId);\n      const offset = rangeId * rangeSize;\n      return loadRange(offset, rangeSize);\n    };\n\n    /**\n     * Set total items count\n     */\n    const setTotalItems = (total: number): void => {\n      totalItems = total;\n\n      // Update viewport state's total items\n      const viewportState = (component.viewport as any).state;\n      if (viewportState) {\n        viewportState.totalItems = total;\n      }\n\n      component.emit?.(\"viewport:total-items-changed\", { total });\n    };\n\n    // Hook into viewport initialization\n    const originalInitialize = component.viewport.initialize;\n    component.viewport.initialize = () => {\n      const result = originalInitialize();\n      // Skip if already initialized\n      if (result === false) {\n        return false;\n      }\n\n      // Set initial total if provided\n      if (component.totalItems) {\n        totalItems = component.totalItems;\n      }\n\n      // Listen for drag events\n      component.on?.(\"viewport:drag-start\", () => {\n        isDragging = true;\n      });\n\n      component.on?.(\"viewport:drag-end\", () => {\n        isDragging = false;\n        // Process any queued requests after drag ends (safety measure)\n        // This ensures placeholders are replaced even if idle detection fails\n        if (loadOnDragEnd) {\n          processQueue();\n        }\n      });\n\n      // Listen for range changes\n      component.on?.(\"viewport:range-changed\", async (data: any) => {\n        // Extract range from event data - virtual feature emits { range: { start, end }, scrollPosition }\n        const range = data.range || data;\n\n        // Don't load during fast scrolling - loadMissingRanges will handle velocity check\n\n        // Skip if autoLoad is disabled AND we haven't manually loaded yet\n        // This prevents unwanted page 1 loads when using reloadAt()\n        // But allows subsequent loads from scrolling after reloadAt() completes\n        if (!autoLoad && !hasManuallyLoaded) {\n          return;\n        }\n\n        const { start, end } = range;\n\n        // Validate range before loading\n        if (typeof start !== \"number\" || typeof end !== \"number\") {\n          console.warn(\n            \"[Collection] Invalid range in viewport:range-changed event:\",\n            data,\n          );\n          return;\n        }\n\n        // Skip loading page 1 if we have an initialScrollIndex and haven't completed initial load yet\n        // This prevents the requestAnimationFrame in virtual.ts from triggering a page 1 load\n        // after we've already started loading the correct initial page\n        if (hasInitialScrollIndex && !hasCompletedInitialPositionLoad) {\n          const page1EndIndex = rangeSize - 1; // e.g., 29 for rangeSize=30\n          if (start === 0 && end <= page1EndIndex) {\n            // This is a request for page 1, skip it\n            return;\n          }\n        }\n\n        // Skip loading page 1 if a reload is in progress (e.g., reloadAt is loading a specific page)\n        // This prevents stale viewport:range-changed events from loading page 1\n        // while reloadAt is loading a different page\n        if (reloadInProgress && reloadTargetRange) {\n          const page1EndIndex = rangeSize - 1;\n          if (start === 0 && end <= page1EndIndex) {\n            // This is a request for page 1 during a reload targeting a different range\n            // Check if the target range is NOT page 1\n            if (reloadTargetRange.start > page1EndIndex) {\n              return;\n            }\n          }\n        }\n\n        // Load missing ranges if needed - don't await to avoid blocking scroll\n        // The loading happens in the background and UI updates when data arrives\n        loadMissingRanges({ start, end }, \"viewport:range-changed\");\n\n        // Evict distant items to prevent memory bloat\n        evictDistantItems(start, end);\n\n        // For cursor mode, check if we need to update virtual size\n        if (strategy === \"cursor\" && !hasReachedEnd) {\n          // Use cachedItemCount instead of O(n) filter operation\n          const loadedItemsCount = cachedItemCount;\n          const marginItems =\n            rangeSize *\n            VIEWPORT_CONSTANTS.PAGINATION.CURSOR_SCROLL_MARGIN_MULTIPLIER;\n          const minVirtualItems =\n            rangeSize *\n            VIEWPORT_CONSTANTS.PAGINATION.CURSOR_MIN_VIRTUAL_SIZE_MULTIPLIER;\n          const dynamicTotal = Math.max(\n            loadedItemsCount + marginItems,\n            minVirtualItems,\n          );\n\n          if (dynamicTotal !== totalItems) {\n            // console.log(\n            //   `[Collection] Updating cursor virtual size from ${totalItems} to ${dynamicTotal}`,\n            // );\n            setTotalItems(dynamicTotal);\n          }\n        }\n      });\n\n      // Listen for velocity changes\n      component.on?.(\"viewport:velocity-changed\", (data: any) => {\n        const previousVelocity = currentVelocity;\n        currentVelocity = Math.abs(data.velocity || 0);\n\n        // When velocity drops below threshold, process queue\n        if (\n          previousVelocity > cancelLoadThreshold &&\n          currentVelocity <= cancelLoadThreshold\n        ) {\n          processQueue();\n        }\n      });\n\n      // Listen for idle state to process queue\n      component.on?.(\"viewport:idle\", async (data: any) => {\n        currentVelocity = 0;\n\n        // Reset dragging state on idle since user has stopped moving\n        if (isDragging) {\n          isDragging = false;\n        }\n\n        // Get current visible range from viewport\n        const viewportState = (component.viewport as any).state;\n        const visibleRange = viewportState?.visibleRange;\n\n        if (visibleRange) {\n          // Clear stale requests from queue that are far from current visible range\n          const buffer = rangeSize * 2; // Allow some buffer\n          loadRequestQueue = loadRequestQueue.filter((request) => {\n            const requestEnd = request.range.end;\n            const requestStart = request.range.start;\n            const isRelevant =\n              requestEnd >= visibleRange.start - buffer &&\n              requestStart <= visibleRange.end + buffer;\n\n            if (!isRelevant) {\n              request.resolve(); // Resolve to avoid hanging promises\n            }\n            return isRelevant;\n          });\n\n          // Load the current visible range if needed\n          await loadMissingRanges(visibleRange, \"viewport:idle\");\n        }\n\n        // Also process any queued requests\n        processQueue();\n      });\n\n      // Listen for item removal - DON'T clear loadedRanges to prevent unnecessary reload\n      // The data is already shifted locally in api.ts and rendering.ts\n      // Reloading would cause race conditions and overwrite the correct totalItems\n      component.on?.(\"item:removed\", (data: any) => {\n        // console.log(`[Collection] item:removed event - index: ${data.index}`);\n        // console.log(`[Collection] items.length: ${items.length}`);\n\n        // Update discoveredTotal to match the new count\n        // This prevents stale discoveredTotal from being used on next load\n        if (discoveredTotal !== null && discoveredTotal > 0) {\n          discoveredTotal = discoveredTotal - 1;\n          // console.log(\n          //   `[Collection] Updated discoveredTotal to: ${discoveredTotal}`,\n          // );\n        }\n\n        // NOTE: Do NOT decrement totalItems here!\n        // api.ts already calls setTotalItems() after emitting item:remove-request,\n        // which properly updates totalItems. Decrementing here would cause a double-decrement.\n\n        // DON'T clear loadedRanges - we want to keep using the local data\n        // The data has been shifted locally and is still valid\n        // Clearing would trigger a reload which causes race conditions\n        // console.log(\n        //   `[Collection] Keeping loadedRanges intact:`,\n        //   Array.from(loadedRanges),\n        // );\n      });\n\n      // Load initial data if collection is available and autoLoad is enabled\n      if (collection && autoLoad) {\n        // If we have an initial scroll index OR a selectId, load data for that position directly\n        // Don't use scrollToIndex() as it triggers animation/velocity tracking\n        // virtual.ts has already set the scroll position and calculated the visible range\n        if (\n          initialScrollIndex > 0 ||\n          (selectId !== undefined && selectId !== null)\n        ) {\n          // Get the visible range that was already calculated by virtual.ts\n          // We missed the initial viewport:range-changed event because our listener wasn't ready yet\n          const visibleRange = component.viewport?.getVisibleRange?.();\n\n          if (\n            visibleRange &&\n            (visibleRange.start > 0 || visibleRange.end > 0)\n          ) {\n            // Use the pre-calculated visible range from virtual.ts\n            loadMissingRanges(visibleRange, \"initial-position\")\n              .then(() => {\n                hasCompletedInitialPositionLoad = true;\n                // Emit event to select item after initial load if selectId is provided\n                if (selectId !== undefined) {\n                  component.emit?.(\"collection:initial-load-complete\", {\n                    selectId,\n                    initialScrollIndex,\n                  });\n                }\n              })\n              .catch((error) => {\n                console.error(\n                  \"[Collection] Failed to load initial position data:\",\n                  error,\n                );\n                hasCompletedInitialPositionLoad = true; // Allow normal loading even on error\n              });\n          } else {\n            // Fallback: calculate range from initialScrollIndex\n            // This handles edge cases where visibleRange wasn't ready\n            const overscan = 2;\n            const estimatedVisibleCount = Math.ceil(600 / 50); // ~12 items\n            const start = Math.max(0, initialScrollIndex - overscan);\n            const end = initialScrollIndex + estimatedVisibleCount + overscan;\n\n            loadMissingRanges({ start, end }, \"initial-position-fallback\")\n              .then(() => {\n                hasCompletedInitialPositionLoad = true;\n                // Emit event to select item after initial load if selectId is provided\n                if (selectId !== undefined) {\n                  component.emit?.(\"collection:initial-load-complete\", {\n                    selectId,\n                    initialScrollIndex,\n                  });\n                }\n              })\n              .catch((error) => {\n                console.error(\n                  \"[Collection] Failed to load initial position data (fallback):\",\n                  error,\n                );\n                hasCompletedInitialPositionLoad = true; // Allow normal loading even on error\n              });\n          }\n          return;\n        }\n\n        // No initial scroll index - load from beginning as normal\n        loadRange(0, rangeSize, \"initialize-page1\")\n          .then(() => {\n            // Handle autoSelectFirst - get first item ID and emit selection event\n            if (autoSelectFirst && items.length > 0) {\n              const firstItem = items[0];\n              const firstId = firstItem?._id || firstItem?.id;\n              if (firstId !== undefined) {\n                component.emit?.(\"collection:initial-load-complete\", {\n                  selectId: firstId,\n                  initialScrollIndex: 0,\n                });\n              }\n            }\n          })\n          .catch((error) => {\n            console.error(\"[Collection] Failed to load initial data:\", error);\n          });\n      }\n\n      return result;\n    };\n\n    /**\n     * Reset collection state without destroying the component\n     * Clears all loaded data and prepares for fresh load\n     */\n    const reset = () => {\n      logMemoryStats(\"reset:before\");\n\n      // Abort all in-flight requests\n      abortControllers.forEach((controller) => {\n        try {\n          controller.abort();\n        } catch (e) {\n          // Ignore abort errors\n        }\n      });\n      abortControllers.clear();\n\n      // Clear all data structures\n      items.length = 0;\n      loadRequestQueue.length = 0;\n      loadedRanges.clear();\n      pendingRanges.clear();\n      failedRanges.clear();\n      activeLoadRanges.clear();\n      activeRequests.clear();\n      cursorMap.clear();\n      pageToOffsetMap.clear();\n\n      // Reset state\n      totalItems = 0;\n      currentCursor = null;\n      highestLoadedPage = 0;\n      discoveredTotal = null;\n      hasReachedEnd = false;\n      hasCompletedInitialPositionLoad = false;\n      hasManuallyLoaded = false;\n\n      // Reset cached item count\n      cachedItemCount = 0;\n\n      // Reset counters\n      activeLoadCount = 0;\n      completedLoads = 0;\n      failedLoads = 0;\n      cancelledLoads = 0;\n\n      // Update component reference\n      component.items = items;\n      component.totalItems = 0;\n\n      logMemoryStats(\"reset:after\");\n\n      // Emit reset event\n      component.emit?.(\"collection:reset\");\n    };\n\n    /**\n     * Clear the request queue - used by reloadAt to prevent stale queued requests\n     */\n    const clearQueue = () => {\n      // Resolve all pending promises to avoid hanging\n      loadRequestQueue.forEach((request) => {\n        request.resolve();\n      });\n      loadRequestQueue.length = 0;\n    };\n\n    /**\n     * Mark that data has been manually loaded (e.g., via reloadAt)\n     * This enables subsequent loads from viewport:range-changed\n     */\n    const setManuallyLoaded = () => {\n      hasManuallyLoaded = true;\n    };\n\n    /**\n     * Set reload in progress flag with target range\n     * Used by reloadAt to prevent viewport:range-changed from loading page 1\n     */\n    const setReloadInProgress = (\n      inProgress: boolean,\n      targetRange?: { start: number; end: number },\n    ) => {\n      reloadInProgress = inProgress;\n      reloadTargetRange = targetRange || null;\n    };\n\n    // Add collection API to viewport\n    component.viewport.collection = {\n      loadRange: (offset: number, limit: number) => loadRange(offset, limit),\n      loadMissingRanges: (\n        range: { start: number; end: number },\n        caller?: string,\n      ) => loadMissingRanges(range, caller || \"viewport.collection\"),\n      getLoadedRanges: () => loadedRanges,\n      getPendingRanges: () => pendingRanges,\n      clearFailedRanges: () => failedRanges.clear(),\n      clearQueue,\n      setManuallyLoaded,\n      setReloadInProgress,\n      retryFailedRange,\n      setTotalItems,\n      getTotalItems: () => totalItems,\n      // Cursor-specific methods\n      getCurrentCursor: () => currentCursor,\n      getCursorForPage: (page: number) => cursorMap.get(page) || null,\n      // Reset method for reload functionality\n      reset,\n    };\n\n    // Add collection data access with direct assignment\n    (component as any).collection = {\n      items,\n      getItems: () => items,\n      getItem: (index: number) => items[index],\n      loadRange,\n      loadMissingRanges: (\n        range: { start: number; end: number },\n        caller?: string,\n      ) => loadMissingRanges(range, caller || \"component.collection\"),\n      getLoadingStats: () => ({\n        pendingRequests: activeLoadCount,\n        completedRequests: completedLoads,\n        failedRequests: failedLoads,\n        cancelledRequests: cancelledLoads,\n        currentVelocity,\n        canLoad: canLoad(),\n        queuedRequests: loadRequestQueue.length,\n      }),\n      // Total items management\n      getTotalItems: () => totalItems,\n      setTotalItems,\n      // Cursor methods\n      getCurrentCursor: () => currentCursor,\n      getCursorForPage: (page: number) => cursorMap.get(page) || null,\n      // Reset method for reload functionality\n      reset,\n    };\n\n    // Also ensure component.items is updated\n    component.items = items;\n\n    // Cleanup function - comprehensive memory cleanup\n    const destroy = () => {\n      logMemoryStats(\"destroy:before\");\n\n      // Abort all in-flight requests\n      abortControllers.forEach((controller) => {\n        try {\n          controller.abort();\n        } catch (e) {\n          // Ignore abort errors\n        }\n      });\n      abortControllers.clear();\n\n      // Clear all data structures\n      items.length = 0;\n      loadRequestQueue.length = 0;\n      loadedRanges.clear();\n      pendingRanges.clear();\n      failedRanges.clear();\n      activeLoadRanges.clear();\n      activeRequests.clear();\n      cursorMap.clear();\n      pageToOffsetMap.clear();\n\n      // Reset state\n      totalItems = 0;\n      currentCursor = null;\n      highestLoadedPage = 0;\n      discoveredTotal = null;\n      hasReachedEnd = false;\n\n      // Clear component reference\n      if (component.items === items) {\n        component.items = [];\n      }\n\n      logMemoryStats(\"destroy:after\");\n    };\n\n    // Wire destroy into the component's destroy chain\n    wrapDestroy(component, destroy);\n\n    // Return enhanced component\n    return {\n      ...component,\n      collection: {\n        // Data access methods\n        items,\n        getItems: () => items,\n        getItem: (index: number) => items[index],\n        // Loading methods\n        loadRange,\n        loadMissingRanges: (\n          range: { start: number; end: number },\n          caller?: string,\n        ) => loadMissingRanges(range, caller || \"return.collection\"),\n        getLoadedRanges: () => loadedRanges,\n        getPendingRanges: () => pendingRanges,\n        clearFailedRanges: () => failedRanges.clear(),\n        clearQueue,\n        setManuallyLoaded,\n        setReloadInProgress,\n        retryFailedRange,\n        setTotalItems,\n        getTotalItems: () => totalItems,\n        // Cursor-specific methods\n        getCurrentCursor: () => currentCursor,\n        getCursorForPage: (page: number) => cursorMap.get(page) || null,\n        // Reset method for reload functionality\n        reset,\n      },\n    };\n  };\n}\n",
    "// src/core/viewport/features/placeholders.ts\n\n/**\n * Placeholder Feature - Smart placeholder generation\n * Analyzes first loaded data to generate realistic masked placeholders\n * Shows placeholders while data is loading\n */\n\nimport type { ViewportContext } from \"../types\";\nimport type { CollectionComponent } from \"./collection\";\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\n\n/**\n * Configuration for placeholder feature\n */\nexport interface PlaceholderConfig {\n  enabled?: boolean;\n  analyzeFirstLoad?: boolean;\n  maskCharacter?: string;\n  randomLengthVariance?: boolean;\n}\n\n/**\n * Field structure for placeholder generation\n */\ninterface FieldStructure {\n  minLength: number;\n  maxLength: number;\n  avgLength: number;\n}\n\nexport interface PlaceholderComponent {\n  placeholders: {\n    analyzeDataStructure: (items: any[]) => void;\n    hasAnalyzedStructure: () => boolean;\n    generatePlaceholderItem: (index: number) => any;\n    generatePlaceholderItems: (range: { start: number; end: number }) => any[];\n    showPlaceholders: (range: { start: number; end: number }) => void;\n    isPlaceholder: (item: any) => boolean;\n    replacePlaceholders: (items: any[], offset: number) => void;\n    clear: () => void;\n  };\n}\n\n/**\n * Adds placeholder functionality to viewport component\n */\nexport function withPlaceholders(config: PlaceholderConfig = {}) {\n  return <T extends ViewportContext & CollectionComponent>(\n    component: T\n  ): T & PlaceholderComponent => {\n    const {\n      enabled = true,\n      analyzeFirstLoad = true,\n      maskCharacter = VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER,\n      randomLengthVariance = VIEWPORT_CONSTANTS.PLACEHOLDER\n        .RANDOM_LENGTH_VARIANCE,\n    } = config;\n\n    // State\n    let fieldStructures: Map<string, FieldStructure> | null = null;\n    let hasAnalyzed = false;\n    let placeholderIdCounter = 0;\n\n    /**\n     * Analyze data structure from first loaded items\n     */\n    const analyzeDataStructure = (items: any[]): void => {\n      if (!enabled || hasAnalyzed || !items.length) {\n        return;\n      }\n\n      // console.log(\n      //   `🔍 [PLACEHOLDERS] Analyzing data structure from ${items.length} items`\n      // );\n\n      const structures = new Map<string, FieldStructure>();\n      const sampleSize = Math.min(\n        items.length,\n        VIEWPORT_CONSTANTS.PLACEHOLDER.MAX_SAMPLE_SIZE\n      );\n\n      // Analyze each field across all sample items\n      const fieldStats = new Map<string, number[]>();\n\n      for (let i = 0; i < sampleSize; i++) {\n        const item = items[i];\n        if (!item || typeof item !== \"object\") continue;\n\n        Object.keys(item).forEach((field) => {\n          // Skip internal fields\n          if (\n            field.startsWith(\"_\") ||\n            field === VIEWPORT_CONSTANTS.PLACEHOLDER.PLACEHOLDER_FLAG\n          ) {\n            return;\n          }\n\n          const value = String(item[field] || \"\");\n          const length = value.length;\n\n          if (!fieldStats.has(field)) {\n            fieldStats.set(field, []);\n          }\n          fieldStats.get(field)!.push(length);\n        });\n      }\n\n      // Calculate statistics for each field\n      fieldStats.forEach((lengths, field) => {\n        if (lengths.length === 0) return;\n\n        const minLength = Math.min(...lengths);\n        const maxLength = Math.max(...lengths);\n        const avgLength = Math.round(\n          lengths.reduce((sum, len) => sum + len, 0) / lengths.length\n        );\n\n        structures.set(field, {\n          minLength,\n          maxLength,\n          avgLength,\n        });\n      });\n\n      fieldStructures = structures;\n      hasAnalyzed = true;\n\n      // console.log(\n      //   `✅ [PLACEHOLDERS] Structure analyzed:`,\n      //   Object.fromEntries(structures)\n      // );\n\n      // Emit event\n      component.emit?.(\"viewport:placeholders-structure-analyzed\", {\n        structure: Object.fromEntries(structures),\n      });\n    };\n\n    /**\n     * Generate a single placeholder item\n     */\n    const generatePlaceholderItem = (index: number): any => {\n      const placeholder: Record<string, any> = {\n        id: `placeholder-${placeholderIdCounter++}`,\n        [VIEWPORT_CONSTANTS.PLACEHOLDER.PLACEHOLDER_FLAG]: true,\n        _index: index,\n      };\n\n      if (!fieldStructures || fieldStructures.size === 0) {\n        // No structure analyzed yet - return basic placeholder\n        placeholder.label = maskCharacter.repeat(10);\n        return placeholder;\n      }\n\n      // Generate fields based on analyzed structure\n      fieldStructures.forEach((structure, field) => {\n        let length: number;\n\n        if (\n          randomLengthVariance &&\n          structure.minLength !== structure.maxLength\n        ) {\n          // Random length within range\n          length = Math.floor(\n            Math.random() * (structure.maxLength - structure.minLength + 1) +\n              structure.minLength\n          );\n        } else {\n          // Use average length\n          length = structure.avgLength;\n        }\n\n        // Apply some variation to make it look more natural\n        if (randomLengthVariance && Math.random() < 0.3) {\n          length = Math.max(1, length + Math.floor(Math.random() * 3) - 1);\n        }\n\n        placeholder[field] = maskCharacter.repeat(length);\n      });\n\n      return placeholder;\n    };\n\n    /**\n     * Generate multiple placeholder items\n     */\n    const generatePlaceholderItems = (range: {\n      start: number;\n      end: number;\n    }): any[] => {\n      const items: any[] = [];\n      for (let i = range.start; i <= range.end; i++) {\n        items.push(generatePlaceholderItem(i));\n      }\n      return items;\n    };\n\n    /**\n     * Show placeholders for a range\n     */\n    const showPlaceholders = (range: { start: number; end: number }): void => {\n      if (!enabled) return;\n\n      const placeholders = generatePlaceholderItems(range);\n\n      // Update items array\n      if (component.items) {\n        for (let i = 0; i < placeholders.length; i++) {\n          const index = range.start + i;\n          if (!component.items[index]) {\n            component.items[index] = placeholders[i];\n          }\n        }\n      }\n\n      console.log(\n        `🔄 [PLACEHOLDERS] Showing ${placeholders.length} placeholders for range ${range.start}-${range.end}`\n      );\n\n      // Emit event\n      component.emit?.(\"viewport:placeholders-shown\", {\n        range,\n        count: placeholders.length,\n      });\n    };\n\n    /**\n     * Check if an item is a placeholder\n     */\n    const isPlaceholder = (item: any): boolean => {\n      return (\n        item &&\n        typeof item === \"object\" &&\n        item[VIEWPORT_CONSTANTS.PLACEHOLDER.PLACEHOLDER_FLAG] === true\n      );\n    };\n\n    /**\n     * Replace placeholders with real data\n     */\n    const replacePlaceholders = (items: any[], offset: number): void => {\n      if (!component.items) return;\n\n      let replacedCount = 0;\n\n      for (let i = 0; i < items.length; i++) {\n        const index = offset + i;\n        const currentItem = component.items[index];\n\n        if (isPlaceholder(currentItem)) {\n          component.items[index] = items[i];\n          replacedCount++;\n        }\n      }\n\n      if (replacedCount > 0) {\n        console.log(\n          `✨ [PLACEHOLDERS] Replaced ${replacedCount} placeholders at offset ${offset}`\n        );\n\n        // Emit event\n        component.emit?.(\"viewport:placeholders-replaced\", {\n          offset,\n          count: replacedCount,\n        });\n      }\n    };\n\n    /**\n     * Clear all placeholder state\n     */\n    const clear = (): void => {\n      fieldStructures = null;\n      hasAnalyzed = false;\n      placeholderIdCounter = 0;\n    };\n\n    // Initialize function\n    const initialize = () => {\n      if (!enabled) return;\n\n      // Listen for first data load to analyze structure\n      if (analyzeFirstLoad) {\n        const handleRangeLoaded = (data: any) => {\n          if (!hasAnalyzed && data.items && data.items.length > 0) {\n            analyzeDataStructure(data.items);\n          }\n\n          // Replace any placeholders with real data\n          replacePlaceholders(data.items, data.offset);\n        };\n\n        component.on?.(\"viewport:range-loaded\", handleRangeLoaded);\n      }\n\n      // Show initial placeholders if configured\n      const totalItems = component.collection?.getTotalItems() || 0;\n      if (totalItems > 0) {\n        const initialRange = {\n          start: 0,\n          end: Math.min(\n            VIEWPORT_CONSTANTS.PLACEHOLDER.MAX_SAMPLE_SIZE - 1,\n            totalItems - 1\n          ),\n        };\n        showPlaceholders(initialRange);\n      }\n    };\n\n    // Cleanup function\n    const destroy = () => {\n      clear();\n    };\n\n    // Store functions for viewport to call\n    (component as any)._placeholdersInitialize = initialize;\n    (component as any)._placeholdersDestroy = destroy;\n\n    // Return enhanced component\n    return {\n      ...component,\n      placeholders: {\n        analyzeDataStructure,\n        hasAnalyzedStructure: () => hasAnalyzed,\n        generatePlaceholderItem,\n        generatePlaceholderItems,\n        showPlaceholders,\n        isPlaceholder,\n        replacePlaceholders,\n        clear,\n      },\n    };\n  };\n}\n",
    "/**\n * Rendering Feature - Item rendering and positioning for viewport\n * Handles DOM element creation, positioning, recycling, and updates\n */\n\nimport { addClass, removeClass, hasClass } from \"mtrl\";\nimport type { ViewportContext, ViewportComponent } from \"../types\";\nimport { VIEWPORT_CONSTANTS } from \"../constants\";\nimport {\n  isPlaceholder,\n  getViewportState,\n  wrapInitialize,\n  wrapDestroy,\n} from \"./utils\";\nimport { createLayout } from \"../../layout\";\n\nexport interface RenderingConfig {\n  template?: (\n    item: any,\n    index: number,\n  ) => string | HTMLElement | any[] | Record<string, any>;\n  overscan?: number;\n  measureItems?: boolean;\n  enableRecycling?: boolean;\n  maxPoolSize?: number;\n  /**\n   * Maintain DOM order to match visual index order.\n   * Enables CSS selectors like :first-child, :nth-child() to work correctly.\n   * Default: true\n   */\n  maintainDomOrder?: boolean;\n}\n\ninterface ViewportState {\n  scrollPosition: number;\n  totalItems: number;\n  itemSize: number;\n  containerSize: number;\n  virtualTotalSize: number;\n  visibleRange: { start: number; end: number };\n  itemsContainer: HTMLElement | null;\n}\n\n/**\n * Rendering feature for viewport\n */\nexport const withRendering = (config: RenderingConfig = {}) => {\n  return <T extends ViewportContext & ViewportComponent>(component: T): T => {\n    const {\n      template,\n      overscan = 5,\n      measureItems = false,\n      enableRecycling = true,\n      maxPoolSize = VIEWPORT_CONSTANTS.RENDERING.DEFAULT_MAX_POOL_SIZE,\n      maintainDomOrder = true,\n    } = config;\n\n    // Helper to get items from collection (single source of truth)\n    const getCollectionItems = (): any[] => {\n      return (\n        (component as any).collection?.items || (component as any).items || []\n      );\n    };\n\n    // State\n    const renderedElements = new Map<number, HTMLElement>();\n    const elementPool: HTMLElement[] = [];\n    const poolStats = { created: 0, recycled: 0, poolSize: 0, released: 0 };\n\n    // Store layout results for proper cleanup (prevents memory leak)\n    const layoutResults = new WeakMap<HTMLElement, { destroy: () => void }>();\n\n    // Reusable template element for HTML string parsing (more efficient than div)\n    const templateParser = document.createElement(\"template\");\n\n    let viewportState: ViewportState | null = null;\n    let currentVisibleRange = { start: 0, end: 0 };\n    let lastRenderTime = 0;\n    let isRemovingItem = false;\n\n    // Element pool management\n    const getPooledElement = (): HTMLElement => {\n      if (enableRecycling && elementPool.length > 0) {\n        poolStats.recycled++;\n        return elementPool.pop()!;\n      }\n      const element = document.createElement(\"div\");\n      element.className = \"mtrl-viewport-item\";\n      poolStats.created++;\n      return element;\n    };\n\n    const releaseElement = (element: HTMLElement): void => {\n      poolStats.released++;\n\n      // CRITICAL: Call destroy on layoutResult to clean up components and event listeners\n      // This fixes the memory leak when using layout templates\n      const layoutResult = layoutResults.get(element);\n      if (layoutResult && typeof layoutResult.destroy === \"function\") {\n        try {\n          layoutResult.destroy();\n        } catch (e) {\n          // Ignore destroy errors - element may already be cleaned up\n        }\n        layoutResults.delete(element);\n      }\n\n      if (!enableRecycling) {\n        element.remove();\n        return;\n      }\n      // Clean element for reuse (no cloning - reuse the actual element)\n      element.className = \"mtrl-viewport-item\";\n      element.removeAttribute(\"data-index\");\n      element.style.cssText = \"\";\n      element.innerHTML = \"\";\n\n      // Remove from DOM first\n      if (element.parentNode) {\n        element.parentNode.removeChild(element);\n      }\n\n      // Add to pool if not full\n      if (elementPool.length < maxPoolSize) {\n        elementPool.push(element);\n        poolStats.poolSize = elementPool.length;\n      }\n      // If pool is full, element is just dereferenced and GC'd\n    };\n\n    // Initialize\n    wrapInitialize(component, () => {\n      viewportState = getViewportState(component) as ViewportState;\n\n      // Set initial items container height from current virtual size\n      if (viewportState?.itemsContainer && viewportState.virtualTotalSize > 0) {\n        viewportState.itemsContainer.style.height = `${viewportState.virtualTotalSize}px`;\n      }\n\n      // Listen for item update requests from API\n      component.on?.(\"item:update-request\", (data: any) => {\n        const { index, item, previousItem } = data;\n\n        // Item is already updated in collection.items by api.ts\n\n        // Check if this item is currently rendered\n        const existingElement = renderedElements.get(index);\n        const wasVisible = !!existingElement;\n\n        // Check if item was selected before update\n        const wasSelected = existingElement\n          ? hasClass(\n              existingElement,\n              VIEWPORT_CONSTANTS.SELECTION.SELECTED_CLASS,\n            ) || hasClass(existingElement, \"mtrl-viewport-item--selected\")\n          : false;\n\n        if (existingElement && existingElement.parentNode) {\n          // Re-render the item\n          const newElement = renderItem(item, index);\n\n          if (newElement) {\n            // Copy position styles from existing element\n            Object.assign(newElement.style, {\n              position: existingElement.style.position,\n              transform: existingElement.style.transform,\n              width: existingElement.style.width,\n            });\n\n            // Preserve selected state\n            if (wasSelected) {\n              addClass(newElement, VIEWPORT_CONSTANTS.SELECTION.SELECTED_CLASS);\n              addClass(newElement, \"mtrl-viewport-item--selected\");\n            }\n\n            // Add update animation class to inner content for visibility\n            addClass(newElement, \"viewport-item--updated\");\n            // Also try to add to first child if it exists (the actual item content)\n            const innerItem = newElement.firstElementChild as HTMLElement;\n            if (innerItem) {\n              addClass(innerItem, \"item--updated\");\n            }\n\n            // Replace in DOM\n            existingElement.parentNode.replaceChild(\n              newElement,\n              existingElement,\n            );\n            renderedElements.set(index, newElement);\n            releaseElement(existingElement);\n\n            // Remove the animation class after transition\n            setTimeout(() => {\n              removeClass(newElement, \"viewport-item--updated\");\n              if (innerItem) {\n                removeClass(innerItem, \"item--updated\");\n              }\n            }, 500);\n          }\n        }\n\n        // Emit completion event\n        component.emit?.(\"item:updated\", {\n          item,\n          index,\n          previousItem,\n          wasVisible,\n          wasSelected,\n        });\n      });\n\n      // Listen for item remove requests from API\n      component.on?.(\"item:remove-request\", (data: any) => {\n        const { index, item } = data;\n        isRemovingItem = true;\n\n        // Item is already removed from collection.items by api.ts\n        // We just need to update rendered elements\n\n        // Remove the rendered element at this index\n        const existingElement = renderedElements.get(index);\n        if (existingElement && existingElement.parentNode) {\n          releaseElement(existingElement);\n        }\n        renderedElements.delete(index);\n\n        // Shift rendered elements indices down\n        const renderedKeys = Array.from(renderedElements.keys()).sort(\n          (a, b) => a - b,\n        );\n        const newRenderedElements = new Map<number, HTMLElement>();\n        for (const key of renderedKeys) {\n          if (key > index) {\n            const element = renderedElements.get(key);\n            if (element) {\n              // Update data-index attribute\n              element.dataset.index = String(key - 1);\n              newRenderedElements.set(key - 1, element);\n            }\n          } else if (key < index) {\n            const element = renderedElements.get(key);\n            if (element) {\n              newRenderedElements.set(key, element);\n            }\n          }\n        }\n        renderedElements.clear();\n        for (const [key, element] of newRenderedElements) {\n          renderedElements.set(key, element);\n        }\n\n        // Decrement totalItems NOW so renderItems() uses the correct count\n        // setTotalItems() will be called later by the API, which will emit\n        // viewport:total-items-changed for virtual size recalculation\n        if (viewportState && viewportState.totalItems > 0) {\n          viewportState.totalItems--;\n        }\n\n        // Reset visible range to force re-render\n        currentVisibleRange = { start: -1, end: -1 };\n\n        // Emit completion event\n        component.emit?.(\"item:removed\", {\n          item,\n          index,\n        });\n\n        // NOTE: Do NOT clear loadedRanges or call loadMissingRanges here!\n        // The items array has been spliced in-place by api.ts, so the data is\n        // already in memory. When the user scrolls and the visible range changes,\n        // the normal viewport:range-changed handler will fetch missing data if needed.\n        // Clearing loadedRanges here would trigger an unnecessary fetch on every removal.\n\n        // Trigger re-render (uses data already in memory)\n        renderItems();\n        isRemovingItem = false;\n      });\n\n      // Listen for items add requests from API\n      component.on?.(\"items:add-request\", (data: any) => {\n        const { items: newItems, position, previousCount } = data;\n\n        if (!newItems || newItems.length === 0) return;\n\n        // Items are already added to collection.items by api.ts\n        // We just need to update rendered elements indices if prepending\n\n        const itemsAdded = newItems.length;\n\n        if (position === \"start\") {\n          // Items were prepended - shift rendered element indices\n          const renderedKeys = Array.from(renderedElements.keys()).sort(\n            (a, b) => b - a,\n          );\n          const newRenderedElements = new Map<number, HTMLElement>();\n          for (const key of renderedKeys) {\n            const element = renderedElements.get(key)!;\n            const newIndex = key + itemsAdded;\n            element.setAttribute(\"data-index\", String(newIndex));\n            newRenderedElements.set(newIndex, element);\n          }\n          renderedElements.clear();\n          newRenderedElements.forEach((el, idx) =>\n            renderedElements.set(idx, el),\n          );\n        }\n        // For append, no index shifting needed\n\n        // Update totalItems in viewportState\n        if (viewportState) {\n          viewportState.totalItems =\n            (viewportState.totalItems || 0) + itemsAdded;\n        }\n\n        // Reset visible range to force re-render\n        currentVisibleRange = { start: -1, end: -1 };\n\n        // Clear loadedRanges to ensure proper reload tracking\n        const collection = (component.viewport as any)?.collection;\n        if (collection?.getLoadedRanges) {\n          const loadedRanges = collection.getLoadedRanges();\n          loadedRanges.clear();\n        }\n\n        // Trigger re-render\n        renderItems();\n\n        // Emit completion event\n        component.emit?.(\"items:render-complete\", {\n          items: newItems,\n          position,\n          total: viewportState?.totalItems || 0,\n        });\n      });\n\n      // Listen for collection items evicted - clean up rendered elements\n      component.on?.(\"collection:items-evicted\", (data: any) => {\n        const { keepStart, keepEnd } = data;\n\n        // Release rendered elements outside the keep range\n        renderedElements.forEach((element, index) => {\n          if (index < keepStart || index > keepEnd) {\n            releaseElement(element);\n            renderedElements.delete(index);\n          }\n        });\n      });\n\n      // Listen for reload:start to reset feature-specific state\n      component.on?.(\"reload:start\", () => {\n        // Reset visible range tracking\n        currentVisibleRange = { start: -1, end: -1 };\n        lastRenderTime = 0;\n        isRemovingItem = false;\n\n        // Clear element pool to free memory\n        elementPool.length = 0;\n        poolStats.poolSize = 0;\n      });\n\n      // Listen for collection reset to clear rendering state\n      component.on?.(\"collection:reset\", () => {\n        // Release and clear all rendered elements\n        renderedElements.forEach((element) => {\n          releaseElement(element);\n        });\n        renderedElements.clear();\n\n        // Reset visible range tracking\n        currentVisibleRange = { start: -1, end: -1 };\n      });\n\n      // Listen for pool clear request (on reload)\n      component.on?.(\"viewport:clear-pool\", () => {\n        // Clear element pool to free memory\n        elementPool.length = 0;\n        poolStats.poolSize = 0;\n\n        // Reset last render time to avoid stale calculations\n        lastRenderTime = 0;\n      });\n\n      // Listen for collection data loaded\n      component.on?.(\"collection:range-loaded\", (data: any) => {\n        if (!data.items?.length) return;\n\n        // Analyze data structure on first load\n        const placeholders = (component as any).placeholders;\n        if (placeholders && !placeholders.hasAnalyzedStructure()) {\n          placeholders.analyzeDataStructure(data.items);\n        }\n\n        // Items are already in collection.items - replace any placeholder DOM elements\n        data.items.forEach((item: any, i: number) => {\n          const index = data.offset + i;\n          const element = renderedElements.get(index);\n\n          // Check if current rendered element is a placeholder that needs replacing\n          // Note: The actual class has 'mtrl-' prefix, so check for both\n          const isPlaceholderElement =\n            element?.classList.contains(VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS) ||\n            element?.classList.contains(\n              `mtrl-${VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS}`,\n            );\n          if (isPlaceholderElement) {\n            const newElement = renderItem(item, index);\n            if (newElement) {\n              // Remove placeholder classes from wrapper\n              removeClass(newElement, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);\n              // Also remove from inner element (for string templates)\n              if (newElement.firstElementChild) {\n                removeClass(\n                  newElement.firstElementChild as HTMLElement,\n                  VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS,\n                );\n              }\n\n              // Add replaced class for fade-in animation\n              addClass(newElement, \"viewport-item--replaced\");\n\n              // Copy position and replace\n              if (element) {\n                Object.assign(newElement.style, {\n                  position: element.style.position,\n                  transform: element.style.transform,\n                  width: element.style.width,\n                });\n                element.parentNode?.replaceChild(newElement, element);\n              }\n              renderedElements.set(index, newElement);\n              if (element) {\n                releaseElement(element);\n              }\n\n              // Remove the replaced class after animation completes\n              setTimeout(() => {\n                removeClass(newElement, \"viewport-item--replaced\");\n              }, 300);\n            } else {\n              // renderItem returned null - still release the old element\n              if (element) {\n                releaseElement(element);\n              }\n              renderedElements.delete(index);\n            }\n          }\n        });\n\n        // Check if we need to render new items (items that weren't rendered at all)\n        const { visibleRange } = viewportState || {};\n        if (visibleRange) {\n          const renderStart = Math.max(0, visibleRange.start - overscan);\n          const renderEnd = Math.min(\n            viewportState?.totalItems ?? 0 - 1,\n            visibleRange.end + overscan,\n          );\n          const loadedStart = data.offset;\n          const loadedEnd = data.offset + data.items.length - 1;\n\n          // Check if loaded data overlaps with render range and we're missing rendered elements\n          const needsRender =\n            loadedStart <= renderEnd &&\n            loadedEnd >= renderStart &&\n            renderedElements.size < renderEnd - renderStart + 1;\n\n          if (needsRender) renderItems();\n        }\n      });\n\n      // Listen for events\n      component.on?.(\"viewport:range-changed\", renderItems);\n      component.on?.(\"viewport:scroll\", updateItemPositions);\n\n      // Update items container height when virtual size changes\n      component.on?.(\"viewport:virtual-size-changed\", (data: any) => {\n        if (\n          viewportState?.itemsContainer &&\n          data.totalVirtualSize !== undefined\n        ) {\n          viewportState.itemsContainer.style.height = `${data.totalVirtualSize}px`;\n        }\n      });\n    });\n\n    // Template helpers\n    const getDefaultTemplate = () => (item: any, index: number) => {\n      // Use layout system for default template\n      return [\n        {\n          tag: \"div\",\n          class: \"viewport-item\",\n          text:\n            typeof item === \"object\"\n              ? item.name || item.label || item.text || `Item ${index}`\n              : String(item),\n        },\n      ];\n    };\n\n    // Process layout schema with item data substitution\n    const processLayoutSchema = (\n      schema: any,\n      item: any,\n      index: number,\n    ): any => {\n      if (typeof schema === \"string\") {\n        // Handle variable substitution like {{name}}, {{index}}\n        return schema.replace(/\\{\\{([^}]+)\\}\\}/g, (match, key) => {\n          if (key === \"index\") return String(index);\n          if (key === \"item\") return String(item);\n\n          // Handle nested properties like {{user.name}}\n          const value = key.split(\".\").reduce((obj: any, prop: string) => {\n            return obj?.[prop.trim()];\n          }, item);\n\n          return value !== undefined ? String(value) : match;\n        });\n      }\n\n      if (Array.isArray(schema)) {\n        return schema.map((child) => processLayoutSchema(child, item, index));\n      }\n\n      if (typeof schema === \"object\" && schema !== null) {\n        const processed: any = {};\n        for (const [key, value] of Object.entries(schema)) {\n          processed[key] = processLayoutSchema(value, item, index);\n        }\n        return processed;\n      }\n\n      return schema;\n    };\n\n    // Position calculation\n    const calculateItemPosition = (\n      index: number,\n      scrollPosition: number,\n      totalItems: number,\n      itemSize: number,\n      virtualTotalSize: number,\n      containerSize: number,\n      targetScrollIndex?: number,\n    ): number => {\n      const actualTotalSize = totalItems * itemSize;\n      const isCompressed =\n        actualTotalSize > virtualTotalSize && virtualTotalSize > 0;\n\n      // If we have a targetScrollIndex (from initialScrollIndex), use it directly\n      // This ensures items are positioned correctly even with compression\n      if (targetScrollIndex !== undefined && targetScrollIndex > 0) {\n        // Position items relative to the target index\n        // The target index should appear at the top of the viewport\n        return (index - targetScrollIndex) * itemSize;\n      }\n\n      if (!isCompressed || totalItems === 0) {\n        return index * itemSize - scrollPosition;\n      }\n\n      // Compressed space handling\n      const maxScrollPosition = virtualTotalSize - containerSize;\n      const distanceFromBottom = maxScrollPosition - scrollPosition;\n      const nearBottomThreshold = containerSize;\n\n      if (\n        distanceFromBottom <= nearBottomThreshold &&\n        distanceFromBottom >= -1\n      ) {\n        // Near bottom interpolation\n        const itemsAtBottom = Math.floor(containerSize / itemSize);\n        const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);\n        const scrollRatio = scrollPosition / virtualTotalSize;\n        const exactScrollIndex = scrollRatio * totalItems;\n        const interpolation = Math.max(\n          0,\n          Math.min(1, 1 - distanceFromBottom / nearBottomThreshold),\n        );\n\n        const bottomPosition = (index - firstVisibleAtBottom) * itemSize;\n        const normalPosition = (index - exactScrollIndex) * itemSize;\n        return (\n          normalPosition + (bottomPosition - normalPosition) * interpolation\n        );\n      }\n\n      // Normal compressed scrolling\n      const scrollRatio = scrollPosition / virtualTotalSize;\n      return (index - scrollRatio * totalItems) * itemSize;\n    };\n\n    // Render single item\n    const renderItem = (item: any, index: number): HTMLElement | null => {\n      const itemTemplate = template || getDefaultTemplate();\n\n      try {\n        const result = itemTemplate(item, index);\n        let element: HTMLElement;\n\n        // Check if result is a layout schema (array or object)\n        if (\n          Array.isArray(result) ||\n          (typeof result === \"object\" &&\n            result !== null &&\n            !(result instanceof HTMLElement))\n        ) {\n          // Process schema to substitute variables\n          const processedSchema = processLayoutSchema(result, item, index);\n\n          // Use layout system to create element\n          const layoutResult = createLayout(processedSchema);\n          element = layoutResult.element;\n\n          // If the layout created a wrapper, use it directly\n          if (element && element.nodeType === 1) {\n            // Element is already created by layout system\n            // Store layoutResult for cleanup when element is released (prevents memory leak)\n            layoutResults.set(element, layoutResult);\n          } else {\n            // Fallback if layout didn't create a proper element\n            element = getPooledElement();\n            if (layoutResult.element) {\n              element.appendChild(layoutResult.element);\n              // Store layoutResult on wrapper element for cleanup\n              layoutResults.set(element, layoutResult);\n            }\n          }\n        } else if (typeof result === \"string\") {\n          // Parse HTML using template element - optimized path\n          // Move nodes directly instead of cloning - much faster, no memory overhead\n          templateParser.innerHTML = result;\n          const content = templateParser.content;\n\n          if (content.children.length === 1) {\n            // Single root element - move directly (faster than cloneNode)\n            element = content.firstElementChild as HTMLElement;\n            content.removeChild(element);\n            addClass(element, \"mtrl-viewport-item\");\n            if (isPlaceholder(item)) {\n              addClass(element, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);\n            }\n          } else {\n            // Multiple children - move all into pooled element\n            element = getPooledElement();\n            while (content.firstChild) {\n              element.appendChild(content.firstChild);\n            }\n          }\n        } else if (result instanceof HTMLElement) {\n          element = getPooledElement();\n          element.appendChild(result);\n        } else {\n          console.warn(`[Rendering] Invalid template result for item ${index}`);\n          return null;\n        }\n\n        // Add classes\n        if (!hasClass(element, \"viewport-item\"))\n          addClass(element, \"viewport-item\");\n        if (isPlaceholder(item)) {\n          addClass(element, VIEWPORT_CONSTANTS.PLACEHOLDER.CLASS);\n        }\n\n        element.dataset.index = String(index);\n\n        // Copy data-id from item to viewport element for selection support\n        const itemId = item?._id || item?.id;\n        if (itemId !== undefined && itemId !== null) {\n          element.dataset.id = String(itemId);\n        }\n        return element;\n      } catch (error) {\n        console.error(`[Rendering] Error rendering item ${index}:`, error);\n        return null;\n      }\n    };\n\n    // Update positions\n    const updateItemPositions = (): void => {\n      if (!viewportState || renderedElements.size === 0) return;\n\n      const {\n        scrollPosition,\n        itemSize: itemSize,\n        totalItems,\n        virtualTotalSize,\n        containerSize,\n      } = viewportState;\n      const actualTotalSize = totalItems * itemSize;\n      const isCompressed =\n        actualTotalSize > virtualTotalSize && virtualTotalSize > 0;\n\n      const sortedIndices = Array.from(renderedElements.keys()).sort(\n        (a, b) => a - b,\n      );\n      if (!sortedIndices.length) return;\n\n      const firstIndex = sortedIndices[0];\n      let currentPosition = 0;\n\n      if (isCompressed) {\n        const maxScroll = virtualTotalSize - containerSize;\n        const distanceFromBottom = maxScroll - scrollPosition;\n\n        if (distanceFromBottom <= containerSize && distanceFromBottom >= -1) {\n          // Near bottom interpolation\n          const itemsAtBottom = Math.floor(containerSize / itemSize);\n          const firstVisibleAtBottom = Math.max(0, totalItems - itemsAtBottom);\n          const scrollRatio = scrollPosition / virtualTotalSize;\n          const exactScrollIndex = scrollRatio * totalItems;\n          const interpolation = Math.max(\n            0,\n            Math.min(1, 1 - distanceFromBottom / containerSize),\n          );\n\n          const bottomPos = (firstIndex - firstVisibleAtBottom) * itemSize;\n          const normalPos = (firstIndex - exactScrollIndex) * itemSize;\n          currentPosition = normalPos + (bottomPos - normalPos) * interpolation;\n        } else {\n          const scrollRatio = scrollPosition / virtualTotalSize;\n          currentPosition = (firstIndex - scrollRatio * totalItems) * itemSize;\n        }\n      } else {\n        currentPosition = firstIndex * itemSize - scrollPosition;\n      }\n\n      // Position each item\n      sortedIndices.forEach((index) => {\n        const element = renderedElements.get(index);\n        if (element) {\n          element.style.transform = `translateY(${Math.round(\n            currentPosition,\n          )}px)`;\n\n          // Strategic log for last items\n          // if (index >= totalItems - 5) {\n          //   console.log(\n          //     `[Rendering] Last item positioned: index=${index}, position=${Math.round(\n          //       currentPosition\n          //     )}px, itemSize=${itemSize}px, totalItems=${totalItems}`\n          //   );\n          // }\n\n          currentPosition += itemSize;\n        }\n      });\n    };\n\n    // Main render function\n    const renderItems = () => {\n      if (!viewportState?.itemsContainer) {\n        return;\n      }\n\n      const {\n        visibleRange,\n        itemsContainer,\n        totalItems,\n        itemSize,\n        scrollPosition,\n        containerSize,\n        virtualTotalSize,\n      } = viewportState;\n\n      // Validate range - skip rendering if no items or range is invalid\n      if (\n        !visibleRange ||\n        totalItems <= 0 ||\n        visibleRange.start < 0 ||\n        visibleRange.start >= totalItems ||\n        visibleRange.end < visibleRange.start ||\n        isNaN(visibleRange.start) ||\n        isNaN(visibleRange.end)\n      ) {\n        // If totalItems is 0, clear all rendered elements to remove stale placeholders\n        if (totalItems <= 0 && renderedElements.size > 0) {\n          Array.from(renderedElements.entries()).forEach(([index, element]) => {\n            if (element.parentNode) releaseElement(element);\n            renderedElements.delete(index);\n          });\n          currentVisibleRange = { start: -1, end: -1 };\n        }\n        return;\n      }\n\n      // Check if range changed\n      if (\n        visibleRange.start === currentVisibleRange.start &&\n        visibleRange.end === currentVisibleRange.end &&\n        renderedElements.size > 0\n      ) {\n        updateItemPositions();\n        return;\n      }\n\n      lastRenderTime = Date.now();\n      const renderStart = Math.max(0, visibleRange.start - overscan);\n      const renderEnd = Math.min(totalItems - 1, visibleRange.end + overscan);\n\n      // if (isRemovingItem) {\n      //   console.log(\n      //     `[RENDER-FIX] renderItems calc: visibleRange=${JSON.stringify(visibleRange)}, overscan=${overscan}, totalItems=${totalItems}`,\n      //   );\n      //   console.log(\n      //     `[RENDER-FIX] renderItems calc: renderStart=${renderStart}, renderEnd=${renderEnd}`,\n      //   );\n      // }\n\n      // Remove items outside range\n      const toRemove = Array.from(renderedElements.entries()).filter(\n        ([index]) => index < renderStart || index > renderEnd,\n      );\n\n      toRemove.forEach(([index, element]) => {\n        if (element.parentNode) releaseElement(element);\n        renderedElements.delete(index);\n      });\n\n      // Get items from collection (single source of truth)\n      const items = getCollectionItems();\n      const missingItems: number[] = [];\n\n      // Collect new elements to insert (index -> element)\n      const newElements: Array<[number, HTMLElement]> = [];\n\n      // Render items in range\n      for (let i = renderStart; i <= renderEnd; i++) {\n        if (i < 0 || i >= totalItems || renderedElements.has(i)) continue;\n\n        let item = items[i];\n        if (!item) {\n          missingItems.push(i);\n          // Generate placeholder (rendered dynamically, not stored)\n          const placeholders = (component as any).placeholders;\n          item = placeholders?.generatePlaceholderItem(i) || {\n            _placeholder: true,\n            index: i,\n            id: `placeholder-${i}`,\n            name: VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER.repeat(15),\n            text: VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER.repeat(25),\n            description:\n              VIEWPORT_CONSTANTS.PLACEHOLDER.MASK_CHARACTER.repeat(40),\n          };\n        }\n\n        const element = renderItem(item, i);\n        if (element) {\n          // Get targetScrollIndex from viewportState if available\n          const targetScrollIndex = (viewportState as any)?.targetScrollIndex;\n          const position = calculateItemPosition(\n            i,\n            scrollPosition,\n            totalItems,\n            itemSize,\n            virtualTotalSize,\n            containerSize,\n            targetScrollIndex,\n          );\n\n          Object.assign(element.style, {\n            position: \"absolute\",\n            transform: `translateY(${position}px)`,\n            width: \"100%\",\n          });\n\n          // Collect for batch insertion (if maintaining order) or just append\n          if (maintainDomOrder) {\n            newElements.push([i, element]);\n          } else {\n            itemsContainer.appendChild(element);\n          }\n          renderedElements.set(i, element);\n        }\n      }\n\n      // Batch insert new elements in correct DOM order (only when maintainDomOrder is enabled)\n      // This ensures CSS selectors like :first-child, :nth-child() work correctly\n      if (maintainDomOrder && newElements.length > 0) {\n        // Sort new elements by index\n        newElements.sort(([a], [b]) => a - b);\n\n        // Get existing DOM children sorted by their data-index\n        const existingChildren = Array.from(\n          itemsContainer.children,\n        ) as HTMLElement[];\n\n        // Merge new elements into correct positions\n        let newIdx = 0;\n        let existingIdx = 0;\n\n        while (newIdx < newElements.length) {\n          const [newIndex, newElement] = newElements[newIdx];\n\n          // Find the first existing child with index > newIndex\n          while (\n            existingIdx < existingChildren.length &&\n            parseInt(existingChildren[existingIdx].dataset.index || \"-1\", 10) <\n              newIndex\n          ) {\n            existingIdx++;\n          }\n\n          if (existingIdx < existingChildren.length) {\n            // Insert before the existing child\n            itemsContainer.insertBefore(\n              newElement,\n              existingChildren[existingIdx],\n            );\n          } else {\n            // Append at the end\n            itemsContainer.appendChild(newElement);\n          }\n          newIdx++;\n        }\n      }\n\n      // Request missing items\n      if (\n        missingItems.length > 0 &&\n        component.viewport?.collection?.loadMissingRanges\n      ) {\n        component.viewport.collection.loadMissingRanges(\n          {\n            start: Math.min(...missingItems),\n            end: Math.max(...missingItems),\n          },\n          \"rendering:missing-items\",\n        );\n      }\n\n      currentVisibleRange = visibleRange;\n\n      // Emit items rendered event with elements for size calculation\n      const renderedElementsArray = Array.from(renderedElements.values());\n      component.emit?.(\"viewport:items-rendered\", {\n        elements: renderedElementsArray,\n        range: visibleRange,\n      });\n\n      component.emit?.(\"viewport:rendered\", {\n        range: visibleRange,\n        renderedCount: renderedElements.size,\n      });\n      updateItemPositions();\n\n      // Load data if no items rendered\n      if (\n        renderedElements.size === 0 &&\n        totalItems > 0 &&\n        component.viewport?.collection\n      ) {\n        component.viewport.collection.loadMissingRanges(\n          visibleRange,\n          \"rendering:no-items\",\n        );\n      }\n    };\n\n    // Extend viewport API\n    const originalRenderItems = component.viewport.renderItems;\n    component.viewport.renderItems = () => {\n      renderItems();\n      originalRenderItems?.();\n    };\n\n    // Cleanup\n    wrapDestroy(component, () => {\n      // Release all rendered elements - use releaseElement to properly destroy layoutResults\n      renderedElements.forEach((element) => {\n        releaseElement(element);\n      });\n      renderedElements.clear();\n\n      // Clear element pool\n      elementPool.length = 0;\n\n      // Reset state\n      currentVisibleRange = { start: -1, end: -1 };\n      viewportState = null;\n      lastRenderTime = 0;\n\n      // Reset pool stats\n      poolStats.created = 0;\n      poolStats.recycled = 0;\n      poolStats.poolSize = 0;\n    });\n\n    return component;\n  };\n};\n",
    "/**\n * @module core/layout/schema\n * @description Unified layout schema processor with integrated optimizations\n * Consolidates array, object, JSX, and template processing with built-in performance enhancements\n */\n\n// ============================================================================\n// TYPES (Essential only)\n// ============================================================================\n\nexport interface LayoutConfig {\n  /** Base layout type */\n  type?: \"stack\" | \"row\" | \"grid\" | string;\n  /** Spacing between elements */\n  gap?: number | string;\n  /** Additional CSS classes */\n  class?: string;\n  /** Alignment of items along the cross axis */\n  align?: \"start\" | \"center\" | \"end\" | \"stretch\";\n  /** Alignment of items along the main axis */\n  justify?: \"start\" | \"center\" | \"end\" | \"between\" | \"around\" | \"evenly\";\n  /** Whether and how items should wrap */\n  wrap?: boolean | \"reverse\" | \"nowrap\";\n  /** Whether row items should stack vertically on mobile */\n  mobileStack?: boolean;\n  /** Whether row items should scroll horizontally on mobile */\n  mobileScroll?: boolean;\n  /** Number of columns or automatic sizing method */\n  columns?: number | \"auto-fit\" | \"auto-fill\";\n  /** Whether to use dense packing algorithm for grid */\n  dense?: boolean;\n  /** Whether grid items should adjust height automatically */\n  autoHeight?: boolean;\n}\n\nexport interface LayoutItemConfig {\n  /** Column width in a 12-column grid */\n  width?: number;\n  /** Width on small screens */\n  sm?: number;\n  /** Width on medium screens */\n  md?: number;\n  /** Width on large screens */\n  lg?: number;\n  /** Width on extra-large screens */\n  xl?: number;\n  /** Number of grid columns to span */\n  span?: number;\n  /** Number of grid rows to span */\n  rowSpan?: number;\n  /** Display order */\n  order?: number | \"first\" | \"last\";\n  /** Self-alignment within container */\n  align?: \"start\" | \"center\" | \"end\" | \"stretch\";\n  /** Whether item should automatically size */\n  auto?: boolean;\n}\n\nexport interface LayoutOptions {\n  /** Default creator function to use if not specified in schema */\n  creator?: Function;\n  /** Whether to apply CSS class prefix @default true */\n  prefix?: boolean;\n  /** Additional options */\n  [key: string]: any;\n}\n\nexport interface LayoutResult {\n  /** The raw layout object with all components */\n  layout: Record<string, any>;\n  /** Reference to the root element for convenience */\n  element: HTMLElement | any;\n  /** Flattened component map */\n  component: Record<string, any>;\n  /** Gets a component by name */\n  get(name: string): any;\n  /** Gets all components in a flattened map */\n  getAll(): Record<string, any>;\n  /** Destroys the layout, cleaning up all components */\n  destroy(): void;\n}\n\ntype ComponentLike = { element: HTMLElement; [key: string]: any };\ntype SchemaItem = Function | string | Record<string, any> | SchemaItem[];\n\n// ============================================================================\n// BUILT-IN OPTIMIZATIONS\n// ============================================================================\n\n/**\n * Fragment Pool for efficient DocumentFragment reuse\n * Reduces GC pressure in high-frequency layout creation scenarios\n */\nclass FragmentPool {\n  private pool: DocumentFragment[] = [];\n  private maxSize = 8; // Optimized size for memory efficiency\n\n  get(): DocumentFragment {\n    return this.pool.pop() || document.createDocumentFragment();\n  }\n\n  release(fragment: DocumentFragment): void {\n    if (this.pool.length < this.maxSize && fragment.childNodes.length === 0) {\n      this.pool.push(fragment);\n    }\n  }\n\n  clear(): void {\n    this.pool.length = 0;\n  }\n}\n\nconst fragmentPool = new FragmentPool();\n\n/**\n * Class name cache for layout configurations\n * Reduces string operations by caching generated class names\n */\nconst classCache = new Map<string, string>();\n\n// Configuration constants\nconst PREFIX = \"mtrl\"; // TODO: Make this configurable\nconst PREFIX_WITH_DASH = `${PREFIX}-`;\n\n/**\n * Gets a cached class name for layout configuration\n * Optimized for different class naming patterns\n */\nfunction getCachedClassName(\n  type: string,\n  property: string,\n  value: string | number,\n): string {\n  const key = `${type}-${property}-${value}`;\n  if (!classCache.has(key)) {\n    if (type === \"item\") {\n      classCache.set(\n        key,\n        property === \"\"\n          ? `layout__item--${value}`\n          : `layout__item--${property}-${value}`,\n      );\n    } else {\n      // For layout classes, align uses layout--{type}-{value}\n      // but justify and others use layout--{type}-{property}-{value}\n      if (property === \"align\") {\n        classCache.set(key, `layout--${type}-${value}`);\n      } else {\n        classCache.set(key, `layout--${type}-${property}-${value}`);\n      }\n    }\n  }\n  return classCache.get(key)!;\n}\n\n// ============================================================================\n// OPTIMIZED UTILITIES\n// ============================================================================\n\n/**\n * Checks if a value is a component object (has an element property)\n */\nfunction isComponent(value: any): value is ComponentLike {\n  return value && typeof value === \"object\" && \"element\" in value;\n}\n\n/**\n * Creates a document fragment using pooling for better performance\n */\nfunction createFragment(): DocumentFragment {\n  return fragmentPool.get();\n}\n\n/**\n * Releases a fragment back to the pool for reuse\n */\nfunction releaseFragment(fragment: DocumentFragment): void {\n  fragmentPool.release(fragment);\n}\n\n/**\n * Optimized class processing with minimal string operations\n * Handles arrays, strings, className aliases, and rawClass efficiently\n */\nfunction processClassNames(\n  options: Record<string, any>,\n  skipPrefix = false,\n): Record<string, any> {\n  if (!options) return options;\n\n  const hasRawClass = options.rawClass;\n  const hasRegularClass = options.class || options.className;\n\n  // Fast path: no class properties at all\n  if (!hasRawClass && !hasRegularClass) return options;\n\n  // Fast path: only rawClass and skipping prefix (most common rawClass scenario)\n  if (hasRawClass && !hasRegularClass && skipPrefix) {\n    const processed = { ...options };\n    delete processed.rawClass;\n\n    // Direct assignment for simple string\n    if (typeof hasRawClass === \"string\") {\n      processed.class = hasRawClass;\n    } else {\n      // Handle array case\n      processed.class = hasRawClass.join(\" \");\n    }\n    return processed;\n  }\n\n  // Full processing path (only when needed)\n  const processed = { ...options };\n  let finalClasses = \"\";\n\n  // Handle prefixed classes only if not skipping prefix\n  if (!skipPrefix && hasRegularClass) {\n    let prefixedString = \"\";\n\n    if (processed.class) {\n      prefixedString += Array.isArray(processed.class)\n        ? processed.class.join(\" \")\n        : processed.class;\n    }\n    if (processed.className) {\n      prefixedString += (prefixedString ? \" \" : \"\") + processed.className;\n    }\n\n    if (prefixedString) {\n      finalClasses = prefixedString\n        .split(/\\s+/)\n        .filter(Boolean)\n        .map((cls) =>\n          cls.startsWith(PREFIX_WITH_DASH) ? cls : PREFIX_WITH_DASH + cls,\n        )\n        .join(\" \");\n    }\n  }\n\n  // Handle rawClass (always processed when present)\n  if (hasRawClass) {\n    const rawString = Array.isArray(hasRawClass)\n      ? hasRawClass.filter(Boolean).join(\" \")\n      : hasRawClass;\n\n    finalClasses += (finalClasses ? \" \" : \"\") + rawString;\n  }\n\n  if (finalClasses) {\n    processed.class = finalClasses;\n  }\n\n  // Clean up in one operation\n  delete processed.className;\n  delete processed.rawClass;\n\n  return processed;\n}\n\n/**\n * Optimized parameter extraction for array schemas\n * Reduces multiple array lookups with batch processing\n */\ninterface ExtractedParameters {\n  creator: Function;\n  name?: string;\n  options: Record<string, any>;\n  consumed: number;\n}\n\nfunction extractParameters(\n  schema: SchemaItem[],\n  startIndex: number,\n  defaultCreator: Function,\n): ExtractedParameters {\n  const items = schema.slice(startIndex, startIndex + 3);\n  let creator, name, options;\n  let consumed = 1;\n\n  const [first, second, third] = items;\n\n  if (typeof first === \"function\") {\n    creator = first;\n    if (typeof second === \"string\") {\n      name = second;\n      consumed = 2;\n      if (isObject(third)) {\n        options = third;\n        consumed = 3;\n      }\n    } else if (isObject(second)) {\n      options = second;\n      consumed = 2;\n    }\n  } else if (typeof first === \"string\") {\n    creator = defaultCreator;\n    name = first;\n    if (isObject(second)) {\n      options = second;\n      consumed = 2;\n    }\n  } else if (isObject(first)) {\n    creator = defaultCreator;\n    options = first;\n  }\n\n  return {\n    creator: creator || defaultCreator,\n    name,\n    options: (options || {}) as Record<string, any>,\n    consumed,\n  };\n}\n\n/**\n * Simple object type check\n */\nfunction isObject(value: any): boolean {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\n// ============================================================================\n// DOM UTILITIES (Simplified)\n// ============================================================================\n\n/**\n * Simple DOM element creation\n */\nfunction createElement(options: Record<string, any> = {}): HTMLElement {\n  const tag = options.tag || \"div\";\n  const element = document.createElement(tag);\n\n  if (options.class) {\n    element.className = options.class;\n  }\n\n  if (options.style) {\n    if (typeof options.style === \"string\") {\n      element.setAttribute(\"style\", options.style);\n    } else if (typeof options.style === \"object\") {\n      Object.assign(element.style, options.style);\n    }\n  }\n\n  if (options.textContent) {\n    element.textContent = options.textContent;\n  }\n\n  if (options.text) {\n    element.textContent = options.text;\n  }\n\n  return element;\n}\n\n/**\n * Adds a CSS class to an element\n */\nfunction addClass(element: HTMLElement, className: string): void {\n  if (element && className) {\n    element.classList.add(className);\n  }\n}\n\n/**\n * Checks if element has a CSS class\n */\nfunction hasClass(element: HTMLElement, className: string): boolean {\n  return element && element.classList.contains(className);\n}\n\n// ============================================================================\n// UNIFIED COMPONENT CREATION (with destructuring optimization)\n// ============================================================================\n\n/**\n * Creates a component instance with optimized option processing\n * Uses destructuring for cleaner separation of concerns\n */\nfunction createComponentInstance(\n  Component: any,\n  options: Record<string, any> = {},\n): any {\n  try {\n    // Destructure special configs in one operation\n    const {\n      layout: layoutConfig,\n      layoutItem: layoutItemConfig,\n      style: styleConfig,\n      attributes: attributesConfig,\n      events: eventsConfig,\n      event, // Legacy support\n      ...cleanOptions\n    } = options;\n\n    // Use events over event (events is preferred)\n    const finalEventsConfig = eventsConfig || event;\n\n    // If style is a string, always pass it through to the component\n    if (styleConfig && typeof styleConfig === \"string\") {\n      cleanOptions.style = styleConfig;\n    }\n\n    // Create component\n    const isClass =\n      typeof Component === \"function\" &&\n      Object.getOwnPropertyDescriptor(Component, \"prototype\")?.writable ===\n        false;\n\n    const component = isClass\n      ? new Component(cleanOptions)\n      : Component(cleanOptions);\n\n    // Apply configurations if component has element\n    if (component) {\n      const element =\n        component.element ||\n        (component instanceof HTMLElement ? component : null);\n      if (element) {\n        // Apply layout classes\n        if (layoutConfig) applyLayoutClasses(element, layoutConfig);\n\n        // Apply layout item classes\n        if (layoutItemConfig) applyLayoutItemClasses(element, layoutItemConfig);\n\n        // Apply style\n        if (styleConfig && typeof styleConfig === \"object\") {\n          Object.assign(element.style, styleConfig);\n        }\n\n        // Apply attributes\n        if (attributesConfig && typeof attributesConfig === \"object\") {\n          for (const [key, value] of Object.entries(attributesConfig)) {\n            if (value !== undefined && value !== null) {\n              element.setAttribute(key, value.toString());\n            }\n          }\n        }\n\n        // Apply events\n        if (finalEventsConfig && typeof finalEventsConfig === \"object\") {\n          if (Array.isArray(finalEventsConfig)) {\n            for (const eventDef of finalEventsConfig) {\n              if (Array.isArray(eventDef) && eventDef.length >= 2) {\n                const [eventName, handler] = eventDef;\n                if (\n                  typeof eventName === \"string\" &&\n                  typeof handler === \"function\"\n                ) {\n                  element.addEventListener(eventName, handler);\n                }\n              }\n            }\n          } else {\n            for (const [eventName, handler] of Object.entries(\n              finalEventsConfig,\n            )) {\n              if (typeof handler === \"function\") {\n                element.addEventListener(eventName, handler);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return component;\n  } catch (error) {\n    console.error(\"Error creating component instance:\", error);\n    return document.createElement(\"div\");\n  }\n}\n\n// ============================================================================\n// INTEGRATED LAYOUT CONFIGURATION (with caching)\n// ============================================================================\n\n/**\n * Applies layout classes based on configuration\n * Uses integrated caching for optimal performance\n */\nfunction applyLayoutClasses(\n  element: HTMLElement,\n  layoutConfig: LayoutConfig,\n): void {\n  if (!element || !layoutConfig) return;\n\n  // Apply base layout type\n  if (layoutConfig.type) {\n    addClass(element, `${PREFIX_WITH_DASH}layout--${layoutConfig.type}`);\n  }\n\n  // Apply properties with caching\n  const layoutType = layoutConfig.type || getLayoutType(element);\n  if (layoutType) {\n    if (layoutConfig.gap !== undefined) {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(layoutType, \"gap\", layoutConfig.gap),\n      );\n    }\n    if (layoutConfig.align) {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(layoutType, \"align\", layoutConfig.align),\n      );\n    }\n    if (layoutConfig.justify) {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(layoutType, \"justify\", layoutConfig.justify),\n      );\n    }\n  }\n\n  // Grid-specific properties\n  if (layoutConfig.type === \"grid\" || getLayoutType(element) === \"grid\") {\n    if (typeof layoutConfig.columns === \"number\") {\n      addClass(\n        element,\n        PREFIX_WITH_DASH +\n          getCachedClassName(\"grid\", \"cols\", layoutConfig.columns),\n      );\n    } else if (layoutConfig.columns === \"auto-fill\") {\n      addClass(\n        element,\n        PREFIX_WITH_DASH + getCachedClassName(\"grid\", \"fill\", \"auto\"),\n      );\n    } else if (layoutConfig.columns === \"auto-fit\") {\n      addClass(\n        element,\n        PREFIX_WITH_DASH + getCachedClassName(\"grid\", \"cols\", \"auto-fit\"),\n      );\n    }\n    if (layoutConfig.dense)\n      addClass(element, `${PREFIX_WITH_DASH}layout--grid-dense`);\n    if (layoutConfig.autoHeight)\n      addClass(element, `${PREFIX_WITH_DASH}layout--grid-auto-height`);\n  }\n\n  // Row-specific properties\n  if (layoutConfig.type === \"row\" || getLayoutType(element) === \"row\") {\n    if (layoutConfig.wrap === false || layoutConfig.wrap === \"nowrap\") {\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-nowrap`);\n    } else if (layoutConfig.wrap === \"reverse\") {\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-wrap-reverse`);\n    }\n    if (layoutConfig.mobileStack)\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-mobile-stack`);\n    if (layoutConfig.mobileScroll)\n      addClass(element, `${PREFIX_WITH_DASH}layout--row-mobile-scroll`);\n  }\n\n  // Custom classes\n  if (layoutConfig.class) {\n    layoutConfig.class\n      .split(\" \")\n      .filter(Boolean)\n      .forEach((cls) => element.classList.add(cls));\n  }\n}\n\n/**\n * Applies layout item classes based on configuration\n * Uses integrated caching for optimal performance\n */\nfunction applyLayoutItemClasses(\n  element: HTMLElement,\n  itemConfig: LayoutItemConfig,\n): void {\n  if (!element || !itemConfig) return;\n\n  addClass(element, `${PREFIX_WITH_DASH}layout__item`);\n\n  // Width and responsive classes with caching\n  if (itemConfig.width && itemConfig.width >= 1 && itemConfig.width <= 12) {\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"\", itemConfig.width),\n    );\n  }\n  if (itemConfig.sm)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"sm\", itemConfig.sm),\n    );\n  if (itemConfig.md)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"md\", itemConfig.md),\n    );\n  if (itemConfig.lg)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"lg\", itemConfig.lg),\n    );\n  if (itemConfig.xl)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"xl\", itemConfig.xl),\n    );\n\n  // Grid span classes\n  if (itemConfig.span)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"span\", itemConfig.span),\n    );\n  if (itemConfig.rowSpan)\n    addClass(\n      element,\n      PREFIX_WITH_DASH +\n        getCachedClassName(\"item\", \"row-span\", itemConfig.rowSpan),\n    );\n\n  // Order and alignment\n  if (itemConfig.order)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"order\", itemConfig.order),\n    );\n  if (itemConfig.align)\n    addClass(\n      element,\n      PREFIX_WITH_DASH + getCachedClassName(\"item\", \"self\", itemConfig.align),\n    );\n  if (itemConfig.auto)\n    addClass(element, `${PREFIX_WITH_DASH}layout__item--auto`);\n}\n\n/**\n * Gets the layout type from element classes\n */\nfunction getLayoutType(element: HTMLElement): string {\n  return hasClass(element, `${PREFIX_WITH_DASH}layout--stack`)\n    ? \"stack\"\n    : hasClass(element, `${PREFIX_WITH_DASH}layout--row`)\n      ? \"row\"\n      : hasClass(element, `${PREFIX_WITH_DASH}layout--grid`)\n        ? \"grid\"\n        : \"\";\n}\n\n// ============================================================================\n// UNIFIED SCHEMA PROCESSORS\n// ============================================================================\n\n/**\n * Processes array-based schema definitions\n * Optimized with parameter extraction and integrated configuration\n */\nfunction processArraySchema(\n  schema: SchemaItem[] | any,\n  parentElement: HTMLElement | null = null,\n  level: number = 0,\n  options: LayoutOptions = {},\n): LayoutResult {\n  level++;\n  const layout: Record<string, any> = {};\n  const components: Array<[string, any]> = [];\n  const fragment = createFragment();\n  let component = null;\n\n  if (!Array.isArray(schema)) {\n    return createLayoutResult(layout);\n  }\n\n  const defaultCreator = (options as any).creator || createElement;\n\n  for (let i = 0; i < schema.length; i++) {\n    const item = schema[i];\n    if (!item) continue;\n\n    // Handle nested arrays\n    if (Array.isArray(item)) {\n      const container = component || parentElement;\n      const result = processArraySchema(item, container, level, options);\n      // Merge nested components array instead of overwriting\n      if (Array.isArray(result.layout.components)) {\n        components.push(...result.layout.components);\n        delete result.layout.components;\n      }\n      Object.assign(layout, result.layout);\n      continue;\n    }\n\n    // Use optimized parameter extraction\n    const {\n      creator,\n      name,\n      options: itemOptions,\n      consumed,\n    } = extractParameters(schema, i, defaultCreator);\n\n    if (!creator) {\n      console.warn(\"Skipping unsupported item type:\", item);\n      continue;\n    }\n\n    // Default to div for createElement\n    if (creator === createElement && !(\"tag\" in itemOptions)) {\n      itemOptions.tag = \"div\";\n    }\n\n    // Advance index by consumed items minus 1 (loop increment handles the +1)\n    i += consumed - 1;\n\n    // Process options with prefix - optimized decision logic\n    const shouldApplyPrefix =\n      \"prefix\" in itemOptions ? itemOptions.prefix : options.prefix !== false;\n\n    // Fast path: process only when needed\n    const processedOptions =\n      shouldApplyPrefix || itemOptions.rawClass\n        ? processClassNames(itemOptions, !shouldApplyPrefix)\n        : itemOptions; // No copy needed if no processing\n\n    // Add name to options if needed\n    if (\n      name &&\n      !(\"name\" in processedOptions) &&\n      !(creator === createElement || (creator as any).isElement)\n    ) {\n      processedOptions.name = name;\n    }\n\n    // Create component\n    component = createComponentInstance(creator, processedOptions);\n    const element = isComponent(component) ? component.element : component;\n\n    if (level === 1) layout.element = element;\n    if (name) {\n      layout[name] = component;\n      components.push([name, component]);\n    }\n\n    // Append to DOM\n    if (component) {\n      if (\"insert\" in component && typeof component.insert === \"function\") {\n        component.insert(fragment);\n      } else {\n        fragment.appendChild(element);\n      }\n\n      if (parentElement) {\n        component._container = parentElement;\n        if (\n          \"onInserted\" in component &&\n          typeof component.onInserted === \"function\"\n        ) {\n          component.onInserted(parentElement);\n        }\n      }\n    }\n  }\n\n  // Append fragment to parent\n  if (parentElement && fragment.hasChildNodes()) {\n    const wrapper = isComponent(parentElement)\n      ? parentElement.element\n      : parentElement;\n    wrapper.appendChild(fragment);\n  }\n\n  // Release fragment back to pool\n  releaseFragment(fragment);\n\n  layout.components = components;\n  return createLayoutResult(layout);\n}\n\n/**\n * Processes object-based schema definitions\n * Simplified and optimized for better performance\n */\nfunction processObjectSchema(\n  schema: Record<string, any> | string,\n  parentElement: HTMLElement | null = null,\n  options: LayoutOptions = {},\n): LayoutResult {\n  const layout: Record<string, any> = {};\n  const defaultCreator = options.creator || createElement;\n\n  // Handle root element creation\n  if ((schema as any).element && !parentElement) {\n    const elementDef = (schema as any).element;\n    const createElementFn = elementDef.creator || defaultCreator;\n\n    const elementOptions = elementDef.options || {};\n    const processedOptions =\n      options.prefix !== false\n        ? processClassNames(elementOptions)\n        : { ...elementOptions };\n\n    const rootComponent = createComponentInstance(\n      createElementFn,\n      processedOptions,\n    );\n    layout.element = rootComponent;\n    if (elementDef.name) layout[elementDef.name] = rootComponent;\n\n    // Process children\n    if (elementDef.children) {\n      const rootElement = isComponent(rootComponent)\n        ? rootComponent.element\n        : rootComponent;\n      const childResult = processObjectSchema(\n        elementDef.children,\n        rootElement,\n        options,\n      );\n      Object.assign(layout, childResult.layout);\n    }\n\n    return createLayoutResult(layout);\n  }\n\n  // Process normal schema elements\n  const fragment = parentElement ? createFragment() : null;\n\n  for (const key in schema as Record<string, any>) {\n    const def = (schema as Record<string, any>)[key];\n    if (!def) continue;\n\n    const elementCreator = def.creator || defaultCreator;\n    const elementOptions = def.options || {};\n    const shouldApplyPrefix =\n      \"prefix\" in elementOptions\n        ? elementOptions.prefix\n        : options.prefix !== false;\n    const processedOptions = shouldApplyPrefix\n      ? processClassNames(elementOptions)\n      : { ...elementOptions };\n\n    if (!def.name && key !== \"element\") {\n      def.name = key;\n    }\n\n    const created = createComponentInstance(elementCreator, processedOptions);\n    layout[key] = created;\n    if (def.name && def.name !== key) layout[def.name] = created;\n\n    const element = isComponent(created) ? created.element : created;\n    if (fragment) fragment.appendChild(element);\n\n    // Process children\n    if (def.children) {\n      const childResult = processObjectSchema(def.children, element, options);\n      Object.assign(layout, childResult.layout);\n    }\n  }\n\n  // Append to parent\n  if (parentElement && fragment) {\n    const parentDom = isComponent(parentElement)\n      ? parentElement.element\n      : parentElement;\n    parentDom.appendChild(fragment);\n    releaseFragment(fragment);\n  }\n\n  return createLayoutResult(layout);\n}\n\n// ============================================================================\n// LAYOUT RESULT CREATION\n// ============================================================================\n\n/**\n * Flattens a nested layout into a simple object with element and component references\n */\nfunction flattenLayout(layout: Record<string, any>): Record<string, any> {\n  const flattened: Record<string, any> = {};\n\n  if (!layout || typeof layout !== \"object\") return flattened;\n\n  for (const key in layout) {\n    const value = layout[key];\n    if (\n      value &&\n      typeof value !== \"function\" &&\n      (value instanceof HTMLElement ||\n        (typeof SVGElement !== \"undefined\" && value instanceof SVGElement) ||\n        isComponent(value))\n    ) {\n      flattened[key] = value;\n    }\n  }\n\n  return flattened;\n}\n\n/**\n * Creates a layout result object with utility functions\n */\nfunction createLayoutResult(layout: Record<string, any>): LayoutResult {\n  const flattenedComponents = flattenLayout(layout);\n\n  return {\n    layout,\n    element: layout.element,\n    component: flattenedComponents,\n\n    get(name: string): any {\n      return layout[name] ?? null;\n    },\n\n    getAll(): Record<string, any> {\n      return flattenedComponents;\n    },\n\n    destroy(): void {\n      // Track destroyed components to avoid double-destroy\n      const destroyed = new Set<any>();\n\n      // Helper to safely destroy a component\n      const destroyComponent = (component: any): void => {\n        if (!component || destroyed.has(component)) return;\n\n        // Skip plain HTML elements and non-objects\n        if (component instanceof HTMLElement || typeof component !== \"object\")\n          return;\n\n        // Check if it's a component with destroy method\n        if (typeof component.destroy === \"function\") {\n          destroyed.add(component);\n          try {\n            component.destroy();\n          } catch (e) {\n            // Ignore destroy errors - component may already be cleaned up\n          }\n        }\n      };\n\n      // First destroy components from the components array (if present)\n      // This ensures all named components are destroyed even if nested\n      if (Array.isArray(layout.components)) {\n        for (const [name, component] of layout.components) {\n          destroyComponent(component);\n        }\n      }\n\n      // Then iterate over all layout keys for any missed components\n      for (const key in layout) {\n        if (key === \"element\" || key === \"components\") continue;\n        destroyComponent(layout[key]);\n      }\n\n      // Clear the components array\n      if (Array.isArray(layout.components)) {\n        layout.components.length = 0;\n      }\n\n      // Remove root element from DOM\n      if (layout.element) {\n        const element = isComponent(layout.element)\n          ? layout.element.element\n          : layout.element;\n        if (element && element.parentNode) {\n          element.parentNode.removeChild(element);\n        }\n      }\n\n      // Clear references to help GC\n      for (const key in layout) {\n        delete layout[key];\n      }\n    },\n  };\n}\n\n// ============================================================================\n// UNIFIED ENTRY POINT\n// ============================================================================\n\n/**\n * Creates a layout from various schema formats\n * Unified processor for arrays, objects, JSX, and HTML strings\n */\nexport function createLayout(\n  schema: any,\n  parentElement: HTMLElement | null = null,\n  options: LayoutOptions = {},\n): LayoutResult {\n  // Handle function schemas\n  if (typeof schema === \"function\") {\n    schema = schema();\n  }\n\n  // Handle HTML string schemas\n  if (typeof schema === \"string\") {\n    const template = document.createElement(\"template\");\n    template.innerHTML = schema.trim();\n    const fragment = template.content;\n\n    if (parentElement && fragment.hasChildNodes()) {\n      parentElement.appendChild(fragment);\n    }\n\n    const layout = { element: fragment.firstElementChild as HTMLElement };\n    return createLayoutResult(layout);\n  }\n\n  // Handle JSX-like schemas (array with function, string, object pattern)\n  if (\n    Array.isArray(schema) &&\n    schema.length >= 3 &&\n    typeof schema[0] === \"function\" &&\n    typeof schema[1] === \"string\" &&\n    isObject(schema[2])\n  ) {\n    return processArraySchema(schema, parentElement, 0, options);\n  }\n\n  // Route to appropriate processor\n  return Array.isArray(schema)\n    ? processArraySchema(schema, parentElement, 0, options)\n    : processObjectSchema(schema, parentElement, options);\n}\n\n// ============================================================================\n// EXPORTS\n// ============================================================================\n\n// Clear functions for the unified system\nexport function clearClassCache(): void {\n  classCache.clear();\n}\n\nexport function clearFragmentPool(): void {\n  fragmentPool.clear();\n}\n\nexport {\n  processClassNames,\n  isComponent,\n  flattenLayout,\n  applyLayoutClasses,\n  applyLayoutItemClasses,\n  createLayoutResult,\n};\n",
    "// src/core/viewport/features/events.ts\n\n/**\n * Events Feature - Centralized event system for viewport\n * Provides event emission and subscription for inter-feature communication\n */\n\nimport type { ViewportContext, ViewportComponent } from \"../types\";\n\nexport interface EventsConfig {\n  debug?: boolean;\n}\n\n/**\n * Events feature for viewport\n * Centralizes all event handling for viewport features\n */\nexport const withEvents = (config: EventsConfig = {}) => {\n  return <T extends ViewportContext & ViewportComponent>(component: T): T => {\n    const { debug = false } = config;\n\n    // Event listeners map\n    const listeners = new Map<string, Set<Function>>();\n\n    // Emit an event\n    const emit = (event: string, data?: any) => {\n      // if (debug) {\n      //   console.log(`[Events] Emit: ${event}`, data);\n      // }\n\n      const eventListeners = listeners.get(event);\n      if (eventListeners) {\n        eventListeners.forEach((listener) => {\n          try {\n            listener(data);\n          } catch (error) {\n            console.error(`[Events] Error in listener for ${event}:`, error);\n          }\n        });\n      }\n    };\n\n    // Subscribe to an event\n    const on = (event: string, handler: Function): (() => void) => {\n      if (!listeners.has(event)) {\n        listeners.set(event, new Set());\n      }\n\n      listeners.get(event)!.add(handler);\n\n      // if (debug) {\n      //   console.log(`[Events] Subscribed to: ${event}`);\n      // }\n\n      // Return unsubscribe function\n      return () => {\n        const eventListeners = listeners.get(event);\n        if (eventListeners) {\n          eventListeners.delete(handler);\n          if (eventListeners.size === 0) {\n            listeners.delete(event);\n          }\n        }\n      };\n    };\n\n    // Subscribe to an event once\n    const once = (event: string, handler: Function): (() => void) => {\n      const wrappedHandler = (data: any) => {\n        handler(data);\n        off(event, wrappedHandler);\n      };\n      return on(event, wrappedHandler);\n    };\n\n    // Unsubscribe from an event\n    const off = (event: string, handler: Function) => {\n      const eventListeners = listeners.get(event);\n      if (eventListeners) {\n        eventListeners.delete(handler);\n        if (eventListeners.size === 0) {\n          listeners.delete(event);\n        }\n      }\n    };\n\n    // Clear all listeners for an event\n    const clear = (event?: string) => {\n      if (event) {\n        listeners.delete(event);\n      } else {\n        listeners.clear();\n      }\n    };\n\n    // Add event methods to component\n    component.emit = emit;\n    component.on = on;\n    component.once = once;\n    component.off = off;\n\n    // Add events API to viewport\n    (component.viewport as any).events = {\n      emit,\n      on,\n      once,\n      off,\n      clear,\n      getListenerCount: (event?: string) => {\n        if (event) {\n          return listeners.get(event)?.size || 0;\n        }\n        let total = 0;\n        listeners.forEach((set) => (total += set.size));\n        return total;\n      },\n    };\n\n    // Clean up on destroy\n    if (\"destroy\" in component && typeof component.destroy === \"function\") {\n      const originalDestroy = component.destroy;\n      component.destroy = () => {\n        clear();\n        originalDestroy?.();\n      };\n    }\n\n    return component;\n  };\n};\n"
  ],
  "mappings": "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",
  "debugId": "BD481E0A015C99EC64756E2164756E21",
  "names": []
}