react-native-pdfrender 0.1.0

package/android/src/main/java/com/pdfrender/PdfViewerActivity.kt

@@ -0,0 +1,3467 @@
+package com.pdfrender
+
+/**
+ * PDF Viewer Activity - Main Entry Point
+ * 
+ * This file contains the main PDF viewer implementation with the following structure:
+ * 
+ * FILE ORGANIZATION:
+ * ==================
+ * 1. PdfViewerActivity - Android Activity class (entry point)
+ * 2. PdfRendererView - Main composable that orchestrates the PDF viewer
+ * 3. State Management - All state variables and their initialization
+ * 4. Helper Functions - Utility functions for safe context switching
+ * 5. Rendering System - Render queue, worker, and page rendering logic
+ * 6. Cache Management - Batch loading and cache size management
+ * 7. Gesture Handling - Pinch zoom gesture detection and handling
+ * 8. Zoom Management - Zoom change handling and debouncing
+ * 9. UI Components - Scaffold, LazyColumn, and page display
+ * 
+ * RELATED FILES:
+ * ==============
+ * - PdfConstants.kt - Constants and configuration values
+ * - PdfRenderingLogic.kt - Page rendering functions
+ * - PdfCacheManager.kt - Cache management utilities
+ * - PdfUIComponents.kt - Reusable UI components
+ * 
+ * KEY CONCEPTS:
+ * ============
+ * - Batch Loading: Pages are loaded in batches of 15 for memory efficiency
+ * - Render Queue: Sequential processing of render requests prevents conflicts
+ * - Cache Management: Keeps only nearby batches in memory to prevent OOM
+ * - Gesture Handling: Smooth pinch zoom with 60fps updates
+ * - Scale Management: Tracks rendered vs. current scale to avoid stale renders
+ */
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color as AndroidColor
+import android.graphics.pdf.PdfRenderer
+import android.net.Uri
+import android.os.Bundle
+import android.os.ParcelFileDescriptor
+import android.util.Log
+import java.io.InputStream
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.Image
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.platform.LocalContext
+import android.graphics.BitmapFactory
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.net.URL
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.gestures.detectTransformGestures
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.material.Button
+import androidx.compose.material.ButtonDefaults
+import androidx.compose.material.Text
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Scaffold
+import androidx.compose.material.TopAppBar
+import androidx.compose.material.CircularProgressIndicator
+import androidx.compose.material.LinearProgressIndicator
+import androidx.compose.material.Slider
+import androidx.compose.material.Card
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.foundation.layout.size
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.background
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material.Icon
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.tooling.preview.Preview
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.Job
+import androidx.compose.animation.core.AnimationState
+import androidx.compose.animation.core.animateDecay
+import androidx.compose.animation.core.exponentialDecay
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.ui.input.pointer.util.VelocityTracker
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.ConcurrentHashMap
+
+// ============================================================================
+// SECTION 1: ACTIVITY CLASS
+// ============================================================================
+
+/**
+ * Main Activity for PDF Viewer
+ *
+ * Receives PDF URI and optional initial page index from intent,
+ * then displays the PDF viewer composable.
+ */
+class PdfViewerActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val uriString = intent?.getStringExtra("pdf_uri") ?: ""
+        val uri = Uri.parse(uriString)
+        val initialPageIndex = intent?.getIntExtra("initial_page_index", -1) ?: -1
+
+        setContent {
+            MaterialTheme {
+                Box(modifier = Modifier.fillMaxSize().background(Color.Transparent)) {
+                    PdfRendererView(uri, initialPageIndex)
+                }
+            }
+        }
+    }
+}
+
+// ============================================================================
+// SECTION 2: MAIN COMPOSABLE - PDF RENDERER VIEW
+// ============================================================================
+
+/**
+ * Main PDF Renderer View Composable
+ *
+ * This is the root composable that manages the entire PDF viewer state and UI.
+ * It handles:
+ * - PDF loading and initialization
+ * - Page rendering and caching
+ * - Gesture handling (pinch zoom)
+ * - Zoom management
+ * - Scroll handling
+ *
+ * @param uri The URI of the PDF file to display (default: Uri.EMPTY for preview)
+ * @param initialPageIndex The page index to scroll to initially (-1 for start)
+ */
+@Preview(showBackground = true)
+@Composable
+fun PdfRendererView(
+    uri: Uri = Uri.EMPTY,
+    initialPageIndex: Int = -1,
+    maxWidthDp: androidx.compose.ui.unit.Dp? = null,
+    maxZoom: Float = PdfViewerConfig.MAX_SCALE_SMALL_SCREEN,
+    screenWidthPercentage: Float = 100f,
+    iconUrls: Map<String, String?>? = null,
+    iconSize: androidx.compose.ui.unit.Dp = 40.dp, // Dynamic icon size with default
+    defaultZoom: Float = 1.5f, // Dynamic default zoom scale with fallback
+    isFullScreen: Boolean = false,
+    rightLayout: Boolean = false, // PDF position: true = right side, false = left side
+    backButtonText: String? = null,
+    headerText: String? = null,
+    onFullScreenChange: ((Boolean) -> Unit)? = null,
+    onLeftScreenChange: ((Boolean) -> Unit)? = null,
+    onRightScreenChange: ((Boolean) -> Unit)? = null,
+    onZoomChange: ((Int) -> Unit)? = null
+) {
+
+    // ========================================================================
+    // SECTION 2.1: STATE VARIABLES - PDF Data
+    // ========================================================================
+
+    var pageCount by remember { mutableStateOf(0) }
+    val context = androidx.compose.ui.platform.LocalContext.current
+    var pdfRenderer by remember { mutableStateOf<PdfRenderer?>(null) }
+    var pfd by remember { mutableStateOf<ParcelFileDescriptor?>(null) }
+
+    // ========================================================================
+    // SECTION 2.2: STATE VARIABLES - Page Cache and Rendering
+    // ========================================================================
+
+    // Cache map: pageIndex -> (Bitmap, scale at which it was rendered)
+    var pageCache by remember { mutableStateOf<Map<Int, Pair<Bitmap, Float>>>(emptyMap()) }
+    val renderingPages = remember { ConcurrentHashMap<Int, Long>() }  // Thread-safe: pageIndex -> timestamp
+    val queuedPages = remember { mutableStateOf<Set<Int>>(emptySet()) }  // Pages queued for rendering
+    val activeBitmaps = remember { mutableSetOf<Bitmap>() }  // Track active bitmaps to prevent recycling
+    var reloadVisiblePagesToken by remember { mutableStateOf(0) }  // Triggers reload of currently visible pages
+    val renderingStats = remember { RenderingStats() }  // Track rendering performance statistics
+
+    // ========================================================================
+    // SECTION 2.3: STATE VARIABLES - Zoom and Scale
+    // ========================================================================
+
+    // ========================================================================
+    // ZOOM CONSTANTS - STRICT REQUIREMENTS
+    // ========================================================================
+    // If defaultZoom is provided from JS, use it as the minimum zoom floor.
+    // Otherwise fall back to the global constant (PdfViewerConfig.MIN_SCALE).
+    val MIN_ZOOM = defaultZoom.coerceAtMost(PdfViewerConfig.MAX_SCALE_SMALL_SCREEN)
+
+    // Initialize scale to defaultZoom (dynamic from JS)
+    var scale by remember { mutableStateOf(defaultZoom) }  // Current zoom scale (dynamic default)
+    var lastRenderedScale by remember { mutableStateOf(defaultZoom) }  // Last scale that was rendered (dynamic default)
+    var isZoomInProgress by remember { mutableStateOf(false) }  // True when zoom is changing
+    var lastScaleUpdateTime by remember { mutableStateOf(0L) }  // Throttle scale updates
+
+    // ========================================================================
+    // SECTION 2.4: STATE VARIABLES - Gesture Handling
+    // ========================================================================
+
+    var isPinchZoomActive by remember { mutableStateOf(false) }  // Track active pinch gesture
+    var lastPinchZoomTime by remember { mutableStateOf(0L) }  // Track last pinch zoom time
+    var touchGestureCount by remember { mutableStateOf(0) }  // Track number of touch gestures
+    var recentPinchZoom by remember { mutableStateOf(false) }  // Track if pinch zoom happened recently (keeps pages visible)
+    // Initialize fullscreen state from prop (React Native controls the state)
+    var isFullScreenState by remember { mutableStateOf(true) } // Default to fullscreen
+
+    // Sync with prop changes from React Native (parent controls fullscreen)
+    LaunchedEffect(isFullScreen) {
+        isFullScreenState = isFullScreen
+    }
+
+    // ========================================================================
+    // SECTION 2.5: STATE VARIABLES - Loading State
+    // ========================================================================
+
+    var isInitialLoading by remember { mutableStateOf(true) }
+    var loadingProgress by remember { mutableStateOf(0) }  // 0-100 percentage
+    var loadingStatus by remember { mutableStateOf("Opening PDF...") }
+
+    // ========================================================================
+    // SECTION 2.6: STATE VARIABLES - Batch Management
+    // ========================================================================
+
+    var loadedBatches by remember { mutableStateOf<Set<Int>>(emptySet()) }  // Track which batches are loaded
+
+    // ========================================================================
+    // SECTION 2.7: CONFIGURATION AND HELPERS
+    // ========================================================================
+
+    val renderMutex = remember { Mutex() }  // Mutex for thread-safe PDF renderer access
+    val renderQueue = remember { Channel<RenderRequest>(capacity = Channel.UNLIMITED) }  // Render request queue
+    val configuration = LocalConfiguration.current
+    val screenWidthDp = maxWidthDp ?: configuration.screenWidthDp.dp  // Use maxWidthDp if provided, otherwise use screen width
+    val density = androidx.compose.ui.platform.LocalDensity.current.density
+
+    // Use maxZoom parameter directly (always 2.5f = 250% from ViewManager)
+    // This ensures both buttons and pinch gestures use the same limits: 100% min, 250% max
+    // The maxZoom parameter is always set to 2.5f (250%) to match button zoom limits
+    val effectiveMaxZoom = maxZoom.coerceIn(MIN_ZOOM, PdfViewerConfig.MAX_SCALE_SMALL_SCREEN)
+
+    // Ensure scale is within STRICT bounds (1.0f MINIMUM to effectiveMaxZoom MAXIMUM)
+    LaunchedEffect(effectiveMaxZoom) {
+        scale = scale.coerceIn(MIN_ZOOM, effectiveMaxZoom)
+        lastRenderedScale = lastRenderedScale.coerceIn(MIN_ZOOM, effectiveMaxZoom)
+    }
+
+    // Send zoom percentage updates to React Native when scale changes
+    LaunchedEffect(scale) {
+        // Convert scale (1.0 = 100%) to percentage and send to React Native
+        val zoomPercentage = (scale * 100).toInt()
+        onZoomChange?.invoke(zoomPercentage)
+    }
+
+    // Calculate button disabled states - derived from zoom bounds (NO re-renders)
+    val isZoomInDisabled = scale >= effectiveMaxZoom
+    val isZoomOutDisabled = scale <= MIN_ZOOM
+    
+    // Calculate layout button disabled states based on PDF position
+    // When rightLayout = true: PDF is on right → disable right button, enable left button
+    // When rightLayout = false: PDF is on left → disable left button, enable right button
+    val isLeftLayoutDisabled = !rightLayout // Disable left button when PDF is on left
+    val isRightLayoutDisabled = rightLayout // Disable right button when PDF is on right
+
+    // Use constants from PdfViewerConfig
+    val batchSize = PdfViewerConfig.BATCH_SIZE
+    val maxCacheSize = PdfViewerConfig.MAX_CACHE_SIZE
+    val RENDERING_TIMEOUT_MS = PdfViewerConfig.RENDERING_TIMEOUT_MS
+
+    // ========================================================================
+    // SECTION 2.8: DYNAMIC ZOOM STEP SIZES BASED ON SCREEN SIZE
+    // ========================================================================
+
+    /**
+     * Calculate zoom step sizes based on screen width percentage
+     * - Full screen (100%): Smaller steps (5%) for precise control
+     * - Split screen (<100%): Larger steps proportional to maxZoom for efficient navigation
+     *
+     * The step size is calculated as a percentage of maxZoom to maintain proportional scaling:
+     * - Full screen: step = 0.6f * 0.0833 = 0.05f (5%)
+     * - Split screen: step = 2.5f * 0.04f = 0.10f (10%) - capped for usability
+     */
+    val zoomInStep = if (screenWidthPercentage >= 100f) {
+        // Full screen: use standard 5% step (8.33% of maxZoom 0.6f)
+        0.05f
+    } else {
+        // Split screen: calculate step as percentage of maxZoom, but cap at reasonable value
+        // Use 4% of maxZoom, but ensure minimum 0.10f and maximum 0.15f for usability
+        val calculatedStep = maxZoom * 0.04f
+        calculatedStep.coerceIn(0.10f, 0.15f)
+    }
+
+    val zoomOutStep = zoomInStep  // Use same step size for both directions
+
+    // ========================================================================
+    // SECTION 3: HELPER FUNCTIONS
+    // ========================================================================
+
+    /**
+     * Safely switches to Main thread with proper cancellation handling
+     *
+     * This function handles LeftCompositionCancellationException which is
+     * expected when a composable leaves composition. It's not an error.
+     *
+     * @param block The code block to execute on Main thread
+     * @return The result of the block, or null if cancelled/errored
+     */
+    suspend fun <T> safeMainContext(block: suspend () -> T): T? {
+        return try {
+            withContext(Dispatchers.Main) {
+                block()
+            }
+        } catch (e: kotlinx.coroutines.CancellationException) {
+            // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+            if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                // Expected when composable leaves composition - not an error
+            }
+            throw e
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Requests the UI layer to re-queue currently visible pages.
+     *
+     * This is triggered after aggressive cache cleanups (usually at max zoom) to make
+     * sure the pages that just got evicted are scheduled for rendering again.
+     */
+    suspend fun requestVisiblePagesReload(reason: String) {
+        try {
+            safeMainContext {
+                reloadVisiblePagesToken = reloadVisiblePagesToken + 1
+            }
+        } catch (e: Exception) {
+        }
+    }
+
+    // ========================================================================
+    // SECTION 4: PAGE RENDERING SYSTEM
+    // ========================================================================
+
+    /**
+     * Internal rendering function - renders a single PDF page to a Bitmap
+     *
+     * This function is called by the render worker. It handles:
+     * - Page validation
+     * - Thread-safe page opening (using mutex)
+     * - Bitmap creation with memory management
+     * - Error handling and cleanup
+     * - Performance timing tracking
+     *
+     * @param pageIndex The index of the page to render (0-based)
+     * @param targetScale The scale at which to render (1.0f minimum, up to maxZoom)
+     * @return The rendered Bitmap, or null if rendering failed
+     */
+    suspend fun renderPageInternal(pageIndex: Int, targetScale: Float): Bitmap? = withContext(Dispatchers.Default) {
+        // Use the optimized rendering function with timing
+        val result = renderPageToBitmap(
+            pageIndex = pageIndex,
+            targetScale = targetScale,
+            pageCount = pageCount,
+            pdfRenderer = pdfRenderer,
+            renderMutex = renderMutex,
+            density = density,
+            activeBitmaps = activeBitmaps,
+            logTimings = true  // Enable detailed timing logs
+        )
+        
+        // Add timing to statistics if rendering was successful
+        result?.let { (bitmap, timings) ->
+            renderingStats.addTiming(timings)
+            
+            // Log aggregated stats every 10 pages
+            if (renderingStats.getStats().contains("10")) {
+                Log.i("PdfRenderer", renderingStats.getStats())
+            }
+            
+            bitmap
+        }
+    }
+
+    // ========================================================================
+    // SECTION 5: RENDER WORKER AND WATCHDOG
+    // ========================================================================
+
+    /**
+     * Watchdog - Monitors and clears stuck pages in renderingPages
+     *
+     * Checks every 2 seconds for pages that have been "rendering" for too long
+     * (longer than RENDERING_TIMEOUT_MS). These are likely stuck and need to be cleared.
+     */
+    LaunchedEffect(Unit) {
+        launch(Dispatchers.Default) {
+            while (true) {
+                try {
+                    delay(100) // Check every 2 seconds
+                    val currentTime = System.currentTimeMillis()
+                    val stuckPages = mutableListOf<Int>()
+
+                    // Check for stuck pages in renderingPages
+                    renderingPages.forEach { (pageIndex, startTime) ->
+                        if (currentTime - startTime > RENDERING_TIMEOUT_MS) {
+                            stuckPages.add(pageIndex)
+                        }
+                    }
+
+                    // Clear stuck pages from both renderingPages and queuedPages
+                    if (stuckPages.isNotEmpty()) {
+                        stuckPages.forEach { pageIndex ->
+                            renderingPages.remove(pageIndex)
+                        }
+
+                        try {
+                            withContext(Dispatchers.Main) {
+                                val currentQueued = queuedPages.value
+                                queuedPages.value = currentQueued - stuckPages.toSet()
+                            }
+                        } catch (e: kotlinx.coroutines.CancellationException) {
+                            // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                            if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                                // Expected when composable leaves composition - not an error
+                            } else {
+                                // Other cancellation - also expected
+                            }
+                            throw e
+                        }
+
+                    }
+                } catch (e: kotlinx.coroutines.CancellationException) {
+                    // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                    if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                        // Expected when composable leaves composition - not an error
+                    } else {
+                        // Other cancellation - also expected
+                    }
+                    throw e
+                } catch (e: Exception) {
+                    // Only log actual errors, not cancellations
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    /**
+     * Render Worker - Processes render requests sequentially
+     *
+     * This worker processes render requests from the queue one at a time.
+     * It handles:
+     * - Request validation
+     * - Stale request detection (scale changed)
+     * - Memory management
+     * - Cache updates
+     * - Bitmap recycling
+     */
+    LaunchedEffect(Unit) {
+        launch(Dispatchers.Default) {
+
+            try {
+                for (request in renderQueue) {
+                    var pageIndex: Int? = null
+                    try {
+                        pageIndex = request.pageIndex
+
+                        // Check if PDF renderer is still valid
+                        if (pdfRenderer == null) {
+                            renderingPages.remove(request.pageIndex)
+                            safeMainContext {
+                                queuedPages.value = queuedPages.value - request.pageIndex
+                            }
+                            continue
+                        }
+
+                        // Validate page index
+                        if (request.pageIndex < 0 || request.pageIndex >= pageCount) {
+                            renderingPages.remove(request.pageIndex)
+                            safeMainContext {
+                                queuedPages.value = queuedPages.value - request.pageIndex
+                            }
+                            continue
+                        }
+
+                        // CRITICAL FIX: Don't skip rendering during pinch zoom - allow pages to render
+                        // Only skip during button zoom (isZoomInProgress) to avoid conflicts
+                        // During pinch zoom, pages should render to prevent white screen
+                        val zoomActive = safeMainContext { isZoomInProgress } ?: false
+                        val pinchActive = safeMainContext { isPinchZoomActive } ?: false
+                        val recentPinch = safeMainContext { recentPinchZoom } ?: false
+
+                        // Skip only if button zoom is active (not pinch zoom)
+                        if (zoomActive && !pinchActive && !recentPinch) {
+                            renderingPages.remove(request.pageIndex)
+                            safeMainContext {
+                                queuedPages.value = queuedPages.value - request.pageIndex
+                            }
+                            continue
+                        }
+
+                        // Check if scale has changed significantly since request was queued
+                        // CRITICAL FIX: Reduced threshold from 10% to 5% to catch stale renders faster
+                        // This prevents rendering pages at stale scales during rapid zoom changes
+                        // CRITICAL FIX: During pinch zoom, be more lenient with stale render detection
+                        // This allows pages to render during pinch zoom even if scale changes slightly
+                        val currentRenderedScale = safeMainContext { lastRenderedScale } ?: request.targetScale
+                        val currentScale = safeMainContext { scale } ?: request.targetScale
+                        val scaleDiff = kotlin.math.abs(currentRenderedScale - request.targetScale)
+                        val currentScaleDiff = kotlin.math.abs(currentScale - request.targetScale)
+
+                        // During pinch zoom, use current scale instead of lastRenderedScale for stale detection
+                        // This allows rendering during pinch zoom even if lastRenderedScale hasn't updated yet
+                        val effectiveScaleDiff = if (pinchActive || recentPinch) {
+                            currentScaleDiff  // Use current scale during pinch zoom
+                        } else {
+                            scaleDiff  // Use lastRenderedScale for normal zoom
+                        }
+
+                        // More lenient threshold during pinch zoom
+                        val staleThreshold = if (pinchActive || recentPinch) {
+                            0.15f  // 15% threshold during pinch zoom (more lenient)
+                        } else {
+                            0.05f  // 5% threshold for normal zoom
+                        }
+
+                        if (effectiveScaleDiff > staleThreshold) {
+                            renderingPages.remove(request.pageIndex)
+                            safeMainContext {
+                                queuedPages.value = queuedPages.value - request.pageIndex
+                            }
+                            continue
+                        }
+
+                        // Skip if already cached at this scale (with error handling)
+                        val cached = safeMainContext { pageCache[request.pageIndex] }
+                        if (cached != null && kotlin.math.abs(cached.second - request.targetScale) < 0.08f) {
+                            // Remove from queued if it was there
+                            safeMainContext {
+                                queuedPages.value = queuedPages.value - request.pageIndex
+                            }
+                            continue
+                        }
+
+                        // Check if page is being rendered - but allow stale entries to be re-rendered
+                        val renderStartTime = renderingPages[request.pageIndex]
+                        val currentTime = System.currentTimeMillis()
+                        val isStale = renderStartTime != null && (currentTime - renderStartTime) > RENDERING_TIMEOUT_MS
+
+                        if (renderStartTime != null && !isStale) {
+                            // Remove from queued if it was there
+                            try {
+            withContext(Dispatchers.Main) {
+                                    queuedPages.value = queuedPages.value - request.pageIndex
+                                }
+                            } catch (e: Exception) {
+                            }
+                            continue
+                        }
+
+                        if (isStale && renderStartTime != null) {
+                            renderingPages.remove(request.pageIndex)  // Clear stale entry
+                        }
+
+                        // Check memory before rendering
+                        val runtime = Runtime.getRuntime()
+                        val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+                        val maxMemory = runtime.maxMemory()
+                        val memoryUsagePercent = (usedMemory * 100 / maxMemory).toInt()
+
+                        // CRITICAL FIX: At max zoom, be more conservative with memory thresholds
+                        // Max zoom creates much larger bitmaps, so we need higher thresholds
+                        // Reuse currentScale from above (line 568) to avoid duplicate declaration
+                        val isMaxZoom = currentScale > 1.0f
+
+                        // Adjust memory threshold based on zoom level
+                        // At max zoom, allow higher memory usage before aggressive cleanup
+                        val memoryThreshold = if (isMaxZoom) {
+                            85  // Higher threshold for max zoom (was 75)
+                        } else {
+                            75  // Normal threshold for regular zoom
+                        }
+
+                        // If memory is high, clean cache before rendering
+                        if (memoryUsagePercent > memoryThreshold) {
+
+                            // CRITICAL FIX: At max zoom, preserve pages at current scale to prevent white screen
+                            // Keep visible pages and pages at current scale, not just batches
+                            val currentBatch = request.pageIndex / batchSize
+                            val batchesToKeep = setOf(currentBatch - 1, currentBatch, currentBatch + 1)
+                                .filter { batchNum -> batchNum >= 0 && batchNum * batchSize < pageCount }
+
+                            try {
+                                // CRITICAL: Collect bitmaps to recycle BEFORE updating cache
+                                val bitmapsToRecycle = mutableListOf<Bitmap>()
+
+                                withContext(Dispatchers.Main) {
+                                    // CRITICAL FIX: At max zoom, preserve pages at current scale
+                                    // This prevents white screen when scrolling at max zoom
+                                    val pagesToKeep = if (isMaxZoom) {
+                                        pageCache.filter { (pageIndex, pair) ->
+                                            val pageBatch = pageIndex / batchSize
+                                            val bitmapScale = pair.second
+                                            val scaleDiff = kotlin.math.abs(bitmapScale - currentScale)
+
+                                            // Keep pages in nearby batches OR pages at current scale (max zoom)
+                                            batchesToKeep.contains(pageBatch) || scaleDiff < 0.50f
+                                        }
+                                    } else {
+                                        // Normal zoom: just keep nearby batches
+                                        pageCache.filter { (pageIndex, _) ->
+                                            val pageBatch = pageIndex / batchSize
+                                            batchesToKeep.contains(pageBatch)
+                                        }
+                                    }
+
+                                    // Collect bitmaps that will be removed (but don't recycle yet)
+                                    pageCache.forEach { (pageIndex, pair) ->
+                                        if (!pagesToKeep.containsKey(pageIndex)) {
+                                            bitmapsToRecycle.add(pair.first)
+                                        }
+                                    }
+
+                                    // CRITICAL: Update cache FIRST
+                                    pageCache = pagesToKeep
+                                }
+
+                                // CRITICAL: Wait to ensure UI has stopped using removed bitmaps
+                                delay(100)
+
+                                // CRITICAL: Now safely recycle removed bitmaps AFTER cache update
+                                bitmapsToRecycle.forEach { bitmap ->
+                                    try {
+                                        // Double-check bitmap is not still in cache
+                                        val stillInCache = withContext(Dispatchers.Main) {
+                                            pageCache.values.any { it.first == bitmap }
+                                        }
+
+                                        if (stillInCache) {
+                                            return@forEach
+                                        }
+
+                                        activeBitmaps.remove(bitmap)
+                                        if (!bitmap.isRecycled && bitmap.width > 0 && bitmap.height > 0) {
+                                            bitmap.recycle()
+                                        }
+        } catch (e: Exception) {
+                                    }
+                                }
+                            } catch (e: Exception) {
+                            }
+                            System.gc()
+                            if (isMaxZoom) {
+                                requestVisiblePagesReload("RenderWorkerCacheCleanup")
+                            }
+                        }
+
+                        // Remove from queued and mark as rendering with timestamp
+                        try {
+            withContext(Dispatchers.Main) {
+                                queuedPages.value = queuedPages.value - request.pageIndex
+                            }
+                        } catch (e: Exception) {
+                        }
+
+                        renderingPages[request.pageIndex] = System.currentTimeMillis()
+
+                        var bitmap: Bitmap? = null
+                        var renderSuccess = false
+
+                        try {
+                            bitmap = renderPageInternal(request.pageIndex, request.targetScale)
+                        } catch (e: OutOfMemoryError) {
+                            // Clean cache aggressively
+                            try {
+                                withContext(Dispatchers.Main) {
+                                    val currentBatch = request.pageIndex / batchSize
+                                    val batchesToKeep = setOf(currentBatch).filter { batchNum -> batchNum >= 0 }
+                                    pageCache = pageCache.filter { (idx, _) ->
+                                        val pageBatch = idx / batchSize
+                                        batchesToKeep.contains(pageBatch)
+                                    }
+                                }
+                            } catch (ex: Exception) {
+                            }
+                            System.gc()
+                            delay(100)
+                            bitmap = null // Return null, page will be retried later
+            } catch (e: Exception) {
+                e.printStackTrace()
+                            bitmap = null
+                        }
+
+                        if (bitmap != null) {
+                            // CRITICAL: Store reference to old bitmap BEFORE updating cache
+                            val oldCachedBitmap = cached?.first
+
+                            // CRITICAL FIX: Check if pinch zoom is active before recycling old bitmap
+                            // During pinch zoom, keep old bitmap to prevent white screen
+                            val pinchActive = safeMainContext { isPinchZoomActive } ?: false
+                            val recentPinch = safeMainContext { recentPinchZoom } ?: false
+
+                            // CRITICAL: Update cache FIRST on main thread
+                            // This ensures UI switches to new bitmap before old one is recycled
+                            try {
+                                withContext(Dispatchers.Main) {
+                                    pageCache = pageCache.toMutableMap().apply {
+                                        put(request.pageIndex, bitmap!! to request.targetScale)
+                                    }
+                                }
+                                renderSuccess = true
+            } catch (e: Exception) {
+                                // Still mark as success since bitmap was created
+                                renderSuccess = true
+                            }
+
+                            // CRITICAL FIX: During pinch zoom or recent pinch zoom, DON'T recycle old bitmap immediately
+                            // Keep it available for visual scaling to prevent white screen
+                            if (!pinchActive && !recentPinch) {
+                                // CRITICAL: Wait a bit to ensure UI has switched to new bitmap
+                                delay(50)
+
+                                // CRITICAL: Now safely recycle old bitmap AFTER cache update
+                                if (oldCachedBitmap != null) {
+                                    try {
+                                        // Double-check old bitmap is not still in cache
+                                        val stillInCache = withContext(Dispatchers.Main) {
+                                            pageCache[request.pageIndex]?.first == oldCachedBitmap
+                                        }
+
+                                        if (stillInCache) {
+                                        } else {
+                                            // Remove from active bitmaps
+                                            activeBitmaps.remove(oldCachedBitmap)
+
+                                            // Final validation before recycling
+                                            if (!oldCachedBitmap.isRecycled && oldCachedBitmap.width > 0 && oldCachedBitmap.height > 0) {
+                                                oldCachedBitmap.recycle()
+                                            } else {
+                                            }
+                                        }
+                                    } catch (e: Exception) {
+                                    }
+                                }
+                            } else {
+                                // During pinch zoom, keep old bitmap for visual scaling
+                            }
+                        }
+
+                        // ALWAYS remove from renderingPages, even on error
+                        renderingPages.remove(request.pageIndex)
+                        if (!renderSuccess) {
+                            // Remove from queued if render failed
+                            try {
+                                withContext(Dispatchers.Main) {
+                                    queuedPages.value = queuedPages.value - request.pageIndex
+                }
+            } catch (e: Exception) {
+                            }
+                        }
+
+                        // Small delay to prevent CPU hogging
+                        delay(5)
+
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        // Clean up on cancellation
+                        if (pageIndex != null) {
+                            renderingPages.remove(pageIndex)
+                        }
+                        throw e // Re-throw cancellation
+                    } catch (e: Exception) {
+                e.printStackTrace()
+                        // Ensure cleanup even if outer try fails
+                        if (pageIndex != null) {
+                            renderingPages.remove(pageIndex)
+                            try {
+                                withContext(Dispatchers.Main) {
+                                    queuedPages.value = queuedPages.value - pageIndex
+                                }
+                            } catch (ex: Exception) {
+                            }
+                        }
+                    }
+                }
+            } catch (e: kotlinx.coroutines.CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+    }
+
+    // ========================================================================
+    // SECTION 6: CACHE AND BATCH MANAGEMENT FUNCTIONS
+    // ========================================================================
+
+    /**
+     * Calculates which batch a page belongs to
+     * Uses helper function from PdfCacheManager
+     */
+    fun getBatchNumber(pageIndex: Int): Int {
+        return getBatchNumber(pageIndex, batchSize)
+    }
+
+    /**
+     * Gets the page range for a specific batch
+     * Uses helper function from PdfCacheManager
+     */
+    fun getBatchRange(batchNumber: Int): IntRange {
+        return getBatchRange(batchNumber, batchSize, pageCount)
+    }
+
+    /**
+     * Clears the render queue and all rendering states
+     *
+     * Called when scroll/zoom changes to prevent stale renders.
+     * Clears:
+     * - Render queue (pending requests)
+     * - Queued pages tracking
+     * - Rendering pages tracking
+     */
+    @OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+    suspend fun clearRenderQueue() = withContext(Dispatchers.Default) {
+        var cleared = 0
+        try {
+            while (!renderQueue.isEmpty) {
+                renderQueue.tryReceive().getOrNull()?.let { cleared++ }
+            }
+        } catch (e: kotlinx.coroutines.CancellationException) {
+            // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+            if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                // Expected when composable leaves composition - not an error
+            } else {
+                // Other cancellation - also expected
+            }
+            throw e
+        } catch (e: Exception) {
+            // Only log actual errors
+        }
+
+        // Clear queued pages tracking and stuck rendering pages
+        try {
+            withContext(Dispatchers.Main) {
+                queuedPages.value = emptySet()
+            }
+        } catch (e: kotlinx.coroutines.CancellationException) {
+            // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+            if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                // Expected when composable leaves composition - not an error
+            } else {
+                // Other cancellation - also expected
+            }
+            throw e
+        } catch (e: Exception) {
+            // Only log actual errors
+        }
+
+        // Also clear renderingPages to prevent stuck states
+        renderingPages.clear()
+
+        if (cleared > 0) {
+        }
+    }
+
+    /**
+     * Loads a batch of pages by submitting them to the render queue
+     *
+     * This function queues pages for rendering but doesn't render them directly.
+     * The render worker processes them sequentially.
+     *
+     * @param batchNumber The batch number to load
+     * @param targetScale The scale at which to render pages
+     * @param priority Priority level (0=highest, 1=medium, 2=low)
+     */
+    suspend fun loadBatch(batchNumber: Int, targetScale: Float, priority: Int = 2) = withContext(Dispatchers.Default) {
+        if (loadedBatches.contains(batchNumber)) {
+            return@withContext
+        }
+
+        val range = getBatchRange(batchNumber)
+
+        // Submit each page to the render queue (worker will process them smoothly)
+        for (pageIndex in range) {
+            // Skip if already in cache at correct scale
+            val cached = pageCache[pageIndex]
+            val needsRender = cached == null ||
+                kotlin.math.abs(cached.second - targetScale) > 0.08f
+
+            if (needsRender) {
+                val request = RenderRequest(pageIndex, targetScale, priority)
+                renderQueue.send(request)  // Non-blocking send to queue
+
+                // Track queued pages
+                withContext(Dispatchers.Main) {
+                    queuedPages.value = queuedPages.value + pageIndex
+                }
+
+            }
+        }
+
+        // Mark batch as loaded (pages are now queued for rendering)
+        withContext(Dispatchers.Main) {
+            loadedBatches = loadedBatches + batchNumber
+        }
+
+    }
+
+    /**
+     * Manages cache size by removing batches far from current position
+     *
+     * Keeps only nearby batches (current ± 1) in memory to prevent OOM.
+     * More aggressive cleanup if memory usage is high.
+     *
+     * @param currentVisiblePage The currently visible page index
+     */
+    suspend fun manageCacheSize(currentVisiblePage: Int) = withContext(Dispatchers.Default) {
+        // Check memory usage and cache size
+        val runtime = Runtime.getRuntime()
+        val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+        val maxMemory = runtime.maxMemory()
+        val memoryUsagePercent = (usedMemory * 100 / maxMemory).toInt()
+
+        // CRITICAL FIX: At max zoom, be more conservative with cache management
+        // Max zoom creates much larger bitmaps, so we need to preserve more pages
+        val currentScale = safeMainContext { scale } ?: MIN_ZOOM
+        val isMaxZoom = currentScale > 1.0f
+
+        // More aggressive cache management if memory is high
+        // But at max zoom, be more lenient to prevent white screen
+        val effectiveCacheSize = if (isMaxZoom) {
+            // At max zoom, preserve more pages to prevent white screen
+            if (memoryUsagePercent > 80) {
+                (maxCacheSize * 2 / 3).toInt()  // Only reduce to 2/3 if memory > 80%
+            } else if (memoryUsagePercent > 70) {
+                (maxCacheSize * 3 / 4).toInt()  // Reduce to 3/4 if memory > 70%
+            } else {
+                maxCacheSize  // Keep full cache if memory < 70%
+            }
+        } else {
+            // Normal zoom: use original logic
+            if (memoryUsagePercent > 60) {
+                maxCacheSize / 2  // Reduce cache size by half if memory > 60%
+            } else if (memoryUsagePercent > 50) {
+                (maxCacheSize * 2 / 3).toInt()  // Reduce to 2/3 if memory > 50%
+            } else {
+                maxCacheSize
+            }
+        }
+
+        // CRITICAL FIX: At max zoom, use higher memory threshold before aggressive cleanup
+        val memoryThreshold = if (isMaxZoom) {
+            80  // Higher threshold for max zoom (was 70)
+        } else {
+            70  // Normal threshold
+        }
+
+        if (pageCache.size > effectiveCacheSize || memoryUsagePercent > memoryThreshold) {
+            try {
+                val currentBatch = getBatchNumber(currentVisiblePage)
+
+                // Keep current batch and 1 batch before/after (3 batches total = 60 pages)
+                val batchesToKeep = setOf(
+                    currentBatch - 1,
+                    currentBatch,
+                    currentBatch + 1
+                ).filter { it >= 0 && it * batchSize < pageCount }
+
+                val pagesToKeep = mutableMapOf<Int, Pair<Bitmap, Float>>()
+                val pagesToRemove = mutableListOf<Bitmap>()
+                val batchesToUnload = mutableSetOf<Int>()
+
+                // CRITICAL FIX: Get current scale to preserve pages at max zoom AND minimum zoom
+                val currentScale = safeMainContext { scale } ?: MIN_ZOOM
+                val scaleDiffThreshold = when {
+                    currentScale > 1.0f -> 0.50f  // For max zoom, be more lenient (50% difference)
+                    currentScale <= 0.35f -> 0.50f  // For minimum zoom, also be lenient (keeps pages at higher scales)
+                    currentScale >= 1.0f && currentScale <= 1.5f -> 0.50f  // CRITICAL FIX: For moderate zoom (135-150%), be lenient to prevent white screen
+                    else -> 0.10f  // For normal zoom, use 10% threshold
+                }
+
+                pageCache.forEach { (pageIndex, pair) ->
+                    val pageBatch = getBatchNumber(pageIndex)
+                    val bitmapScale = pair.second
+                    val scaleDiff = kotlin.math.abs(bitmapScale - currentScale)
+
+                    // Keep pages if they're in nearby batches OR if they're at the current scale (max zoom)
+                    // This prevents clearing pages at max zoom when scrolling
+                    if (batchesToKeep.contains(pageBatch) || scaleDiff < scaleDiffThreshold) {
+                        pagesToKeep[pageIndex] = pair
+                    } else {
+                        pagesToRemove.add(pair.first)
+                        batchesToUnload.add(pageBatch)
+                    }
+                }
+
+                // CRITICAL: Update cache on main thread FIRST, then wait before recycling
+                // This ensures UI stops using bitmaps before they're recycled
+                try {
+                    safeMainContext {
+                        pageCache = pagesToKeep
+                        loadedBatches = loadedBatches.filter { batchesToKeep.contains(it) }.toSet()
+                        if (isMaxZoom) {
+                            reloadVisiblePagesToken = reloadVisiblePagesToken + 1
+                        }
+                    }
+                } catch (e: kotlinx.coroutines.CancellationException) {
+                    // Expected cancellation - re-throw to propagate
+                    throw e
+                }
+
+                // CRITICAL: Longer delay to ensure UI has stopped using removed bitmaps
+                // This prevents race condition where bitmap is recycled while still being drawn
+                try {
+                    delay(300)
+                } catch (e: kotlinx.coroutines.CancellationException) {
+                    // Expected cancellation - re-throw to propagate
+                    throw e
+                }
+
+                // Safely recycle removed bitmaps - double check they're not in cache
+                pagesToRemove.forEach { bitmap ->
+                    try {
+                        // CRITICAL: Check if bitmap is still in cache (shouldn't be, but double-check)
+                        val stillInCache = safeMainContext {
+                            pageCache.values.any { it.first == bitmap }
+                        } ?: false
+
+                        if (stillInCache) {
+                            return@forEach
+                        }
+
+                        // Don't recycle if still in active use
+                        if (activeBitmaps.contains(bitmap)) {
+                            return@forEach
+                        }
+
+                        // Final check before recycling
+                        if (!bitmap.isRecycled && bitmap.width > 0 && bitmap.height > 0) {
+                            bitmap.recycle()
+                        } else {
+                        }
+                    } catch (e: Exception) {
+                    }
+                }
+
+            } catch (e: kotlinx.coroutines.CancellationException) {
+                // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                    // Expected when composable leaves composition - not an error
+                } else {
+                    // Other cancellation - also expected
+                }
+                throw e
+            } catch (e: Exception) {
+                // Only log actual errors, not cancellations
+                e.printStackTrace()
+            }
+        }
+    }
+
+    // ========================================================================
+    // SECTION 7: CLEANUP AND RESOURCE MANAGEMENT
+    // ========================================================================
+
+    /**
+     * Cleanup - Recycles bitmaps and closes PDF renderer when composable is disposed
+     *
+     * This ensures proper resource cleanup when the viewer is closed.
+     */
+    DisposableEffect(Unit) {
+        onDispose {
+
+            // Close render queue
+            try {
+                renderQueue.close()
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+
+            // Recycle all cached bitmaps
+            pageCache.values.forEach { (bitmap, _) ->
+                try {
+                    activeBitmaps.remove(bitmap)
+                    if (!bitmap.isRecycled) {
+                        bitmap.recycle()
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+
+            // Recycle any remaining active bitmaps
+            activeBitmaps.forEach { bitmap ->
+                try {
+                    if (!bitmap.isRecycled) {
+                        bitmap.recycle()
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+            activeBitmaps.clear()
+            renderingPages.clear()
+
+            // Close PDF renderer and file descriptor
+            try {
+                pdfRenderer?.close()
+                pdfRenderer = null
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+
+            try {
+                pfd?.close()
+                pfd = null
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+
+        }
+    }
+
+    // ========================================================================
+    // SECTION 8: PDF INITIALIZATION AND LOADING
+    // ========================================================================
+
+    /**
+     * Initial PDF Load - Opens PDF and pre-loads first few batches
+     *
+     * This LaunchedEffect runs when the URI changes. It:
+     * - Opens the PDF file
+     * - Creates the PdfRenderer
+     * - Pre-loads first 4 batches (60 pages) for smooth initial experience
+     * - Switches to on-demand loading for remaining pages
+     */
+    LaunchedEffect(uri) {
+        isInitialLoading = true
+        loadingProgress = 0
+        loadingStatus = "Opening PDF..."
+
+        try {
+            val contentResolver = context.contentResolver
+            val tempPfd = contentResolver.openFileDescriptor(uri, "r")
+
+            if (tempPfd == null) {
+                Log.e("PdfRenderer", "Failed to open PDF file")
+                isInitialLoading = false
+                return@LaunchedEffect
+            }
+
+            // Store PDF renderer and file descriptor
+            pfd = tempPfd
+            pdfRenderer = PdfRenderer(tempPfd)
+            pageCount = pdfRenderer!!.pageCount
+
+            loadingStatus = "Preparing PDF..."
+            // Initialize lastRenderedScale to default scale (100%)
+            lastRenderedScale = scale.coerceIn(0.3f, maxZoom)
+
+            // Hybrid approach: Pre-load first few batches, then load rest on-demand
+            // This prevents OOM for large PDFs while still providing smooth initial experience
+            withContext(Dispatchers.Default) {
+                val totalBatches = (pageCount + batchSize - 1) / batchSize
+                val initialBatchesToLoad = minOf(4, totalBatches) // Pre-load first 4 batches (60 pages max)
+
+
+                // Pre-load initial batches sequentially
+                for (batchNum in 0 until initialBatchesToLoad) {
+                    val batchStart = batchNum * batchSize
+                    val batchEnd = minOf((batchNum + 1) * batchSize - 1, pageCount - 1)
+
+                    loadingStatus = "Loading pages ${batchStart + 1}-${batchEnd + 1}..."
+                    loadingProgress = ((batchNum + 1) * 100 / initialBatchesToLoad).coerceAtMost(90)
+
+
+                    // Load this batch
+                    loadBatch(batchNum, scale, priority = 0)
+
+                    // Wait for batch to complete
+                    var batchComplete = false
+                    var attempts = 0
+                    while (!batchComplete && attempts < 1000) {
+                        delay(10)
+                        val allPagesInBatchLoaded = (batchStart..batchEnd).all { pageIndex ->
+                            pageCache.containsKey(pageIndex)
+                        }
+                        if (allPagesInBatchLoaded) {
+                            batchComplete = true
+                        }
+                        attempts++
+                    }
+
+                    // Check memory before loading next batch
+                    val runtime = Runtime.getRuntime()
+                    val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+                    val maxMemory = runtime.maxMemory()
+                    val memoryUsagePercent = (usedMemory * 100 / maxMemory).toInt()
+
+
+                    // If memory usage is high, stop pre-loading and switch to on-demand
+                    if (memoryUsagePercent > 70) {
+                        break
+                    }
+
+                    delay(50) // Small delay between batches
+                }
+
+                // Mark initial batches as loaded
+                val loadedBatchesSet = (0 until minOf(initialBatchesToLoad, totalBatches)).toSet()
+                withContext(Dispatchers.Main) {
+                    loadedBatches = loadedBatchesSet
+                }
+
+                loadingProgress = 95
+
+                // More accurate loading status
+                val pagesLoaded = pageCache.size
+                val totalPages = pageCount
+                if (pagesLoaded < totalPages) {
+                    loadingStatus = "Loaded $pagesLoaded of $totalPages pages. Remaining pages will load as you scroll."
+            } else {
+                    loadingStatus = "Ready!"
+                }
+
+            }
+
+            // Small delay to show completion
+            delay(100)
+
+            isInitialLoading = false
+
+            // Log loading status
+            val pagesLoaded = pageCache.size
+            val totalPages = pageCount
+            if (pagesLoaded < totalPages) {
+                Log.i("PdfRenderer", "PDF opened: $pagesLoaded of $totalPages pages loaded. Scroll to load more.")
+            } else {
+                Log.i("PdfRenderer", "PDF loaded: $pageCount pages ready")
+            }
+
+        } catch (e: OutOfMemoryError) {
+            e.printStackTrace()
+
+            // Clear cache and trigger GC
+            pageCache = emptyMap()
+            activeBitmaps.clear()
+            renderingPages.clear()
+            queuedPages.value = emptySet()
+            System.gc()
+
+            Log.e("PdfRenderer", "Out of memory loading PDF. Switching to on-demand loading.")
+
+            // Still show viewer, but with on-demand loading only
+            isInitialLoading = false
+
+        } catch (e: SecurityException) {
+            e.printStackTrace()
+            Log.e("PdfRenderer", "Permission denied: Cannot access PDF file", e)
+            isInitialLoading = false
+
+        } catch (e: java.io.IOException) {
+            e.printStackTrace()
+            Log.e("PdfRenderer", "IO Error: Cannot read PDF file", e)
+            isInitialLoading = false
+
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Log.e("PdfRenderer", "Error loading PDF: ${e.message}", e)
+            isInitialLoading = false
+        }
+    }
+
+    // ========================================================================
+    // SECTION 9: ZOOM CHANGE HANDLING
+    // ========================================================================
+
+    /**
+     * Zoom Change Handler - Debounced to avoid constant re-rendering
+     *
+     * This LaunchedEffect triggers when scale changes. It:
+     * - Waits for zoom gesture to complete (debouncing)
+     * - Clears render queue and cache at wrong scales
+     * - Updates lastRenderedScale to prevent stale renders
+     * - Allows pages to reload at new scale on-demand
+     *
+     * Uses scale as key so previous effect is cancelled when scale changes rapidly.
+     */
+    LaunchedEffect(scale) {
+        if (!isInitialLoading && pageCount > 0) {
+            var crashContext = "ZoomHandlerStart"
+            try {
+
+                crashContext = "ScaleValidation"
+                // Validate scale values
+                val currentScale = scale
+                val currentLastRendered = lastRenderedScale
+
+                if (currentScale.isNaN() || currentScale.isInfinite() || currentScale <= 0f) {
+                    return@LaunchedEffect
+                }
+
+                if (currentLastRendered.isNaN() || currentLastRendered.isInfinite() || currentLastRendered <= 0f) {
+                    try {
+                        lastRenderedScale = currentScale
+            } catch (e: Exception) {
+                    }
+                    return@LaunchedEffect
+                }
+
+                crashContext = "ScaleDifferenceCalculation"
+                val scaleDifference = try {
+                    kotlin.math.abs(currentScale - currentLastRendered)
+                } catch (e: Exception) {
+                    return@LaunchedEffect
+                }
+
+                // Reduced threshold from 0.08f to 0.03f (3%) for smoother zoom transitions
+                if (scaleDifference >= 0.03f) {
+
+                    crashContext = "WaitTimeCalculation"
+                    // If pinch zoom is active, wait longer for gesture to complete
+                    // For button clicks (Zoom In/Out), use much shorter wait time for smoother, faster response
+                    val waitTime = try {
+                        if (isPinchZoomActive || recentPinchZoom) {
+                            1200L  // Wait 1.2 seconds for pinch gesture to complete or recent pinch zoom to settle
+                        } else {
+                            100L   // Reduced from 300ms to 100ms for button clicks - much smoother response
+                        }
+                    } catch (e: Exception) {
+                        100L  // Default to shorter wait for smoother response
+                    }
+
+                    crashContext = "ZoomInProgressFlag"
+                    // CRITICAL FIX: Don't set isZoomInProgress during active pinch zoom
+                    // This allows pages to be displayed with visual scaling during pinch gestures
+                    // For button clicks, set it briefly but allow visual scaling for smooth experience
+                    try {
+                        val pinchActive = isPinchZoomActive
+                        val recentPinch = recentPinchZoom
+                        if (!pinchActive && !recentPinch) {
+                            // Set isZoomInProgress for button clicks, but keep it brief for smooth visual scaling
+                            isZoomInProgress = true
+                        } else {
+                            // Pinch zoom is active or recent - cancel button zoom handling to prevent interference
+                            val reason = if (pinchActive) "Pinch zoom active" else "Recent pinch zoom"
+                            // Don't proceed with cache clearing or other button zoom logic
+                            return@LaunchedEffect
+                        }
+            } catch (e: Exception) {
+                        // Continue anyway
+                    }
+
+                    // CRITICAL FIX: Update lastRenderedScale IMMEDIATELY to prevent stale renders
+                    // This ensures that any renders queued at old scales will be rejected
+                    crashContext = "ImmediateScaleUpdate"
+                    try {
+                        lastRenderedScale = currentScale
+                    } catch (e: Exception) {
+                        // Continue anyway
+                    }
+
+                    // CRITICAL FIX: Don't clear cache during active pinch zoom OR recent pinch zoom - keep all pages for visual scaling
+                    // Only clear cache for button/slider zoom (not pinch)
+                    crashContext = "ClearWrongScaleCache"
+                    try {
+                        val pinchActive = isPinchZoomActive
+                        val recentPinch = recentPinchZoom
+                        // Triple-check: Don't clear cache if pinch zoom is active OR recent pinch zoom OR button zoom is in progress
+                        // This prevents interference between button and pinch zoom AND prevents white screen after pinch zoom ends
+                        if (!pinchActive && !recentPinch && !isZoomInProgress) {
+                            // Only clear cache if NOT pinch zooming AND NOT recent pinch zoom AND NOT button zooming
+                            val currentCache = pageCache
+                            val isZoomingOut = currentScale < currentLastRendered
+
+                            val pagesToKeep = currentCache.filter { (pageIndex, pair) ->
+                                val bitmapScale = pair.second
+                                val scaleDiff = kotlin.math.abs(bitmapScale - currentScale)
+
+                                if (isZoomingOut) {
+                                    // Zoom out: Keep pages that are larger (can be scaled down visually) OR within reasonable range
+                                    // CRITICAL FIX: For minimum zoom (100% = 1.0f), be more lenient to prevent white screen
+                                    // Allow pages at any scale that can be visually scaled down to minimum zoom
+                                    val minZoomThreshold = if (currentScale <= 1.1f) {
+                                        0.50f  // For minimum zoom (100% = 1.0f), allow up to 50% difference (keeps pages at higher scales)
+                                    } else {
+                                        0.10f  // For normal zoom out, use 10% threshold
+                                    }
+                                    bitmapScale >= currentScale * 0.9f || scaleDiff < minZoomThreshold || bitmapScale <= currentScale * 2.0f
+                                } else {
+                                    // Zoom in: Keep pages that can be scaled up visually OR within reasonable range
+                                    // For max zoom (e.g., 2.5f) and moderate zoom (135-150%), keep pages even if scale difference is large
+                                    // This prevents white screen when zooming to max or moderate zoom levels
+                                    val maxScaleDiff = when {
+                                        currentScale > 1.5f -> 0.50f  // For max zoom (>150%), be more lenient (50% difference allowed)
+                                        currentScale >= 1.0f && currentScale <= 1.5f -> 0.50f  // CRITICAL FIX: For moderate zoom (135-150%), be lenient to prevent white screen
+                                        else -> 0.05f  // For normal zoom, strict (5% difference)
+                                    }
+                                    scaleDiff < maxScaleDiff || bitmapScale <= currentScale * 1.5f
+                                }
+                            }
+
+                            if (pagesToKeep.size < currentCache.size) {
+                                pageCache = pagesToKeep
+                            }
+                        } else {
+                            val reason = when {
+                                pinchActive -> "Pinch zoom active"
+                                recentPinch -> "Recent pinch zoom (keeping pages visible)"
+                                isZoomInProgress -> "Button zoom in progress"
+                                else -> "Unknown"
+                            }
+                        }
+                    } catch (e: Exception) {
+                        // Continue anyway
+                    }
+
+                    crashContext = "ClearRenderQueue"
+                    try {
+                        // Clear render queue and stuck rendering states
+                        clearRenderQueue()
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                        if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                            // Expected when composable leaves composition - not an error
+                        } else {
+                            // Other cancellation - also expected
+                        }
+                        throw e
+                    } catch (e: Exception) {
+                        // Only log actual errors, not cancellations
+                        // Continue anyway - don't crash
+                    }
+
+                    crashContext = "ClearRenderingPages"
+                    try {
+                        // Clear all renderingPages to prevent stuck states (ConcurrentHashMap is thread-safe)
+                        renderingPages.clear()
+                    } catch (e: Exception) {
+                        // Continue anyway - don't crash
+                    }
+
+                    crashContext = "ClearQueuedPages"
+                    try {
+                        withContext(Dispatchers.Main) {
+                            queuedPages.value = emptySet()
+                        }
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                        if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                            // Expected when composable leaves composition - not an error
+                        } else {
+                            // Other cancellation - also expected
+                        }
+                        throw e
+                    } catch (e: Exception) {
+                        // Only log actual errors, not cancellations
+                        // Continue anyway - don't crash
+                    }
+
+
+                    crashContext = "WaitDelay"
+                    // Wait for user to finish gesture (longer for pinch zoom)
+                    try {
+                        delay(waitTime)
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        throw e
+                    } catch (e: Exception) {
+                        isZoomInProgress = false
+                    return@LaunchedEffect
+                }
+
+                    crashContext = "ScaleRecheck"
+                    // Check if scale changed again during the delay (cancellation check)
+                    val updatedScale = try {
+                        scale
+                    } catch (e: Exception) {
+                        isZoomInProgress = false
+                        return@LaunchedEffect
+                    }
+
+                    val updatedLastRendered = try {
+                        lastRenderedScale
+                    } catch (e: Exception) {
+                        isZoomInProgress = false
+                        return@LaunchedEffect
+                    }
+
+                    crashContext = "ScaleValidationAfterWait"
+                    // Validate updated values
+                    if (updatedScale.isNaN() || updatedScale.isInfinite() || updatedScale <= 0f ||
+                        updatedLastRendered.isNaN() || updatedLastRendered.isInfinite() || updatedLastRendered <= 0f) {
+                        try {
+                            isZoomInProgress = false
+                        } catch (e: Exception) {
+                        }
+                        return@LaunchedEffect
+                    }
+
+                    crashContext = "PinchZoomStillActiveCheck"
+                    // Check if pinch zoom is still active - if so, wait more
+                    if (isPinchZoomActive) {
+                        try {
+                            delay(500)
+                        } catch (e: kotlinx.coroutines.CancellationException) {
+                            throw e
+                        } catch (e: Exception) {
+                            isZoomInProgress = false
+                            return@LaunchedEffect
+                        }
+
+                        crashContext = "FinalScaleCheck"
+                        // Re-check scale after additional wait
+                        val finalScale = try {
+                            scale
+                        } catch (e: Exception) {
+                            isZoomInProgress = false
+                            return@LaunchedEffect
+                        }
+
+                        if (finalScale.isNaN() || finalScale.isInfinite() || finalScale <= 0f) {
+                            try {
+                                isZoomInProgress = false
+                            } catch (e: Exception) {
+                            }
+                            return@LaunchedEffect
+                        }
+
+                        val scaleChange = try {
+                            kotlin.math.abs(finalScale - updatedScale)
+                    } catch (e: Exception) {
+                            0f
+                        }
+
+                        if (scaleChange > 0.05f) {
+                            // Scale changed significantly, restart
+                            return@LaunchedEffect
+                        }
+                    }
+
+                    crashContext = "ScaleSettledCheck"
+                    // Check if scale changed again during the delay
+                    val finalScaleDiff = try {
+                        kotlin.math.abs(updatedScale - updatedLastRendered)
+                    } catch (e: Exception) {
+                        0f
+                    }
+
+                    // Reduced threshold from 0.08f to 0.03f for smoother transitions
+                    if (finalScaleDiff < 0.03f) {
+                        // Scale settled back, no need to re-render
+                        try {
+                            isZoomInProgress = false
+                        } catch (e: Exception) {
+                        }
+                        return@LaunchedEffect
+                    }
+
+
+                    crashContext = "UpdateLastRenderedScale"
+                    // Note: lastRenderedScale was already updated immediately when zoom started
+                    // This is just a confirmation/validation step
+                    try {
+                        // Double-check scale hasn't changed during wait
+                        val finalScale = scale
+                        if (kotlin.math.abs(finalScale - updatedScale) > 0.01f) {
+                            lastRenderedScale = finalScale
+                        } else {
+                            lastRenderedScale = updatedScale
+                        }
+                    } catch (e: Exception) {
+                        isZoomInProgress = false
+                        return@LaunchedEffect
+                    }
+
+                    crashContext = "ClearLoadedBatches"
+                    // Clear loaded batches so pages reload at new scale
+                    try {
+                        loadedBatches = emptySet()
+                    } catch (e: Exception) {
+                        // Continue anyway
+                    }
+
+                    // Don't queue ALL pages - let scroll handler load them on-demand
+                    // This prevents memory issues and conflicts
+
+                    crashContext = "ResetZoomInProgress"
+                    // Reset zoom flag immediately so scroll handler can start loading
+                    try {
+                        isZoomInProgress = false
+                    } catch (e: Exception) {
+                    }
+
+                    crashContext = "FinalDelay"
+                    // Minimal delay to let UI update - reduced for faster response and smoother zoom
+                    try {
+                        delay(30)  // Reduced from 50ms to 30ms for even faster, smoother page reload
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        throw e
+                    } catch (e: Exception) {
+                        // Continue anyway
+                    }
+
+                    // Note: Scroll handler will automatically reload visible pages when lastRenderedScale changes
+                    // The reduced delay (30ms) ensures pages reload quickly after zoom, preventing white screen
+                    // Visual scaling ensures smooth transitions even before re-render completes
+                }
+            } catch (e: kotlinx.coroutines.CancellationException) {
+                // Expected when scale changes rapidly - previous effect cancelled
+                throw e
+            } catch (e: OutOfMemoryError) {
+                System.gc()
+                // Reset zoom state on error
+                try {
+                    isZoomInProgress = false
+                } catch (ex: Exception) {
+                }
+            } catch (e: Exception) {
+                // Reset zoom state on error
+                try {
+                    isZoomInProgress = false
+                } catch (ex: Exception) {
+                }
+            } catch (e: Throwable) {
+                // Reset zoom state on error
+                try {
+                    isZoomInProgress = false
+                } catch (ex: Exception) {
+                }
+            }
+        }
+    }
+
+    // ========================================================================
+    // SECTION 10: UI COMPOSITION
+    // ========================================================================
+
+    /**
+     * Helper function to load image from URL, local file, or fallback to drawable
+     */
+    @Composable
+    fun loadIconImage(imageUrl: String?, drawableName: String, modifier: Modifier, tint: Color, contentDescription: String) {
+        val context = LocalContext.current
+        var bitmap by remember { mutableStateOf<android.graphics.Bitmap?>(null) }
+
+        LaunchedEffect(imageUrl) {
+            if (!imageUrl.isNullOrEmpty()) {
+                // Load from URL or local file
+                bitmap = withContext(Dispatchers.IO) {
+                    try {
+                        val result = when {
+                            // Handle React Native resource URIs (res://drawable/... or res:/drawable/...)
+                            imageUrl.startsWith("res://") || imageUrl.startsWith("res:/") -> {
+                                try {
+                                    // Extract resource name from URI (e.g., "res://drawable/icon_name" -> "icon_name")
+                                    val resourceName = imageUrl.substringAfterLast("/").substringBefore(".")
+                                    val resourceId = context.resources.getIdentifier(resourceName, "drawable", context.packageName)
+                                    if (resourceId != 0) {
+                                        BitmapFactory.decodeResource(context.resources, resourceId)
+                                    } else {
+                                        null
+                                    }
+                                } catch (e: Exception) {
+                                    null
+                                }
+                            }
+                            // Handle asset URIs (file:///android_asset/...)
+                            imageUrl.startsWith("file:///android_asset/") -> {
+                                val assetPath = imageUrl.removePrefix("file:///android_asset/")
+                                try {
+                                    context.assets.open(assetPath).use { inputStream ->
+                                        BitmapFactory.decodeStream(inputStream)
+                                    }
+                                } catch (e: Exception) {
+                                    null
+                                }
+                            }
+                            // Handle local file URIs (file://...)
+                            imageUrl.startsWith("file://") -> {
+                                val filePath = imageUrl.removePrefix("file://")
+                                BitmapFactory.decodeFile(filePath)
+                            }
+                            // Handle content:// URIs (content provider)
+                            imageUrl.startsWith("content://") -> {
+                                try {
+                                    context.contentResolver.openInputStream(android.net.Uri.parse(imageUrl))?.use { inputStream ->
+                                        BitmapFactory.decodeStream(inputStream)
+                                    }
+                                } catch (e: Exception) {
+                                    null
+                                }
+                            }
+                            // Handle http/https URLs
+                            imageUrl.startsWith("http://") || imageUrl.startsWith("https://") -> {
+                                try {
+                                    val url = URL(imageUrl)
+                                    val connection = url.openConnection()
+                                    connection.connectTimeout = 5000
+                                    connection.readTimeout = 5000
+                                    connection.connect()
+                                    val inputStream = connection.getInputStream()
+                                    BitmapFactory.decodeStream(inputStream)
+                                } catch (e: Exception) {
+                                    null
+                                }
+                            }
+                            // Try as numeric resource ID (React Native sometimes returns just the ID)
+                            imageUrl.matches(Regex("^\\d+$")) -> {
+                                try {
+                                    val resourceId = imageUrl.toInt()
+                                    BitmapFactory.decodeResource(context.resources, resourceId)
+                                } catch (e: Exception) {
+                                    null
+                                }
+                            }
+                            // Try as asset name directly (React Native bundled assets)
+                            else -> {
+                                try {
+                                    // First try as drawable resource
+                                    val resourceId = context.resources.getIdentifier(imageUrl, "drawable", context.packageName)
+                                    if (resourceId != 0) {
+                                        BitmapFactory.decodeResource(context.resources, resourceId)
+                                    } else {
+                                        // Try as asset
+                                        val assetPaths = listOf(
+                                            imageUrl,
+                                            "drawable-mdpi/$imageUrl",
+                                            "drawable-hdpi/$imageUrl",
+                                            "drawable-xhdpi/$imageUrl",
+                                            "drawable-xxhdpi/$imageUrl"
+                                        )
+
+                                        var loadedBitmap: android.graphics.Bitmap? = null
+                                        assetLoop@ for (path in assetPaths) {
+                                            try {
+                                                val inputStream = context.assets.open(path)
+                                                loadedBitmap = BitmapFactory.decodeStream(inputStream)
+                                                inputStream.close()
+                                                if (loadedBitmap != null) {
+                                                    break@assetLoop
+                                                }
+                                            } catch (e: Exception) {
+                                                // Try next path
+                                            }
+                                        }
+                                        loadedBitmap ?: BitmapFactory.decodeFile(imageUrl)
+                                    }
+                                } catch (e: Exception) {
+                                    // Try as file path
+                                    BitmapFactory.decodeFile(imageUrl)
+                                }
+                            }
+                        }
+                        if (result != null) {
+                        } else {
+                        }
+                        result
+                    } catch (e: Exception) {
+                        null
+                    }
+                }
+            } else {
+                // Fallback to drawable
+                val resourceId = context.resources.getIdentifier(drawableName, "drawable", context.packageName)
+                if (resourceId != 0) {
+                    bitmap = BitmapFactory.decodeResource(context.resources, resourceId)
+                }
+            }
+        }
+
+        bitmap?.let {
+            Image(
+                bitmap = it.asImageBitmap(),
+                contentDescription = contentDescription,
+                modifier = modifier,
+                colorFilter = ColorFilter.tint(tint)
+            )
+        } ?: run {
+            // Fallback to drawable if URL loading failed
+            val resourceId = context.resources.getIdentifier(drawableName, "drawable", context.packageName)
+            if (resourceId != 0) {
+                Image(
+                    painter = painterResource(id = resourceId),
+                    contentDescription = contentDescription,
+                    modifier = modifier,
+                    colorFilter = ColorFilter.tint(tint)
+                )
+            } else {
+                // If drawable not found, show empty space (or a placeholder)
+                Box(modifier = modifier)
+            }
+        }
+    }
+
+    /**
+     * Zoom In Icon - Loads from URL or drawable resource
+     */
+    @Composable
+    fun ZoomInIcon(modifier: Modifier = Modifier, tint: Color = Color(0xFF424242), imageUrl: String? = null) {
+        loadIconImage(imageUrl, "zoom_in_enable", modifier, tint, "Zoom In")
+    }
+
+    /**
+     * Zoom Out Icon - Loads from URL or drawable resource
+     */
+    @Composable
+    fun ZoomOutIcon(modifier: Modifier = Modifier, tint: Color = Color(0xFF424242), imageUrl: String? = null) {
+        loadIconImage(imageUrl, "zoom_out_enable", modifier, tint, "Zoom Out")
+    }
+
+    /**
+     * Fullscreen Icon - Loads from URL or drawable resource
+     */
+    @Composable
+    fun FullscreenIcon(modifier: Modifier = Modifier, tint: Color = Color(0xFF424242), imageUrl: String? = null) {
+        loadIconImage(imageUrl, "full_screen", modifier, tint, "Fullscreen")
+    }
+
+    /**
+     * Minimize Icon - Loads from URL or drawable resource
+     */
+    @Composable
+    fun MinimizeIcon(modifier: Modifier = Modifier, tint: Color = Color(0xFF424242), imageUrl: String? = null) {
+        loadIconImage(imageUrl, "minimize_screen", modifier, tint, "Minimize")
+    }
+
+    /**
+     * Left Layout Sidebar Icon - Loads from URL or drawable resource
+     */
+    @Composable
+    fun LeftLayoutSidebarIcon(modifier: Modifier = Modifier, tint: Color = Color(0xFF424242), imageUrl: String? = null) {
+        loadIconImage(imageUrl, "left_layout_sidebar_enable", modifier, tint, "Left Layout")
+    }
+
+    /**
+     * Right Layout Sidebar Icon - Loads from URL or drawable resource
+     */
+    @Composable
+    fun RightLayoutSidebarIcon(modifier: Modifier = Modifier, tint: Color = Color(0xFF424242), imageUrl: String? = null) {
+        loadIconImage(imageUrl, "right_layout_sidebar_enable", modifier, tint, "Right Layout")
+    }
+
+    /**
+     * Custom Reset Icon (circular arrow)
+     */
+    @Composable
+    fun ResetIcon(modifier: Modifier = Modifier, tint: Color = Color(0x66000000)) {
+        Canvas(modifier = modifier.size(24.dp)) {
+            val centerX = size.width / 2
+            val centerY = size.height / 2
+            val radius = size.minDimension * 0.3f
+
+            // Draw circular arrow (reset/refresh icon)
+            val path = Path()
+            val startAngle = 45f
+            val sweepAngle = 270f
+
+            // Create Rect for arc
+            val oval = androidx.compose.ui.geometry.Rect(
+                left = centerX - radius,
+                top = centerY - radius,
+                right = centerX + radius,
+                bottom = centerY + radius
+            )
+
+            // Draw arc
+            path.addArc(
+                oval = oval,
+                startAngleDegrees = startAngle,
+                sweepAngleDegrees = sweepAngle
+            )
+
+            // Draw arrow head
+            val arrowAngle = Math.toRadians((startAngle + sweepAngle).toDouble())
+            val arrowX = centerX + radius * kotlin.math.cos(arrowAngle).toFloat()
+            val arrowY = centerY + radius * kotlin.math.sin(arrowAngle).toFloat()
+            val arrowSize = size.minDimension * 0.1f
+
+            // Arrow pointing right
+            path.moveTo(arrowX, arrowY)
+            path.lineTo(arrowX - arrowSize, arrowY - arrowSize)
+            path.moveTo(arrowX, arrowY)
+            path.lineTo(arrowX - arrowSize, arrowY + arrowSize)
+
+            drawPath(path, color = tint, style = Stroke(width = 2.dp.toPx()))
+        }
+    }
+
+    /**
+     * Main UI Scaffold
+     *
+     * Contains:
+     * - PDF page list (LazyColumn)
+     * - Gesture handling (pinch zoom)
+     * - Top bar with back button and text
+     * - Bottom bar with zoom controls
+     * - Loading screen
+     */
+    Scaffold(
+      
+        topBar = {
+            if (!isInitialLoading && pageCount > 0 && backButtonText != null && isFullScreenState) {
+                TopAppBar(
+                    backgroundColor = Color.Transparent,
+                    elevation = 0.dp,
+                    contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp)
+                ) {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.Start,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        // Left side: Back Button (Red pill-shaped button with left arrow and "Topics" text)
+                        Box(
+                            modifier = Modifier
+                                .background(
+                                    Color(0xFFF97A60.toInt()), // Red background, full opacity
+                                    shape = RoundedCornerShape(30.dp)
+                                )
+                                .clickable(
+                                    onClick = {
+                                        // Exit fullscreen mode when back button is clicked
+                                        isFullScreenState = false
+                                        onFullScreenChange?.invoke(false)
+                                    }
+                                )
+                                .padding(horizontal = 16.dp, vertical = 8.dp),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            Row(
+                                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                                verticalAlignment = Alignment.CenterVertically
+                            ) {
+                                // Left Arrow Icon (gray)
+                                Icon(
+                                    imageVector = Icons.Default.ArrowBack,
+                                    contentDescription = "Back",
+                                    tint = Color(0xFFFFFFFF),
+                                    modifier = Modifier.size(20.dp)
+                                )
+                                // Back Button Text (e.g., "Topics")
+                                Text(
+                                    text = backButtonText,
+                                    color = Color.White,
+                                    style = MaterialTheme.typography.body1,
+                                    fontWeight = FontWeight.Medium
+                                )
+                            }
+                        }
+
+                        // Right side: Header Text (e.g., "Book") - positioned right next to button
+                        if (headerText != null) {
+                            Text(
+                                text = headerText,
+                                color = Color.Black,
+                                style = MaterialTheme.typography.body1,
+                                fontWeight = FontWeight.Medium,
+                                modifier = Modifier.padding(start = 16.dp)
+                            )
+                        }
+                    }
+                }
+            }
+        },
+        bottomBar = {
+            if (!isInitialLoading && pageCount > 0) {
+                // Toolbar with gray background when not fullscreen, transparent when fullscreen
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .then(
+                            if (!isFullScreenState) {
+                                Modifier.background( Color(0x66000000) )
+                            } else {
+                                Modifier // No background when fullscreen
+                            }
+                        )
+                        .padding(horizontal = 8.dp, vertical = 12.dp),
+                    contentAlignment = if (isFullScreenState) Alignment.Center else Alignment.TopStart
+                ) {
+                    Row(
+                        modifier = if (isFullScreenState) {
+                            // Fullscreen: Center buttons with fixed spacing
+                            Modifier.wrapContentWidth()
+                        } else {
+                            // Split-screen: Full width with even distribution
+                            Modifier.fillMaxWidth()
+                        },
+                        horizontalArrangement = if (isFullScreenState) {
+                            // Fullscreen: Fixed 15.dp spacing between buttons
+                            Arrangement.spacedBy(25.dp)
+                        } else {
+                            // Split-screen: Even distribution across width
+                            Arrangement.SpaceEvenly
+                        },
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        //*  pdf positen left Icon Button  */
+                        if(!isFullScreenState) {
+                            Box(
+                                modifier = Modifier
+                                    .size(48.dp)
+                                    .clickable(
+                                        enabled = !isLeftLayoutDisabled, // Disable when PDF is on left
+                                        onClick = {
+                                            if (!isLeftLayoutDisabled) {
+                                            onLeftScreenChange?.invoke(true)
+                                            }
+                                        }
+                                    ),
+                                contentAlignment = Alignment.Center
+                            ) {
+                                LeftLayoutSidebarIcon(
+                                    tint = if (isLeftLayoutDisabled) {
+                                        Color(0xFF9E9E9E) // Lighter gray if disabled
+                                    } else {
+                                        if (isFullScreenState) Color(0xFF424242) else Color.White // Gray when fullscreen, white when not
+                                    },
+                                    modifier = Modifier.size(iconSize),
+                                    imageUrl = iconUrls?.get("leftLayout")
+                                )
+                            }
+
+                            // ** pdf positen Right Icon Button (bordered style) */
+                            Box(
+                                modifier = Modifier
+                                    .size(48.dp)
+                                    .clickable(
+                                        enabled = !isRightLayoutDisabled, // Disable when PDF is on right
+                                        onClick = {
+                                            if (!isRightLayoutDisabled) {
+                                            onRightScreenChange?.invoke(true)
+                                            }
+                                        }
+                                    ),
+                                contentAlignment = Alignment.Center
+                            ) {
+                                RightLayoutSidebarIcon(
+                                    tint = if (isRightLayoutDisabled) {
+                                        Color(0xFF9E9E9E) // Lighter gray if disabled
+                                    } else {
+                                        if (isFullScreenState) Color(0xFF424242) else Color.White // Gray when fullscreen, white when not
+                                    },
+                                    modifier = Modifier.size(iconSize),
+                                    imageUrl = iconUrls?.get("rightLayout")
+                                )
+                            }
+                        }
+                        // Zoom In Icon Button (bordered style)
+                        Box(
+                            modifier = Modifier
+                                .size(48.dp)
+                                .clickable(
+                                    enabled = !isPinchZoomActive && !isZoomInDisabled,  // Disable when at max zoom
+                                    onClick = {
+                                        if (!isPinchZoomActive && !isZoomInDisabled) {
+                                            // Clamp to ensure we never exceed max zoom
+                                            scale = (scale + zoomInStep).coerceAtMost(effectiveMaxZoom)
+                                        }
+                                    }
+                                ),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            ZoomInIcon(
+                                tint = if (isZoomInDisabled || isPinchZoomActive) {
+                                    Color(0xFF9E9E9E) // Lighter gray if disabled
+                                } else {
+                                    if (isFullScreenState) Color(0xFF424242) else Color.White // Gray when fullscreen, white when not
+                                },
+                                modifier = Modifier.size(iconSize),
+                                imageUrl = iconUrls?.get("zoomIn")
+                            )
+                        }
+
+                        // Zoom Out Icon Button (bordered style)
+                        Box(
+                            modifier = Modifier
+                                .size(48.dp)
+                                .clickable(
+                                    enabled = !isPinchZoomActive && !isZoomOutDisabled,  // Disable when at min zoom (100%)
+                                    onClick = {
+                                        if (!isPinchZoomActive && !isZoomOutDisabled) {
+                                            // Clamp to ensure we never go below 100% (1.0f)
+                                            scale = (scale - zoomOutStep).coerceAtLeast(MIN_ZOOM)
+                                        }
+                                    }
+                                ),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            ZoomOutIcon(
+                                tint = if (isZoomOutDisabled || isPinchZoomActive) {
+                                    Color(0xFF9E9E9E) // Lighter gray if disabled
+                                } else {
+                                    if (isFullScreenState) Color(0xFF424242) else Color.White // Gray when fullscreen, white when not
+                                },
+                                modifier = Modifier.size(iconSize),
+                                imageUrl = iconUrls?.get("zoomOut")
+                            )
+                        }
+
+
+                        // Full Screen / Minimize Icon Button (bordered style)
+                        // Shows minimize icon when fullscreen, fullscreen icon when not
+                        Box(
+                            modifier = Modifier
+                                .size(48.dp)
+                                .clickable(
+                                    onClick = {
+                                        // Toggle fullscreen state and notify parent
+                                        val newFullScreenState = !isFullScreenState
+                                        isFullScreenState = newFullScreenState
+                                        onFullScreenChange?.invoke(newFullScreenState)
+                                    }
+                                ),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            // Show minimize icon when fullscreen, fullscreen icon when not
+                            if (isFullScreenState) {
+                                MinimizeIcon(
+                                    tint = Color(0xFF424242), // Gray icon when fullscreen
+                                    modifier = Modifier.size(iconSize),
+                                    imageUrl = iconUrls?.get("minimizeScreen")
+                                )
+                            } else {
+                                FullscreenIcon(
+                                    tint = Color.White, // White icon when not fullscreen
+                                    modifier = Modifier.size(iconSize),
+                                    imageUrl = iconUrls?.get("fullScreen")
+                                )
+                            }
+                        }
+
+
+
+
+                        // Reset Icon Button (bordered style)
+//                        Box(
+//                            modifier = Modifier
+//                                .size(48.dp)
+//                                .background(
+//                                    Color(0xFFF5F5F5), // Light gray background
+//                                    shape = RoundedCornerShape(8.dp)
+//                                )
+//                                .border(
+//                                    1.dp,
+//                                    Color(0xFFE0E0E0), // Light border
+//                                    shape = RoundedCornerShape(8.dp)
+//                                )
+//                                .clickable(
+//                                    onClick = {
+//                                        scale = 0.3f
+//                                    }
+//                                ),
+//                            contentAlignment = Alignment.Center
+//                        ) {
+//                            ResetIcon(
+//                                tint = Color(0xFF424242), // Dark gray icon
+//                                modifier = Modifier.size(24.dp)
+//                            )
+//                        }
+                    }
+                }
+            }
+        }
+    ) { paddingValues ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .then(
+                    if (!isFullScreenState) {
+                        // CRITICAL: Clip ONLY TOP corners to match border radius (10.dp)
+                        // This ensures the entire container (border + content) is clipped consistently
+                        Modifier
+                            .clip(RoundedCornerShape(topStart = 10.dp, topEnd = 10.dp, bottomStart = 0.dp, bottomEnd = 0.dp))
+                            .background(Color.Transparent)
+                    } else {
+                        Modifier
+                    }
+                )
+                .then(
+                    if (!isFullScreenState) {
+                        Modifier.padding(
+                            top = 0.dp,
+                            bottom = paddingValues.calculateBottomPadding(),
+                            start = paddingValues.calculateStartPadding(LayoutDirection.Ltr),
+                            end = paddingValues.calculateEndPadding(LayoutDirection.Ltr)
+                        )
+                    } else {
+                        Modifier.padding(paddingValues)
+                    }
+                )
+                .drawBehind {
+                    // Draw gray border with rounded corners ONLY at TOP - straight bottom
+                    if (!isFullScreenState) {
+                        val cornerRadius = 10.dp.toPx()
+                        val strokeWidth = 20.dp.toPx()
+                        val halfStroke = strokeWidth / 2f
+
+                        val path = Path().apply {
+                            // Start from bottom-left (straight corner)
+                            moveTo(halfStroke, size.height)
+                            
+                            // Left border up to top-left corner
+                            lineTo(halfStroke, cornerRadius + halfStroke)
+                            
+                            // Top-left rounded corner
+                            arcTo(
+                                rect = androidx.compose.ui.geometry.Rect(
+                                    left = halfStroke,
+                                    top = halfStroke,
+                                    right = cornerRadius * 2 + halfStroke,
+                                    bottom = cornerRadius * 2 + halfStroke
+                                ),
+                                startAngleDegrees = 180f,
+                                sweepAngleDegrees = 90f,
+                                forceMoveTo = false
+                            )
+                            
+                            // Top border
+                            lineTo(size.width - cornerRadius * 2 - halfStroke, halfStroke)
+                            
+                            // Top-right rounded corner
+                            arcTo(
+                                rect = androidx.compose.ui.geometry.Rect(
+                                    left = size.width - cornerRadius * 2 - halfStroke,
+                                    top = halfStroke,
+                                    right = size.width - halfStroke,
+                                    bottom = cornerRadius * 2 + halfStroke
+                                ),
+                                startAngleDegrees = 270f,
+                                sweepAngleDegrees = 90f,
+                                forceMoveTo = false
+                            )
+                            
+                            // Right border straight down to bottom-right (NO rounded corner)
+                            lineTo(size.width - halfStroke, size.height)
+                        }
+                        drawPath(
+                            path = path,
+                            color = Color(0x66000000), // Gray border
+                            style = Stroke(width = strokeWidth)
+                        )
+                    }
+                }
+        ) {
+            if (!isInitialLoading && pageCount > 0) {
+                Column(modifier = Modifier.fillMaxSize()) {
+                    // Rendering Performance Stats Panel (in debug mode or when explicitly enabled)
+                    // TODO: Make this toggleable via a debug flag or settings
+                    val showStats = remember { mutableStateOf(false) }  // Set to true to enable stats display
+                    if (showStats.value) {
+                        RenderingStatsPanel(
+                            renderingStats = renderingStats,
+                            showStats = true
+                        )
+                    }
+                    
+                    val lazyListState = rememberLazyListState()
+                    val horizontalScrollState = rememberScrollState()
+                    val gestureScope = rememberCoroutineScope()
+                    
+                    // Get current visible page
+                    val currentPage = remember {
+                        derivedStateOf {
+                            lazyListState.firstVisibleItemIndex + 1
+                        }
+                    }
+                
+                // Scroll to initial page when PDF is loaded
+                LaunchedEffect(isInitialLoading, pageCount, initialPageIndex) {
+                    if (!isInitialLoading && pageCount > 0 && initialPageIndex >= 0 && initialPageIndex < pageCount) {
+                        // Wait for the list to be ready and ensure the target batch is loaded
+                        delay(500)
+                        
+                        // Load the batch containing the target page if not already loaded
+                        val targetBatch = getBatchNumber(initialPageIndex)
+                        if (!loadedBatches.contains(targetBatch)) {
+                            loadBatch(targetBatch, lastRenderedScale, priority = 0)
+                            
+                            // Wait for batch to load (with timeout)
+                            var attempts = 0
+                            while (attempts < 50 && !loadedBatches.contains(targetBatch)) {
+                                delay(100)
+                                attempts++
+                            }
+                        }
+                        
+                        // Wait a bit more for the page to render
+                        delay(300)
+                        
+                        try {
+                            // Scroll to the specified page index
+                            lazyListState.animateScrollToItem(
+                                index = initialPageIndex,
+                                scrollOffset = 0
+                            )
+                        } catch (e: Exception) {
+                            e.printStackTrace()
+                        }
+                    }
+                }
+                
+                // Retry mechanism for visible pages that failed to load
+                LaunchedEffect(lazyListState.firstVisibleItemIndex) {
+                    delay(500) // Wait 1 second after scroll settles
+                    
+                    // CRITICAL: Allow retry during recentPinchZoom to prevent white screen
+                    // Only skip during active zoom or active pinch zoom
+                    if (isZoomInProgress || isPinchZoomActive) {
+                        return@LaunchedEffect
+                    }
+                    
+                    val visiblePages = lazyListState.layoutInfo.visibleItemsInfo.map { it.index }
+                    val targetScale = lastRenderedScale
+                    
+                    // Check visible pages and retry failed ones
+                    visiblePages.forEach { pageIndex ->
+                        val cached = pageCache[pageIndex]
+                        val isRendering = renderingPages.containsKey(pageIndex)
+                        val isQueued = queuedPages.value.contains(pageIndex)
+                        
+                        // If page is not cached, not rendering, and not queued, retry it
+                        if (cached == null && !isRendering && !isQueued) {
+                            launch(Dispatchers.Default) {
+                                try {
+                                    val request = RenderRequest(pageIndex, targetScale, priority = 0)
+                                    renderQueue.send(request)
+                                    withContext(Dispatchers.Main) {
+                                        queuedPages.value = queuedPages.value + pageIndex
+                                    }
+                                } catch (e: Exception) {
+                                }
+                            }
+                        }
+                    }
+                }
+                
+                // Load pages on-demand as user scrolls (for pages beyond initial pre-load)
+                LaunchedEffect(lazyListState.firstVisibleItemIndex, lastRenderedScale) {
+                    // CRITICAL: If lastRenderedScale just changed (zoom completed), reduce delay
+                    // This prevents white screen after rapid zoom, especially zoom out
+                    // Allow loading during recentPinchZoom to prevent white screen when scrolling
+                    val delayTime = if (isZoomInProgress || isPinchZoomActive) {
+                        500L  // Wait longer if zoom still in progress or active pinch zoom
+                    } else {
+                        50L  // Very short delay if zoom just completed - prioritize visible pages immediately
+                    }
+                    
+                    delay(delayTime)
+                    
+                    // Skip only if zoom is actively in progress (not recentPinchZoom)
+                    if (isZoomInProgress || isPinchZoomActive) {
+                        return@LaunchedEffect
+                    }
+                    
+                    // CRITICAL FIX: Only skip if pinch zoom is actively happening (not recentPinchZoom)
+                    // Allow scroll handler to load pages during recentPinchZoom to prevent white screen
+                    // Skip only during active pinch zoom to prevent conflicts
+                    val timeSinceLastPinch = System.currentTimeMillis() - lastPinchZoomTime
+                    if (isPinchZoomActive) {
+                        // Only skip during active pinch zoom, not during recentPinchZoom period
+                        return@LaunchedEffect
+                    }
+                    // Note: We allow loading during recentPinchZoom to prevent white screen when scrolling
+                    
+                    val firstVisibleIndex = lazyListState.firstVisibleItemIndex
+                    val currentBatch = getBatchNumber(firstVisibleIndex)
+                    // CRITICAL FIX: Use current scale if recentPinchZoom is active to prevent loading old pages
+                    // When scrolling after max/min pinch zoom, we want to load at current scale, not old lastRenderedScale
+                    val targetScale = if (recentPinchZoom || isPinchZoomActive) {
+                        // During recent pinch zoom, use current scale to ensure pages load at correct zoom (max or min)
+                        scale.coerceIn(MIN_ZOOM, effectiveMaxZoom)
+                    } else {
+                        // Otherwise use lastRenderedScale (for normal scrolling)
+                        lastRenderedScale
+                    }
+                    
+                    // Get visible pages - prioritize loading them first
+                    val visiblePages = lazyListState.layoutInfo.visibleItemsInfo.map { it.index }
+                    
+                    // First, queue visible pages that need rendering (at correct scale or missing)
+                    // CRITICAL: Use more lenient threshold for max zoom AND minimum zoom to prevent white screen
+                    val scaleDiffThreshold = when {
+                        targetScale > 1.5f -> 0.50f  // For max zoom (>150%), allow up to 50% difference
+                        targetScale >= 1.0f && targetScale <= 1.5f -> 0.50f  // CRITICAL FIX: For moderate zoom (135-150%), allow 50% difference to ensure pages reload
+                        targetScale <= 1.1f -> 0.50f  // For minimum zoom (100% = 1.0f), also allow 50% difference (keeps pages at higher scales)
+                        else -> 0.08f  // For normal zoom, use 8% threshold
+                    }
+                    
+                    visiblePages.forEach { pageIndex ->
+                        val cached = pageCache[pageIndex]
+                        val needsRender = cached == null || 
+                            kotlin.math.abs(cached.second - targetScale) > scaleDiffThreshold
+                        
+                        if (needsRender && !renderingPages.containsKey(pageIndex) && !queuedPages.value.contains(pageIndex)) {
+                            launch(Dispatchers.Default) {
+                                try {
+                                    val request = RenderRequest(pageIndex, targetScale, priority = 0)
+                                    renderQueue.send(request)
+                                    withContext(Dispatchers.Main) {
+                                        queuedPages.value = queuedPages.value + pageIndex
+                                    }
+                                } catch (e: Exception) {
+                                }
+                            }
+                        }
+                    }
+                    
+                    // Load current batch if not loaded (or needs re-render at new scale)
+                    // CRITICAL: Use same lenient threshold for max zoom
+                    val batchNeedsLoad = !loadedBatches.contains(currentBatch) || 
+                        (0 until batchSize).any { offset ->
+                            val pageIndex = currentBatch * batchSize + offset
+                            if (pageIndex >= pageCount) false
+                            else {
+                                val cached = pageCache[pageIndex]
+                                cached == null || kotlin.math.abs(cached.second - targetScale) > scaleDiffThreshold
+                            }
+                        }
+                    
+                    if (batchNeedsLoad) {
+                        launch(Dispatchers.Default) {
+                            try {
+                                loadBatch(currentBatch, targetScale, priority = 1)
+                                
+                                // Mark batch as loaded
+                                withContext(Dispatchers.Main) {
+                                    loadedBatches = loadedBatches + currentBatch
+                                }
+                            } catch (e: Exception) {
+                                e.printStackTrace()
+                            }
+                        }
+                    }
+                    
+                    // Prefetch next batch if near end of current batch (using configurable threshold)
+                    val positionInBatch = firstVisibleIndex % batchSize
+                    val nextBatch = currentBatch + 1
+                    if (positionInBatch >= batchSize - PdfViewerConfig.SCROLL_PREFETCH_THRESHOLD && nextBatch * batchSize < pageCount) {
+                        val nextBatchNeedsLoad = !loadedBatches.contains(nextBatch) ||
+                            ((nextBatch * batchSize) until minOf((nextBatch + 1) * batchSize, pageCount)).any { pageIndex ->
+                                val cached = pageCache[pageIndex]
+                                cached == null || kotlin.math.abs(cached.second - targetScale) > 0.08f
+                            }
+                        
+                        if (nextBatchNeedsLoad) {
+                            launch(Dispatchers.Default) {
+                                try {
+                                    loadBatch(nextBatch, targetScale, priority = 2)
+                                    safeMainContext {
+                                        loadedBatches = loadedBatches + nextBatch
+                                    }
+                                } catch (e: kotlinx.coroutines.CancellationException) {
+                                    // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                                    if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                                        // Expected when composable leaves composition - not an error
+                                    } else {
+                                        // Other cancellation - also expected
+                                    }
+                                    throw e
+                                } catch (e: Exception) {
+                                    // Only log actual errors, not cancellations
+                                }
+                            }
+                        }
+                    }
+                    
+                    // Prefetch previous batch if scrolling up (using configurable threshold)
+                    val prevBatch = currentBatch - 1
+                    if (positionInBatch <= PdfViewerConfig.SCROLL_PREFETCH_THRESHOLD && prevBatch >= 0) {
+                        val prevBatchNeedsLoad = !loadedBatches.contains(prevBatch) ||
+                            ((prevBatch * batchSize) until minOf((prevBatch + 1) * batchSize, pageCount)).any { pageIndex ->
+                                val cached = pageCache[pageIndex]
+                                cached == null || kotlin.math.abs(cached.second - targetScale) > 0.08f
+                            }
+                        
+                        if (prevBatchNeedsLoad) {
+                            launch(Dispatchers.Default) {
+                                try {
+                                    loadBatch(prevBatch, targetScale, priority = 2)
+                                    safeMainContext {
+                                        loadedBatches = loadedBatches + prevBatch
+                                    }
+                                } catch (e: kotlinx.coroutines.CancellationException) {
+                                    // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                                    if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                                        // Expected when composable leaves composition - not an error
+                                    } else {
+                                        // Other cancellation - also expected
+                                    }
+                                    throw e
+                                } catch (e: Exception) {
+                                    // Only log actual errors, not cancellations
+                                }
+                            }
+                        }
+                    }
+                    
+                    // Manage cache size - keep only nearby batches
+                    // CRITICAL: Skip cache management during zoom OR recentPinchZoom to prevent clearing visible pages
+                    // This prevents white screen when scrolling after max pinch zoom
+                    if (!isZoomInProgress && !isPinchZoomActive && !recentPinchZoom) {
+                        try {
+                            manageCacheSize(firstVisibleIndex)
+                        } catch (e: kotlinx.coroutines.CancellationException) {
+                            // Check if it's a LeftCompositionCancellationException (expected when composable leaves)
+                            if (e.javaClass.simpleName == "LeftCompositionCancellationException") {
+                                // Expected when composable leaves composition - not an error
+                            } else {
+                                // Other cancellation - also expected
+                            }
+                            throw e
+                        } catch (e: Exception) {
+                            // Only log actual errors, not cancellations
+                            e.printStackTrace()
+                        }
+                    } else {
+                        val reason = when {
+                            isZoomInProgress -> "zoom in progress"
+                            isPinchZoomActive -> "pinch zoom active"
+                            recentPinchZoom -> "recent pinch zoom (keeping pages at max zoom)"
+                            else -> "unknown"
+                        }
+                    }
+                }
+                
+                // Force reload visible pages when cache cleanup requested it (e.g., after aggressive cleanup at max zoom)
+                LaunchedEffect(reloadVisiblePagesToken) {
+                    if (reloadVisiblePagesToken == 0) {
+                        return@LaunchedEffect
+                    }
+                    
+                    
+                    // Wait briefly if zoom or pinch is still active to avoid racing with gestures
+                    var attempts = 0
+                    while ((isZoomInProgress || isPinchZoomActive) && attempts < 20) {
+                        delay(100)
+                        attempts++
+                    }
+                    
+                    val visiblePages = lazyListState.layoutInfo.visibleItemsInfo.map { it.index }
+                    if (visiblePages.isEmpty()) {
+                        return@LaunchedEffect
+                    }
+                    
+                    val targetScale = if (recentPinchZoom || isPinchZoomActive) {
+                        scale.coerceIn(MIN_ZOOM, effectiveMaxZoom)
+                    } else {
+                        lastRenderedScale
+                    }
+                    
+                    val scaleDiffThreshold = if (targetScale > 1.5f || (targetScale >= 1.0f && targetScale <= 1.5f) || targetScale <= 0.35f) {
+                        0.50f  // CRITICAL FIX: Include moderate zoom (135-150%) in lenient threshold
+                    } else {
+                        0.08f
+                    }
+                    
+                    visiblePages.forEach { pageIndex ->
+                        val cached = pageCache[pageIndex]
+                        val needsRender = cached == null ||
+                            kotlin.math.abs(cached.second - targetScale) > scaleDiffThreshold
+                        
+                        if (needsRender && !renderingPages.containsKey(pageIndex) && !queuedPages.value.contains(pageIndex)) {
+                            launch(Dispatchers.Default) {
+                                try {
+                                    val request = RenderRequest(pageIndex, targetScale, priority = 0)
+                                    renderQueue.send(request)
+                                    withContext(Dispatchers.Main) {
+                                        queuedPages.value = queuedPages.value + pageIndex
+                                    }
+                                } catch (e: Exception) {
+                                }
+                            }
+                        }
+                    }
+                }
+                
+                // LaunchedEffect to detect when pinch zoom gesture ends (no updates for 500ms)
+                // Use a single job that gets cancelled and restarted
+                LaunchedEffect(lastPinchZoomTime) {
+                    try {
+                        delay(500)
+                        val currentTime = System.currentTimeMillis()
+                        val timeSinceLastUpdate = currentTime - lastPinchZoomTime
+                        if (timeSinceLastUpdate >= 500 && isPinchZoomActive) {
+                            isPinchZoomActive = false
+                            // CRITICAL FIX: Update lastRenderedScale immediately when pinch zoom ends
+                            // This ensures scroll handler loads pages at the correct (max) zoom scale
+                            try {
+                                lastRenderedScale = scale.coerceIn(MIN_ZOOM, effectiveMaxZoom)
+                            } catch (e: Exception) {
+                            }
+                            
+                            // Set recentPinchZoom to true to keep pages visible while re-rendering
+                            recentPinchZoom = true
+                            Log.d("PdfRendererTag", "pinch zoom is deactivated")
+                            
+                            // Keep recentPinchZoom true for 3 seconds to allow re-rendering to complete
+                            delay(3000)
+                            recentPinchZoom = false
+                        }
+                    } catch (e: kotlinx.coroutines.CancellationException) {
+                        // Expected when new gesture starts
+                        throw e
+                    } catch (e: Exception) {
+                    }
+                }
+                
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .then(
+                            if (!isFullScreenState) {
+                                // CRITICAL: Inset content by the full border stroke width
+                                // Border stroke is 20.dp wide, centered on path at 10.dp from edge
+                                // Inner edge of border = path (10.dp) + halfStroke (10.dp) = 20.dp
+                                // This ensures PDF content stays fully inside the gray border
+                                Modifier.padding(start = 20.dp, end = 20.dp, top = 20.dp, bottom = 0.dp)
+                            } else {
+                                Modifier // No padding in fullscreen
+                            }
+                        )
+                        // FULLY MANUAL GESTURE HANDLER: All scrolling is handled manually for consistency
+                        // - 1 finger: Manual scroll (both vertical and horizontal)
+                        // - 2 fingers: Pinch zoom ONLY (scroll disabled)
+                        // - 3+ fingers: Manual scroll (both vertical and horizontal)
+                        // - NO system scroll - LazyColumn has userScrollEnabled = false
+                        .pointerInput(lazyListState, horizontalScrollState) {
+                            // Track gesture state
+                            var isScrolling = false
+                            var lastScrollY = 0f
+                            var lastScrollX = 0f
+                            var scrollDirection: String? = null
+                            var refPointerId: Long = -1L
+                            var scrollMode = "NONE"
+
+                            val directionLockThreshold = 15f
+
+                            val flingDecay = exponentialDecay<Float>(frictionMultiplier = 1.2f)
+                            val velocityTracker = VelocityTracker()
+                            var flingJob: Job? = null
+                            var stopFling = false
+
+                            var prevHorizontalDistance = -1f
+                            var twoFingerFrameCount = 0
+
+                            val minStablePinchFrames = 3
+                            val horizontalZoomThreshold = 2f
+                            val horizontalDominanceRatio = 1.2f
+                            val maxZoomPerFrame = 1.05f
+                            val fullDistanceZoomThreshold = 10f
+                            
+                            awaitPointerEventScope {
+                                while (true) {
+                                    val event = awaitPointerEvent(PointerEventPass.Initial)
+                                    val pointers = event.changes.filter { it.pressed }
+                                    val pointerCount = pointers.size
+                                    
+                                    event.changes.forEach { it.consume() }
+                                    
+                                    when {
+                                        // 1 finger OR 3+ fingers: AXIS-LOCKED SCROLL
+                                        // Uses a single reference pointer (pointers[0] or
+                                        // the previously tracked pointer), NOT centroid.
+                                        pointerCount == 1 || pointerCount >= 3 -> {
+                                            prevHorizontalDistance = -1f
+                                            twoFingerFrameCount    = 0
+
+                                            scrollMode = if (pointerCount == 1) "SINGLE_SCROLL" else "MULTI_SCROLL"
+
+                                            val refPointer = pointers.firstOrNull {
+                                                it.id.value == refPointerId
+                                            } ?: pointers[0]
+                                            val refX = refPointer.position.x
+                                            val refY = refPointer.position.y
+                                            val refIdChanged = refPointer.id.value != refPointerId
+
+                                            val needsReAnchor = refIdChanged || !isScrolling
+
+                                            velocityTracker.addPosition(
+                                                refPointer.uptimeMillis,
+                                                Offset(refX, refY)
+                                            )
+
+                                            if (needsReAnchor) {
+                                                if (!isScrolling) {
+                                                    val hadActiveFling = flingJob?.isActive == true
+                                                    stopFling = true
+                                                    flingJob?.cancel()
+                                                    flingJob = null
+                                                    velocityTracker.resetTracking()
+                                                    velocityTracker.addPosition(
+                                                        refPointer.uptimeMillis,
+                                                        Offset(refX, refY)
+                                                    )
+                                                    if (!hadActiveFling) {
+                                                        scrollDirection = null
+                                                    }
+                                                    Log.d("PdfGesture",
+                                                        "GESTURE_START hadFling=$hadActiveFling " +
+                                                        "preservedDir=$scrollDirection"
+                                                    )
+                                                }
+                                                isScrolling  = true
+                                                lastScrollX  = refX
+                                                lastScrollY  = refY
+                                                refPointerId = refPointer.id.value
+                                                Log.d("PdfGesture",
+                                                    "mode=$scrollMode " +
+                                                    "${if (refIdChanged) "RE-ANCHOR" else "START"} " +
+                                                    "refPtr=$refPointerId " +
+                                                    "X=${"%.1f".format(refX)} Y=${"%.1f".format(refY)} " +
+                                                    "dir=$scrollDirection"
+                                                )
+                                            } else {
+                                                val rawDeltaX = lastScrollX - refX
+                                                val rawDeltaY = lastScrollY - refY
+
+                                                if (scrollDirection == null) {
+                                                    val absX = kotlin.math.abs(rawDeltaX)
+                                                    val absY = kotlin.math.abs(rawDeltaY)
+
+                                                    if (absX > directionLockThreshold || absY > directionLockThreshold) {
+                                                        scrollDirection = if (absX > absY) "horizontal" else "vertical"
+                                                        Log.d("PdfGesture",
+                                                            "mode=$scrollMode axis=$scrollDirection " +
+                                                            "refPtr=$refPointerId"
+                                                        )
+                                                    }
+                                                }
+
+                                                when (scrollDirection) {
+                                                    "vertical" -> {
+                                                        val deltaY = rawDeltaY
+                                                        if (kotlin.math.abs(deltaY) > 0.1f) {
+                                                            lazyListState.dispatchRawDelta(deltaY)
+                                                        }
+                                                        lastScrollY = refY
+                                                    }
+                                                    "horizontal" -> {
+                                                        val deltaX = rawDeltaX
+                                                        if (kotlin.math.abs(deltaX) > 0.1f) {
+                                                            horizontalScrollState.dispatchRawDelta(deltaX)
+                                                        }
+                                                        lastScrollX = refX
+                                                    }
+                                                    null -> {
+                                                        lastScrollX = refX
+                                                        lastScrollY = refY
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        
+                                        // 2 fingers: HORIZONTAL-ONLY PINCH ZOOM
+                                        // During settling, scroll state is preserved so that brief
+                                        // 3→2→3 pointer-count jitter doesn't destroy momentum.
+                                        pointerCount == 2 -> {
+                                            twoFingerFrameCount++
+
+                                            // ── Settling + was scrolling → keep scrolling ─────
+                                            if (twoFingerFrameCount <= minStablePinchFrames && isScrolling) {
+                                                val refPointer = pointers.firstOrNull {
+                                                    it.id.value == refPointerId
+                                                } ?: pointers[0]
+                                                val refX = refPointer.position.x
+                                                val refY = refPointer.position.y
+                                                val refIdChanged = refPointer.id.value != refPointerId
+
+                                                velocityTracker.addPosition(
+                                                    refPointer.uptimeMillis,
+                                                    Offset(refX, refY)
+                                                )
+
+                                                if (refIdChanged) {
+                                                    lastScrollX  = refX
+                                                    lastScrollY  = refY
+                                                    refPointerId = refPointer.id.value
+                                                } else {
+                                                    val rawDeltaX = lastScrollX - refX
+                                                    val rawDeltaY = lastScrollY - refY
+                                                    when (scrollDirection) {
+                                                        "vertical" -> {
+                                                            if (kotlin.math.abs(rawDeltaY) > 0.1f) {
+                                                                lazyListState.dispatchRawDelta(rawDeltaY)
+                                                            }
+                                                            lastScrollY = refY
+                                                        }
+                                                        "horizontal" -> {
+                                                            if (kotlin.math.abs(rawDeltaX) > 0.1f) {
+                                                                horizontalScrollState.dispatchRawDelta(rawDeltaX)
+                                                            }
+                                                            lastScrollX = refX
+                                                        }
+                                                        null -> {
+                                                            lastScrollX = refX
+                                                            lastScrollY = refY
+                                                        }
+                                                    }
+                                                }
+
+                                                prevHorizontalDistance = kotlin.math.abs(
+                                                    pointers[1].position.x - pointers[0].position.x
+                                                )
+                                                Log.d("PdfGesture",
+                                                    "2-finger SETTLING (scroll preserved) " +
+                                                    "frame=$twoFingerFrameCount/$minStablePinchFrames " +
+                                                    "mode=$scrollMode refPtr=$refPointerId"
+                                                )
+
+                                            // ── Settling complete or wasn't scrolling → zoom path ─
+                                            } else {
+                                                isScrolling      = false
+                                                scrollDirection   = null
+                                                refPointerId      = -1L
+                                                scrollMode        = "PINCH_ZOOM"
+                                                velocityTracker.resetTracking()
+
+                                                val pointer1 = pointers[0]
+                                                val pointer2 = pointers[1]
+
+                                                val pos1     = pointer1.position
+                                                val pos2     = pointer2.position
+                                                val prevPos1 = pointer1.previousPosition
+                                                val prevPos2 = pointer2.previousPosition
+
+                                                val currentDx       = pos2.x - pos1.x
+                                                val currentDy       = pos2.y - pos1.y
+                                                val currentDistance = kotlin.math.sqrt(currentDx * currentDx + currentDy * currentDy)
+
+                                                val prevDx           = prevPos2.x - prevPos1.x
+                                                val prevDy           = prevPos2.y - prevPos1.y
+                                                val previousDistance = kotlin.math.sqrt(prevDx * prevDx + prevDy * prevDy)
+
+                                                val currentHorizDist = kotlin.math.abs(pos2.x - pos1.x)
+                                                val currentVertDist  = kotlin.math.abs(pos2.y - pos1.y)
+
+                                                val horizDelta =
+                                                    if (prevHorizontalDistance >= 0f)
+                                                        kotlin.math.abs(currentHorizDist - prevHorizontalDistance)
+                                                    else 0f
+
+                                                Log.d("PdfGesture",
+                                                    "PinchZoom | pointers=2 | " +
+                                                    "frame=$twoFingerFrameCount | " +
+                                                    "fullDist=${currentDistance.toInt()} | " +
+                                                    "horizDist=${currentHorizDist.toInt()} | " +
+                                                    "vertDist=${currentVertDist.toInt()} | " +
+                                                    "horizDelta=${"%.1f".format(horizDelta)} | " +
+                                                    "prevHorizDist=${prevHorizontalDistance.toInt()}"
+                                                )
+
+                                                if (prevHorizontalDistance < 0f) {
+                                                    Log.d("PdfGesture", "PinchZoom SKIP — setting horizontal reference (safety)")
+                                                    prevHorizontalDistance = currentHorizDist
+
+                                                } else {
+                                                    val fullDistanceDelta    = if (previousDistance > 0f) kotlin.math.abs(currentDistance - previousDistance) else 0f
+                                                    val fullDistanceOverride = fullDistanceDelta >= fullDistanceZoomThreshold
+
+                                                    val isHorizDominant = currentHorizDist >= currentVertDist * horizontalDominanceRatio
+
+                                                    val hasMeaningfulHorizChange = horizDelta >= horizontalZoomThreshold
+
+                                                    if (!isHorizDominant && !fullDistanceOverride) {
+                                                        Log.d("PdfGesture",
+                                                            "PinchZoom BLOCKED — vertical dominant " +
+                                                            "(horizDist=${currentHorizDist.toInt()} " +
+                                                            "vertDist=${currentVertDist.toInt()})"
+                                                        )
+                                                    } else if (!fullDistanceOverride && !hasMeaningfulHorizChange) {
+                                                        Log.d("PdfGesture",
+                                                            "PinchZoom BLOCKED — horizDelta ${"%.1f".format(horizDelta)} < $horizontalZoomThreshold px"
+                                                        )
+                                                    } else if (previousDistance > 0f && currentDistance > 0f) {
+                                                        val rawZoom = currentDistance / previousDistance
+                                                        val zoom    = rawZoom.coerceIn(1f / maxZoomPerFrame, maxZoomPerFrame)
+
+                                                        Log.d("PdfGesture",
+                                                            "PinchZoom ALLOWED | " +
+                                                            "rawZoom=${"%.4f".format(rawZoom)} | " +
+                                                            "zoom=${"%.4f".format(zoom)} | " +
+                                                            "horizDelta=${"%.1f".format(horizDelta)} | " +
+                                                            "fullDelta=${"%.1f".format(fullDistanceDelta)}" +
+                                                            if (fullDistanceOverride) " [full-dist override]" else ""
+                                                        )
+
+                                                        touchGestureCount++
+
+                                                        try {
+                                                            if (!zoom.isNaN() && !zoom.isInfinite() && zoom > 0f) {
+                                                                if (kotlin.math.abs(zoom - 1.0f) >= 0.005f) {
+                                                                    val currentTime = System.currentTimeMillis()
+                                                                    isPinchZoomActive = true
+                                                                    lastPinchZoomTime = currentTime
+
+                                                                    val timeSinceLastUpdate = currentTime - lastScaleUpdateTime
+                                                                    val throttleTime = 16L
+
+                                                                    if (timeSinceLastUpdate >= throttleTime) {
+                                                                        val currentScale = scale
+                                                                        if (!currentScale.isNaN() && !currentScale.isInfinite() && currentScale > 0f) {
+                                                                            val newScale = (currentScale * zoom).coerceIn(MIN_ZOOM, effectiveMaxZoom)
+                                                                            if (!newScale.isNaN() && !newScale.isInfinite()) {
+                                                                                if (kotlin.math.abs(currentScale - newScale) > 0.005f) {
+                                                                                    scale = newScale
+                                                                                    lastScaleUpdateTime = currentTime
+                                                                                    Log.d("PdfGesture",
+                                                                                        "Scale updated: ${"%.3f".format(newScale)} " +
+                                                                                        "(${(newScale * 100).toInt()}%)"
+                                                                                    )
+                                                                                }
+                                                                            }
+                                                                        } else {
+                                                                            scale = MIN_ZOOM
+                                                                            lastScaleUpdateTime = currentTime
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        } catch (e: OutOfMemoryError) {
+                                                            System.gc()
+                                                        } catch (e: Exception) {
+                                                            // skip update on error
+                                                        }
+                                                    }
+
+                                                    prevHorizontalDistance = currentHorizDist
+                                                }
+                                            }
+                                        }
+                                        
+                                        // 0 fingers: all pointers lifted — launch fling if scrolling
+                                        else -> {
+                                            prevHorizontalDistance = -1f
+                                            twoFingerFrameCount    = 0
+                                            refPointerId           = -1L
+
+                                            val launchedFling = isScrolling && scrollDirection != null
+                                            if (launchedFling) {
+                                                val velocity = velocityTracker.calculateVelocity()
+                                                val capturedDirection = scrollDirection!!
+                                                Log.d("PdfGesture",
+                                                    "FLING_LAUNCH dir=$capturedDirection " +
+                                                    "vx=${"%.0f".format(velocity.x)} " +
+                                                    "vy=${"%.0f".format(velocity.y)}"
+                                                )
+                                                flingJob?.cancel()
+                                                stopFling = false
+                                                flingJob = gestureScope.launch {
+                                                    try {
+                                                        when (capturedDirection) {
+                                                            "vertical" -> {
+                                                                val initialVelocity = -velocity.y
+                                                                if (kotlin.math.abs(initialVelocity) > 50f) {
+                                                                    lazyListState.scroll {
+                                                                        val scrollScope = this
+                                                                        var lastValue = 0f
+                                                                        AnimationState(
+                                                                            initialValue = 0f,
+                                                                            initialVelocity = initialVelocity
+                                                                        ).animateDecay(flingDecay) {
+                                                                            if (stopFling) {
+                                                                                Log.d("PdfGesture", "FLING_KILLED by flag")
+                                                                                cancelAnimation()
+                                                                                return@animateDecay
+                                                                            }
+                                                                            val delta = value - lastValue
+                                                                            lastValue = value
+                                                                            val consumed = scrollScope.scrollBy(delta)
+                                                                            if (kotlin.math.abs(consumed) < kotlin.math.abs(delta) * 0.5f) {
+                                                                                Log.d("PdfGesture", "FLING_END boundary hit")
+                                                                                cancelAnimation()
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                } else {
+                                                                    Log.d("PdfGesture", "FLING_SKIP velocity too low: ${"%.0f".format(initialVelocity)}")
+                                                                }
+                                                            }
+                                                            "horizontal" -> {
+                                                                val initialVelocity = -velocity.x
+                                                                if (kotlin.math.abs(initialVelocity) > 50f) {
+                                                                    horizontalScrollState.scroll {
+                                                                        val scrollScope = this
+                                                                        var lastValue = 0f
+                                                                        AnimationState(
+                                                                            initialValue = 0f,
+                                                                            initialVelocity = initialVelocity
+                                                                        ).animateDecay(flingDecay) {
+                                                                            if (stopFling) {
+                                                                                Log.d("PdfGesture", "FLING_KILLED by flag")
+                                                                                cancelAnimation()
+                                                                                return@animateDecay
+                                                                            }
+                                                                            val delta = value - lastValue
+                                                                            lastValue = value
+                                                                            scrollScope.scrollBy(delta)
+                                                                        }
+                                                                    }
+                                                                } else {
+                                                                    Log.d("PdfGesture", "FLING_SKIP velocity too low: ${"%.0f".format(initialVelocity)}")
+                                                                }
+                                                            }
+                                                        }
+                                                        Log.d("PdfGesture", "FLING_COMPLETE dir=$capturedDirection")
+                                                    } catch (e: Exception) {
+                                                        if (e !is kotlinx.coroutines.CancellationException) {
+                                                            Log.e("PdfGesture", "Fling error: ${e.message}")
+                                                        } else {
+                                                            Log.d("PdfGesture", "FLING_CANCELLED dir=$capturedDirection")
+                                                        }
+                                                    }
+                                                }
+                                            }
+
+                                            isScrolling      = false
+                                            lastScrollX      = 0f
+                                            lastScrollY      = 0f
+                                            if (!launchedFling) scrollDirection = null
+                                            scrollMode       = "NONE"
+                                            velocityTracker.resetTracking()
+
+                                            Log.d("PdfGesture",
+                                                "ALL_UP launchedFling=$launchedFling " +
+                                                "preservedDir=$scrollDirection"
+                                            )
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                ) {
+                    LazyColumn(
+                        state = lazyListState,
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .horizontalScroll(horizontalScrollState, enabled = false) // Disabled - fully manual control
+                            .padding(start = 0.dp, end = 0.dp, bottom = 16.dp, top = 0.dp), // No side padding (parent Box handles border inset)
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.spacedBy(24.dp),
+                        // DISABLE system scroll - all scrolling (both vertical and horizontal) is handled manually in pointerInput
+                        userScrollEnabled = false
+                    ) {
+                        items(pageCount) { index ->
+                            val cachedPage = pageCache[index]
+                            val bitmap = cachedPage?.first
+                            val bitmapScale = cachedPage?.second ?: scale
+                            
+                            Column(
+                                horizontalAlignment = Alignment.CenterHorizontally,
+                                modifier = Modifier.wrapContentSize()
+                            ) {
+                                // Check if scale difference is significant (for zoom re-rendering)
+                                val scaleDifference = kotlin.math.abs(scale - bitmapScale)
+                                // Reduced threshold from 0.08f to 0.05f (5%) for more responsive re-rendering
+                                val needsRerender = scaleDifference > 0.05f
+                                
+                                // CRITICAL: Validate bitmap is not null and not recycled RIGHT BEFORE USE
+                                // This prevents race condition where bitmap is recycled between check and use
+                                val isValidBitmap = try {
+                                    bitmap != null && !bitmap.isRecycled && bitmap.width > 0 && bitmap.height > 0
+                                } catch (e: Exception) {
+                                    false
+                                }
+                                
+                                // FIX: Show pages with visual scaling for smooth zoom experience
+                                // CRITICAL: During pinch zoom, always allow visual scaling (no hiding pages)
+                                // For zoom out: be more lenient - allow showing larger pages (can scale down)
+                                // For zoom in: only show pages within reasonable range
+                                val isZoomingOut = bitmapScale > scale
+                                val maxVisualScaleDiff = if (isZoomingOut) {
+                                    // CRITICAL FIX: For minimum zoom, allow much larger visual scaling
+                                    // This prevents white screen when zooming out to minimum
+                                    if (scale <= 1.1f) {
+                                        10.0f  // Allow up to 10x visual scaling for minimum zoom (e.g., 2.5f -> 1.0f)
+                                    } else {
+                                        0.50f  // For normal zoom out, allow up to 50% difference
+                                    }
+                                } else {
+                                    // CRITICAL FIX: For zoom in, increase threshold to handle 100% -> 150% (50% difference)
+                                    // Also handle moderate zoom levels (135-150%) properly
+                                    if (scale >= 1.0f && scale <= 1.5f) {
+                                        0.60f  // Allow up to 60% difference for moderate zoom (handles 100% -> 150%)
+                                    } else {
+                                        0.40f  // Stricter for other zoom in - 40% difference
+                                    }
+                                }
+                                // CRITICAL FIX: During pinch zoom AND recent pinch zoom, ALWAYS show pages regardless of scale difference
+                                // This prevents white screen during pinch zoom, especially at max zoom
+                                // recentPinchZoom keeps pages visible for 3 seconds after pinch ends to allow re-rendering
+                                // For button clicks, also allow visual scaling for smooth experience
+                                val isScaleAcceptable = if (isPinchZoomActive || recentPinchZoom) {
+                                    true  // Always show during pinch zoom and recent pinch zoom - visual scaling handles it, even at max zoom
+                                } else {
+                                    // For button clicks, also allow visual scaling for smooth experience
+                                    // Only hide if scale difference is too large AND we're not actively zooming
+                                    scaleDifference < maxVisualScaleDiff || isZoomInProgress
+                                }
+                                
+                                // CRITICAL: During pinch zoom or recent pinch zoom, always show something (bitmap or placeholder)
+                                // This prevents white screen at max zoom
+                                // CRITICAL FIX: During pinch zoom, ALWAYS show bitmap if it exists, even if being re-rendered
+                                // This prevents white screen on the page being zoomed
+                                val shouldShowBitmap = if (isPinchZoomActive || recentPinchZoom) {
+                                    // During pinch zoom, show bitmap if it exists (even if scale doesn't match perfectly)
+                                    isValidBitmap
+                                } else {
+                                    // Normal case: show bitmap if valid and scale is acceptable
+                                    isValidBitmap && (isScaleAcceptable || isZoomInProgress)
+                                }
+                                val shouldShowPlaceholder = (isPinchZoomActive || recentPinchZoom) && !isValidBitmap
+                                
+                                if (shouldShowBitmap || shouldShowPlaceholder) {
+                                    // Page is loaded - show it with visual scaling if needed
+                                    // OR show placeholder during pinch zoom if bitmap not available
+                                    // CRITICAL: Re-check bitmap validity right before using it
+                                    val safeBitmap = try {
+                                        if (bitmap != null && !bitmap.isRecycled && bitmap.width > 0 && bitmap.height > 0) {
+                                            bitmap
+                                } else {
+                                            null
+                                        }
+                                    } catch (e: Exception) {
+                                        null
+                                    }
+                                    
+                                    if (safeBitmap == null) {
+                                        // Bitmap was recycled or not available - show placeholder
+                                        // During pinch zoom, always show placeholder to prevent white screen
+                                        Box(
+                                            modifier = Modifier
+                                                .width((screenWidthDp - 32.dp) * scale)
+                                                .height((screenWidthDp - 32.dp) * scale * 1.414f), // A4 aspect ratio
+                                            contentAlignment = Alignment.Center
+                                        ) {
+                                            CircularProgressIndicator()
+                                        }
+                                    } else {
+                                        // CRITICAL: Final validation right before asImageBitmap()
+                                        val finalBitmap = try {
+                                            if (!safeBitmap.isRecycled && safeBitmap.width > 0 && safeBitmap.height > 0) {
+                                                safeBitmap
+                                            } else {
+                                                null
+                                            }
+                                        } catch (e: Exception) {
+                                            null
+                                        }
+                                        
+                                        if (finalBitmap == null) {
+                                            // Show placeholder if bitmap became invalid
+                                            Box(
+                                                modifier = Modifier
+                                                    .width((screenWidthDp - 32.dp) * scale)
+                                                    .height((screenWidthDp - 32.dp) * scale * 1.414f),
+                                                contentAlignment = Alignment.Center
+                                            ) {
+                                                CircularProgressIndicator()
+                                            }
+                                        } else {
+                                            val aspectRatio = finalBitmap.width.toFloat() / finalBitmap.height.toFloat()
+                                            
+                                            // FIX: Prevent double-scaling issue
+                                            // Problem: When zooming in, displayWidth was set to new scale AND graphicsLayer scaled again
+                                            // Solution: Calculate displayWidth based on bitmapScale, then apply visual scaling factor
+                                            
+                                            // Base display width should match the bitmap's actual rendered scale
+                                            val baseDisplayWidth = (screenWidthDp - 32.dp) * bitmapScale
+                                            
+                                            // Calculate visual scale factor to match current scale
+                                            // CRITICAL: During pinch zoom AND recent pinch zoom, allow MUCH larger visual scaling
+                                            // This prevents white screen when zooming to max zoom (e.g., from 1.0f to 2.5f)
+                                            // Apply visual scaling for all differences during pinch zoom and recent pinch zoom
+                                            val effectiveMaxDiff = if (isPinchZoomActive || recentPinchZoom) {
+                                                // During pinch zoom and recent pinch zoom, allow ANY scale difference - no limit
+                                                // This ensures pages are always shown during pinch zoom, even at max zoom
+                                                Float.MAX_VALUE  // No limit during pinch zoom and recent pinch zoom
+                                            } else if (isZoomInProgress) {
+                                                // During button zoom, use the same threshold as maxVisualScaleDiff for consistency
+                                                // This ensures pages stay visible during zoom transitions at moderate zoom levels
+                                                maxVisualScaleDiff  // Use dynamic threshold based on zoom level
+                                            } else {
+                                                maxVisualScaleDiff
+                                            }
+                                            
+                                            val visualScaleFactor = if (isPinchZoomActive || recentPinchZoom) {
+                                                // During pinch zoom and recent pinch zoom, always apply visual scaling regardless of difference
+                                                // This prevents white screen at max zoom AND minimum zoom
+                                                // Cap visual scaling factor to prevent extreme distortion (max 10x scaling)
+                                                val rawFactor = scale / bitmapScale
+                                                // CRITICAL FIX: For zoom out to minimum, allow larger visual scaling
+                                                val maxVisualScale = if (scale <= 1.1f && bitmapScale > scale) {
+                                                    10f  // Allow up to 10x for zoom out to minimum (e.g., 2.5f -> 1.0f)
+                                                } else {
+                                                    10f  // Standard cap at 10x
+                                                }
+                                                kotlin.math.min(rawFactor, maxVisualScale)  // Cap to prevent rendering issues
+                                            } else if (scaleDifference > 0.05f && scaleDifference < effectiveMaxDiff) {
+                                                scale / bitmapScale  // Scale factor to match current scale
+                                            } else if (scaleDifference >= effectiveMaxDiff) {
+                                                // For very large differences during button zoom, cap visual scaling
+                                                val maxAllowedScale = bitmapScale + maxVisualScaleDiff
+                                                kotlin.math.min(scale, maxAllowedScale) / bitmapScale
+                                            } else {
+                                                // No scaling needed if scale matches closely (< 5%)
+                                                1f
+                                            }
+                                            
+                                            // Final display width: base width * visual scale factor
+                                            val displayWidth = baseDisplayWidth * visualScaleFactor
+                                            
+                                            Box {
+                                Image(
+                                                    bitmap = finalBitmap.asImageBitmap(),
+                                    contentDescription = "PDF Page ${index + 1}",
+                                    contentScale = ContentScale.Fit,
+                                    modifier = Modifier
+                                        .width(displayWidth)
+                                        .aspectRatio(aspectRatio)
+                                        // Remove graphicsLayer scaling - width modifier already handles the scaling
+                                        // This prevents double-scaling that caused 50% to appear as 70%
+                                )
+                                                
+                                                // Show small indicator if actively re-rendering at new zoom level (not stale)
+                                                val renderStartTime = renderingPages[index]
+                                                val currentTime = System.currentTimeMillis()
+                                                val isActivelyRendering = renderStartTime != null && 
+                                                    (currentTime - renderStartTime) < RENDERING_TIMEOUT_MS
+                                                
+                                                if (needsRerender && isActivelyRendering && !isZoomInProgress) {
+                                                    Card(
+                                                        modifier = Modifier
+                                                            .align(Alignment.TopEnd)
+                                                            .padding(8.dp),
+                                                        elevation = 4.dp,
+                                                        backgroundColor = androidx.compose.ui.graphics.Color.White.copy(alpha = 0.9f)
+                                                    ) {
+                                                        CircularProgressIndicator(
+                                                            modifier = Modifier
+                                                                .size(20.dp)
+                                                                .padding(4.dp),
+                                                            strokeWidth = 2.dp
+                                                        )
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                } else if (shouldShowPlaceholder) {
+                                    // Show placeholder during pinch zoom if bitmap not available
+                                    Box(
+                                        modifier = Modifier
+                                            .width((screenWidthDp - 32.dp) * scale)
+                                            .height((screenWidthDp - 32.dp) * scale * 1.414f),
+                                        contentAlignment = Alignment.Center
+                                    ) {
+                                        CircularProgressIndicator()
+                                    }
+                                } else if (!isScaleAcceptable && isValidBitmap && !(isPinchZoomActive || recentPinchZoom)) {
+                                    // CRITICAL FIX: Page is at wrong scale during rapid zoom - show loading indicator
+                                    // BUT only if NOT during pinch zoom or recent pinch zoom
+                                    // This prevents showing pages at old scales (e.g., 40% when zoomed to 60%)
+                                    Box(
+                                        modifier = Modifier
+                                            .width((screenWidthDp - 32.dp) * scale)
+                                            .height((screenWidthDp - 32.dp) * scale * 1.4f)
+                                            .padding(8.dp),
+                                        contentAlignment = Alignment.Center
+                                    ) {
+                                        Column(
+                                            horizontalAlignment = Alignment.CenterHorizontally
+                                        ) {
+                                            CircularProgressIndicator(
+                                                modifier = Modifier.size(32.dp)
+                                            )
+                                            Spacer(modifier = Modifier.height(8.dp))
+                                            Text(
+//                                                text = " ${(scale * 100).toInt()}%...",
+                                                text = "",
+                                                style = MaterialTheme.typography.caption
+                                            )
+                                        }
+                                    }
+                                } else {
+                                    // Page not loaded yet - check if actively rendering or queued
+                                    val renderStartTime = renderingPages[index]
+                                    val currentTime = System.currentTimeMillis()
+                                    val isActivelyRendering = renderStartTime != null && 
+                                        (currentTime - renderStartTime) < RENDERING_TIMEOUT_MS
+                                    val isQueued = queuedPages.value.contains(index)
+                                    
+                                    // Only show loading if actively rendering (not stale) or queued
+                                    if (isActivelyRendering || isQueued) {
+                                        Box(
+                                            modifier = Modifier
+                                                .width((screenWidthDp - 32.dp) * scale)
+                                                .height((screenWidthDp - 32.dp) * scale * 1.4f) // Approximate A4 ratio
+                                                .padding(8.dp),
+                                            contentAlignment = Alignment.Center
+                                        ) {
+                                            Column(
+                                                horizontalAlignment = Alignment.CenterHorizontally
+                                            ) {
+                                                CircularProgressIndicator(
+                                                    modifier = Modifier.size(32.dp)
+                                                )
+                                                Spacer(modifier = Modifier.height(8.dp))
+                                                Text(
+                                                    text = "Loading page ${index + 1}...",
+                                                    style = MaterialTheme.typography.caption
+                                                )
+                                            }
+                                        }
+                                    } else {
+                                        // Page not loading (might be stuck) - show empty space
+                                        // This prevents stuck loaders
+                                        Box(
+                                            modifier = Modifier
+                                                .width((screenWidthDp - 32.dp) * scale)
+                                                .height((screenWidthDp - 32.dp) * scale * 1.4f)
+                                                .padding(8.dp),
+                                            contentAlignment = Alignment.Center
+                                        ) {
+                                            // Empty - page will load when scrolled into view or retried
+                                        }
+                                    }
+                                }
+                                
+                                // Add page number label
+                                Text(
+                                    text = "Page ${index + 1} of $pageCount",
+                                    modifier = Modifier.padding(vertical = 8.dp),
+                                    style = MaterialTheme.typography.caption
+                                )
+                            }
+                        }
+                    }
+                    
+                    // Current page indicator (floating badge) - bottom-right corner
+                    Card(
+                        modifier = Modifier
+                            .align(Alignment.BottomEnd)
+                            .padding(16.dp),
+                        elevation = 4.dp,
+                        backgroundColor = androidx.compose.ui.graphics.Color(0xFFF5F5F5), // Light grey background
+                        shape = androidx.compose.foundation.shape.RoundedCornerShape(8.dp)
+                    ) {
+                        Text(
+                            text = "Page ${currentPage.value} of $pageCount",
+                            modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
+                            style = MaterialTheme.typography.body2,
+                            color = androidx.compose.ui.graphics.Color.Black
+                        )
+                    }
+                }
+                } // Close Column
+            } else {
+                // Show loading progress during initial load
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.Center,
+                        modifier = Modifier.padding(32.dp)
+                    ) {
+                        CircularProgressIndicator(
+                            modifier = Modifier.size(64.dp),
+                            color = androidx.compose.ui.graphics.Color(0xFF9C27B0) // Purple color
+                        )
+                        Spacer(modifier = Modifier.height(24.dp))
+                        Text(
+//                            text = "${(scale * 100).toInt()}%...",
+                            text = "",
+                            style = MaterialTheme.typography.h6,
+                            color = androidx.compose.ui.graphics.Color.Black
+                        )
+                    }
+                    
+                    // Page info in bottom-right corner (even during loading)
+                    if (pageCount > 0) {
+                        Card(
+                            modifier = Modifier
+                                .align(Alignment.BottomEnd)
+                                .padding(16.dp),
+                            elevation = 4.dp,
+                            backgroundColor = androidx.compose.ui.graphics.Color(0xFFF5F5F5), // Light grey background
+                            shape = androidx.compose.foundation.shape.RoundedCornerShape(8.dp)
+                        ) {
+                            Text(
+                                text = "Page 1 of $pageCount",
+                                modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
+                                style = MaterialTheme.typography.body2,
+                                color = androidx.compose.ui.graphics.Color.Black
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ============================================================================
+// PREVIEW FUNCTION
+// ============================================================================
+
+@Preview(showBackground = true, name = "PDF Viewer Preview")
+@Composable
+fun PdfRendererViewPreview() {
+    MaterialTheme {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(Color.White)
+        ) {
+            PdfRendererView(
+                uri = Uri.EMPTY,
+                initialPageIndex = -1,
+                maxWidthDp = null,
+                maxZoom = PdfViewerConfig.MAX_SCALE_SMALL_SCREEN,
+                screenWidthPercentage = 100f,
+                iconUrls = null,
+                isFullScreen = false,
+                backButtonText = "Back",
+                headerText = "PDF Preview",
+                onFullScreenChange = null,
+                onLeftScreenChange = null,
+                onRightScreenChange = null,
+                onZoomChange = null
+            )
+        }
+    }
+}