openms-insight 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

openms_insight/rendering/bridge.py

@@ -12,6 +12,8 @@ import streamlit as st
 
 # Configure debug logging for hash tracking
 _DEBUG_HASH_TRACKING = os.environ.get("SVC_DEBUG_HASH", "").lower() == "true"
+# Debug logging for page navigation / state sync issues
+_DEBUG_STATE_SYNC = os.environ.get("SVC_DEBUG_STATE", "").lower() == "true"
 _logger = logging.getLogger(__name__)
 
 
@@ -128,10 +130,27 @@ def clear_component_annotations() -> None:
         st.session_state[_COMPONENT_ANNOTATIONS_KEY].clear()
 
 
+def _compute_annotation_hash(component: "BaseComponent") -> Optional[str]:
+    """
+    Compute hash of component's dynamic annotations, if any.
+
+    Args:
+        component: The component to check for annotations
+
+    Returns:
+        Short hash string if annotations exist, None otherwise
+    """
+    annotations = getattr(component, "_dynamic_annotations", None)
+    if annotations is None:
+        return None
+    # Hash the sorted keys (sufficient for change detection)
+    return hashlib.md5(str(sorted(annotations.keys())).encode()).hexdigest()[:8]
+
+
 def _get_cached_vue_data(
     component_id: str,
     filter_state_hashable: Tuple[Tuple[str, Any], ...],
-) -> Optional[Tuple[Dict[str, Any], str]]:
+) -> Optional[Tuple[Dict[str, Any], str, Optional[str]]]:
     """
     Get cached Vue data for component if filter state matches.
 
@@ -143,13 +162,19 @@ def _get_cached_vue_data(
         filter_state_hashable: Current filter state (for cache validation)
 
     Returns:
-        Tuple of (vue_data, data_hash) if cache hit, None otherwise
+        Tuple of (vue_data, data_hash, annotation_hash) if cache hit, None otherwise
     """
     cache = _get_component_cache()
     if component_id in cache:
-        cached_state, vue_data, data_hash = cache[component_id]
+        entry = cache[component_id]
+        # Support both old (3-tuple) and new (4-tuple) format
+        if len(entry) == 4:
+            cached_state, vue_data, data_hash, ann_hash = entry
+        else:
+            cached_state, vue_data, data_hash = entry
+            ann_hash = None
         if cached_state == filter_state_hashable:
-            return (vue_data, data_hash)
+            return (vue_data, data_hash, ann_hash)
     return None
 
 
@@ -158,6 +183,7 @@ def _set_cached_vue_data(
     filter_state_hashable: Tuple[Tuple[str, Any], ...],
     vue_data: Dict[str, Any],
     data_hash: str,
+    ann_hash: Optional[str] = None,
 ) -> None:
     """
     Cache Vue data for component, replacing any previous entry.
@@ -169,9 +195,10 @@ def _set_cached_vue_data(
         filter_state_hashable: Current filter state
         vue_data: Data to cache
         data_hash: Hash of the data
+        ann_hash: Hash of dynamic annotations (if any)
     """
     cache = _get_component_cache()
