1. Off-by-one waste on first/last pages → unnecessary pagination                                                                                                                                                                                                                                                 
   
  computePageSlice reserves space for both Previous and Next rows on every page (itemsPerPage = listLimit - 2), but page 0 has no Previous and the last page has no Next. So one slot is wasted at each end of the pagination, and lists that should fit on a single page get split.                               
                                                            
  Example with listLimit = 10, totalItems = 9:                                                                                                                                                                                                                                                                     
                                                            
  - itemsPerPage = 8                                                                                                                                                                                                                                                                                               
  - Page 0: 8 entities + Next = 9 rows
  - Page 1: Prev + 1 entity = 2 rows                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                   
  …even though all 9 entities would fit on a single page (9 ≤ 10). The user has to tap "Next" for one orphan entity.                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                   
  Fix: compute the slot reservation per-page based on whether nav rows are actually rendered. Roughly:                                                                                                                                                                                                             
                                                            
  val capacity = listLimit - (if (page > 0) 1 else 0)  // reserve Prev                                                                                                                                                                                                                                             
  val tentativeTo = minOf(page * itemsPerPage(prevPages) + capacity, totalItems)                                                                                                                                                                                                                                   
  val needsNext = tentativeTo < totalItems                                                                                                                                                                                                                                                                         
  val from = page * itemsPerPage                                                                                                                                                                                                                                                                                   
  val to = minOf(from + capacity - if (needsNext) 1 else 0, totalItems)                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                   
  You'll want a few unit tests for boundaries (totalItems == listLimit, totalItems == listLimit + 1, last-page-just-fits).                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                   
  2. Overflow when listLimit ≤ 3                                                                                                                                                                                                                                                                                   
                                                            
  itemsPerPage = (listLimit - 2).coerceAtLeast(1) clamps the items, but the total rows on middle pages is Prev + items + Next = items + 2. With listLimit = 2 or 3 and a middle page, you render 3 rows against a 2- or 3-row host limit. Latent bug — current AAOS hosts return 6+, but worth defending against.  
   
  3. subList reads entities twice without a snapshot                                                                                                                                                                                                                                                               
                                                            
  val pageSlice = computePageSlice(entities.size, page, listLimit)                                                                                                                                                                                                                                                 
  val pageEntities = if (isLoaded && pageSlice.fromIndex < entities.size) {                                                                                                                                                                                                                                        
      entities.subList(pageSlice.fromIndex, pageSlice.toIndex)  // ← entities may have changed
  } else { emptyList() }                                                                                                                                                                                                                                                                                           
                                                            
  entities is reassigned by the toggle handler (lifecycleScope.launch) and by the allEntities collector — and the logs from the previous turn show the collector is running on background threads. onGetTemplate runs on the Car App thread. So the size used to compute pageSlice and the size of entities at     
  subList time can differ.                                  
                                                                                                                                                                                                                                                                                                                   
  If entities.size shrinks between the two reads to below pageSlice.toIndex, subList throws IndexOutOfBoundsException. Snapshot once:                                                                                                                                                                              
   
  val snapshot = entities                                                                                                                                                                                                                                                                                          
  val pageSlice = computePageSlice(snapshot.size, page, listLimit)                                                                                                                                                                                                                                                 
  val pageEntities = if (isLoaded && pageSlice.fromIndex < snapshot.size) {
      snapshot.subList(pageSlice.fromIndex, pageSlice.toIndex)                                                                                                                                                                                                                                                     
  } else emptyList()                                        
                                                                                                                                                                                                                                                                                                                   
  4. page is never clamped against current size                                                                                                                                                                                                                                                                    
   
  Nothing recovers if page outlives a list shrink in a way that doesn't trip the listChanged reset (e.g., size shrinks while IDs at lower indices remain identical — your equality check is on the prefix of the list). The user can land on an empty page that only shows "Previous" and has to tap back manually.
   Cheap fix in onGetTemplate:                              
                                                                                                                                                                                                                                                                                                                   
  val maxPage = ((entities.size - 1) / itemsPerPage).coerceAtLeast(0)
  if (page > maxPage) page = maxPage