-    cache[component_id] = (filter_state_hashable, vue_data, data_hash)
+    cache[component_id] = (filter_state_hashable, vue_data, data_hash, ann_hash)
 
 
 def _prepare_vue_data_cached(
@@ -208,8 +235,14 @@ def _prepare_vue_data_cached(
     # Try cache first (works for ALL components now)
     cached = _get_cached_vue_data(component_id, filter_state_hashable)
 
+    if _DEBUG_HASH_TRACKING:
+        cache_hit = cached is not None
+        _logger.warning(
+            f"[CacheDebug] {component._cache_id}: cache_hit={cache_hit}"
+        )
+
     if cached is not None:
-        cached_data, cached_hash = cached
+        cached_data, cached_hash, _ = cached  # Ignore cached annotation hash here
 
         if has_dynamic_annotations:
             # Cache hit but need to re-apply annotations (they may have changed)
@@ -232,6 +265,9 @@ def _prepare_vue_data_cached(
     # Cache miss - compute data
     vue_data = component._prepare_vue_data(state_dict)
 
+    # Compute annotation hash for cache storage
+    ann_hash = _compute_annotation_hash(component)
+
     if has_dynamic_annotations:
         # Store BASE data (without dynamic annotation columns) in cache
         if hasattr(component, "_strip_dynamic_columns"):
@@ -240,7 +276,7 @@ def _prepare_vue_data_cached(
             # Fallback: store without _plotConfig (may have stale column refs)
             base_data = {k: v for k, v in vue_data.items() if k != "_plotConfig"}
         base_hash = _hash_data(base_data)
-        _set_cached_vue_data(component_id, filter_state_hashable, base_data, base_hash)
+        _set_cached_vue_data(component_id, filter_state_hashable, base_data, base_hash, ann_hash)
 
         # Return full data with annotations
         data_hash = _hash_data(vue_data)
@@ -248,7 +284,7 @@ def _prepare_vue_data_cached(
     else:
         # Store complete data in cache
         data_hash = _hash_data(vue_data)
-        _set_cached_vue_data(component_id, filter_state_hashable, vue_data, data_hash)
+        _set_cached_vue_data(component_id, filter_state_hashable, vue_data, data_hash, ann_hash)
         return vue_data, data_hash
 
 
@@ -303,14 +339,17 @@ def render_component(
     """
     Render a component in Streamlit.
 
-    This function:
-    1. Gets current state from StateManager
-    2. Calls component._prepare_vue_data() to get filtered data (cached!)
-    3. Computes hash for change detection
-    4. Only sends data if hash changed from last render (optimization)
-    5. Calls the Vue component with data payload
-    6. Updates StateManager from Vue response
-    7. Triggers st.rerun() if state changed
+    This function uses a two-phase approach to handle state synchronization:
+
+    Phase 1: Call vue_func with CACHED data to get Vue's request
+    Phase 2: Apply Vue's request, then prepare UPDATED data for next render
+
+    This order is critical because Vue's request (e.g., page change, sort) is only
+    available after calling vue_func(). By calling it first with cached data, we:
+    1. Get Vue's request immediately
+    2. Apply it to state BEFORE preparing data
+    3. Prepare correct data for the next render
+    4. Rerun to send the correct data
 
     Args:
         component: The component to render
@@ -321,146 +360,113 @@ def render_component(
     Returns:
         The value returned by the Vue component
     """
-    # Get current state
-    state = state_manager.get_state_for_vue()
-
-    # Batch resend: if any component requested data in previous run, clear ALL hashes
-    # This ensures all components get data in one rerun instead of O(N) reruns
-    if st.session_state.get(_BATCH_RESEND_KEY):
-        st.session_state[_VUE_ECHOED_HASH_KEY] = {}
-        st.session_state.pop(_BATCH_RESEND_KEY, None)
-
-    # Generate unique key if not provided (needed for cache)
-    # Use cache_id instead of id(component) since components are recreated each rerun
-    # Use JSON serialization for deterministic key generation (hash() can vary)
+    # === PHASE 0: Generate key and get component info ===
     if key is None:
         interactivity_str = json.dumps(component._interactivity or {}, sort_keys=True)
         key = f"svc_{component._cache_id}_{hashlib.md5(interactivity_str.encode()).hexdigest()[:8]}"
 
-    # Check if component has required filters without values
-    # Don't send potentially huge unfiltered datasets - wait for filter selection
-    filters = getattr(component, "_filters", None) or {}
-    filter_defaults = getattr(component, "_filter_defaults", None) or {}
-
-    awaiting_filter = False
-    if filters:
-        # Check each filter - if no value AND no default, we're waiting
-        for identifier in filters.keys():
-            filter_value = state.get(identifier)
-            has_default = identifier in filter_defaults
-            if filter_value is None and not has_default:
-                awaiting_filter = True
-                break
-
-    # Extract state keys that affect this component's data for cache key
-    # This includes filters and any additional dependencies (e.g., zoom for heatmaps)
-    # Uses get_state_dependencies() which can be overridden by subclasses
-    state_keys = set(component.get_state_dependencies())
-
-    # Build hashable version for cache key (converts dicts/lists to JSON strings)
-    filter_state_hashable = tuple(
-        sorted((k, _make_hashable(state.get(k))) for k in state_keys)
-    )
-
-    # Build original state dict for passing to _prepare_vue_data
-    # (contains actual values, not JSON strings)
-    relevant_state = {k: state.get(k) for k in state_keys}
-
-    # Build component ID for cache (includes type to avoid collisions)
     component_type = component._get_vue_component_name()
     component_id = f"{component_type}:{key}"
-
-    # Skip data preparation if awaiting required filter selection
-    # This prevents sending huge unfiltered datasets
-    if awaiting_filter:
-        vue_data = {}
-        data_hash = "awaiting_filter"
-    else:
-        # Get component data using per-component cache
-        # Each component stores exactly one entry (current filter state)
-        # - Filterless components: filter_state=() always → always cache hit
-        # - Filtered components: cache hit when filter values unchanged
-        vue_data, data_hash = _prepare_vue_data_cached(
-            component, component_id, filter_state_hashable, relevant_state
-        )
-
     component_args = component._get_component_args()
+    if height is not None:
+        component_args["height"] = height
+
+    # Batch resend: if any component requested data in previous run, clear ALL hashes
+    if st.session_state.get(_BATCH_RESEND_KEY):
+        st.session_state[_VUE_ECHOED_HASH_KEY] = {}
+        st.session_state.pop(_BATCH_RESEND_KEY, None)
 
     # Initialize hash cache in session state if needed
     if _VUE_ECHOED_HASH_KEY not in st.session_state:
         st.session_state[_VUE_ECHOED_HASH_KEY] = {}
 
-    # Hash tracking key is the component's Streamlit key
-    # Filter state changes are handled by data_hash comparison (different data = different hash)
-    hash_tracking_key = key
+    # === PHASE 1: Get CACHED data from previous render ===
+    cache = _get_component_cache()
+    cached_entry = cache.get(component_id)
 
-    # Get Vue's last-echoed hash for this component
-    # This is what Vue reported having in its last response
-    vue_echoed_hash = st.session_state[_VUE_ECHOED_HASH_KEY].get(hash_tracking_key)
+    # Get current state for initial render (may be stale until we apply Vue's request)
+    initial_state = state_manager.get_state_for_vue()
 
-    # Send data if Vue's hash doesn't match current hash
-    # This handles: first render, data change, browser refresh, Vue hot reload
-    # Vue echoes null/None if it has no data, so mismatch triggers send
-    # IMPORTANT: Also send data if vue_echoed_hash is None - this means Vue
-    # hasn't confirmed receipt yet (e.g., after page navigation destroys Vue component)
-    # NOTE: Hash now correctly reflects annotation state (annotations included in hash),
-    # so normal comparison works for all components including those with dynamic annotations
-    data_changed = (vue_echoed_hash is None) or (vue_echoed_hash != data_hash)
+    # Pre-compute initial selections BEFORE Vue renders (for first render only)
+    if hasattr(component, "get_initial_selection"):
+        initial_selection = component.get_initial_selection(initial_state)
+        if initial_selection:
+            for identifier, value in initial_selection.items():
+                state_manager.set_selection(identifier, value)
+            initial_state = state_manager.get_state_for_vue()
 
-    # Debug logging for hash tracking issues
-    if _DEBUG_HASH_TRACKING:
-        _logger.warning(
-            f"[HashTrack] {component._cache_id}: "
-            f"data_changed={data_changed}, "
-            f"vue_echoed={vue_echoed_hash[:8] if vue_echoed_hash else 'None'}, "
-            f"data_hash={data_hash[:8] if data_hash else 'None'}, "
-            f"key={hash_tracking_key[:50]}..."
-        )
+    # Compute current filter state for cache validity check
+    # This tells us what state the component SHOULD have data for
+    state_keys = set(component.get_state_dependencies())
+    current_filter_state = tuple(
+        sorted((k, _make_hashable(initial_state.get(k))) for k in state_keys)
+    )
 
-    # Only include full data if hash changed
-    if data_changed:
-        # Convert any non-pandas data to pandas for Arrow serialization
-        # pandas DataFrames are passed through (already optimal for Arrow)
-        # Filter out _hash (internal metadata) but keep _plotConfig (needed by Vue)
-        converted_data = {}
-        for data_key, value in vue_data.items():
-            if data_key == "_hash":
-                # Skip internal hash metadata
-                continue
-            if isinstance(value, pl.LazyFrame):
-                converted_data[data_key] = value.collect().to_pandas()
-            elif isinstance(value, pl.DataFrame):
-                converted_data[data_key] = value.to_pandas()
-            else:
-                converted_data[data_key] = value
-            # pandas DataFrames pass through unchanged (optimal for Arrow)
+    # Check if cached data is VALID for current state
+    # KEY FIX: Only send data when cache matches current state
+    # - Before: Always sent cached data, even if stale (page 38 when Vue wants page 1)
+    # - Now: Only send if cache matches current state AND annotation state matches
+    cache_valid = False
+    current_ann_hash = _compute_annotation_hash(component)
+
+    if cached_entry is not None:
+        # Support both old (3-tuple) and new (4-tuple) cache format
+        if len(cached_entry) == 4:
+            cached_state, cached_data, cached_hash, cached_ann_hash = cached_entry
+        else:
+            cached_state, cached_data, cached_hash = cached_entry
+            cached_ann_hash = None
+
+        # Cache valid only if BOTH filter state AND annotation state match
+        filter_state_matches = (cached_state == current_filter_state)
+        ann_state_matches = (cached_ann_hash == current_ann_hash)
+        cache_valid = filter_state_matches and ann_state_matches
+
+        if _DEBUG_STATE_SYNC:
+            _logger.warning(
+                f"[Bridge:{component._cache_id}] Phase1: cache_valid={cache_valid}, "
+                f"filter_match={filter_state_matches}, ann_match={ann_state_matches}, "
+                f"cached_ann={cached_ann_hash}, current_ann={current_ann_hash}"
+            )
+
+    # Build payload - only send data if cache is valid for current state
+    if cache_valid:
+        # Cache HIT - send cached data (it's correct for current state)
         data_payload = {
-            **converted_data,
-            "selection_store": state,
-            "hash": data_hash,
+            **cached_data,
+            "selection_store": initial_state,
+            "hash": cached_hash,
             "dataChanged": True,
-            "awaitingFilter": awaiting_filter,
+            "awaitingFilter": False,
         }
-        # Note: We don't pre-set the hash here anymore. We trust Vue's echo
-        # at the end of the render cycle. This ensures we detect when Vue
-        # loses its data (e.g., page navigation) and needs it resent.
+        if _DEBUG_STATE_SYNC:
+            # Log pagination state for debugging
+            pagination_key = next((k for k in state_keys if "page" in k.lower()), None)
+            if pagination_key:
+                _logger.warning(
+                    f"[Bridge:{component._cache_id}] Phase1: Cache HIT, "
+                    f"sending data with hash={cached_hash[:8]}, "
+                    f"pagination={initial_state.get(pagination_key)}"
+                )
     else:
-        # Data unchanged - only send hash and state, Vue will use cached data
+        # Cache MISS (no cache, or state mismatch) - don't send stale data
+        # Vue will show loading or use its local cache
         data_payload = {
-            "selection_store": state,
-            "hash": data_hash,
+            "selection_store": initial_state,
+            "hash": "",
             "dataChanged": False,
-            "awaitingFilter": awaiting_filter,
+            "awaitingFilter": False,
         }
-
-    # Add height to component args if specified
-    if height is not None:
-        component_args["height"] = height
+        if _DEBUG_STATE_SYNC:
+            _logger.warning(
+                f"[Bridge:{component._cache_id}] Phase1: Cache MISS, "
+                f"not sending data (cached_entry={cached_entry is not None})"
+            )
 
     # Component layout: [[{componentArgs: {...}}]]
     components = [[{"componentArgs": component_args}]]
 
-    # Call Vue component
+    # === PHASE 2: Call vue_func to get Vue's request ===
     vue_func = get_vue_component_function()
 
     kwargs = {
@@ -471,39 +477,141 @@ def render_component(
     if height is not None:
         kwargs["height"] = height
 
+    if _DEBUG_STATE_SYNC:
+        _logger.warning(
+            f"[Bridge:{component._cache_id}] Phase2: Calling vue_func to get request"
+        )
+
     result = vue_func(**kwargs)
 
-    # Update state from Vue response
+    # === PHASE 3: Apply Vue's request FIRST ===
+    state_changed = False
     if result is not None:
-        # Store Vue's echoed hash for next render comparison
-        # Only store non-None hashes - Vue echoes None during initialization
-        # before receiving data, which would corrupt our tracking. Preserving
-        # the previous valid hash prevents unnecessary data resends.
+        # Debug logging: what we received from Vue
+        if _DEBUG_STATE_SYNC:
+            vue_counter = result.get("counter")
+            vue_keys = [k for k in result.keys() if not k.startswith("_")]
+            _logger.warning(
+                f"[Bridge:{component._cache_id}] Phase3: Received counter={vue_counter}, "
+                f"keys={vue_keys}, _requestData={result.get('_requestData', False)}"
+            )
+
+        # Store Vue's echoed hash
         vue_hash = result.get("_vueDataHash")
         if vue_hash is not None:
-            st.session_state[_VUE_ECHOED_HASH_KEY][hash_tracking_key] = vue_hash
-
-        # Check if Vue is requesting data due to cache miss (e.g., after page navigation)
-        # Vue's cache was empty when it received dataChanged=false, so it needs data resent
-        request_data = result.get("_requestData", False)
-        if request_data and not data_changed:
-            # Vue needs data and we didn't just send it - batch for next run
-            # This triggers ONE rerun that clears ALL hashes, so all components
-            # get data together instead of O(N) separate reruns
+            st.session_state[_VUE_ECHOED_HASH_KEY][key] = vue_hash
+
+        # Apply Vue's state update FIRST - this is the key fix!
+        state_changed = state_manager.update_from_vue(result)
+
+        # Check if Vue is requesting data resend
+        if result.get("_requestData", False):
             st.session_state[_BATCH_RESEND_KEY] = True
-            # Note: if data_changed=True, we just sent data so requestData is stale
 
-        # Capture annotations from Vue (e.g., from SequenceView)
-        # Use hash-based change detection for robustness
+    # === PHASE 4: Get UPDATED state and prepare data ===
+    # Now state reflects Vue's request (e.g., new page number after click)
+    state = state_manager.get_state_for_vue()
+
+    # Check if component has required filters without values
+    filters = getattr(component, "_filters", None) or {}
+    filter_defaults = getattr(component, "_filter_defaults", None) or {}
+
+    awaiting_filter = False
+    for identifier in filters.keys():
+        if state.get(identifier) is None and identifier not in filter_defaults:
+            awaiting_filter = True
+            break
+
+    if not awaiting_filter:
+        # Extract state keys that affect this component's data
+        state_keys = set(component.get_state_dependencies())
+        relevant_state = {k: state.get(k) for k in state_keys}
+
+        # Build hashable version for cache key
+        filter_state_hashable = tuple(
+            sorted((k, _make_hashable(state.get(k))) for k in state_keys)
+        )
+
+        if _DEBUG_HASH_TRACKING:
+            _logger.warning(
+                f"[CacheKey] {component._cache_id}: state_keys={list(state_keys)}"
+            )
+            for k in state_keys:
+                if "page" in k.lower():
+                    _logger.warning(
+                        f"[CacheKey] {component._cache_id}: {k}={state.get(k)}"
+                    )
+
+        # Prepare data with UPDATED state (includes Vue's request)
+        # This may also call set_selection() to override (e.g., sort resets page)
+        vue_data, data_hash = _prepare_vue_data_cached(
+            component, component_id, filter_state_hashable, relevant_state
+        )
+
+        # Check if Python overrode state during _prepare_vue_data
+        # (e.g., table.py sets page to last page after sort)
+        final_state = state_manager.get_state_for_vue()
+        if final_state != state:
+            state_changed = True
+            if _DEBUG_STATE_SYNC:
+                _logger.warning(
+                    f"[Bridge:{component._cache_id}] Phase4: Python overrode state"
+                )
+    else:
+        vue_data = {}
+        data_hash = "awaiting_filter"
+        filter_state_hashable = ()
+
+    _logger.info(f"[bridge] Phase4: {component._cache_id} prepared data, hash={data_hash[:8] if data_hash else 'None'}")
+
+    # === PHASE 5: Cache data for next render ===
+    if vue_data:
+        # Convert for caching (Arrow serialization requires pandas)
+        converted_data = {}
+        for data_key, value in vue_data.items():
+            if data_key == "_hash":
+                continue
+            if isinstance(value, pl.LazyFrame):
+                converted_data[data_key] = value.collect().to_pandas()
+            elif isinstance(value, pl.DataFrame):
+                converted_data[data_key] = value.to_pandas()
+            else:
+                converted_data[data_key] = value
+
+        # Store in cache for next render (include annotation hash for validity check)
+        cache[component_id] = (filter_state_hashable, converted_data, data_hash, current_ann_hash)
+
+        # If cache was invalid at Phase 1, we didn't send data to Vue (dataChanged=False).
+        # Trigger a rerun so the newly cached data gets sent on the next render.
+        # This handles cross-component filter changes where the affected component
+        # needs to receive updated data (e.g., new total_rows/total_pages).
+        if not cache_valid:
+            state_changed = True
+            if _DEBUG_STATE_SYNC:
+                _logger.warning(
+                    f"[Bridge:{component._cache_id}] Phase5: Cache was invalid, "
+                    f"triggering rerun to send newly cached data"
+                )
+
+        if _DEBUG_STATE_SYNC:
+            # Log what we're caching for debugging
+            pagination_key = next((k for k, v in filter_state_hashable if "page" in k.lower()), None)
+            if pagination_key:
+                pagination_val = next((v for k, v in filter_state_hashable if k == pagination_key), None)
+                _logger.warning(
+                    f"[Bridge:{component._cache_id}] Phase5: Cached data with hash={data_hash[:8]}, "
+                    f"filter_state includes {pagination_key}={pagination_val}"
+                )
+
+    # Handle annotations from Vue (e.g., from SequenceView)
+    if result is not None:
         annotations = result.get("_annotations")
         annotations_changed = False
 
         if annotations is not None:
-            # Compute hash of new annotations
             peak_ids = annotations.get("peak_id", [])
             new_hash = hash(tuple(peak_ids)) if peak_ids else 0
 
-            # Compare with stored hash
             ann_hash_key = f"_svc_ann_hash_{key}"
             old_hash = st.session_state.get(ann_hash_key)
 
@@ -513,18 +621,27 @@ def render_component(
 
             _store_component_annotations(key, annotations)
         else:
-            # Annotations cleared - check if we had annotations before
             ann_hash_key = f"_svc_ann_hash_{key}"
             if st.session_state.get(ann_hash_key) is not None:
                 annotations_changed = True
                 st.session_state[ann_hash_key] = None
 
-        # Update state and rerun if state changed OR annotations changed OR batch resend needed
-        # Only rerun for requestData if we didn't already send data (to avoid stale triggers)
-        state_changed = state_manager.update_from_vue(result)
-        needs_batch_resend = request_data and not data_changed
-        if state_changed or annotations_changed or needs_batch_resend:
-            st.rerun()
+        if annotations_changed:
+            state_changed = True
+
+    # === PHASE 6: Rerun if state changed ===
+    # This will send the UPDATED data (now in cache) to Vue
+    if state_changed:
+        if _DEBUG_STATE_SYNC:
+            _logger.warning(
+                f"[Bridge:{component._cache_id}] Phase6: RERUN triggered, "
+                f"next render will have cache HIT"
+            )
+        st.rerun()
+    elif _DEBUG_STATE_SYNC:
+        _logger.warning(
+            f"[Bridge:{component._cache_id}] Phase6: No rerun needed, state_changed=False"
+        )
 
     return result
 
@@ -546,8 +663,8 @@ def _hash_data(data: Dict[str, Any]) -> str:
 
     hash_parts = []
     for key, value in sorted(data.items()):
-        # Skip internal metadata but NOT dynamic annotation columns
-        if key.startswith("_") and not key.startswith("_dynamic"):
+        # Skip internal metadata but NOT dynamic annotation columns or pagination
+        if key.startswith("_") and not key.startswith("_dynamic") and not key.startswith("_pagination"):
             continue
         if isinstance(value, pd.DataFrame):
             # Efficient hash for DataFrames

{openms_insight-0.1.7.dist-info → openms_insight-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openms-insight
-Version: 0.1.7
+Version: 0.1.9
 Summary: Interactive visualization components for mass spectrometry data in Streamlit
 Project-URL: Homepage, https://github.com/t0mdavid-m/OpenMS-Insight
 Project-URL: Documentation, https://github.com/t0mdavid-m/OpenMS-Insight#readme
@@ -47,7 +47,7 @@ Interactive visualization components for mass spectrometry data in Streamlit, ba
 - **Memory-efficient preprocessing** via subprocess isolation
 - **Automatic disk caching** with config-based invalidation
 - **Cache reconstruction** - components can be restored from cache without re-specifying configuration
-- **Table component** (Tabulator.js) with filtering, sorting, go-to, pagination, CSV export
+- **Table component** (Tabulator.js) with server-side pagination, filtering, sorting, go-to, CSV export
 - **Line plot component** (Plotly.js) with highlighting, annotations, zoom
 - **Heatmap component** (Plotly scattergl) with multi-resolution downsampling for millions of points
 - **Volcano plot component** for differential expression visualization with significance thresholds
@@ -167,7 +167,7 @@ Table(
 - `index_field`: Column used as unique row identifier (default: 'id')
 - `go_to_fields`: Columns available in "Go to" navigation
 - `initial_sort`: Default sort configuration
-- `pagination`: Enable pagination for large tables (default: True)
+- `pagination`: Enable server-side pagination (default: True). Only the current page of data is sent to the browser, dramatically reducing memory usage for large datasets.
 - `page_size`: Rows per page (default: 100)
 
 **Custom formatters:**

{openms_insight-0.1.7.dist-info → openms_insight-0.1.9.dist-info}/RECORD

@@ -3,28 +3,28 @@ openms_insight/components/__init__.py,sha256=Lcg-D0FILta-YVgMJBlWMKLKC5G5kXOqdy9
 openms_insight/components/heatmap.py,sha256=psrdW4gNzZR1jAIox9YS9EHaZaTRrDHFR0t2_0APU9Y,47214
 openms_insight/components/lineplot.py,sha256=I-JPvDzCr3Nu8Boc1V4D8QQ1bHgTqvM6CbeoIe7zJ-s,30896
 openms_insight/components/sequenceview.py,sha256=0pDOE0xeoc1-85QZNGdNwwoBwXi-5MFfeb9pCcOi6rc,30274
-openms_insight/components/table.py,sha256=wmq1rjGVe4Ef0SAf5p85pfVCeyLlVevZnxBc9EIg2uk,16458
+openms_insight/components/table.py,sha256=6r0SiWTDSJS6AHNCy4jTxByY9aCt4ussCQFKKrEg77U,36955
 openms_insight/components/volcanoplot.py,sha256=F-cmYxJMKXVK-aYJpifp8be7nB8hkQd2kLi9DrBElD8,15155
 openms_insight/core/__init__.py,sha256=EPjKX_FFQRgO8mWHs59I-o0BiuzEMzEU1Pfu9YOfLC4,338
-openms_insight/core/base.py,sha256=6hxmII90LlbwTy06BJvUdJjXpd8Oqjqdt452AJixJSs,19742
+openms_insight/core/base.py,sha256=h0OaubHLky8mk7Yfy3HTIimsz-DfuNRgLfotJu3pZVw,20517
 openms_insight/core/cache.py,sha256=3fnPDWjuWUnxazK2XflcUIeRZZPQ3N45kAKYu-xGBKw,1197
 openms_insight/core/registry.py,sha256=Hak80Jqhx0qa4gbd1YolNZnM6xBrS8I4U_X7zC0bQ8Y,2108
-openms_insight/core/state.py,sha256=_vNYxYHYFgIigbkqYwkIO6cBGFJyF2VN9dr7CBEAQbY,6873
+openms_insight/core/state.py,sha256=CMToxxNyGnqxMccwOcn7FwABNTzjjTsgsMrJCZOZc2o,12438
 openms_insight/core/subprocess_preprocess.py,sha256=m9FbAAFy9Do1Exlh-m4Wo-LDwv6yHlEI4klz5OVwemc,3133
 openms_insight/preprocessing/__init__.py,sha256=xoGdhNVrX8Ty3ywmyaCcWAO3a6QlKceO1xxsy1C8ZTI,596
 openms_insight/preprocessing/compression.py,sha256=T4YbX9PUlfTfPit_kpuLZn8hYpqLYu3xtTme_CG2ymc,12241
 openms_insight/preprocessing/filtering.py,sha256=fkmaIXfR5hfjyWfaMYqaeybMHaZjvUZYaKCqvxPOWMQ,14152
 openms_insight/preprocessing/scatter.py,sha256=2ifCNTUKHEW9UVpv4z9c5GaLnz5zw9o1119IenzAe9s,4703
 openms_insight/rendering/__init__.py,sha256=ApHvKeh87yY4GTIEai-tCeIXpNbwOXWlmcmIwMMRZYc,198
-openms_insight/rendering/bridge.py,sha256=CxOcGWXZkR968_6x5-AkfxNYqKBIuuLya6RZVhZyMr0,21494
+openms_insight/rendering/bridge.py,sha256=a_6lq3jR9tDFxdSxMjeJhyV_Tgw7ALcm-UFEvl_TE_M,25615
 openms_insight/js-component/dist/index.html,sha256=LSJ3B_YmGUrCCdZ1UaZO2p6Wqsih6nTH62Z_0uZxpD8,430
 openms_insight/js-component/dist/assets/index.css,sha256=wFvo7FbG132LL7uw0slXfrL_oSQ8u2RKL1DW9hD9-kk,884264
-openms_insight/js-component/dist/assets/index.js,sha256=rCYOyEKHcbMbz2V4RflVTQ8UW8fGuvZN6kFVxb-10tI,6075229
+openms_insight/js-component/dist/assets/index.js,sha256=aqGc3g7XLTRr7ptEgoA3XDu5oMS47yxxjUBXgansIo0,6091480
 openms_insight/js-component/dist/assets/materialdesignicons-webfont.eot,sha256=CxgxBNL8XyYZbnc8d72vLgVQn9QlnS0V7O3Kebh-hPk,1307880
 openms_insight/js-component/dist/assets/materialdesignicons-webfont.ttf,sha256=YeirpaTpgf4iz3yOi82-oAR251xiw38Bv37jM2HWhCg,1307660
 openms_insight/js-component/dist/assets/materialdesignicons-webfont.woff,sha256=pZKKDVwvYk5G-Y2bFcL2AEU3f3xZTdeKF1kTLqO0Y-s,587984
 openms_insight/js-component/dist/assets/materialdesignicons-webfont.woff2,sha256=Zi_vqPL4qVwYWI0hd0eJwQfGTnccvmWmmvRikcQxGvw,403216
-openms_insight-0.1.7.dist-info/METADATA,sha256=NvzVktj8Tyah67T7yAzUwEGuZFqXkiGV5GlTlY8aZyI,16670
-openms_insight-0.1.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-openms_insight-0.1.7.dist-info/licenses/LICENSE,sha256=INFF4rOMmpah7Oi14hLqu7NTOsx56KRRNChAAUcfh2E,1823
-openms_insight-0.1.7.dist-info/RECORD,,
+openms_insight-0.1.9.dist-info/METADATA,sha256=--VBuRN6Co39E_BZYFk6OwYkOyWEE9uOq_OBK21PdWE,16787
+openms_insight-0.1.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+openms_insight-0.1.9.dist-info/licenses/LICENSE,sha256=INFF4rOMmpah7Oi14hLqu7NTOsx56KRRNChAAUcfh2E,1823
+openms_insight-0.1.9.dist-info/RECORD,,