@june24/expo-pdf-reader 0.1.26 → 0.1.28

package/android/src/main/java/expo/modules/pdfreader/ExpoPdfReaderView.kt

@@ -1,1765 +1,1962 @@
-package expo.modules.pdfreader
-
-import android.content.Context
-import android.graphics.*
-import android.graphics.pdf.PdfRenderer
-import android.os.ParcelFileDescriptor
-import android.text.Layout
-import android.text.StaticLayout
-import android.text.TextPaint
-import android.util.Log
-import android.view.*
-import android.widget.*
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.PagerSnapHelper
-import androidx.recyclerview.widget.RecyclerView
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.viewevent.EventDispatcher
-import expo.modules.kotlin.views.ExpoView
-import kotlinx.coroutines.*
-import java.io.File
-import java.io.FileOutputStream
-import java.net.URL
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Data classes
-// ─────────────────────────────────────────────────────────────────────────────
-
-data class AnnPath(val points: MutableList<PointF> = mutableListOf())
-
-/**
- * Bounds stored in PDF page coordinate space:
- *   origin = bottom-left of the page, y-axis points UP.
- *
- *   RectF.left   = left edge  (PDF x)
- *   RectF.top    = lower y in PDF space  (screen-bottom side, smaller PDF-y value)
- *   RectF.right  = right edge (PDF x)
- *   RectF.bottom = upper y in PDF space  (screen-top side,   larger  PDF-y value)
- *
- * Matches iOS PDFKit: CGRect(x, y=lowerPdfY, width, height).
- */
-data class PdfAnnotation(
-    val type: String,         // "pen" | "highlighter" | "line" | "text" | "note"
-    val pageIndex: Int,
-    var bounds: RectF,
-    val paths: MutableList<AnnPath> = mutableListOf(),
-    var color: String = "#FF0000",
-    var strokeWidth: Float = 2f,
-    var contents: String = "",
-    var fontSize: Float = 14f,
-    var bold: Boolean = false,
-    var italic: Boolean = false
-)
-
-data class UndoEntry(val annotation: PdfAnnotation)
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Main view
-// ─────────────────────────────────────────────────────────────────────────────
-
-class ExpoPdfReaderView(
-    context: Context,
-    appContext: AppContext
-) : ExpoView(context, appContext) {
-
-    // ── Expo Events (ViewEventDelegate — Expo Modules-ын зөв механизм) ────────
-    val onReady by EventDispatcher()
-    val onPageChange by EventDispatcher()
-    val onAnnotationChange by EventDispatcher()
-    val onUndoRedoStateChange by EventDispatcher()
-    val onNotePress by EventDispatcher()
-    val onTextPress by EventDispatcher()
-
-    // ── Coroutines ───────────────────────────────────────────────────────────
-    private val pdfDispatcher = Dispatchers.IO.limitedParallelism(1)
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-    private var renderJob: Job? = null
-
-    // ── PDF state ────────────────────────────────────────────────────────────
-    private var fileDescriptor: ParcelFileDescriptor? = null
-    private var renderer: PdfRenderer? = null
-    private var pagePdfW = intArrayOf()   // PDF points per page
-    private var pagePdfH = intArrayOf()
-    var totalPages = 0
-        private set
-
-    // ── Display state ────────────────────────────────────────────────────────
-    private var displayMode = "continuous"
-    private var pendingUrl: String? = null
-    private var isLayoutReady = false
-    var currentPageIndex = 0
-        private set
-
-    // ── Lazy / chunked rendering ──────────────────────────────────────────────
-    private var renderedUpTo = -1          // last rendered page index (absolute)
-    private var windowStart = 0            // pageEntries[0]-н absolute page index
-    private var chunkLoading = false       // chunk дуусах хүртэл дахин trigger хийхгүй
-    private var currentViewWidth = 0       // chunk load-д дахин хэрэглэнэ
-    private var loadingFooter: View? = null
-
-    companion object {
-        private const val PAGE_CHUNK = 10           // нэг удаа render хийх хуудасны тоо
-        private const val MAX_RENDERED = PAGE_CHUNK * 2  // санах ойд байлгах дээд хязгаар (20 хуудас)
-    }
-
-    // ── Annotation state ─────────────────────────────────────────────────────
-    val annotationMap = mutableMapOf<Int, MutableList<PdfAnnotation>>()
-    var activeTool: String? = null
-    var strokeColorVal = "#FF0000"
-    var strokeWidthVal = 2f
-    var textContentVal = ""
-    var textColorVal = "#000000"
-    var textFontSizeVal = 14f
-    var textBoldVal = false
-    var textItalicVal = false
-    var noteColorVal = "#FFFF00"
-
-    val undoStack = ArrayDeque<UndoEntry>()
-    val redoStack = ArrayDeque<UndoEntry>()
-    private var appliedFingerprint: String? = null
-
-    // ── Page view entries (continuous/twoUp modes) ───────────────────────────
-    // frame: container-аас устгахад шууд reference, bmpHeight: layout болохоос өмнө scroll тооцооны тулд
-    data class PageEntry(val frame: FrameLayout, val canvasView: AnnotationCanvasView, val bmpHeight: Int)
-    val pageEntries = mutableListOf<PageEntry>()
-
-    // ── Single-page pager (single mode) ──────────────────────────────────────
-    private lateinit var pager: RecyclerView
-    private var singleAdapter: SinglePageAdapter? = null
-    private val singlePageCanvases = mutableMapOf<Int, AnnotationCanvasView>()
-
-    // ── Zoom ─────────────────────────────────────────────────────────────────
-    private var minZoom = 1.0f
-    private var maxZoom = 5.0f
-    private var currentZoom = 1.0f
-    private val scaleDetector = ScaleGestureDetector(
-        context,
-        object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
-            override fun onScale(d: ScaleGestureDetector): Boolean {
-                if (activeTool != null) return true
-                applyZoom((currentZoom * d.scaleFactor).coerceIn(minZoom, maxZoom))
-                return true
-            }
-        }
-    )
-
-    // ── UI ───────────────────────────────────────────────────────────────────
-    val scrollView = ScrollView(context).apply {
-        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
-        isFillViewport = true
-    }
-    private val container = LinearLayout(context).apply {
-        orientation = LinearLayout.VERTICAL
-        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)
-        setBackgroundColor(Color.parseColor("#E8E8E8"))
-    }
-
-    init {
-        setBackgroundColor(Color.parseColor("#E8E8E8"))
-        scrollView.addView(container)
-        addView(scrollView)
-        scrollView.setOnScrollChangeListener { _, _, scrollY, _, _ ->
-            detectCurrentPage(scrollY)
-            maybeTriggerChunkLoad(scrollY)
-        }
-
-        // Single-page pager: ZoomRecyclerView + PagerSnapHelper (vertical)
-        pager = ZoomRecyclerView(context).apply {
-            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
-            layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
-            PagerSnapHelper().attachToRecyclerView(this)
-            setBackgroundColor(Color.parseColor("#E8E8E8"))
-            visibility = View.GONE
-            addOnScrollListener(object : RecyclerView.OnScrollListener() {
-                override fun onScrollStateChanged(rv: RecyclerView, newState: Int) {
-                    if (newState == RecyclerView.SCROLL_STATE_IDLE) {
-                        val lm = rv.layoutManager as? LinearLayoutManager ?: return
-                        val pos = lm.findFirstCompletelyVisibleItemPosition()
-                            .takeIf { it >= 0 } ?: return
-                        if (pos != currentPageIndex) {
-                            currentPageIndex = pos
-                            // Хуудас солигдоход zoom-г reset хийнэ
-                            (pager as? ZoomRecyclerView)?.resetZoom()
-                            onPageChange(mapOf("currentPage" to pos, "totalPage" to totalPages))
-                        }
-                    }
-                }
-            })
-        }
-        addView(pager)
-    }
-
-    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
-        super.onLayout(changed, l, t, r, b)
-        if (width > 0 && !isLayoutReady) {
-            isLayoutReady = true
-            pendingUrl?.let {
-                pendingUrl = null
-                startLoad(it)
-            }
-        }
-        // Note: width өөрчлөгдөхөд triggerRender дуудахгүй —
-        // forced layout (forceLayoutScrollView) нь pages-г шууд харагдуулдаг
-    }
-
-    override fun onDetachedFromWindow() {
-        super.onDetachedFromWindow()
-        renderJob?.cancel()
-        scope.cancel()
-        safeCloseRenderer()
-    }
-
-    override fun onTouchEvent(event: MotionEvent): Boolean {
-        scaleDetector.onTouchEvent(event)
-        return super.onTouchEvent(event)
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // Props
-    // ─────────────────────────────────────────────────────────────────────────
-
-    fun setUrl(url: String?) {
-        if (url.isNullOrBlank()) return
-        pendingUrl = url
-        if (isLayoutReady) {
-            startLoad(url)
-        } else {
-            // Layout ирээгүй байж болно — дараагийн frame-д шалгана
-            post { tryStartLoad() }
-        }
-    }
-
-    private fun tryStartLoad() {
-        val url = pendingUrl ?: return   // onLayout аль хэдийн startLoad дуудсан бол pendingUrl = null → exit
-        if (width > 0) {
-            isLayoutReady = true
-            pendingUrl = null   // давхар дуудлагаас сэргийлнэ
-            startLoad(url)
-        } else {
-            scope.launch {
-                delay(50)
-                tryStartLoad()
-            }
-        }
-    }
-
-    fun setDisplayMode(mode: String?) {
-        val newMode = mode?.lowercase() ?: "continuous"
-        if (newMode == displayMode) return
-        displayMode = newMode
-        if (renderer != null && isLayoutReady) triggerRender()
-    }
-
-    fun setInitialPage(page: Int) {
-        if (page < 0 || page >= totalPages) return
-        currentPageIndex = page
-        if (displayMode == "single") {
-            post { scrollToPage(page, smooth = false) }
-            return
-        }
-        val windowEnd = windowStart + pageEntries.size - 1
-        if (page in windowStart..windowEnd) {
-            // Хуудас render хийгдсэн window дотор байна → зүгээр scroll хийнэ
-            post { scrollToPage(page, smooth = false) }
-        } else {
-            // Хуудас render хийгдээгүй → window-г тухайн хуудас руу шилжүүлнэ
-            jumpToPage(page)
-        }
-    }
-
-    fun setMinZoom(v: Double) { minZoom = v.toFloat() }
-    fun setMaxZoom(v: Double) { maxZoom = v.toFloat() }
-
-    fun setTool(tool: String?) {
-        activeTool = tool
-        if (displayMode == "single") {
-            pager.requestDisallowInterceptTouchEvent(tool != null)
-        } else {
-            scrollView.requestDisallowInterceptTouchEvent(tool != null)
-        }
-    }
-
-    fun setStrokeColor(hex: String) { strokeColorVal = hex }
-    fun setStrokeWidth(w: Double) { strokeWidthVal = w.toFloat() }
-    fun setTextContent(t: String) { textContentVal = t }
-    fun setTextColor(hex: String) { textColorVal = hex }
-    fun setTextFontSize(size: Double) { textFontSizeVal = size.toFloat() }
-    fun setTextBold(v: Boolean) { textBoldVal = v }
-    fun setTextItalic(v: Boolean) { textItalicVal = v }
-    fun setNoteColor(hex: String) { noteColorVal = hex }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // Commands
-    // ─────────────────────────────────────────────────────────────────────────
-
-    fun undo() {
-        val e = undoStack.removeLastOrNull() ?: return
-        redoStack.addLast(e)
-        annotationMap[e.annotation.pageIndex]?.remove(e.annotation)
-        invalidateCanvas(e.annotation.pageIndex)
-        notifyAnnotationChange()
-        notifyUndoRedoState()
-    }
-
-    fun redo() {
-        val e = redoStack.removeLastOrNull() ?: return
-        undoStack.addLast(e)
-        annotationMap.getOrPut(e.annotation.pageIndex) { mutableListOf() }.add(e.annotation)
-        invalidateCanvas(e.annotation.pageIndex)
-        notifyAnnotationChange()
-        notifyUndoRedoState()
-    }
-
-    fun setAnnotations(data: List<Map<String, Any?>>) {
-        val fp = buildFingerprint(data)
-        if (fp == appliedFingerprint) return
-        appliedFingerprint = fp
-        annotationMap.clear()
-
-        for (item in data) {
-            val pageIndex = (item["page"] as? Number)?.toInt() ?: continue
-            val typeStr = item["type"] as? String ?: continue
-            val b = item["bounds"] as? Map<*, *> ?: continue
-            val bX = (b["x"] as? Number)?.toFloat() ?: 0f
-            val bY = (b["y"] as? Number)?.toFloat() ?: 0f
-            val bW = (b["width"] as? Number)?.toFloat() ?: 0f
-            val bH = (b["height"] as? Number)?.toFloat() ?: 0f
-
-            val bounds = RectF(bX, bY, bX + bW, bY + bH)
-            val ann = PdfAnnotation(
-                type = typeStr, pageIndex = pageIndex, bounds = bounds,
-                color = item["color"] as? String ?: strokeColorVal,
-                strokeWidth = (item["strokeWidth"] as? Number)?.toFloat() ?: strokeWidthVal,
-                contents = item["contents"] as? String ?: "",
-                fontSize = (item["fontSize"] as? Number)?.toFloat() ?: textFontSizeVal,
-                bold = item["bold"] as? Boolean ?: false,
-                italic = item["italic"] as? Boolean ?: false
-            )
-
-            (item["paths"] as? List<*>)?.forEach { pathData ->
-                val pts = (pathData as? List<*>)?.mapNotNull { pt ->
-                    val m = pt as? Map<*, *> ?: return@mapNotNull null
-                    PointF(
-                        (m["x"] as? Number)?.toFloat() ?: 0f,
-                        (m["y"] as? Number)?.toFloat() ?: 0f
-                    )
-                }
-                if (!pts.isNullOrEmpty()) ann.paths.add(AnnPath(pts.toMutableList()))
-            }
-
-            annotationMap.getOrPut(pageIndex) { mutableListOf() }.add(ann)
-        }
-        if (displayMode == "single") {
-            singlePageCanvases.values.forEach { it.invalidate() }
-        } else {
-            pageEntries.forEach { it.canvasView.invalidate() }
-        }
-    }
-
-    fun updateText(pageIndex: Int, index: Int, contents: String) {
-        val anns = annotationMap[pageIndex]?.filter { it.type == "text" } ?: return
-        if (index >= anns.size) return
-        val ann = anns[index]
-        ann.contents = contents.ifBlank { " " }
-        autoSizeTextAnnotation(ann)
-        invalidateCanvas(pageIndex)
-        notifyAnnotationChange()
-    }
-
-    /**
-     * Recalculate the annotation's bounds so the text fits without clipping.
-     * Width is capped at 70% of the view width; height grows with line count.
-     */
-    private fun autoSizeTextAnnotation(ann: PdfAnnotation) {
-        val text = ann.contents.trim().ifEmpty { return }
-        val pageW = pagePdfW.getOrElse(ann.pageIndex) { 0 }
-        if (pageW <= 0 || width <= 0) return
-        val s = width.toFloat() / pageW.toFloat()
-        val tp = android.text.TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
-            textSize = ann.fontSize * s
-            typeface = when {
-                ann.bold && ann.italic -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC)
-                ann.bold               -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
-                ann.italic             -> Typeface.create(Typeface.DEFAULT, Typeface.ITALIC)
-                else                   -> Typeface.DEFAULT
-            }
-        }
-        val pad = 16f  // screen px total padding (8px each side)
-        val maxW = (width * 0.7f - pad).toInt().coerceAtLeast(80)
-        val layout = StaticLayout.Builder
-            .obtain(text, 0, text.length, tp, maxW)
-            .setAlignment(android.text.Layout.Alignment.ALIGN_NORMAL)
-            .build()
-        val newW = (layout.width + pad) / s
-        val newH = (layout.height + pad) / s
-        // Keep top-left anchor fixed
-        ann.bounds = RectF(ann.bounds.left, ann.bounds.top, ann.bounds.left + newW, ann.bounds.top + newH)
-    }
-
-    fun updateNote(pageIndex: Int, index: Int, contents: String) {
-        val anns = annotationMap[pageIndex]?.filter { it.type == "note" } ?: return
-        if (index >= anns.size) return
-        anns[index].contents = contents.ifBlank { " " }
-        invalidateCanvas(pageIndex)
-        notifyAnnotationChange()
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // Internal helpers (used by inner AnnotationCanvasView)
-    // ─────────────────────────────────────────────────────────────────────────
-
-    fun addAnnotationAndCommit(ann: PdfAnnotation) {
-        annotationMap.getOrPut(ann.pageIndex) { mutableListOf() }.add(ann)
-        undoStack.addLast(UndoEntry(ann))
-        redoStack.clear()
-        invalidateCanvas(ann.pageIndex)
-        notifyAnnotationChange()
-        notifyUndoRedoState()
-    }
-
-    fun invalidateCanvas(pageIndex: Int) {
-        if (displayMode == "single") {
-            singlePageCanvases[pageIndex]?.invalidate()
-        } else {
-            // continuous mode: pageEntries[0] = page windowStart → relative index
-            pageEntries.getOrNull(pageIndex - windowStart)?.canvasView?.invalidate()
-        }
-    }
-
-    fun notifyAnnotationChange() {
-        val all = mutableListOf<Map<String, Any>>()
-        for ((pageIndex, anns) in annotationMap) {
-            for (ann in anns) {
-                val m = mutableMapOf<String, Any>(
-                    "type" to ann.type,
-                    "page" to pageIndex,
-                    "bounds" to mapOf(
-                        "x" to ann.bounds.left.toDouble(),
-                        "y" to ann.bounds.top.toDouble(),
-                        "width" to ann.bounds.width().toDouble(),
-                        "height" to ann.bounds.height().toDouble()
-                    ),
-                    "color" to ann.color,
-                    "strokeWidth" to ann.strokeWidth.toDouble(),
-                    "contents" to ann.contents
-                )
-                if (ann.type == "text") {
-                    m["fontSize"] = ann.fontSize.toDouble()
-                    m["bold"] = ann.bold
-                    m["italic"] = ann.italic
-                }
-                if (ann.paths.isNotEmpty()) {
-                    m["paths"] = ann.paths.map { p ->
-                        p.points.map { pt ->
-                            mapOf("x" to pt.x.toDouble(), "y" to pt.y.toDouble())
-                        }
-                    }
-                }
-                all.add(m)
-            }
-        }
-        onAnnotationChange(mapOf("annotations" to all))
-    }
-
-    fun notifyUndoRedoState() {
-        onUndoRedoStateChange(
-            mapOf("canUndo" to undoStack.isNotEmpty(), "canRedo" to redoStack.isNotEmpty())
-        )
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // Zoom
-    // ─────────────────────────────────────────────────────────────────────────
-
-    private fun applyZoom(newZoom: Float) {
-        currentZoom = newZoom
-        container.pivotX = 0f
-        container.pivotY = 0f
-        container.scaleX = newZoom
-        container.scaleY = newZoom
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // Scroll / page detection
-    // ─────────────────────────────────────────────────────────────────────────
-
-    /** twoupcontinuous: нэг мөр = хос entry (хуудас дараалсан), эсвэл эцсийн ганц entry. */
-    private fun twoupStrideAt(entryIdx: Int): Int {
-        if (displayMode != "twoupcontinuous") return 1
-        if (entryIdx >= pageEntries.size) return 0
-        if (entryIdx + 1 < pageEntries.size) {
-            val a = pageEntries[entryIdx].canvasView.pageIndex
-            val b = pageEntries[entryIdx + 1].canvasView.pageIndex
-            if (b == a + 1) return 2
-        }
-        return 1
-    }
-
-    /** scrollView доторх pageIndex хуудасны мөрийн дээд ирмэгийн Y (continuous / twoupcontinuous). */
-    private fun scrollYForScrollModePage(pageIndex: Int): Int {
-        if (pageEntries.isEmpty()) return 0
-        val lastAbsPage = windowStart + pageEntries.size - 1
-        val clamped = pageIndex.coerceIn(windowStart, lastAbsPage.coerceAtLeast(windowStart))
-        if (displayMode != "twoupcontinuous") {
-            val rel = (clamped - windowStart).coerceIn(0, maxOf(0, pageEntries.size - 1))
-            var y = 0
-            for (i in 0 until rel) {
-                y += (pageEntries[i].bmpHeight.takeIf { it > 0 } ?: 0) + 12
-            }
-            return y
-        }
-        var y = 0
-        var idx = 0
-        while (idx < pageEntries.size) {
-            val stride = twoupStrideAt(idx)
-            val rowH = pageEntries[idx].bmpHeight.takeIf { it > 0 } ?: 0
-            val p0 = pageEntries[idx].canvasView.pageIndex
-            val p1 = if (stride == 2) pageEntries[idx + 1].canvasView.pageIndex else p0
-            if (clamped in p0..p1) return y
-            y += rowH + 12
-            idx += stride
-        }
-        return y
-    }
-
-    private fun detectCurrentPage(scrollY: Int) {
-        if (pageEntries.isEmpty()) return
-        val viewH = scrollView.height.takeIf { it > 0 } ?: height
-        val centerY = scrollY + viewH / 2
-        if (displayMode == "twoupcontinuous") {
-            var accY = 0
-            var idx = 0
-            while (idx < pageEntries.size) {
-                val stride = twoupStrideAt(idx)
-                val rowH = pageEntries[idx].bmpHeight.takeIf { it > 0 } ?: 0
-                val nextY = accY + rowH + 12
-                val p0 = pageEntries[idx].canvasView.pageIndex
-                val p1 = if (stride == 2) pageEntries[idx + 1].canvasView.pageIndex else p0
-                if (centerY <= nextY || idx + stride >= pageEntries.size) {
-                    val vx = scrollView.width.takeIf { it > 0 } ?: width
-                    val absPage = if (stride == 2 && p1 > p0 && vx > 0) {
-                        val midPix = vx / 2
-                        val centerX = scrollView.scrollX + midPix
-                        if (centerX < midPix) p0 else p1
-                    } else p0
-                    if (currentPageIndex != absPage) {
-                        currentPageIndex = absPage
-                        onPageChange(mapOf("currentPage" to absPage, "totalPage" to totalPages))
-                    }
-                    break
-                }
-                accY = nextY
-                idx += stride
-            }
-            return
-        }
-        // continuous — entry бүр нэг босоо мөр
-        var accY = 0
-        for (i in pageEntries.indices) {
-            val h = pageEntries[i].bmpHeight.takeIf { it > 0 } ?: continue
-            accY += h + 12
-            if (centerY <= accY || i == pageEntries.size - 1) {
-                val absolutePage = windowStart + i
-                if (currentPageIndex != absolutePage) {
-                    currentPageIndex = absolutePage
-                    onPageChange(mapOf("currentPage" to absolutePage, "totalPage" to totalPages))
-                }
-                break
-            }
-        }
-    }
-
-    private fun scrollToPage(pageIndex: Int, smooth: Boolean = true) {
-        if (displayMode == "single") {
-            if (smooth) pager.smoothScrollToPosition(pageIndex)
-            else pager.scrollToPosition(pageIndex)
-            currentPageIndex = pageIndex
-            onPageChange(mapOf("currentPage" to pageIndex, "totalPage" to totalPages))
-            return
-        }
-        if (pageEntries.isEmpty()) return
-        val y = scrollYForScrollModePage(pageIndex)
-        if (smooth) scrollView.smoothScrollTo(0, y) else scrollView.scrollTo(0, y)
-        currentPageIndex = pageIndex
-        onPageChange(mapOf("currentPage" to pageIndex, "totalPage" to totalPages))
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // Load & Render
-    // ─────────────────────────────────────────────────────────────────────────
-
-    private fun startLoad(url: String) {
-        Log.d("ExpoPdfReader", "startLoad: $url")
-        renderJob?.cancel()
-        renderJob = scope.launch {
-            try {
-                withContext(pdfDispatcher) { safeCloseRenderer() }
-                val file = withContext(pdfDispatcher) { resolveFile(url) }
-                withContext(pdfDispatcher) {
-                    fileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
-                    renderer = PdfRenderer(fileDescriptor!!)
-                    val r = renderer!!
-                    totalPages = r.pageCount
-                    // Хэмжээг энд бүгдийг нь уншихгүй — renderPageBitmap нээх бүрт бөглөнө (анхны ачаалал хурдан).
-                    pagePdfW = IntArray(totalPages) { 0 }
-                    pagePdfH = IntArray(totalPages) { 0 }
-                }
-                // annotationMap is intentionally NOT cleared here.
-                // setAnnotations() may have already populated it before startLoad() runs
-                // (Expo prop ordering: url first, then initialAnnotations).
-                // Canvases created in renderDocument() read annotationMap on their first onDraw().
-                undoStack.clear(); redoStack.clear()
-                appliedFingerprint = null; currentPageIndex = 0
-                renderDocument()
-                // After canvases are created, re-invalidate all of them so initialAnnotations appear.
-                withContext(Dispatchers.Main) {
-                    if (displayMode == "single") {
-                        singlePageCanvases.values.forEach { it.invalidate() }
-                    } else {
-                        pageEntries.forEach { it.canvasView.invalidate() }
-                    }
-                }
-            } catch (e: CancellationException) { throw e }
-            catch (e: Exception) { Log.e("ExpoPdfReader", "Load error", e) }
-        }
-    }
-
-    private fun triggerRender() {
-        renderJob?.cancel()
-        renderJob = scope.launch {
-            try { renderDocument() }
-            catch (e: CancellationException) { throw e }
-            catch (e: Exception) { Log.e("ExpoPdfReader", "Render error", e) }
-        }
-    }
-
-    private suspend fun renderDocument() {
-        val pdf = renderer ?: return
-        val pageCount = withContext(pdfDispatcher) { pdf.pageCount }
-        if (pageCount <= 0) return
-        val viewWidth = width.takeIf { it > 0 } ?: resources.displayMetrics.widthPixels
-        if (viewWidth <= 0) return
-
-        // Chunk state reset
-        currentViewWidth = viewWidth
-        renderedUpTo = -1
-        windowStart = 0
-        chunkLoading = false
-
-        withContext(Dispatchers.Main) {
-            container.removeAllViews()
-            pageEntries.clear()
-            loadingFooter = null
-        }
-
-        when (displayMode) {
-            "single" -> renderSingleMode()
-            "twoup" -> renderAllPages(pdf, pageCount, viewWidth)
-            else -> renderScrollModeAround(
-                pdf,
-                pageCount,
-                viewWidth,
-                currentPageIndex.coerceIn(0, pageCount - 1)
-            )
-        }
-
-        // onReady: Main thread дээр шууд дуудна
-        withContext(Dispatchers.Main) {
-            val density = resources.displayMetrics.density
-            Log.d("ExpoPdfReader", "onReady firing: totalPages=$pageCount")
-            onReady(
-                mapOf(
-                    "totalPages" to pageCount,
-                    "width" to (this@ExpoPdfReaderView.width / density).toDouble(),
-                    "height" to (this@ExpoPdfReaderView.height / density).toDouble()
-                )
-            )
-        }
-    }
-
-    // single mode: RecyclerView + PagerSnapHelper — нэг хуудас бүрэн харагдана
-    private suspend fun renderSingleMode() {
-        withContext(Dispatchers.Main) {
-            singlePageCanvases.clear()
-            scrollView.visibility = View.GONE
-            pager.visibility = View.VISIBLE
-            singleAdapter = SinglePageAdapter()
-            pager.adapter = singleAdapter
-            pager.scrollToPosition(currentPageIndex)
-            // React Native Fabric blocks child requestLayout() calls, so the RecyclerView
-            // never binds its items until the next Fabric layout pass (e.g. thumbnail panel
-            // opening/closing). Force a manual measure+layout to make items bind immediately.
-            forcePagerLayout()
-        }
-    }
-
-    private fun forcePagerLayout() {
-        val w = width.takeIf { it > 0 } ?: return
-        val h = height.takeIf { it > 0 } ?: return
-        pager.measure(
-            MeasureSpec.makeMeasureSpec(w, MeasureSpec.EXACTLY),
-            MeasureSpec.makeMeasureSpec(h, MeasureSpec.EXACTLY)
-        )
-        pager.layout(0, 0, w, h)
-    }
-
-    // twoup — бүх хуудсыг render хийнэ
-    private suspend fun renderAllPages(pdf: PdfRenderer, pageCount: Int, viewWidth: Int) {
-        withContext(Dispatchers.Main) {
-            scrollView.visibility = View.VISIBLE
-            pager.visibility = View.GONE
-        }
-        renderTwoUpRange(pdf, pageCount, viewWidth, 0, pageCount)
-        withContext(Dispatchers.Main) { renderedUpTo = pageCount - 1 }
-    }
-
-    /**
-     * continuous / twoupcontinuous — [anchorPage]-ийн эргэн тойронд MAX_RENDERED хүртэлх цонх.
-     * Горим солиход одоогийн хуудас хадгалагдана.
-     */
-    private suspend fun renderScrollModeAround(
-        pdf: PdfRenderer,
-        pageCount: Int,
-        viewWidth: Int,
-        anchorPage: Int
-    ) {
-        withContext(Dispatchers.Main) {
-            scrollView.visibility = View.VISIBLE
-            pager.visibility = View.GONE
-        }
-        val target = anchorPage.coerceIn(0, pageCount - 1)
-        val newStart = maxOf(0, target - PAGE_CHUNK / 2)
-        val newEnd = minOf(pageCount, newStart + MAX_RENDERED)
-        withContext(Dispatchers.Main) {
-            windowStart = newStart
-            renderedUpTo = newStart - 1
-        }
-        if (displayMode == "twoupcontinuous") {
-            renderTwoUpRange(pdf, pageCount, viewWidth, newStart, newEnd)
-            withContext(Dispatchers.Main) {
-                val rawUpTo = if (newEnd % 2 == 0) newEnd - 1 else newEnd - 2
-                renderedUpTo = rawUpTo.coerceIn(0, pageCount - 1)
-                if (renderedUpTo < pageCount - 1) showLoadingFooter()
-                forceLayoutScrollView()
-                post { scrollToPage(target, smooth = false) }
-            }
-        } else {
-            for (i in newStart until newEnd) {
-                val bmp = renderPageBitmap(pdf, i, viewWidth)
-                val idx = i
-                withContext(Dispatchers.Main) {
-                    addPageRow(
-                        bmp, idx,
-                        pagePdfW.getOrElse(idx) { 1 }.toFloat(),
-                        pagePdfH.getOrElse(idx) { 1 }.toFloat()
-                    )
-                }
-            }
-            withContext(Dispatchers.Main) {
-                renderedUpTo = (newEnd - 1).coerceIn(0, pageCount - 1)
-                if (newEnd < pageCount) showLoadingFooter()
-                forceLayoutScrollView()
-                post { scrollToPage(target, smooth = false) }
-            }
-        }
-    }
-
-    // twoUp row-г render хийх helper (start..end page range, pairs)
-    private suspend fun renderTwoUpRange(
-        pdf: PdfRenderer, pageCount: Int, viewWidth: Int, startPage: Int, endPage: Int
-    ) {
-        val halfWidth = viewWidth / 2
-        var i = startPage
-        while (i < endPage) {
-            val leftBmp = renderPageBitmap(pdf, i, halfWidth)
-            val rightBmp = if (i + 1 < minOf(endPage, pageCount))
-                renderPageBitmap(pdf, i + 1, halfWidth) else null
-            val li = i; val ri = i + 1
-            withContext(Dispatchers.Main) {
-                // twoUp row-ын өндрийг зүүн хуудасны bitmap-аас авна (хоёр хуудас ижил scale-тай)
-                val rowH = leftBmp.height
-                val row = LinearLayout(context).apply {
-                    orientation = LinearLayout.HORIZONTAL
-                    layoutParams = LinearLayout.LayoutParams(viewWidth, rowH)
-                        .apply { setMargins(0, 6, 0, 6) }
-                }
-                row.addView(buildPageFrame(leftBmp, li,
-                    pagePdfW.getOrElse(li) { 1 }.toFloat(), pagePdfH.getOrElse(li) { 1 }.toFloat(), 1f))
-                if (rightBmp != null) {
-                    row.addView(buildPageFrame(rightBmp, ri,
-                        pagePdfW.getOrElse(ri) { 1 }.toFloat(), pagePdfH.getOrElse(ri) { 1 }.toFloat(), 1f))
-                } else {
-                    row.addView(View(context).apply { layoutParams = LinearLayout.LayoutParams(0, rowH, 1f) })
-                }
-                container.addView(row)
-            }
-            i += 2
-        }
-    }
-
-    // ── Lazy chunk helpers ────────────────────────────────────────────────────
-
-    private fun maybeTriggerChunkLoad(scrollY: Int) {
-        if (chunkLoading) return
-        if (displayMode !in listOf("continuous", "twoupcontinuous")) return
-
-        val visibleBottom = scrollY + scrollView.height
-
-        // Доош scroll: дараагийн chunk ачаална
-        if (renderedUpTo < totalPages - 1) {
-            val forwardTrigger = container.height - scrollView.height * 2
-            if (visibleBottom >= forwardTrigger) {
-                chunkLoading = true
-                scope.launch {
-                    try { loadNextChunk() }
-                    catch (e: CancellationException) { throw e }
-                    catch (e: Exception) { Log.e("ExpoPdfReader", "Chunk load error", e) }
-                    finally { chunkLoading = false }
-                }
-                return
-            }
-        }
-
-        // Дээш scroll: өмнөх chunk (continuous = нэг багана; twoupcontinuous = хос мөр prepend).
-        if (windowStart > 0 && scrollY <= scrollView.height * 2) {
-            chunkLoading = true
-            scope.launch {
-                try { loadPrevChunk() }
-                catch (e: CancellationException) { throw e }
-                catch (e: Exception) { Log.e("ExpoPdfReader", "Prev chunk load error", e) }
-                finally { chunkLoading = false }
-            }
-        }
-    }
-
-    private suspend fun loadNextChunk() {
-        val pdf = renderer ?: return
-        val start = renderedUpTo + 1
-        if (start >= totalPages) return
-        val end = minOf(start + PAGE_CHUNK, totalPages)
-        val viewWidth = currentViewWidth
-
-        withContext(Dispatchers.Main) { removeLoadingFooter() }
-
-        if (displayMode == "twoupcontinuous") {
-            renderTwoUpRange(pdf, totalPages, viewWidth, start, end)
-            withContext(Dispatchers.Main) {
-                renderedUpTo = if (end % 2 == 0) end - 1 else end - 2
-                if (renderedUpTo < totalPages - 1) showLoadingFooter()
-                forceLayoutScrollView()
-            }
-        } else {
-            for (i in start until end) {
-                val bmp = renderPageBitmap(pdf, i, viewWidth)
-                val idx = i
-                withContext(Dispatchers.Main) {
-                    addPageRow(bmp, idx, pagePdfW.getOrElse(idx) { 1 }.toFloat(),
-                        pagePdfH.getOrElse(idx) { 1 }.toFloat())
-                }
-            }
-            withContext(Dispatchers.Main) {
-                renderedUpTo = end - 1
-                // Sliding window: MAX_RENDERED-с илүү болвол дээд хэсгийг устга
-                val excess = pageEntries.size - MAX_RENDERED
-                if (excess > 0) {
-                    val removed = pruneTopPages(excess)
-                    scrollView.scrollBy(0, -removed)
-                }
-                if (end < totalPages) showLoadingFooter()
-                forceLayoutScrollView()
-            }
-        }
-    }
-
-    /**
-     * Дээд хэсгийн [count] хуудсыг устгаж, bitmap санах ойг чөлөөлнэ.
-     * @return устгагдсан хуудсуудын нийт өндөр (px) — scroll тохируулахад ашиглана
-     */
-    private fun pruneTopPages(count: Int): Int {
-        var removedHeight = 0
-        repeat(count) {
-            val entry = pageEntries.removeFirstOrNull() ?: return@repeat
-            removedHeight += entry.bmpHeight + 12  // +12 нь margin (дээш 6 + доош 6)
-            // Bitmap-г чөлөөлнэ
-            (entry.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
-            container.removeView(entry.frame)
-        }
-        windowStart += count
-        return removedHeight
-    }
-
-    /**
-     * Өмнөх [PAGE_CHUNK] хуудсыг дээр нэмж, доод хэсгийг цэвэрлэнэ.
-     */
-    private suspend fun loadPrevChunk() {
-        val pdf = renderer ?: return
-        if (displayMode == "twoupcontinuous") {
-            loadPrevChunkTwoup(pdf)
-            return
-        }
-        val prevStart = maxOf(0, windowStart - PAGE_CHUNK)
-        val prevEnd = windowStart
-        if (prevStart >= prevEnd) return
-        val viewWidth = currentViewWidth
-
-        data class PageBmp(val bmp: Bitmap, val idx: Int, val pdfW: Float, val pdfH: Float)
-        val pages = mutableListOf<PageBmp>()
-        for (i in prevStart until prevEnd) {
-            val bmp = renderPageBitmap(pdf, i, viewWidth)
-            pages.add(PageBmp(bmp, i,
-                pagePdfW.getOrElse(i) { 1 }.toFloat(),
-                pagePdfH.getOrElse(i) { 1 }.toFloat()))
-        }
-
-        withContext(Dispatchers.Main) {
-            var insertedHeight = 0
-            // Reverse order-оор insert хийж эцэст нь зөв дараалал гарна
-            // (бүгд index 0-д insert хийгддэг тул)
-            for (page in pages.reversed()) {
-                prependPageFrame(page.bmp, page.idx, page.pdfW, page.pdfH)
-                insertedHeight += page.bmp.height + 12
-            }
-            windowStart = prevStart
-            renderedUpTo = maxOf(renderedUpTo, windowStart + pageEntries.size - 1)
-
-            // Доод хэсгийг цэвэрлэнэ
-            val excess = pageEntries.size - MAX_RENDERED
-            if (excess > 0) pruneBottomPages(excess)
-
-            // Дээр нэмсэн өндрийг scroll-д нэмж харагдах хэсгийг хэвээр үлдээнэ
-            scrollView.scrollBy(0, insertedHeight)
-            forceLayoutScrollView()
-        }
-    }
-
-    /** twoupcontinuous: өмнөх chunk-ийг хос мөрөөр дээр нэмнэ. */
-    private suspend fun loadPrevChunkTwoup(pdf: PdfRenderer) {
-        val prevStart = maxOf(0, windowStart - PAGE_CHUNK)
-        val prevEnd = windowStart
-        if (prevStart >= prevEnd) return
-        val viewWidth = currentViewWidth
-        val halfW = viewWidth / 2
-
-        data class RowBmps(val leftIdx: Int, val leftBmp: Bitmap, val rightBmp: Bitmap?)
-        val rows = mutableListOf<RowBmps>()
-        var i = prevStart
-        while (i < prevEnd) {
-            val leftBmp = renderPageBitmap(pdf, i, halfW)
-            val rightBmp = if (i + 1 < minOf(prevEnd, totalPages))
-                renderPageBitmap(pdf, i + 1, halfW) else null
-            rows.add(RowBmps(i, leftBmp, rightBmp))
-            i += 2
-        }
-
-        withContext(Dispatchers.Main) {
-            var insertedHeight = 0
-            for (rb in rows.asReversed()) {
-                prependTwoupRowToContainer(
-                    rb.leftBmp, rb.leftIdx,
-                    rb.rightBmp,
-                    if (rb.rightBmp != null) rb.leftIdx + 1 else null,
-                    viewWidth
-                )
-                insertedHeight += rb.leftBmp.height + 12
-            }
-            windowStart = prevStart
-            renderedUpTo = windowStart + pageEntries.size - 1
-
-            while (pageEntries.size > MAX_RENDERED) {
-                pruneBottomTwoupOneRow()
-            }
-
-            scrollView.scrollBy(0, insertedHeight)
-            forceLayoutScrollView()
-        }
-    }
-
-    /** twoup мөрийг container + pageEntries-ийн эхэнд оруулна (дээд chunk). */
-    private fun prependTwoupRowToContainer(
-        leftBmp: Bitmap, li: Int,
-        rightBmp: Bitmap?, ri: Int?,
-        viewWidth: Int
-    ) {
-        val rowH = leftBmp.height
-        val row = LinearLayout(context).apply {
-            orientation = LinearLayout.HORIZONTAL
-            layoutParams = LinearLayout.LayoutParams(viewWidth, rowH)
-                .apply { setMargins(0, 6, 0, 6) }
-        }
-        val (leftFrame, leftEntry) = buildPageFrameDetached(
-            leftBmp, li,
-            pagePdfW.getOrElse(li) { 1 }.toFloat(),
-            pagePdfH.getOrElse(li) { 1 }.toFloat(),
-            1f
-        )
-        row.addView(leftFrame)
-        if (rightBmp != null && ri != null) {
-            val (rightFrame, rightEntry) = buildPageFrameDetached(
-                rightBmp, ri,
-                pagePdfW.getOrElse(ri) { 1 }.toFloat(),
-                pagePdfH.getOrElse(ri) { 1 }.toFloat(),
-                1f
-            )
-            row.addView(rightFrame)
-            pageEntries.add(0, rightEntry)
-            pageEntries.add(0, leftEntry)
-        } else {
-            row.addView(View(context).apply {
-                layoutParams = LinearLayout.LayoutParams(0, rowH, 1f)
-            })
-            pageEntries.add(0, leftEntry)
-        }
-        container.addView(row, 0)
-    }
-
-    /** twoupcontinuous: доод талын нэг мөрийг (эсвэл сүүлийн entry) устгана. */
-    private fun pruneBottomTwoupOneRow() {
-        val last = pageEntries.lastOrNull() ?: return
-        val row = last.frame.parent as? LinearLayout
-        if (row != null && row.parent === container && row.childCount > 0) {
-            val removeList = pageEntries.filter { it.frame.parent === row }
-            for (e in removeList) {
-                (e.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
-                pageEntries.remove(e)
-            }
-            container.removeView(row)
-        } else {
-            val e = pageEntries.removeLastOrNull() ?: return
-            (e.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
-            container.removeView(e.frame)
-        }
-        renderedUpTo = windowStart + pageEntries.size - 1
-    }
-
-    /**
-     * Дээр (index 0) шинэ хуудас оруулна. windowStart-г дуудагч тал шинэчилнэ.
-     */
-    private fun prependPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float) {
-        val bmpW = bmp.width
-        val bmpH = bmp.height
-        val frame = FrameLayout(context).apply {
-            layoutParams = LinearLayout.LayoutParams(bmpW, bmpH).apply { setMargins(0, 6, 0, 6) }
-        }
-        val iv = ImageView(context).apply {
-            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
-            scaleType = ImageView.ScaleType.FIT_XY
-            setImageBitmap(bmp)
-        }
-        val canvasView = AnnotationCanvasView(context, pageIdx, pdfW, pdfH).apply {
-            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
-            translationZ = 1f
-        }
-        frame.addView(iv)
-        frame.addView(canvasView)
-        container.addView(frame, 0)
-        pageEntries.add(0, PageEntry(frame, canvasView, bmpH))
-    }
-
-    /**
-     * Доод хэсгийн [count] хуудсыг устгаж bitmap санах ойг чөлөөлнэ.
-     * renderedUpTo-г буулгаж дараагийн доош scroll-д re-render хийгдэхийг зөвшөөрнэ.
-     */
-    private fun pruneBottomPages(count: Int) {
-        repeat(count) {
-            val entry = pageEntries.removeLastOrNull() ?: return@repeat
-            (entry.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
-            container.removeView(entry.frame)
-        }
-        renderedUpTo = windowStart + pageEntries.size - 1
-    }
-
-    /**
-     * Render хийгдээгүй хуудас руу үсрэх.
-     * Бүх одоогийн view-г цэвэрлэж, targetPage-ийн эргэн тойрны хуудсуудыг render хийнэ.
-     */
-    private fun jumpToPage(targetPage: Int) {
-        val pdf = renderer ?: return
-        val viewWidth = currentViewWidth.takeIf { it > 0 } ?: width.takeIf { it > 0 } ?: return
-        renderJob?.cancel()
-        renderJob = scope.launch {
-            try {
-                // Шинэ window: targetPage-ийн хагас chunk өмнөөс эхэлнэ
-                val newStart = maxOf(0, targetPage - PAGE_CHUNK / 2)
-                val newEnd = minOf(totalPages, newStart + MAX_RENDERED)
-
-                withContext(Dispatchers.Main) {
-                    container.removeAllViews()
-                    pageEntries.clear()
-                    loadingFooter = null
-                    windowStart = newStart
-                    renderedUpTo = newStart - 1
-                    chunkLoading = false
-                }
-
-                if (displayMode == "twoupcontinuous") {
-                    renderTwoUpRange(pdf, totalPages, viewWidth, newStart, newEnd)
-                    withContext(Dispatchers.Main) {
-                        val rawUpTo = if (newEnd % 2 == 0) newEnd - 1 else newEnd - 2
-                        renderedUpTo = rawUpTo.coerceIn(0, totalPages - 1)
-                        if (renderedUpTo < totalPages - 1) showLoadingFooter()
-                        forceLayoutScrollView()
-                        post { scrollToPage(targetPage, smooth = false) }
-                    }
-                } else {
-                    for (i in newStart until newEnd) {
-                        val bmp = renderPageBitmap(pdf, i, viewWidth)
-                        val idx = i
-                        withContext(Dispatchers.Main) {
-                            addPageRow(
-                                bmp, idx,
-                                pagePdfW.getOrElse(idx) { 1 }.toFloat(),
-                                pagePdfH.getOrElse(idx) { 1 }.toFloat()
-                            )
-                        }
-                    }
-                    withContext(Dispatchers.Main) {
-                        renderedUpTo = newEnd - 1
-                        if (newEnd < totalPages) showLoadingFooter()
-                        forceLayoutScrollView()
-                        post { scrollToPage(targetPage, smooth = false) }
-                    }
-                }
-            } catch (e: CancellationException) { throw e }
-            catch (e: Exception) { Log.e("ExpoPdfReader", "JumpToPage error", e) }
-        }
-    }
-
-    /**
-     * React Native Fabric нь child view-н requestLayout()-г таслах тул
-     * addView() дараа layout pass автоматаар ажиллахгүй.
-     * Энэ функц scrollView-г шууд measure + layout хийж pages-г харагдуулна.
-     */
-    private fun forceLayoutScrollView() {
-        val w = width.takeIf { it > 0 } ?: return
-        val h = height.takeIf { it > 0 } ?: return
-        scrollView.measure(
-            MeasureSpec.makeMeasureSpec(w, MeasureSpec.EXACTLY),
-            MeasureSpec.makeMeasureSpec(h, MeasureSpec.EXACTLY)
-        )
-        scrollView.layout(0, 0, w, h)
-    }
-
-    private fun showLoadingFooter() {
-        if (loadingFooter != null) return
-        val footer = ProgressBar(context, null, android.R.attr.progressBarStyleSmall).apply {
-            layoutParams = LinearLayout.LayoutParams(
-                LinearLayout.LayoutParams.MATCH_PARENT, 120
-            ).apply { setMargins(0, 16, 0, 16) }
-            isIndeterminate = true
-        }
-        container.addView(footer)
-        loadingFooter = footer
-    }
-
-    private fun removeLoadingFooter() {
-        loadingFooter?.let { container.removeView(it) }
-        loadingFooter = null
-    }
-
-    private fun addPageRow(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float) =
-        container.addView(buildPageFrame(bmp, pageIdx, pdfW, pdfH))
-
-    private fun buildPageFrameDetached(
-        bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f
-    ): Pair<FrameLayout, PageEntry> {
-        val bmpW = bmp.width
-        val bmpH = bmp.height
-        val frame = FrameLayout(context).apply {
-            layoutParams = if (weight > 0f)
-                LinearLayout.LayoutParams(0, bmpH, weight)
-            else
-                LinearLayout.LayoutParams(bmpW, bmpH)
-                    .apply { setMargins(0, 6, 0, 6) }
-        }
-        val iv = ImageView(context).apply {
-            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
-            scaleType = ImageView.ScaleType.FIT_XY
-            setImageBitmap(bmp)
-        }
-        val canvasView = AnnotationCanvasView(context, pageIdx, pdfW, pdfH).apply {
-            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
-            translationZ = 1f
-        }
-        frame.addView(iv)
-        frame.addView(canvasView)
-        return frame to PageEntry(frame, canvasView, bmpH)
-    }
-
-    private fun buildPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f): FrameLayout {
-        val (frame, entry) = buildPageFrameDetached(bmp, pageIdx, pdfW, pdfH, weight)
-        pageEntries.add(entry)
-        return frame
-    }
-
-    private suspend fun renderPageBitmap(pdf: PdfRenderer, index: Int, targetWidth: Int): Bitmap =
-        withContext(pdfDispatcher) {
-            pdf.openPage(index).use { page ->
-                if (index < pagePdfW.size) {
-                    pagePdfW[index] = page.width
-                    pagePdfH[index] = page.height
-                }
-                val s = targetWidth.toFloat() / page.width.toFloat()
-                val h = (page.height * s).toInt().coerceAtLeast(1)
-                val bmp = Bitmap.createBitmap(targetWidth, h, Bitmap.Config.ARGB_8888)
-                bmp.eraseColor(Color.WHITE)
-                page.render(bmp, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
-                bmp
-            }
-        }
-
-    private fun safeCloseRenderer() {
-        try { renderer?.close(); fileDescriptor?.close() }
-        catch (_: Exception) { }
-        finally { renderer = null; fileDescriptor = null }
-    }
-
-    private suspend fun resolveFile(url: String): File = withContext(pdfDispatcher) {
-        when {
-            url.startsWith("file://") -> File(url.removePrefix("file://"))
-            url.startsWith("/")       -> File(url)
-            else -> {
-                val f = File.createTempFile("pdf_", ".pdf", context.cacheDir)
-                URL(url).openStream().use { inp -> FileOutputStream(f).use { inp.copyTo(it) } }
-                f
-            }
-        }
-    }
-
-    private fun buildFingerprint(data: List<Map<String, Any?>>): String =
-        data.mapNotNull { item ->
-            val p = (item["page"] as? Number)?.toInt() ?: return@mapNotNull null
-            val t = item["type"] as? String ?: return@mapNotNull null
-            val b = item["bounds"] as? Map<*, *> ?: return@mapNotNull null
-            "$p|$t|${b["x"]},${b["y"]},${b["width"]},${b["height"]}"
-        }.sorted().joinToString("||")
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // SinglePageAdapter  — RecyclerView adapter for "single" display mode
-    //   • vertical PagerSnapHelper — босоо scroll-оор хуудас солих
-    //   • ZoomRecyclerView zoom-г удирдана (adapter энгийн FrameLayout ашиглана)
-    //   • lazy bitmap loading
-    // ─────────────────────────────────────────────────────────────────────────
-
-    inner class SinglePageAdapter : RecyclerView.Adapter<SinglePageAdapter.Holder>() {
-
-        inner class Holder(val frame: FrameLayout, val imageView: ImageView) :
-            RecyclerView.ViewHolder(frame) {
-            var boundPage = -1
-            var loadJob: Job? = null
-            var currentCanvas: AnnotationCanvasView? = null
-        }
-
-        override fun getItemCount(): Int = totalPages
-
-        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): Holder {
-            val frame = FrameLayout(context).apply {
-                layoutParams = RecyclerView.LayoutParams(
-                    RecyclerView.LayoutParams.MATCH_PARENT,
-                    RecyclerView.LayoutParams.MATCH_PARENT
-                )
-                setBackgroundColor(Color.parseColor("#E8E8E8"))
-            }
-            val iv = ImageView(context).apply {
-                layoutParams = FrameLayout.LayoutParams(
-                    FrameLayout.LayoutParams.WRAP_CONTENT,
-                    FrameLayout.LayoutParams.WRAP_CONTENT,
-                    android.view.Gravity.CENTER
-                )
-                scaleType = ImageView.ScaleType.FIT_XY
-            }
-            frame.addView(iv)
-            return Holder(frame, iv)
-        }
-
-        override fun onBindViewHolder(holder: Holder, position: Int) {
-            holder.boundPage = position
-            holder.loadJob?.cancel()
-            holder.imageView.setImageBitmap(null)
-            // Recycle хийгдсэн view-н zoom transform-г цэвэрлэнэ
-            holder.frame.scaleX = 1f; holder.frame.scaleY = 1f
-            holder.frame.translationX = 0f; holder.frame.translationY = 0f
-
-            holder.currentCanvas?.let {
-                singlePageCanvases.remove(it.pageIndex)
-                holder.frame.removeView(it)
-            }
-            holder.currentCanvas = null
-
-            holder.loadJob = scope.launch {
-                val pdf = renderer ?: return@launch
-                val bmp = renderPageBitmap(pdf, position, this@ExpoPdfReaderView.width)
-                val pdfW = pagePdfW.getOrElse(position) { 1 }.toFloat()
-                val pdfH = pagePdfH.getOrElse(position) { 1 }.toFloat()
-                withContext(Dispatchers.Main) {
-                    if (holder.boundPage != position) return@withContext
-                    val canvas = AnnotationCanvasView(context, position, pdfW, pdfH).apply {
-                        layoutParams = FrameLayout.LayoutParams(
-                            bmp.width, bmp.height,
-                            android.view.Gravity.CENTER
-                        )
-                        translationZ = 1f
-                    }
-                    holder.frame.addView(canvas)
-                    holder.currentCanvas = canvas
-                    singlePageCanvases[position] = canvas
-                    val lp = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
-                    holder.imageView.layoutParams = lp
-                    holder.imageView.setImageBitmap(bmp)
-                    val fw = this@ExpoPdfReaderView.width.takeIf { it > 0 } ?: return@withContext
-                    val fh = this@ExpoPdfReaderView.height.takeIf { it > 0 } ?: return@withContext
-                    holder.frame.measure(
-                        MeasureSpec.makeMeasureSpec(fw, MeasureSpec.EXACTLY),
-                        MeasureSpec.makeMeasureSpec(fh, MeasureSpec.EXACTLY)
-                    )
-                    holder.frame.layout(0, 0, fw, fh)
-                }
-            }
-        }
-
-        override fun onViewRecycled(holder: Holder) {
-            holder.loadJob?.cancel()
-            holder.currentCanvas?.let {
-                singlePageCanvases.remove(it.pageIndex)
-                holder.frame.removeView(it)
-            }
-            holder.currentCanvas = null
-            holder.imageView.setImageBitmap(null)
-        }
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // ZoomRecyclerView — single mode-д pinch-to-zoom + pan дэмждэг RecyclerView
-    //
-    // Яагаад RecyclerView subclass хийх шаардлагатай вэ:
-    //   AnnotationCanvasView ACTION_DOWN-д false буцаана → RecyclerView
-    //   gesture-г эзэмшиж авна → дараагийн ACTION_POINTER_DOWN (2-р хуруу)
-    //   шууд RecyclerView.onTouchEvent-д очдог.
-    //   RecyclerView subclass хийснээр onTouchEvent-д multi-touch-г зохицуулна.
-    //
-    // Zoom тооцоо (pivot=0,0 + translation):
-    //   Item view point (px,py) → дэлгэц: (px*scale + tx, py*scale + ty)
-    //   Focus (fx,fy) тогтвортой байхад: new_tx = fx - (fx - tx) * scaleFactor
-    // ─────────────────────────────────────────────────────────────────────────
-
-    inner class ZoomRecyclerView(context: Context) : RecyclerView(context) {
-        private var currentScale = 1f
-        private var tx = 0f
-        private var ty = 0f
-        private var panX = 0f
-        private var panY = 0f
-
-        private val zoomDetector = ScaleGestureDetector(context,
-            object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
-                override fun onScale(d: ScaleGestureDetector): Boolean {
-                    val newScale = (currentScale * d.scaleFactor).coerceIn(minZoom, maxZoom)
-                    val af = newScale / currentScale
-                    // Focus point тогтвортой байхын zoom-to-point тооцоо
-                    tx = d.focusX - (d.focusX - tx) * af
-                    ty = d.focusY - (d.focusY - ty) * af
-                    currentScale = newScale
-                    clampAndApply()
-                    return true
-                }
-            }
-        )
-
-        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-            // Zoom хийгдсэн + tool идэвхгүй → pan хийхийн тулд ACTION_DOWN-г intercept
-            if (currentScale > 1f && activeTool == null && ev.action == MotionEvent.ACTION_DOWN) {
-                return true
-            }
-            return super.onInterceptTouchEvent(ev)
-        }
-
-        override fun onTouchEvent(ev: MotionEvent): Boolean {
-            zoomDetector.onTouchEvent(ev)
-
-            // 2 хуруу байвал RecyclerView scroll хийхгүйгээр zoom-г л хийнэ
-            if (ev.pointerCount >= 2 || zoomDetector.isInProgress) {
-                return true
-            }
-
-            // Zoom хийгдсэн үед нэг хуруугаар pan (tool идэвхгүй)
-            if (currentScale > 1f && activeTool == null) {
-                when (ev.actionMasked) {
-                    MotionEvent.ACTION_DOWN -> { panX = ev.x; panY = ev.y }
-                    MotionEvent.ACTION_MOVE -> {
-                        tx += ev.x - panX
-                        ty += ev.y - panY
-                        panX = ev.x; panY = ev.y
-                        clampAndApply()
-                    }
-                    MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { }
-                }
-                return true
-            }
-
-            return super.onTouchEvent(ev)
-        }
-
-        fun resetZoom() {
-            currentScale = 1f; tx = 0f; ty = 0f
-            applyToCurrentItem()
-        }
-
-        private fun clampAndApply() {
-            val w = width.toFloat(); val h = height.toFloat()
-            if (w > 0f && h > 0f) {
-                val sw = w * currentScale; val sh = h * currentScale
-                tx = if (sw > w) tx.coerceIn(w - sw, 0f) else 0f
-                ty = if (sh > h) ty.coerceIn(h - sh, 0f) else 0f
-            }
-            applyToCurrentItem()
-        }
-
-        private fun applyToCurrentItem() {
-            val lm = layoutManager as? LinearLayoutManager ?: return
-            val pos = lm.findFirstVisibleItemPosition().takeIf { it >= 0 } ?: return
-            val itemView = lm.findViewByPosition(pos) ?: return
-            itemView.pivotX = 0f; itemView.pivotY = 0f
-            itemView.scaleX = currentScale; itemView.scaleY = currentScale
-            itemView.translationX = tx; itemView.translationY = ty
-        }
-    }
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // AnnotationCanvasView  (inner class — full access to outer view state)
-    // ─────────────────────────────────────────────────────────────────────────
-
-    inner class AnnotationCanvasView(
-        context: Context,
-        val pageIndex: Int,
-        private val pdfWidth: Float,
-        private val pdfHeight: Float
-    ) : View(context) {
-
-        private var drawTool: String? = null
-        private val drawPoints = mutableListOf<PointF>()   // PDF coords
-        private var drawStart: PointF? = null
-
-        // ── No-tool touch state (tap → event, long-press → drag) ─────────────
-        private var noToolDown = false
-        private var noToolDownScreen = PointF()
-        private var isDragging = false
-        private var dragAnn: PdfAnnotation? = null
-        private var dragOrigBounds = RectF()
-        private val LP_TIMEOUT = android.view.ViewConfiguration.getLongPressTimeout().toLong()
-        private val TOUCH_SLOP by lazy { android.view.ViewConfiguration.get(context).scaledTouchSlop.toFloat() }
-        private val lpHandler = android.os.Handler(android.os.Looper.getMainLooper())
-        private val lpRunnable = Runnable {
-            if (dragAnn?.type != "text" && dragAnn?.type != "note") return@Runnable
-            isDragging = true
-            pager.requestDisallowInterceptTouchEvent(true)
-            scrollView.requestDisallowInterceptTouchEvent(true)
-            invalidate()
-        }
-
-        // Reusable objects — no allocation in onDraw
-        private val inkPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-            style = Paint.Style.STROKE; strokeCap = Paint.Cap.ROUND; strokeJoin = Paint.Join.ROUND
-        }
-        private val bgFill = Paint().apply { style = Paint.Style.FILL }
-        private val bgStroke = Paint().apply {
-            style = Paint.Style.STROKE; strokeWidth = 1.5f; color = Color.DKGRAY
-        }
-        private val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
-        private val drawPath = Path()
-
-        // ── Lifecycle ─────────────────────────────────────────────────────────
-
-        override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-            super.onSizeChanged(w, h, oldw, oldh)
-            // Single-mode canvases start with MATCH_PARENT (width=0) and receive their real
-            // size after RecyclerView lays out. Re-draw so initialAnnotations become visible.
-            if (w > 0 && oldw == 0) invalidate()
-        }
-
-        // ── Coordinate helpers ────────────────────────────────────────────────
-
-        private fun scale() = if (width > 0 && pdfWidth > 0) width.toFloat() / pdfWidth else 1f
-
-        /** View-local screen → PDF. */
-        private fun toPdf(sx: Float, sy: Float): PointF {
-            val s = scale(); return PointF(sx / s, pdfHeight - sy / s)
-        }
-
-        /** PDF → view-local screen. */
-        private fun toScreen(px: Float, py: Float): PointF {
-            val s = scale(); return PointF(px * s, (pdfHeight - py) * s)
-        }
-
-        /**
-         * PDF RectF → screen RectF.
-         * bounds.top  = lower PDF y  →  screen bottom
-         * bounds.bottom = upper PDF y →  screen top
-         */
-        private fun toScreenRect(b: RectF): RectF {
-            val s = scale()
-            return RectF(b.left * s, (pdfHeight - b.bottom) * s, b.right * s, (pdfHeight - b.top) * s)
-        }
-
-        // ── Touch ─────────────────────────────────────────────────────────────
-
-        override fun onTouchEvent(event: MotionEvent): Boolean {
-            val tool = activeTool
-            if (tool != null) {
-                // Drawing tool active — consume all events
-                scrollView.requestDisallowInterceptTouchEvent(true)
-                pager.requestDisallowInterceptTouchEvent(true)
-                val pdfPt = toPdf(event.x, event.y)
-                when (tool) {
-                    "eraser" -> {
-                        if (event.action == MotionEvent.ACTION_DOWN || event.action == MotionEvent.ACTION_MOVE)
-                            eraseAt(pdfPt)
-                    }
-                    "text", "note" -> { if (event.action == MotionEvent.ACTION_DOWN) addInstantAnnotation(pdfPt, tool) }
-                    else -> handleDraw(event, pdfPt, tool)
-                }
-                return true
-            }
-            return handleNoToolTouch(event)
-        }
-
-        /**
-         * Touch handling when no drawing tool is active.
-         * - Single tap on text/note → fire onTextPress / onNotePress
-         * - Long press on text/note → drag the annotation
-         * The key issue: returning false on ACTION_DOWN means we never receive ACTION_UP.
-         * So we return true only when we detect a tap/drag target on ACTION_DOWN.
-         */
-        private fun handleNoToolTouch(event: MotionEvent): Boolean {
-            when (event.action) {
-                MotionEvent.ACTION_DOWN -> {
-                    val pdfPt = toPdf(event.x, event.y)
-                    val ann = tapTargetAt(pdfPt) ?: return false
-                    dragAnn = ann
-                    dragOrigBounds = RectF(ann.bounds)
-                    noToolDownScreen = PointF(event.x, event.y)
-                    noToolDown = true
-                    lpHandler.postDelayed(lpRunnable, LP_TIMEOUT)
-                    return true
-                }
-                MotionEvent.ACTION_MOVE -> {
-                    if (!noToolDown) return false
-                    val dx = event.x - noToolDownScreen.x
-                    val dy = event.y - noToolDownScreen.y
-                    if (isDragging) {
-                        val ann = dragAnn ?: return true
-                        val s = scale()
-                        val annW = dragOrigBounds.width()
-                        val annH = dragOrigBounds.height()
-                        // PDF y is inverted: screen down (dy>0) → PDF y decreases
-                        val newLeft   = (dragOrigBounds.left   + dx / s).coerceIn(0f, pdfWidth  - annW)
-                        val newBottom = (dragOrigBounds.bottom - dy / s).coerceIn(annH, pdfHeight)
-                        ann.bounds = RectF(newLeft, newBottom - annH, newLeft + annW, newBottom)
-                        invalidate()
-                        return true
-                    }
-                    // Cancel long-press if finger moved beyond touch slop
-                    if (Math.hypot(dx.toDouble(), dy.toDouble()) > TOUCH_SLOP) {
-                        lpHandler.removeCallbacks(lpRunnable)
-                        noToolDown = false
-                        dragAnn = null
-                        return false
-                    }
-                    return true
-                }
-                MotionEvent.ACTION_UP -> {
-                    lpHandler.removeCallbacks(lpRunnable)
-                    val wasDown = noToolDown
-                    val wasDragging = isDragging
-                    noToolDown = false; isDragging = false
-                    pager.requestDisallowInterceptTouchEvent(false)
-                    scrollView.requestDisallowInterceptTouchEvent(false)
-                    if (!wasDown) { dragAnn = null; return false }
-                    if (wasDragging) {
-                        dragAnn = null
-                        notifyAnnotationChange()
-                    } else {
-                        dragAnn = null
-                        handleTap(event.x, event.y)
-                    }
-                    return true
-                }
-                MotionEvent.ACTION_CANCEL -> {
-                    lpHandler.removeCallbacks(lpRunnable)
-                    if (isDragging) { dragAnn?.bounds = RectF(dragOrigBounds); invalidate() }
-                    noToolDown = false; isDragging = false; dragAnn = null
-                    pager.requestDisallowInterceptTouchEvent(false)
-                    scrollView.requestDisallowInterceptTouchEvent(false)
-                    return false
-                }
-            }
-            return noToolDown
-        }
-
-        /** Returns the first text or note annotation under [pdfPt], or null. */
-        private fun tapTargetAt(pdfPt: PointF): PdfAnnotation? {
-            val pageAnns = annotationMap[pageIndex] ?: return null
-            return pageAnns.firstOrNull { (it.type == "text" || it.type == "note") && it.bounds.contains(pdfPt.x, pdfPt.y) }
-        }
-
-        private fun handleDraw(event: MotionEvent, pdfPt: PointF, tool: String) {
-            when (event.action) {
-                MotionEvent.ACTION_DOWN -> {
-                    drawTool = tool; drawPoints.clear()
-                    drawStart = PointF(pdfPt.x, pdfPt.y); drawPoints.add(PointF(pdfPt.x, pdfPt.y))
-                    invalidate()
-                }
-                MotionEvent.ACTION_MOVE -> {
-                    if (tool == "line") {
-                        drawPoints.clear(); drawStart?.let { drawPoints.add(PointF(it.x, it.y)) }
-                    }
-                    drawPoints.add(PointF(pdfPt.x, pdfPt.y)); invalidate()
-                }
-                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
-                    if (drawPoints.size >= 2) commitStroke(tool)
-                    drawTool = null; drawPoints.clear(); drawStart = null; invalidate()
-                }
-            }
-        }
-
-        private fun commitStroke(tool: String) {
-            val pad = strokeWidthVal / 2f
-            val ann = PdfAnnotation(
-                type = tool, pageIndex = pageIndex,
-                bounds = RectF(
-                    drawPoints.minOf { it.x } - pad, drawPoints.minOf { it.y } - pad,
-                    drawPoints.maxOf { it.x } + pad, drawPoints.maxOf { it.y } + pad
-                ),
-                color = strokeColorVal, strokeWidth = strokeWidthVal
-            )
-            ann.paths.add(AnnPath(drawPoints.map { PointF(it.x, it.y) }.toMutableList()))
-            addAnnotationAndCommit(ann)
-        }
-
-        private fun eraseAt(pdfPt: PointF) {
-            val pageAnns = annotationMap[pageIndex] ?: return
-            val r = 10f / scale()
-            val hit = RectF(pdfPt.x - r, pdfPt.y - r, pdfPt.x + r, pdfPt.y + r)
-            val toRemove = pageAnns.filter { RectF.intersects(it.bounds, hit) }
-            if (toRemove.isNotEmpty()) {
-                pageAnns.removeAll(toRemove.toSet())
-                toRemove.forEach { ann -> undoStack.removeAll { it.annotation === ann } }
-                invalidate(); notifyAnnotationChange(); notifyUndoRedoState()
-            }
-        }
-
-        private fun addInstantAnnotation(pdfPt: PointF, tool: String) {
-            val s = scale()
-            val ann = if (tool == "note") {
-                PdfAnnotation("note", pageIndex,
-                    RectF(pdfPt.x, pdfPt.y, pdfPt.x + 32f / s, pdfPt.y + 32f / s),
-                    color = noteColorVal, contents = textContentVal.ifBlank { " " })
-            } else {
-                val w = 180f / s; val h = 40f / s
-                PdfAnnotation("text", pageIndex,
-                    RectF(pdfPt.x, pdfPt.y - h, pdfPt.x + w, pdfPt.y),
-                    color = textColorVal, contents = textContentVal.ifBlank { " " },
-                    fontSize = textFontSizeVal, bold = textBoldVal, italic = textItalicVal)
-            }
-            addAnnotationAndCommit(ann)
-        }
-
-        private fun handleTap(screenX: Float, screenY: Float) {
-            val pdfPt = toPdf(screenX, screenY)
-            val pageAnns = annotationMap[pageIndex] ?: return
-
-            pageAnns.filter { it.type == "text" }.forEachIndexed { idx, ann ->
-                if (ann.bounds.contains(pdfPt.x, pdfPt.y)) {
-                    onTextPress(mapOf("page" to pageIndex, "index" to idx,
-                        "bounds" to boundsMap(ann), "contents" to ann.contents)); return
-                }
-            }
-            pageAnns.filter { it.type == "note" }.forEachIndexed { idx, ann ->
-                if (ann.bounds.contains(pdfPt.x, pdfPt.y)) {
-                    onNotePress(mapOf("page" to pageIndex, "index" to idx,
-                        "bounds" to boundsMap(ann), "contents" to ann.contents)); return
-                }
-            }
-        }
-
-        private fun boundsMap(ann: PdfAnnotation) = mapOf(
-            "x" to ann.bounds.left.toDouble(), "y" to ann.bounds.top.toDouble(),
-            "width" to ann.bounds.width().toDouble(), "height" to ann.bounds.height().toDouble()
-        )
-
-        // ── Draw ──────────────────────────────────────────────────────────────
-
-        override fun onDraw(canvas: Canvas) {
-            for (ann in annotationMap[pageIndex] ?: emptyList()) drawAnn(canvas, ann)
-            drawTool?.let { drawActiveStroke(canvas, it) }
-        }
-
-        private fun drawAnn(canvas: Canvas, ann: PdfAnnotation) = when (ann.type) {
-            "pen", "highlighter", "line" -> drawInk(canvas, ann)
-            "text" -> drawTextAnn(canvas, ann)
-            "note" -> drawNoteAnn(canvas, ann)
-            else -> Unit
-        }
-
-        private fun drawInk(canvas: Canvas, ann: PdfAnnotation) {
-            val s = scale(); val base = safeColor(ann.color)
-            inkPaint.strokeWidth = ann.strokeWidth * s
-            inkPaint.color = if (ann.type == "highlighter")
-                Color.argb(102, Color.red(base), Color.green(base), Color.blue(base)) else base
-            for (ap in ann.paths) {
-                if (ap.points.isEmpty()) continue
-                drawPath.reset()
-                ap.points.forEachIndexed { i, pt ->
-                    val sp = toScreen(pt.x, pt.y)
-                    if (i == 0) drawPath.moveTo(sp.x, sp.y) else drawPath.lineTo(sp.x, sp.y)
-                }
-                canvas.drawPath(drawPath, inkPaint)
-            }
-        }
-
-        private fun drawTextAnn(canvas: Canvas, ann: PdfAnnotation) {
-            val text = ann.contents.trim().ifEmpty { return }
-            val rect = toScreenRect(ann.bounds)
-            val s = scale()
-            textPaint.textSize = ann.fontSize * s
-            textPaint.color = safeColor(ann.color)
-            textPaint.typeface = when {
-                ann.bold && ann.italic -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC)
-                ann.bold               -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
-                ann.italic             -> Typeface.create(Typeface.DEFAULT, Typeface.ITALIC)
-                else                   -> Typeface.DEFAULT
-            }
-            // No background — fully transparent
-            val maxW = (rect.width() - 8f).toInt().coerceAtLeast(1)
-            canvas.save()
-            canvas.translate(rect.left + 4f, rect.top + 4f)
-            StaticLayout.Builder.obtain(text, 0, text.length, textPaint, maxW)
-                .setAlignment(Layout.Alignment.ALIGN_NORMAL).build().draw(canvas)
-            canvas.restore()
-        }
-
-        private fun drawNoteAnn(canvas: Canvas, ann: PdfAnnotation) {
-            val rect = toScreenRect(ann.bounds)
-            bgFill.color = try { Color.parseColor(ann.color) } catch (_: Exception) { Color.YELLOW }
-            canvas.drawRect(rect, bgFill); canvas.drawRect(rect, bgStroke)
-            textPaint.textSize = rect.height() * 0.55f; textPaint.color = Color.DKGRAY
-            textPaint.textAlign = Paint.Align.CENTER; textPaint.typeface = Typeface.DEFAULT
-            canvas.drawText("✎", rect.centerX(), rect.centerY() + textPaint.textSize * 0.35f, textPaint)
-            textPaint.textAlign = Paint.Align.LEFT
-        }
-
-        private fun drawActiveStroke(canvas: Canvas, tool: String) {
-            if (drawPoints.isEmpty()) return
-            val s = scale(); val base = safeColor(strokeColorVal)
-            inkPaint.strokeWidth = strokeWidthVal * s
-            inkPaint.color = if (tool == "highlighter")
-                Color.argb(102, Color.red(base), Color.green(base), Color.blue(base)) else base
-            drawPath.reset()
-            drawPoints.forEachIndexed { i, pt ->
-                val sp = toScreen(pt.x, pt.y)
-                if (i == 0) drawPath.moveTo(sp.x, sp.y) else drawPath.lineTo(sp.x, sp.y)
-            }
-            canvas.drawPath(drawPath, inkPaint)
-        }
-
-        private fun safeColor(hex: String): Int =
-            try { Color.parseColor(hex) } catch (_: Exception) { Color.RED }
-    }
-}
+package expo.modules.pdfreader
+
+import android.content.Context
+import android.graphics.*
+import android.graphics.pdf.PdfRenderer
+import android.os.ParcelFileDescriptor
+import android.text.Layout
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.util.Log
+import android.view.*
+import android.widget.*
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.PagerSnapHelper
+import androidx.recyclerview.widget.RecyclerView
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+import kotlinx.coroutines.*
+import java.io.File
+import java.io.FileOutputStream
+import java.net.URL
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Data classes
+// ─────────────────────────────────────────────────────────────────────────────
+
+data class AnnPath(val points: MutableList<PointF> = mutableListOf())
+
+/**
+ * Bounds stored in PDF page coordinate space:
+ *   origin = bottom-left of the page, y-axis points UP.
+ *
+ *   RectF.left   = left edge  (PDF x)
+ *   RectF.top    = lower y in PDF space  (screen-bottom side, smaller PDF-y value)
+ *   RectF.right  = right edge (PDF x)
+ *   RectF.bottom = upper y in PDF space  (screen-top side,   larger  PDF-y value)
+ *
+ * Matches iOS PDFKit: CGRect(x, y=lowerPdfY, width, height).
+ */
+data class PdfAnnotation(
+    val type: String,         // "pen" | "highlighter" | "line" | "text" | "note"
+    val pageIndex: Int,
+    var bounds: RectF,
+    val paths: MutableList<AnnPath> = mutableListOf(),
+    var color: String = "#FF0000",
+    var strokeWidth: Float = 2f,
+    var contents: String = "",
+    var fontSize: Float = 14f,
+    var bold: Boolean = false,
+    var italic: Boolean = false
+)
+
+data class UndoEntry(val annotation: PdfAnnotation)
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Main view
+// ─────────────────────────────────────────────────────────────────────────────
+
+class ExpoPdfReaderView(
+    context: Context,
+    appContext: AppContext
+) : ExpoView(context, appContext) {
+
+    // ── Expo Events (ViewEventDelegate — Expo Modules-ын зөв механизм) ────────
+    val onReady by EventDispatcher()
+    val onPageChange by EventDispatcher()
+    val onAnnotationChange by EventDispatcher()
+    val onUndoRedoStateChange by EventDispatcher()
+    val onNotePress by EventDispatcher()
+    val onTextPress by EventDispatcher()
+
+    // ── Coroutines ───────────────────────────────────────────────────────────
+    private val pdfDispatcher = Dispatchers.IO.limitedParallelism(1)
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    private var renderJob: Job? = null
+
+    // ── PDF state ────────────────────────────────────────────────────────────
+    private var fileDescriptor: ParcelFileDescriptor? = null
+    private var renderer: PdfRenderer? = null
+    private var pagePdfW = intArrayOf()   // PDF points per page
+    private var pagePdfH = intArrayOf()
+    var totalPages = 0
+        private set
+
+    // ── Display state ────────────────────────────────────────────────────────
+    private var displayMode = "continuous"
+    private var pendingUrl: String? = null
+    private var isLayoutReady = false
+    var currentPageIndex = 0
+        private set
+
+    // ── Lazy / chunked rendering ──────────────────────────────────────────────
+    private var renderedUpTo = -1          // last rendered page index (absolute)
+    private var windowStart = 0            // pageEntries[0]-н absolute page index
+    private var chunkLoading = false       // chunk дуусах хүртэл дахин trigger хийхгүй
+    private var currentViewWidth = 0       // chunk load-д дахин хэрэглэнэ
+    /** Thumbnail panel нээх/хаах зэргээр RN өргөн өөрчлөгдөнө — reflow-ийн суурь */
+    private var lastHostWidthForPdf = 0
+    private var loadingFooter: View? = null
+
+    companion object {
+        private const val PAGE_CHUNK = 10           // нэг удаа render хийх хуудасны тоо
+        private const val MAX_RENDERED = PAGE_CHUNK * 2  // санах ойд байлгах дээд хязгаар (20 хуудас)
+    }
+
+    // ── Annotation state ─────────────────────────────────────────────────────
+    val annotationMap = mutableMapOf<Int, MutableList<PdfAnnotation>>()
+    var activeTool: String? = null
+    var strokeColorVal = "#FF0000"
+    var strokeWidthVal = 2f
+    var textContentVal = ""
+    var textColorVal = "#000000"
+    var textFontSizeVal = 14f
+    var textBoldVal = false
+    var textItalicVal = false
+    var noteColorVal = "#FFFF00"
+
+    val undoStack = ArrayDeque<UndoEntry>()
+    val redoStack = ArrayDeque<UndoEntry>()
+    private var appliedFingerprint: String? = null
+
+    // ── Page view entries (continuous/twoUp modes) ───────────────────────────
+    // frame: container-аас устгахад шууд reference, bmpHeight: layout болохоос өмнө scroll тооцооны тулд
+    data class PageEntry(val frame: FrameLayout, val canvasView: AnnotationCanvasView, val bmpHeight: Int)
+    val pageEntries = mutableListOf<PageEntry>()
+
+    // ── Single-page pager (single mode) ──────────────────────────────────────
+    private lateinit var pager: RecyclerView
+    private var singleAdapter: SinglePageAdapter? = null
+    private val singlePageCanvases = mutableMapOf<Int, AnnotationCanvasView>()
+
+    // ── Zoom ─────────────────────────────────────────────────────────────────
+    private var minZoom = 1.0f
+    private var maxZoom = 5.0f
+    private var currentZoom = 1.0f
+
+    /** RN / Drawer зэрэг дээд scroll хуудас pinch-ийг scroll болгож идэвхжүүлэхээс сэргийлнэ */
+    private fun propagateDisallowInterceptFrom(view: View, disallow: Boolean) {
+        var p: ViewParent? = view.parent
+        while (p is ViewGroup) {
+            p.requestDisallowInterceptTouchEvent(disallow)
+            p = p.parent
+        }
+    }
+
+    /**
+     * continuous / twoup / twoupcontinuous — pinch-ийг [dispatchTouchEvent]-ийн эхэнд дуудаж
+     * 2 хурууны POINTER_DOWN canvas-д баригдахаас өмнө хүлээнэ. Zoom хийсэн ч босоо scroll хэвээр (зөвхөн pinch үед scroll intercept унтрана).
+     */
+    private inner class ZoomableScrollView(ctx: Context) : ScrollView(ctx) {
+
+        private val pinch = ScaleGestureDetector(
+            ctx,
+            object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+                override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+                    if (activeTool != null) return false
+                    stopNestedScroll()
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomableScrollView, true)
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                    return true
+                }
+
+                override fun onScale(detector: ScaleGestureDetector): Boolean {
+                    if (activeTool != null) return false
+                    applyZoom(
+                        (currentZoom * detector.scaleFactor).coerceIn(minZoom, maxZoom),
+                        detector.focusX,
+                        detector.focusY
+                    )
+                    return true
+                }
+
+                override fun onScaleEnd(detector: ScaleGestureDetector) {
+                    parent?.requestDisallowInterceptTouchEvent(false)
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomableScrollView, false)
+                }
+            }
+        )
+
+        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool != null) return super.onInterceptTouchEvent(ev)
+            if (ev.pointerCount > 1 || pinch.isInProgress) return false
+            return super.onInterceptTouchEvent(ev)
+        }
+
+        override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool == null) {
+                pinch.onTouchEvent(ev)
+                if (ev.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+                    stopNestedScroll()
+                }
+                if (pinch.isInProgress || ev.pointerCount > 1) {
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomableScrollView, true)
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                }
+                if (ev.actionMasked == MotionEvent.ACTION_UP ||
+                    ev.actionMasked == MotionEvent.ACTION_CANCEL
+                ) {
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomableScrollView, false)
+                }
+            }
+            return super.dispatchTouchEvent(ev)
+        }
+
+        override fun onTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool != null) return super.onTouchEvent(ev)
+            if (pinch.isInProgress || ev.pointerCount > 1) {
+                return true
+            }
+            return super.onTouchEvent(ev)
+        }
+    }
+
+    // ── UI ───────────────────────────────────────────────────────────────────
+    private val scrollView = ZoomableScrollView(context).apply {
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        isFillViewport = true
+    }
+    private val container = LinearLayout(context).apply {
+        orientation = LinearLayout.VERTICAL
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)
+        setBackgroundColor(Color.parseColor("#E8E8E8"))
+    }
+
+    init {
+        setBackgroundColor(Color.parseColor("#E8E8E8"))
+        scrollView.addView(container)
+        addView(scrollView)
+        scrollView.setOnScrollChangeListener { _, _, scrollY, _, _ ->
+            detectCurrentPage(scrollY)
+            maybeTriggerChunkLoad(scrollY)
+        }
+
+        // Single-page pager: ZoomRecyclerView + PagerSnapHelper (vertical)
+        pager = ZoomRecyclerView(context).apply {
+            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+            layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
+            PagerSnapHelper().attachToRecyclerView(this)
+            setBackgroundColor(Color.parseColor("#E8E8E8"))
+            overScrollMode = View.OVER_SCROLL_NEVER
+            isNestedScrollingEnabled = false
+            visibility = View.GONE
+            addOnScrollListener(object : RecyclerView.OnScrollListener() {
+                override fun onScrollStateChanged(rv: RecyclerView, newState: Int) {
+                    if (newState == RecyclerView.SCROLL_STATE_IDLE) {
+                        val lm = rv.layoutManager as? LinearLayoutManager ?: return
+                        var pos = lm.findFirstCompletelyVisibleItemPosition()
+                        if (pos < 0) pos = lm.findFirstVisibleItemPosition()
+                        if (pos < 0) return
+                        if (pos != currentPageIndex) {
+                            currentPageIndex = pos
+                            // Хуудас солигдоход zoom-г reset хийнэ
+                            (pager as? ZoomRecyclerView)?.resetZoom()
+                            onPageChange(mapOf("currentPage" to pos, "totalPage" to totalPages))
+                        } else {
+                            // scrollToPage() нь currentPageIndex-ийг урьдчилан тохируулдаг тул энд орохгүй —
+                            // гэхдээ zoom transform + Fabric layout-оос хуудас шинэчлэгдэхгүй үлдэхээс сэргийлнэ
+                            (pager as? ZoomRecyclerView)?.resetZoom()
+                        }
+                    }
+                }
+            })
+        }
+        addView(pager)
+    }
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+        super.onLayout(changed, l, t, r, b)
+        if (width > 0 && !isLayoutReady) {
+            isLayoutReady = true
+            pendingUrl?.let {
+                pendingUrl = null
+                startLoad(it)
+            }
+        }
+        // RN: thumbnail panel нээх/хаахад өргөн өөрчлөгдөнө; Fabric child requestLayout сул → reflow шаардлагатай
+        if (renderer != null && isLayoutReady && lastHostWidthForPdf > 0 && width > 0) {
+            val dw = kotlin.math.abs(width - lastHostWidthForPdf)
+            if (dw > 4) {
+                post { reflowForHostWidthChange() }
+            }
+        }
+    }
+
+    /** Хостын өргөн өөрчлөгдсөний дараа PDF-ийг шинэ өргөнөөр дахин тохируулна */
+    private fun reflowForHostWidthChange() {
+        val w = width.takeIf { it > 0 } ?: return
+        if (renderer == null) return
+        if (lastHostWidthForPdf > 0 && kotlin.math.abs(w - lastHostWidthForPdf) <= 4) return
+        lastHostWidthForPdf = w
+        currentViewWidth = w
+        when (displayMode) {
+            "single" -> {
+                forcePagerLayout()
+                singleAdapter?.notifyDataSetChanged()
+                forcePagerLayout()
+                val p = currentPageIndex.coerceIn(0, maxOf(0, totalPages - 1))
+                post { scrollToPage(p, smooth = false) }
+            }
+            else -> triggerRender()
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        renderJob?.cancel()
+        scope.cancel()
+        safeCloseRenderer()
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Props
+    // ─────────────────────────────────────────────────────────────────────────
+
+    fun setUrl(url: String?) {
+        if (url.isNullOrBlank()) return
+        pendingUrl = url
+        if (isLayoutReady) {
+            startLoad(url)
+        } else {
+            // Layout ирээгүй байж болно — дараагийн frame-д шалгана
+            post { tryStartLoad() }
+        }
+    }
+
+    private fun tryStartLoad() {
+        val url = pendingUrl ?: return   // onLayout аль хэдийн startLoad дуудсан бол pendingUrl = null → exit
+        if (width > 0) {
+            isLayoutReady = true
+            pendingUrl = null   // давхар дуудлагаас сэргийлнэ
+            startLoad(url)
+        } else {
+            scope.launch {
+                delay(50)
+                tryStartLoad()
+            }
+        }
+    }
+
+    fun setDisplayMode(mode: String?) {
+        val newMode = mode?.lowercase() ?: "continuous"
+        if (newMode == displayMode) return
+        displayMode = newMode
+        if (renderer != null && isLayoutReady) triggerRender()
+    }
+
+    fun setInitialPage(page: Int) {
+        if (page < 0 || page >= totalPages) return
+        currentPageIndex = page
+        if (displayMode == "single") {
+            post { scrollToPage(page, smooth = false) }
+            return
+        }
+        val windowEnd = windowStart + pageEntries.size - 1
+        if (page in windowStart..windowEnd) {
+            // Хуудас render хийгдсэн window дотор байна → зүгээр scroll хийнэ
+            post { scrollToPage(page, smooth = false) }
+        } else {
+            // Хуудас render хийгдээгүй → window-г тухайн хуудас руу шилжүүлнэ
+            jumpToPage(page)
+        }
+    }
+
+    fun setMinZoom(v: Double) { minZoom = v.toFloat() }
+    fun setMaxZoom(v: Double) { maxZoom = v.toFloat() }
+
+    fun setTool(tool: String?) {
+        activeTool = tool
+        if (displayMode == "single") {
+            pager.requestDisallowInterceptTouchEvent(tool != null)
+        } else {
+            scrollView.requestDisallowInterceptTouchEvent(tool != null)
+        }
+    }
+
+    fun setStrokeColor(hex: String) { strokeColorVal = hex }
+    fun setStrokeWidth(w: Double) { strokeWidthVal = w.toFloat() }
+    fun setTextContent(t: String) { textContentVal = t }
+    fun setTextColor(hex: String) { textColorVal = hex }
+    fun setTextFontSize(size: Double) { textFontSizeVal = size.toFloat() }
+    fun setTextBold(v: Boolean) { textBoldVal = v }
+    fun setTextItalic(v: Boolean) { textItalicVal = v }
+    fun setNoteColor(hex: String) { noteColorVal = hex }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Commands
+    // ─────────────────────────────────────────────────────────────────────────
+
+    fun undo() {
+        val e = undoStack.removeLastOrNull() ?: return
+        redoStack.addLast(e)
+        annotationMap[e.annotation.pageIndex]?.remove(e.annotation)
+        invalidateCanvas(e.annotation.pageIndex)
+        notifyAnnotationChange()
+        notifyUndoRedoState()
+    }
+
+    fun redo() {
+        val e = redoStack.removeLastOrNull() ?: return
+        undoStack.addLast(e)
+        annotationMap.getOrPut(e.annotation.pageIndex) { mutableListOf() }.add(e.annotation)
+        invalidateCanvas(e.annotation.pageIndex)
+        notifyAnnotationChange()
+        notifyUndoRedoState()
+    }
+
+    fun setAnnotations(data: List<Map<String, Any?>>) {
+        val fp = buildFingerprint(data)
+        if (fp == appliedFingerprint) return
+        appliedFingerprint = fp
+        annotationMap.clear()
+
+        for (item in data) {
+            val pageIndex = (item["page"] as? Number)?.toInt() ?: continue
+            val typeStr = item["type"] as? String ?: continue
+            val b = item["bounds"] as? Map<*, *> ?: continue
+            val bX = (b["x"] as? Number)?.toFloat() ?: 0f
+            val bY = (b["y"] as? Number)?.toFloat() ?: 0f
+            val bW = (b["width"] as? Number)?.toFloat() ?: 0f
+            val bH = (b["height"] as? Number)?.toFloat() ?: 0f
+
+            val bounds = RectF(bX, bY, bX + bW, bY + bH)
+            val ann = PdfAnnotation(
+                type = typeStr, pageIndex = pageIndex, bounds = bounds,
+                color = item["color"] as? String ?: strokeColorVal,
+                strokeWidth = (item["strokeWidth"] as? Number)?.toFloat() ?: strokeWidthVal,
+                contents = item["contents"] as? String ?: "",
+                fontSize = (item["fontSize"] as? Number)?.toFloat() ?: textFontSizeVal,
+                bold = item["bold"] as? Boolean ?: false,
+                italic = item["italic"] as? Boolean ?: false
+            )
+
+            (item["paths"] as? List<*>)?.forEach { pathData ->
+                val pts = (pathData as? List<*>)?.mapNotNull { pt ->
+                    val m = pt as? Map<*, *> ?: return@mapNotNull null
+                    PointF(
+                        (m["x"] as? Number)?.toFloat() ?: 0f,
+                        (m["y"] as? Number)?.toFloat() ?: 0f
+                    )
+                }
+                if (!pts.isNullOrEmpty()) ann.paths.add(AnnPath(pts.toMutableList()))
+            }
+
+            annotationMap.getOrPut(pageIndex) { mutableListOf() }.add(ann)
+        }
+        if (displayMode == "single") {
+            singlePageCanvases.values.forEach { it.invalidate() }
+        } else {
+            pageEntries.forEach { it.canvasView.invalidate() }
+        }
+    }
+
+    fun updateText(pageIndex: Int, index: Int, contents: String) {
+        val anns = annotationMap[pageIndex]?.filter { it.type == "text" } ?: return
+        if (index >= anns.size) return
+        val ann = anns[index]
+        ann.contents = contents.ifBlank { " " }
+        autoSizeTextAnnotation(ann)
+        invalidateCanvas(pageIndex)
+        notifyAnnotationChange()
+    }
+
+    /**
+     * Recalculate the annotation's bounds so the text fits without clipping.
+     * Width is capped at 70% of the view width; height grows with line count.
+     */
+    private fun autoSizeTextAnnotation(ann: PdfAnnotation) {
+        val text = ann.contents.trim().ifEmpty { return }
+        val pageW = pagePdfW.getOrElse(ann.pageIndex) { 0 }
+        if (pageW <= 0 || width <= 0) return
+        val s = width.toFloat() / pageW.toFloat()
+        val tp = android.text.TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
+            textSize = ann.fontSize * s
+            typeface = when {
+                ann.bold && ann.italic -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC)
+                ann.bold               -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
+                ann.italic             -> Typeface.create(Typeface.DEFAULT, Typeface.ITALIC)
+                else                   -> Typeface.DEFAULT
+            }
+        }
+        val pad = 16f  // screen px total padding (8px each side)
+        val maxW = (width * 0.7f - pad).toInt().coerceAtLeast(80)
+        val layout = StaticLayout.Builder
+            .obtain(text, 0, text.length, tp, maxW)
+            .setAlignment(android.text.Layout.Alignment.ALIGN_NORMAL)
+            .build()
+        val newW = (layout.width + pad) / s
+        val newH = (layout.height + pad) / s
+        // Keep top-left anchor fixed
+        ann.bounds = RectF(ann.bounds.left, ann.bounds.top, ann.bounds.left + newW, ann.bounds.top + newH)
+    }
+
+    fun updateNote(pageIndex: Int, index: Int, contents: String) {
+        val anns = annotationMap[pageIndex]?.filter { it.type == "note" } ?: return
+        if (index >= anns.size) return
+        anns[index].contents = contents.ifBlank { " " }
+        invalidateCanvas(pageIndex)
+        notifyAnnotationChange()
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Internal helpers (used by inner AnnotationCanvasView)
+    // ─────────────────────────────────────────────────────────────────────────
+
+    fun addAnnotationAndCommit(ann: PdfAnnotation) {
+        annotationMap.getOrPut(ann.pageIndex) { mutableListOf() }.add(ann)
+        undoStack.addLast(UndoEntry(ann))
+        redoStack.clear()
+        invalidateCanvas(ann.pageIndex)
+        notifyAnnotationChange()
+        notifyUndoRedoState()
+    }
+
+    fun invalidateCanvas(pageIndex: Int) {
+        if (displayMode == "single") {
+            singlePageCanvases[pageIndex]?.invalidate()
+        } else {
+            // continuous mode: pageEntries[0] = page windowStart → relative index
+            pageEntries.getOrNull(pageIndex - windowStart)?.canvasView?.invalidate()
+        }
+    }
+
+    fun notifyAnnotationChange() {
+        val all = mutableListOf<Map<String, Any>>()
+        for ((pageIndex, anns) in annotationMap) {
+            for (ann in anns) {
+                val m = mutableMapOf<String, Any>(
+                    "type" to ann.type,
+                    "page" to pageIndex,
+                    "bounds" to mapOf(
+                        "x" to ann.bounds.left.toDouble(),
+                        "y" to ann.bounds.top.toDouble(),
+                        "width" to ann.bounds.width().toDouble(),
+                        "height" to ann.bounds.height().toDouble()
+                    ),
+                    "color" to ann.color,
+                    "strokeWidth" to ann.strokeWidth.toDouble(),
+                    "contents" to ann.contents
+                )
+                if (ann.type == "text") {
+                    m["fontSize"] = ann.fontSize.toDouble()
+                    m["bold"] = ann.bold
+                    m["italic"] = ann.italic
+                }
+                if (ann.paths.isNotEmpty()) {
+                    m["paths"] = ann.paths.map { p ->
+                        p.points.map { pt ->
+                            mapOf("x" to pt.x.toDouble(), "y" to pt.y.toDouble())
+                        }
+                    }
+                }
+                all.add(m)
+            }
+        }
+        onAnnotationChange(mapOf("annotations" to all))
+    }
+
+    fun notifyUndoRedoState() {
+        onUndoRedoStateChange(
+            mapOf("canUndo" to undoStack.isNotEmpty(), "canRedo" to redoStack.isNotEmpty())
+        )
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Zoom
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Scroll mode: pivot (0,0) + translation — pinch төв (focus) тогтвортой үлдэхийн тулд translation-ийг
+     * scrollX/scrollY-тай нийлүүлэн шинэчилнэ (ZoomRecyclerView-тай ижил математик).
+     */
+    private fun applyZoom(
+        newZoom: Float,
+        pinchFocusX: Float = Float.NaN,
+        pinchFocusY: Float = Float.NaN
+    ) {
+        val prevZoom = currentZoom
+        currentZoom = newZoom.coerceIn(minZoom, maxZoom)
+        container.pivotX = 0f
+        container.pivotY = 0f
+
+        if (displayMode != "single") {
+            if (currentZoom <= 1.02f) {
+                container.translationX = 0f
+                container.translationY = 0f
+            } else if (!pinchFocusX.isNaN() && !pinchFocusY.isNaN() && prevZoom > 0.01f) {
+                val af = currentZoom / prevZoom
+                if (kotlin.math.abs(af - 1f) > 1e-5f) {
+                    val scrX = scrollView.scrollX.toFloat()
+                    val scrY = scrollView.scrollY.toFloat()
+                    val tx = container.translationX
+                    val ty = container.translationY
+                    val contentFx = pinchFocusX + scrX
+                    val contentFy = pinchFocusY + scrY
+                    container.translationX = contentFx - (contentFx - tx) * af
+                    container.translationY = contentFy - (contentFy - ty) * af
+                }
+            }
+        }
+        container.scaleX = currentZoom
+        container.scaleY = currentZoom
+        if (displayMode != "single" && currentZoom > 1.02f) {
+            clampContainerTranslationsInPlace()
+        }
+    }
+
+    private fun clampContainerTranslationsInPlace() {
+        val ch = container.height.toFloat()
+        val cw = container.width.toFloat()
+        if (ch <= 0f || cw <= 0f) return
+        val scaledH = ch * currentZoom
+        val scaledW = cw * currentZoom
+        val vw = scrollView.width.toFloat()
+        val vh = scrollView.height.toFloat()
+        var tx = container.translationX
+        var ty = container.translationY
+        if (scaledW <= vw) tx = 0f else tx = tx.coerceIn(vw - scaledW, 0f)
+        if (scaledH <= vh) ty = 0f else ty = ty.coerceIn(vh - scaledH, 0f)
+        container.translationX = tx
+        container.translationY = ty
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Scroll / page detection
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /** twoupcontinuous: нэг мөр = хос entry (хуудас дараалсан), эсвэл эцсийн ганц entry. */
+    private fun twoupStrideAt(entryIdx: Int): Int {
+        if (displayMode != "twoupcontinuous") return 1
+        if (entryIdx >= pageEntries.size) return 0
+        if (entryIdx + 1 < pageEntries.size) {
+            val a = pageEntries[entryIdx].canvasView.pageIndex
+            val b = pageEntries[entryIdx + 1].canvasView.pageIndex
+            if (b == a + 1) return 2
+        }
+        return 1
+    }
+
+    /** scrollView доторх pageIndex хуудасны мөрийн дээд ирмэгийн Y (continuous / twoupcontinuous). */
+    private fun scrollYForScrollModePage(pageIndex: Int): Int {
+        if (pageEntries.isEmpty()) return 0
+        val lastAbsPage = windowStart + pageEntries.size - 1
+        val clamped = pageIndex.coerceIn(windowStart, lastAbsPage.coerceAtLeast(windowStart))
+        if (displayMode != "twoupcontinuous") {
+            val rel = (clamped - windowStart).coerceIn(0, maxOf(0, pageEntries.size - 1))
+            var y = 0
+            for (i in 0 until rel) {
+                y += (pageEntries[i].bmpHeight.takeIf { it > 0 } ?: 0) + 12
+            }
+            return y
+        }
+        var y = 0
+        var idx = 0
+        while (idx < pageEntries.size) {
+            val stride = twoupStrideAt(idx)
+            val rowH = pageEntries[idx].bmpHeight.takeIf { it > 0 } ?: 0
+            val p0 = pageEntries[idx].canvasView.pageIndex
+            val p1 = if (stride == 2) pageEntries[idx + 1].canvasView.pageIndex else p0
+            if (clamped in p0..p1) return y
+            y += rowH + 12
+            idx += stride
+        }
+        return y
+    }
+
+    private fun detectCurrentPage(scrollY: Int) {
+        if (pageEntries.isEmpty()) return
+        val viewH = scrollView.height.takeIf { it > 0 } ?: height
+        val centerY = scrollY + viewH / 2
+        if (displayMode == "twoupcontinuous") {
+            var accY = 0
+            var idx = 0
+            while (idx < pageEntries.size) {
+                val stride = twoupStrideAt(idx)
+                val rowH = pageEntries[idx].bmpHeight.takeIf { it > 0 } ?: 0
+                val nextY = accY + rowH + 12
+                val p0 = pageEntries[idx].canvasView.pageIndex
+                val p1 = if (stride == 2) pageEntries[idx + 1].canvasView.pageIndex else p0
+                if (centerY <= nextY || idx + stride >= pageEntries.size) {
+                    val vx = scrollView.width.takeIf { it > 0 } ?: width
+                    val absPage = if (stride == 2 && p1 > p0 && vx > 0) {
+                        val midPix = vx / 2
+                        val centerX = scrollView.scrollX + midPix
+                        if (centerX < midPix) p0 else p1
+                    } else p0
+                    if (currentPageIndex != absPage) {
+                        currentPageIndex = absPage
+                        onPageChange(mapOf("currentPage" to absPage, "totalPage" to totalPages))
+                    }
+                    break
+                }
+                accY = nextY
+                idx += stride
+            }
+            return
+        }
+        // continuous — entry бүр нэг босоо мөр
+        var accY = 0
+        for (i in pageEntries.indices) {
+            val h = pageEntries[i].bmpHeight.takeIf { it > 0 } ?: continue
+            accY += h + 12
+            if (centerY <= accY || i == pageEntries.size - 1) {
+                val absolutePage = windowStart + i
+                if (currentPageIndex != absolutePage) {
+                    currentPageIndex = absolutePage
+                    onPageChange(mapOf("currentPage" to absolutePage, "totalPage" to totalPages))
+                }
+                break
+            }
+        }
+    }
+
+    private fun scrollToPage(pageIndex: Int, smooth: Boolean = true) {
+        if (displayMode == "single") {
+            pager.stopScroll()
+            currentPageIndex = pageIndex
+            onPageChange(mapOf("currentPage" to pageIndex, "totalPage" to totalPages))
+            // scrollToPosition нь заримдаа layout/bind хойшлуулна (RN Fabric); post + forcePagerLayout
+            pager.post {
+                if (smooth) pager.smoothScrollToPosition(pageIndex)
+                else pager.scrollToPosition(pageIndex)
+                forcePagerLayout()
+                singleAdapter?.notifyItemChanged(pageIndex)
+                (pager as? ZoomRecyclerView)?.resetZoom()
+            }
+            return
+        }
+        if (pageEntries.isEmpty()) return
+        val y = scrollYForScrollModePage(pageIndex)
+        if (smooth) scrollView.smoothScrollTo(0, y) else scrollView.scrollTo(0, y)
+        currentPageIndex = pageIndex
+        onPageChange(mapOf("currentPage" to pageIndex, "totalPage" to totalPages))
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Load & Render
+    // ─────────────────────────────────────────────────────────────────────────
+
+    private fun startLoad(url: String) {
+        Log.d("ExpoPdfReader", "startLoad: $url")
+        renderJob?.cancel()
+        renderJob = scope.launch {
+            try {
+                withContext(pdfDispatcher) { safeCloseRenderer() }
+                val file = withContext(pdfDispatcher) { resolveFile(url) }
+                withContext(pdfDispatcher) {
+                    fileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
+                    renderer = PdfRenderer(fileDescriptor!!)
+                    val r = renderer!!
+                    totalPages = r.pageCount
+                    // Хэмжээг энд бүгдийг нь уншихгүй — renderPageBitmap нээх бүрт бөглөнө (анхны ачаалал хурдан).
+                    pagePdfW = IntArray(totalPages) { 0 }
+                    pagePdfH = IntArray(totalPages) { 0 }
+                }
+                // annotationMap is intentionally NOT cleared here.
+                // setAnnotations() may have already populated it before startLoad() runs
+                // (Expo prop ordering: url first, then initialAnnotations).
+                // Canvases created in renderDocument() read annotationMap on their first onDraw().
+                undoStack.clear(); redoStack.clear()
+                appliedFingerprint = null; currentPageIndex = 0
+                renderDocument()
+                // After canvases are created, re-invalidate all of them so initialAnnotations appear.
+                withContext(Dispatchers.Main) {
+                    if (displayMode == "single") {
+                        singlePageCanvases.values.forEach { it.invalidate() }
+                    } else {
+                        pageEntries.forEach { it.canvasView.invalidate() }
+                    }
+                }
+            } catch (e: CancellationException) { throw e }
+            catch (e: Exception) { Log.e("ExpoPdfReader", "Load error", e) }
+        }
+    }
+
+    private fun triggerRender() {
+        renderJob?.cancel()
+        renderJob = scope.launch {
+            try { renderDocument() }
+            catch (e: CancellationException) { throw e }
+            catch (e: Exception) { Log.e("ExpoPdfReader", "Render error", e) }
+        }
+    }
+
+    private suspend fun renderDocument() {
+        val pdf = renderer ?: return
+        val pageCount = withContext(pdfDispatcher) { pdf.pageCount }
+        if (pageCount <= 0) return
+        val viewWidth = width.takeIf { it > 0 } ?: resources.displayMetrics.widthPixels
+        if (viewWidth <= 0) return
+
+        // Chunk state reset
+        currentViewWidth = viewWidth
+        renderedUpTo = -1
+        windowStart = 0
+        chunkLoading = false
+
+        withContext(Dispatchers.Main) {
+            currentZoom = 1f
+            container.scaleX = 1f
+            container.scaleY = 1f
+            container.translationX = 0f
+            container.translationY = 0f
+            container.removeAllViews()
+            pageEntries.clear()
+            loadingFooter = null
+        }
+
+        when (displayMode) {
+            "single" -> renderSingleMode()
+            "twoup" -> renderAllPages(pdf, pageCount, viewWidth)
+            else -> renderScrollModeAround(
+                pdf,
+                pageCount,
+                viewWidth,
+                currentPageIndex.coerceIn(0, pageCount - 1)
+            )
+        }
+
+        // onReady: Main thread дээр шууд дуудна
+        withContext(Dispatchers.Main) {
+            val density = resources.displayMetrics.density
+            Log.d("ExpoPdfReader", "onReady firing: totalPages=$pageCount")
+            onReady(
+                mapOf(
+                    "totalPages" to pageCount,
+                    "width" to (this@ExpoPdfReaderView.width / density).toDouble(),
+                    "height" to (this@ExpoPdfReaderView.height / density).toDouble()
+                )
+            )
+            lastHostWidthForPdf = this@ExpoPdfReaderView.width.takeIf { it > 0 } ?: viewWidth
+        }
+    }
+
+    // single mode: RecyclerView + PagerSnapHelper — нэг хуудас бүрэн харагдана
+    private suspend fun renderSingleMode() {
+        withContext(Dispatchers.Main) {
+            singlePageCanvases.clear()
+            scrollView.visibility = View.GONE
+            pager.visibility = View.VISIBLE
+            singleAdapter = SinglePageAdapter()
+            pager.adapter = singleAdapter
+            pager.scrollToPosition(currentPageIndex)
+            // React Native Fabric blocks child requestLayout() calls, so the RecyclerView
+            // never binds its items until the next Fabric layout pass (e.g. thumbnail panel
+            // opening/closing). Force a manual measure+layout to make items bind immediately.
+            forcePagerLayout()
+        }
+    }
+
+    private fun forcePagerLayout() {
+        val w = width.takeIf { it > 0 } ?: return
+        val h = height.takeIf { it > 0 } ?: return
+        pager.measure(
+            MeasureSpec.makeMeasureSpec(w, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(h, MeasureSpec.EXACTLY)
+        )
+        pager.layout(0, 0, w, h)
+    }
+
+    // twoup — бүх хуудсыг render хийнэ
+    private suspend fun renderAllPages(pdf: PdfRenderer, pageCount: Int, viewWidth: Int) {
+        withContext(Dispatchers.Main) {
+            scrollView.visibility = View.VISIBLE
+            pager.visibility = View.GONE
+        }
+        renderTwoUpRange(pdf, pageCount, viewWidth, 0, pageCount)
+        withContext(Dispatchers.Main) { renderedUpTo = pageCount - 1 }
+    }
+
+    /**
+     * continuous / twoupcontinuous — [anchorPage]-ийн эргэн тойронд MAX_RENDERED хүртэлх цонх.
+     * Горим солиход одоогийн хуудас хадгалагдана.
+     */
+    private suspend fun renderScrollModeAround(
+        pdf: PdfRenderer,
+        pageCount: Int,
+        viewWidth: Int,
+        anchorPage: Int
+    ) {
+        withContext(Dispatchers.Main) {
+            scrollView.visibility = View.VISIBLE
+            pager.visibility = View.GONE
+        }
+        val target = anchorPage.coerceIn(0, pageCount - 1)
+        val newStart = maxOf(0, target - PAGE_CHUNK / 2)
+        val newEnd = minOf(pageCount, newStart + MAX_RENDERED)
+        withContext(Dispatchers.Main) {
+            windowStart = newStart
+            renderedUpTo = newStart - 1
+        }
+        if (displayMode == "twoupcontinuous") {
+            renderTwoUpRange(pdf, pageCount, viewWidth, newStart, newEnd)
+            withContext(Dispatchers.Main) {
+                val rawUpTo = if (newEnd % 2 == 0) newEnd - 1 else newEnd - 2
+                renderedUpTo = rawUpTo.coerceIn(0, pageCount - 1)
+                if (renderedUpTo < pageCount - 1) showLoadingFooter()
+                forceLayoutScrollView()
+                post { scrollToPage(target, smooth = false) }
+            }
+        } else {
+            for (i in newStart until newEnd) {
+                val bmp = renderPageBitmap(pdf, i, viewWidth)
+                val idx = i
+                withContext(Dispatchers.Main) {
+                    addPageRow(
+                        bmp, idx,
+                        pagePdfW.getOrElse(idx) { 1 }.toFloat(),
+                        pagePdfH.getOrElse(idx) { 1 }.toFloat()
+                    )
+                }
+            }
+            withContext(Dispatchers.Main) {
+                renderedUpTo = (newEnd - 1).coerceIn(0, pageCount - 1)
+                if (newEnd < pageCount) showLoadingFooter()
+                forceLayoutScrollView()
+                post { scrollToPage(target, smooth = false) }
+            }
+        }
+    }
+
+    // twoUp row-г render хийх helper (start..end page range, pairs)
+    private suspend fun renderTwoUpRange(
+        pdf: PdfRenderer, pageCount: Int, viewWidth: Int, startPage: Int, endPage: Int
+    ) {
+        val halfWidth = viewWidth / 2
+        var i = startPage
+        while (i < endPage) {
+            val leftBmp = renderPageBitmap(pdf, i, halfWidth)
+            val rightBmp = if (i + 1 < minOf(endPage, pageCount))
+                renderPageBitmap(pdf, i + 1, halfWidth) else null
+            val li = i; val ri = i + 1
+            withContext(Dispatchers.Main) {
+                // twoUp row-ын өндрийг зүүн хуудасны bitmap-аас авна (хоёр хуудас ижил scale-тай)
+                val rowH = leftBmp.height
+                val row = LinearLayout(context).apply {
+                    orientation = LinearLayout.HORIZONTAL
+                    layoutParams = LinearLayout.LayoutParams(viewWidth, rowH)
+                        .apply { setMargins(0, 6, 0, 6) }
+                }
+                row.addView(buildPageFrame(leftBmp, li,
+                    pagePdfW.getOrElse(li) { 1 }.toFloat(), pagePdfH.getOrElse(li) { 1 }.toFloat(), 1f))
+                if (rightBmp != null) {
+                    row.addView(buildPageFrame(rightBmp, ri,
+                        pagePdfW.getOrElse(ri) { 1 }.toFloat(), pagePdfH.getOrElse(ri) { 1 }.toFloat(), 1f))
+                } else {
+                    row.addView(View(context).apply { layoutParams = LinearLayout.LayoutParams(0, rowH, 1f) })
+                }
+                container.addView(row)
+            }
+            i += 2
+        }
+    }
+
+    // ── Lazy chunk helpers ────────────────────────────────────────────────────
+
+    private fun maybeTriggerChunkLoad(scrollY: Int) {
+        if (chunkLoading) return
+        if (displayMode !in listOf("continuous", "twoupcontinuous")) return
+
+        val visibleBottom = scrollY + scrollView.height
+
+        // Доош scroll: дараагийн chunk ачаална
+        if (renderedUpTo < totalPages - 1) {
+            val forwardTrigger = container.height - scrollView.height * 2
+            if (visibleBottom >= forwardTrigger) {
+                chunkLoading = true
+                scope.launch {
+                    try { loadNextChunk() }
+                    catch (e: CancellationException) { throw e }
+                    catch (e: Exception) { Log.e("ExpoPdfReader", "Chunk load error", e) }
+                    finally { chunkLoading = false }
+                }
+                return
+            }
+        }
+
+        // Дээш scroll: өмнөх chunk (continuous = нэг багана; twoupcontinuous = хос мөр prepend).
+        if (windowStart > 0 && scrollY <= scrollView.height * 2) {
+            chunkLoading = true
+            scope.launch {
+                try { loadPrevChunk() }
+                catch (e: CancellationException) { throw e }
+                catch (e: Exception) { Log.e("ExpoPdfReader", "Prev chunk load error", e) }
+                finally { chunkLoading = false }
+            }
+        }
+    }
+
+    private suspend fun loadNextChunk() {
+        val pdf = renderer ?: return
+        val start = renderedUpTo + 1
+        if (start >= totalPages) return
+        val end = minOf(start + PAGE_CHUNK, totalPages)
+        val viewWidth = currentViewWidth
+
+        withContext(Dispatchers.Main) { removeLoadingFooter() }
+
+        if (displayMode == "twoupcontinuous") {
+            renderTwoUpRange(pdf, totalPages, viewWidth, start, end)
+            withContext(Dispatchers.Main) {
+                renderedUpTo = if (end % 2 == 0) end - 1 else end - 2
+                if (renderedUpTo < totalPages - 1) showLoadingFooter()
+                forceLayoutScrollView()
+            }
+        } else {
+            for (i in start until end) {
+                val bmp = renderPageBitmap(pdf, i, viewWidth)
+                val idx = i
+                withContext(Dispatchers.Main) {
+                    addPageRow(bmp, idx, pagePdfW.getOrElse(idx) { 1 }.toFloat(),
+                        pagePdfH.getOrElse(idx) { 1 }.toFloat())
+                }
+            }
+            withContext(Dispatchers.Main) {
+                renderedUpTo = end - 1
+                // Sliding window: MAX_RENDERED-с илүү болвол дээд хэсгийг устга
+                val excess = pageEntries.size - MAX_RENDERED
+                if (excess > 0) {
+                    val removed = pruneTopPages(excess)
+                    scrollView.scrollBy(0, -removed)
+                }
+                if (end < totalPages) showLoadingFooter()
+                forceLayoutScrollView()
+            }
+        }
+    }
+
+    /**
+     * Дээд хэсгийн [count] хуудсыг устгаж, bitmap санах ойг чөлөөлнэ.
+     * @return устгагдсан хуудсуудын нийт өндөр (px) — scroll тохируулахад ашиглана
+     */
+    private fun pruneTopPages(count: Int): Int {
+        var removedHeight = 0
+        repeat(count) {
+            val entry = pageEntries.removeFirstOrNull() ?: return@repeat
+            removedHeight += entry.bmpHeight + 12  // +12 нь margin (дээш 6 + доош 6)
+            // Bitmap-г чөлөөлнэ
+            (entry.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+            container.removeView(entry.frame)
+        }
+        windowStart += count
+        return removedHeight
+    }
+
+    /**
+     * Өмнөх [PAGE_CHUNK] хуудсыг дээр нэмж, доод хэсгийг цэвэрлэнэ.
+     */
+    private suspend fun loadPrevChunk() {
+        val pdf = renderer ?: return
+        if (displayMode == "twoupcontinuous") {
+            loadPrevChunkTwoup(pdf)
+            return
+        }
+        val prevStart = maxOf(0, windowStart - PAGE_CHUNK)
+        val prevEnd = windowStart
+        if (prevStart >= prevEnd) return
+        val viewWidth = currentViewWidth
+
+        data class PageBmp(val bmp: Bitmap, val idx: Int, val pdfW: Float, val pdfH: Float)
+        val pages = mutableListOf<PageBmp>()
+        for (i in prevStart until prevEnd) {
+            val bmp = renderPageBitmap(pdf, i, viewWidth)
+            pages.add(PageBmp(bmp, i,
+                pagePdfW.getOrElse(i) { 1 }.toFloat(),
+                pagePdfH.getOrElse(i) { 1 }.toFloat()))
+        }
+
+        withContext(Dispatchers.Main) {
+            var insertedHeight = 0
+            // Reverse order-оор insert хийж эцэст нь зөв дараалал гарна
+            // (бүгд index 0-д insert хийгддэг тул)
+            for (page in pages.reversed()) {
+                prependPageFrame(page.bmp, page.idx, page.pdfW, page.pdfH)
+                insertedHeight += page.bmp.height + 12
+            }
+            windowStart = prevStart
+            renderedUpTo = maxOf(renderedUpTo, windowStart + pageEntries.size - 1)
+
+            // Доод хэсгийг цэвэрлэнэ
+            val excess = pageEntries.size - MAX_RENDERED
+            if (excess > 0) pruneBottomPages(excess)
+
+            // Дээр нэмсэн өндрийг scroll-д нэмж харагдах хэсгийг хэвээр үлдээнэ
+            scrollView.scrollBy(0, insertedHeight)
+            forceLayoutScrollView()
+        }
+    }
+
+    /** twoupcontinuous: өмнөх chunk-ийг хос мөрөөр дээр нэмнэ. */
+    private suspend fun loadPrevChunkTwoup(pdf: PdfRenderer) {
+        val prevStart = maxOf(0, windowStart - PAGE_CHUNK)
+        val prevEnd = windowStart
+        if (prevStart >= prevEnd) return
+        val viewWidth = currentViewWidth
+        val halfW = viewWidth / 2
+
+        data class RowBmps(val leftIdx: Int, val leftBmp: Bitmap, val rightBmp: Bitmap?)
+        val rows = mutableListOf<RowBmps>()
+        var i = prevStart
+        while (i < prevEnd) {
+            val leftBmp = renderPageBitmap(pdf, i, halfW)
+            val rightBmp = if (i + 1 < minOf(prevEnd, totalPages))
+                renderPageBitmap(pdf, i + 1, halfW) else null
+            rows.add(RowBmps(i, leftBmp, rightBmp))
+            i += 2
+        }
+
+        withContext(Dispatchers.Main) {
+            var insertedHeight = 0
+            for (rb in rows.asReversed()) {
+                prependTwoupRowToContainer(
+                    rb.leftBmp, rb.leftIdx,
+                    rb.rightBmp,
+                    if (rb.rightBmp != null) rb.leftIdx + 1 else null,
+                    viewWidth
+                )
+                insertedHeight += rb.leftBmp.height + 12
+            }
+            windowStart = prevStart
+            renderedUpTo = windowStart + pageEntries.size - 1
+
+            while (pageEntries.size > MAX_RENDERED) {
+                pruneBottomTwoupOneRow()
+            }
+
+            scrollView.scrollBy(0, insertedHeight)
+            forceLayoutScrollView()
+        }
+    }
+
+    /** twoup мөрийг container + pageEntries-ийн эхэнд оруулна (дээд chunk). */
+    private fun prependTwoupRowToContainer(
+        leftBmp: Bitmap, li: Int,
+        rightBmp: Bitmap?, ri: Int?,
+        viewWidth: Int
+    ) {
+        val rowH = leftBmp.height
+        val row = LinearLayout(context).apply {
+            orientation = LinearLayout.HORIZONTAL
+            layoutParams = LinearLayout.LayoutParams(viewWidth, rowH)
+                .apply { setMargins(0, 6, 0, 6) }
+        }
+        val (leftFrame, leftEntry) = buildPageFrameDetached(
+            leftBmp, li,
+            pagePdfW.getOrElse(li) { 1 }.toFloat(),
+            pagePdfH.getOrElse(li) { 1 }.toFloat(),
+            1f
+        )
+        row.addView(leftFrame)
+        if (rightBmp != null && ri != null) {
+            val (rightFrame, rightEntry) = buildPageFrameDetached(
+                rightBmp, ri,
+                pagePdfW.getOrElse(ri) { 1 }.toFloat(),
+                pagePdfH.getOrElse(ri) { 1 }.toFloat(),
+                1f
+            )
+            row.addView(rightFrame)
+            pageEntries.add(0, rightEntry)
+            pageEntries.add(0, leftEntry)
+        } else {
+            row.addView(View(context).apply {
+                layoutParams = LinearLayout.LayoutParams(0, rowH, 1f)
+            })
+            pageEntries.add(0, leftEntry)
+        }
+        container.addView(row, 0)
+    }
+
+    /** twoupcontinuous: доод талын нэг мөрийг (эсвэл сүүлийн entry) устгана. */
+    private fun pruneBottomTwoupOneRow() {
+        val last = pageEntries.lastOrNull() ?: return
+        val row = last.frame.parent as? LinearLayout
+        if (row != null && row.parent === container && row.childCount > 0) {
+            val removeList = pageEntries.filter { it.frame.parent === row }
+            for (e in removeList) {
+                (e.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+                pageEntries.remove(e)
+            }
+            container.removeView(row)
+        } else {
+            val e = pageEntries.removeLastOrNull() ?: return
+            (e.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+            container.removeView(e.frame)
+        }
+        renderedUpTo = windowStart + pageEntries.size - 1
+    }
+
+    /**
+     * Дээр (index 0) шинэ хуудас оруулна. windowStart-г дуудагч тал шинэчилнэ.
+     */
+    private fun prependPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float) {
+        val bmpW = bmp.width
+        val bmpH = bmp.height
+        val frame = FrameLayout(context).apply {
+            layoutParams = LinearLayout.LayoutParams(bmpW, bmpH).apply { setMargins(0, 6, 0, 6) }
+        }
+        val iv = ImageView(context).apply {
+            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
+            scaleType = ImageView.ScaleType.FIT_XY
+            setImageBitmap(bmp)
+        }
+        val canvasView = AnnotationCanvasView(context, pageIdx, pdfW, pdfH).apply {
+            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
+            translationZ = 1f
+        }
+        frame.addView(iv)
+        frame.addView(canvasView)
+        container.addView(frame, 0)
+        pageEntries.add(0, PageEntry(frame, canvasView, bmpH))
+    }
+
+    /**
+     * Доод хэсгийн [count] хуудсыг устгаж bitmap санах ойг чөлөөлнэ.
+     * renderedUpTo-г буулгаж дараагийн доош scroll-д re-render хийгдэхийг зөвшөөрнэ.
+     */
+    private fun pruneBottomPages(count: Int) {
+        repeat(count) {
+            val entry = pageEntries.removeLastOrNull() ?: return@repeat
+            (entry.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+            container.removeView(entry.frame)
+        }
+        renderedUpTo = windowStart + pageEntries.size - 1
+    }
+
+    /**
+     * Render хийгдээгүй хуудас руу үсрэх.
+     * Бүх одоогийн view-г цэвэрлэж, targetPage-ийн эргэн тойрны хуудсуудыг render хийнэ.
+     */
+    private fun jumpToPage(targetPage: Int) {
+        val pdf = renderer ?: return
+        val viewWidth = currentViewWidth.takeIf { it > 0 } ?: width.takeIf { it > 0 } ?: return
+        renderJob?.cancel()
+        renderJob = scope.launch {
+            try {
+                // Шинэ window: targetPage-ийн хагас chunk өмнөөс эхэлнэ
+                val newStart = maxOf(0, targetPage - PAGE_CHUNK / 2)
+                val newEnd = minOf(totalPages, newStart + MAX_RENDERED)
+
+                withContext(Dispatchers.Main) {
+                    container.removeAllViews()
+                    pageEntries.clear()
+                    loadingFooter = null
+                    windowStart = newStart
+                    renderedUpTo = newStart - 1
+                    chunkLoading = false
+                }
+
+                if (displayMode == "twoupcontinuous") {
+                    renderTwoUpRange(pdf, totalPages, viewWidth, newStart, newEnd)
+                    withContext(Dispatchers.Main) {
+                        val rawUpTo = if (newEnd % 2 == 0) newEnd - 1 else newEnd - 2
+                        renderedUpTo = rawUpTo.coerceIn(0, totalPages - 1)
+                        if (renderedUpTo < totalPages - 1) showLoadingFooter()
+                        forceLayoutScrollView()
+                        post { scrollToPage(targetPage, smooth = false) }
+                    }
+                } else {
+                    for (i in newStart until newEnd) {
+                        val bmp = renderPageBitmap(pdf, i, viewWidth)
+                        val idx = i
+                        withContext(Dispatchers.Main) {
+                            addPageRow(
+                                bmp, idx,
+                                pagePdfW.getOrElse(idx) { 1 }.toFloat(),
+                                pagePdfH.getOrElse(idx) { 1 }.toFloat()
+                            )
+                        }
+                    }
+                    withContext(Dispatchers.Main) {
+                        renderedUpTo = newEnd - 1
+                        if (newEnd < totalPages) showLoadingFooter()
+                        forceLayoutScrollView()
+                        post { scrollToPage(targetPage, smooth = false) }
+                    }
+                }
+            } catch (e: CancellationException) { throw e }
+            catch (e: Exception) { Log.e("ExpoPdfReader", "JumpToPage error", e) }
+        }
+    }
+
+    /**
+     * React Native Fabric нь child view-н requestLayout()-г таслах тул
+     * addView() дараа layout pass автоматаар ажиллахгүй.
+     * Энэ функц scrollView-г шууд measure + layout хийж pages-г харагдуулна.
+     */
+    private fun forceLayoutScrollView() {
+        val w = width.takeIf { it > 0 } ?: return
+        val h = height.takeIf { it > 0 } ?: return
+        scrollView.measure(
+            MeasureSpec.makeMeasureSpec(w, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(h, MeasureSpec.EXACTLY)
+        )
+        scrollView.layout(0, 0, w, h)
+    }
+
+    private fun showLoadingFooter() {
+        if (loadingFooter != null) return
+        val footer = ProgressBar(context, null, android.R.attr.progressBarStyleSmall).apply {
+            layoutParams = LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT, 120
+            ).apply { setMargins(0, 16, 0, 16) }
+            isIndeterminate = true
+        }
+        container.addView(footer)
+        loadingFooter = footer
+    }
+
+    private fun removeLoadingFooter() {
+        loadingFooter?.let { container.removeView(it) }
+        loadingFooter = null
+    }
+
+    private fun addPageRow(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float) =
+        container.addView(buildPageFrame(bmp, pageIdx, pdfW, pdfH))
+
+    private fun buildPageFrameDetached(
+        bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f
+    ): Pair<FrameLayout, PageEntry> {
+        val bmpW = bmp.width
+        val bmpH = bmp.height
+        val frame = FrameLayout(context).apply {
+            layoutParams = if (weight > 0f)
+                LinearLayout.LayoutParams(0, bmpH, weight)
+            else
+                LinearLayout.LayoutParams(bmpW, bmpH)
+                    .apply { setMargins(0, 6, 0, 6) }
+        }
+        val iv = ImageView(context).apply {
+            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
+            scaleType = ImageView.ScaleType.FIT_XY
+            setImageBitmap(bmp)
+        }
+        val canvasView = AnnotationCanvasView(context, pageIdx, pdfW, pdfH).apply {
+            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
+            translationZ = 1f
+        }
+        frame.addView(iv)
+        frame.addView(canvasView)
+        return frame to PageEntry(frame, canvasView, bmpH)
+    }
+
+    private fun buildPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f): FrameLayout {
+        val (frame, entry) = buildPageFrameDetached(bmp, pageIdx, pdfW, pdfH, weight)
+        pageEntries.add(entry)
+        return frame
+    }
+
+    private suspend fun renderPageBitmap(pdf: PdfRenderer, index: Int, targetWidth: Int): Bitmap =
+        withContext(pdfDispatcher) {
+            pdf.openPage(index).use { page ->
+                if (index < pagePdfW.size) {
+                    pagePdfW[index] = page.width
+                    pagePdfH[index] = page.height
+                }
+                val s = targetWidth.toFloat() / page.width.toFloat()
+                val h = (page.height * s).toInt().coerceAtLeast(1)
+                val bmp = Bitmap.createBitmap(targetWidth, h, Bitmap.Config.ARGB_8888)
+                bmp.eraseColor(Color.WHITE)
+                page.render(bmp, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+                bmp
+            }
+        }
+
+    private fun safeCloseRenderer() {
+        try { renderer?.close(); fileDescriptor?.close() }
+        catch (_: Exception) { }
+        finally {
+            renderer = null
+            fileDescriptor = null
+            lastHostWidthForPdf = 0
+        }
+    }
+
+    private suspend fun resolveFile(url: String): File = withContext(pdfDispatcher) {
+        when {
+            url.startsWith("file://") -> File(url.removePrefix("file://"))
+            url.startsWith("/")       -> File(url)
+            else -> {
+                val f = File.createTempFile("pdf_", ".pdf", context.cacheDir)
+                URL(url).openStream().use { inp -> FileOutputStream(f).use { inp.copyTo(it) } }
+                f
+            }
+        }
+    }
+
+    private fun buildFingerprint(data: List<Map<String, Any?>>): String =
+        data.mapNotNull { item ->
+            val p = (item["page"] as? Number)?.toInt() ?: return@mapNotNull null
+            val t = item["type"] as? String ?: return@mapNotNull null
+            val b = item["bounds"] as? Map<*, *> ?: return@mapNotNull null
+            "$p|$t|${b["x"]},${b["y"]},${b["width"]},${b["height"]}"
+        }.sorted().joinToString("||")
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // SinglePageAdapter  — RecyclerView adapter for "single" display mode
+    //   • vertical PagerSnapHelper — босоо scroll-оор хуудас солих
+    //   • ZoomRecyclerView zoom-г удирдана (adapter энгийн FrameLayout ашиглана)
+    //   • lazy bitmap loading
+    // ─────────────────────────────────────────────────────────────────────────
+
+    inner class SinglePageAdapter : RecyclerView.Adapter<SinglePageAdapter.Holder>() {
+
+        inner class Holder(val frame: FrameLayout, val imageView: ImageView) :
+            RecyclerView.ViewHolder(frame) {
+            var boundPage = -1
+            var loadJob: Job? = null
+            var currentCanvas: AnnotationCanvasView? = null
+        }
+
+        override fun getItemCount(): Int = totalPages
+
+        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): Holder {
+            val frame = FrameLayout(context).apply {
+                layoutParams = RecyclerView.LayoutParams(
+                    RecyclerView.LayoutParams.MATCH_PARENT,
+                    RecyclerView.LayoutParams.MATCH_PARENT
+                )
+                setBackgroundColor(Color.parseColor("#E8E8E8"))
+            }
+            val iv = ImageView(context).apply {
+                layoutParams = FrameLayout.LayoutParams(
+                    FrameLayout.LayoutParams.WRAP_CONTENT,
+                    FrameLayout.LayoutParams.WRAP_CONTENT,
+                    android.view.Gravity.CENTER
+                )
+                scaleType = ImageView.ScaleType.FIT_XY
+            }
+            frame.addView(iv)
+            return Holder(frame, iv)
+        }
+
+        override fun onBindViewHolder(holder: Holder, position: Int) {
+            holder.boundPage = position
+            holder.loadJob?.cancel()
+            holder.imageView.setImageBitmap(null)
+            // Recycle хийгдсэн view-н zoom transform-г цэвэрлэнэ
+            holder.frame.scaleX = 1f; holder.frame.scaleY = 1f
+            holder.frame.translationX = 0f; holder.frame.translationY = 0f
+
+            holder.currentCanvas?.let {
+                singlePageCanvases.remove(it.pageIndex)
+                holder.frame.removeView(it)
+            }
+            holder.currentCanvas = null
+
+            holder.loadJob = scope.launch {
+                val pdf = renderer ?: return@launch
+                val bmp = renderPageBitmap(pdf, position, this@ExpoPdfReaderView.width)
+                val pdfW = pagePdfW.getOrElse(position) { 1 }.toFloat()
+                val pdfH = pagePdfH.getOrElse(position) { 1 }.toFloat()
+                withContext(Dispatchers.Main) {
+                    if (holder.boundPage != position) return@withContext
+                    val canvas = AnnotationCanvasView(context, position, pdfW, pdfH).apply {
+                        layoutParams = FrameLayout.LayoutParams(
+                            bmp.width, bmp.height,
+                            android.view.Gravity.CENTER
+                        )
+                        translationZ = 1f
+                    }
+                    holder.frame.addView(canvas)
+                    holder.currentCanvas = canvas
+                    singlePageCanvases[position] = canvas
+                    val lp = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
+                    holder.imageView.layoutParams = lp
+                    holder.imageView.setImageBitmap(bmp)
+                    val fw = this@ExpoPdfReaderView.width.takeIf { it > 0 } ?: return@withContext
+                    val fh = this@ExpoPdfReaderView.height.takeIf { it > 0 } ?: return@withContext
+                    holder.frame.measure(
+                        MeasureSpec.makeMeasureSpec(fw, MeasureSpec.EXACTLY),
+                        MeasureSpec.makeMeasureSpec(fh, MeasureSpec.EXACTLY)
+                    )
+                    holder.frame.layout(0, 0, fw, fh)
+                }
+            }
+        }
+
+        override fun onViewRecycled(holder: Holder) {
+            holder.loadJob?.cancel()
+            holder.currentCanvas?.let {
+                singlePageCanvases.remove(it.pageIndex)
+                holder.frame.removeView(it)
+            }
+            holder.currentCanvas = null
+            holder.imageView.setImageBitmap(null)
+        }
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // ZoomRecyclerView — single mode-д pinch-to-zoom + pan дэмждэг RecyclerView
+    //
+    // Яагаад RecyclerView subclass хийх шаардлагатай вэ:
+    //   AnnotationCanvasView ACTION_DOWN-д false буцаана → RecyclerView
+    //   gesture-г эзэмшиж авна → дараагийн ACTION_POINTER_DOWN (2-р хуруу)
+    //   шууд RecyclerView.onTouchEvent-д очдог.
+    //   RecyclerView subclass хийснээр onTouchEvent-д multi-touch-г зохицуулна.
+    //
+    // Zoom тооцоо (pivot=0,0 + translation):
+    //   Item view point (px,py) → дэлгэц: (px*scale + tx, py*scale + ty)
+    //   Focus (fx,fy) тогтвортой байхад: new_tx = fx - (fx - tx) * scaleFactor
+    // ─────────────────────────────────────────────────────────────────────────
+
+    inner class ZoomRecyclerView(context: Context) : RecyclerView(context) {
+        private var currentScale = 1f
+        private var tx = 0f
+        private var ty = 0f
+        private var panX = 0f
+        private var panY = 0f
+
+        private val zoomDetector = ScaleGestureDetector(context,
+            object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+                override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+                    if (activeTool != null) return false
+                    stopScroll()
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomRecyclerView, true)
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                    return true
+                }
+
+                override fun onScale(d: ScaleGestureDetector): Boolean {
+                    val newScale = (currentScale * d.scaleFactor).coerceIn(minZoom, maxZoom)
+                    val af = newScale / currentScale
+                    // Focus point тогтвортой байхын zoom-to-point тооцоо
+                    tx = d.focusX - (d.focusX - tx) * af
+                    ty = d.focusY - (d.focusY - ty) * af
+                    currentScale = newScale
+                    clampAndApply()
+                    return true
+                }
+
+                override fun onScaleEnd(detector: ScaleGestureDetector) {
+                    parent?.requestDisallowInterceptTouchEvent(false)
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomRecyclerView, false)
+                }
+            }
+        )
+
+        override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool == null) {
+                zoomDetector.onTouchEvent(ev)
+                if (ev.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+                    stopScroll()
+                }
+                if (ev.pointerCount > 1 || zoomDetector.isInProgress) {
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomRecyclerView, true)
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                }
+                if (ev.actionMasked == MotionEvent.ACTION_UP ||
+                    ev.actionMasked == MotionEvent.ACTION_CANCEL
+                ) {
+                    this@ExpoPdfReaderView.propagateDisallowInterceptFrom(this@ZoomRecyclerView, false)
+                }
+            }
+            return super.dispatchTouchEvent(ev)
+        }
+
+        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool != null) return super.onInterceptTouchEvent(ev)
+            // Pinch үед RecyclerView хэвийн scroll intercept хийхгүй
+            if (ev.pointerCount > 1 || zoomDetector.isInProgress) return false
+            // Zoom хийгдсэн + tool идэвхгүй → pan хийхийн тулд ACTION_DOWN-г intercept
+            if (currentScale > 1.02f && ev.action == MotionEvent.ACTION_DOWN) {
+                return true
+            }
+            return super.onInterceptTouchEvent(ev)
+        }
+
+        override fun onTouchEvent(ev: MotionEvent): Boolean {
+            // zoomDetector-ийг dispatchTouchEvent-д аль хэдийн дамжуулсан
+
+            // 2 хуруу байвал RecyclerView scroll хийхгүйгээр zoom-г л хийнэ
+            if (ev.pointerCount >= 2 || zoomDetector.isInProgress) {
+                return true
+            }
+
+            // Zoom хийгдсэн үед нэг хуруугаар pan (tool идэвхгүй)
+            if (currentScale > 1.02f && activeTool == null) {
+                when (ev.actionMasked) {
+                    MotionEvent.ACTION_DOWN -> {
+                        stopScroll()
+                        panX = ev.x; panY = ev.y
+                    }
+                    MotionEvent.ACTION_MOVE -> {
+                        tx += ev.x - panX
+                        ty += ev.y - panY
+                        panX = ev.x; panY = ev.y
+                        clampAndApply()
+                    }
+                    MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { }
+                }
+                return true
+            }
+
+            return super.onTouchEvent(ev)
+        }
+
+        fun resetZoom() {
+            currentScale = 1f; tx = 0f; ty = 0f
+            applyToCurrentItem()
+        }
+
+        private fun clampAndApply() {
+            val w = width.toFloat(); val h = height.toFloat()
+            if (w > 0f && h > 0f) {
+                val sw = w * currentScale; val sh = h * currentScale
+                tx = if (sw > w) tx.coerceIn(w - sw, 0f) else 0f
+                ty = if (sh > h) ty.coerceIn(h - sh, 0f) else 0f
+            }
+            applyToCurrentItem()
+        }
+
+        private fun applyToCurrentItem() {
+            val lm = layoutManager as? LinearLayoutManager ?: return
+            val pos = lm.findFirstVisibleItemPosition().takeIf { it >= 0 } ?: return
+            val itemView = lm.findViewByPosition(pos) ?: return
+            itemView.pivotX = 0f; itemView.pivotY = 0f
+            itemView.scaleX = currentScale; itemView.scaleY = currentScale
+            itemView.translationX = tx; itemView.translationY = ty
+        }
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // AnnotationCanvasView  (inner class — full access to outer view state)
+    // ─────────────────────────────────────────────────────────────────────────
+
+    inner class AnnotationCanvasView(
+        context: Context,
+        val pageIndex: Int,
+        private val pdfWidth: Float,
+        private val pdfHeight: Float
+    ) : View(context) {
+
+        private var drawTool: String? = null
+        private val drawPoints = mutableListOf<PointF>()   // PDF coords
+        private var drawStart: PointF? = null
+
+        // ── No-tool touch state (tap → event, long-press → drag) ─────────────
+        private var noToolDown = false
+        private var noToolDownScreen = PointF()
+        private var isDragging = false
+        private var dragAnn: PdfAnnotation? = null
+        private var dragOrigBounds = RectF()
+        private val LP_TIMEOUT = android.view.ViewConfiguration.getLongPressTimeout().toLong()
+        private val TOUCH_SLOP by lazy { android.view.ViewConfiguration.get(context).scaledTouchSlop.toFloat() }
+        private val lpHandler = android.os.Handler(android.os.Looper.getMainLooper())
+        private val lpRunnable = Runnable {
+            if (dragAnn?.type != "text" && dragAnn?.type != "note") return@Runnable
+            isDragging = true
+            pager.requestDisallowInterceptTouchEvent(true)
+            scrollView.requestDisallowInterceptTouchEvent(true)
+            invalidate()
+        }
+
+        // Reusable objects — no allocation in onDraw
+        private val inkPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            style = Paint.Style.STROKE; strokeCap = Paint.Cap.ROUND; strokeJoin = Paint.Join.ROUND
+        }
+        private val bgFill = Paint().apply { style = Paint.Style.FILL }
+        private val bgStroke = Paint().apply {
+            style = Paint.Style.STROKE; strokeWidth = 1.5f; color = Color.DKGRAY
+        }
+        private val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
+        private val drawPath = Path()
+
+        // ── Lifecycle ─────────────────────────────────────────────────────────
+
+        override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+            super.onSizeChanged(w, h, oldw, oldh)
+            // Single-mode canvases start with MATCH_PARENT (width=0) and receive their real
+            // size after RecyclerView lays out. Re-draw so initialAnnotations become visible.
+            if (w > 0 && oldw == 0) invalidate()
+        }
+
+        // ── Coordinate helpers ────────────────────────────────────────────────
+
+        private fun scale() = if (width > 0 && pdfWidth > 0) width.toFloat() / pdfWidth else 1f
+
+        /** View-local screen → PDF. */
+        private fun toPdf(sx: Float, sy: Float): PointF {
+            val s = scale(); return PointF(sx / s, pdfHeight - sy / s)
+        }
+
+        /** PDF → view-local screen. */
+        private fun toScreen(px: Float, py: Float): PointF {
+            val s = scale(); return PointF(px * s, (pdfHeight - py) * s)
+        }
+
+        /**
+         * PDF RectF → screen RectF.
+         * bounds.top  = lower PDF y  →  screen bottom
+         * bounds.bottom = upper PDF y →  screen top
+         */
+        private fun toScreenRect(b: RectF): RectF {
+            val s = scale()
+            return RectF(b.left * s, (pdfHeight - b.bottom) * s, b.right * s, (pdfHeight - b.top) * s)
+        }
+
+        // ── Touch ─────────────────────────────────────────────────────────────
+
+        override fun onTouchEvent(event: MotionEvent): Boolean {
+            val tool = activeTool
+            if (tool != null) {
+                // Drawing tool active — consume all events
+                scrollView.requestDisallowInterceptTouchEvent(true)
+                pager.requestDisallowInterceptTouchEvent(true)
+                val pdfPt = toPdf(event.x, event.y)
+                when (tool) {
+                    "eraser" -> {
+                        if (event.action == MotionEvent.ACTION_DOWN || event.action == MotionEvent.ACTION_MOVE)
+                            eraseAt(pdfPt)
+                    }
+                    "text", "note" -> { if (event.action == MotionEvent.ACTION_DOWN) addInstantAnnotation(pdfPt, tool) }
+                    else -> handleDraw(event, pdfPt, tool)
+                }
+                return true
+            }
+            return handleNoToolTouch(event)
+        }
+
+        /**
+         * Touch handling when no drawing tool is active.
+         * - Single tap on text/note → fire onTextPress / onNotePress
+         * - Long press on text/note → drag the annotation
+         * The key issue: returning false on ACTION_DOWN means we never receive ACTION_UP.
+         * So we return true only when we detect a tap/drag target on ACTION_DOWN.
+         */
+        private fun handleNoToolTouch(event: MotionEvent): Boolean {
+            when (event.action) {
+                MotionEvent.ACTION_DOWN -> {
+                    val pdfPt = toPdf(event.x, event.y)
+                    val ann = tapTargetAt(pdfPt) ?: return false
+                    dragAnn = ann
+                    dragOrigBounds = RectF(ann.bounds)
+                    noToolDownScreen = PointF(event.x, event.y)
+                    noToolDown = true
+                    lpHandler.postDelayed(lpRunnable, LP_TIMEOUT)
+                    return true
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    if (!noToolDown) return false
+                    val dx = event.x - noToolDownScreen.x
+                    val dy = event.y - noToolDownScreen.y
+                    if (isDragging) {
+                        val ann = dragAnn ?: return true
+                        val s = scale()
+                        val annW = dragOrigBounds.width()
+                        val annH = dragOrigBounds.height()
+                        // PDF y is inverted: screen down (dy>0) → PDF y decreases
+                        val newLeft   = (dragOrigBounds.left   + dx / s).coerceIn(0f, pdfWidth  - annW)
+                        val newBottom = (dragOrigBounds.bottom - dy / s).coerceIn(annH, pdfHeight)
+                        ann.bounds = RectF(newLeft, newBottom - annH, newLeft + annW, newBottom)
+                        invalidate()
+                        return true
+                    }
+                    // Cancel long-press if finger moved beyond touch slop
+                    if (Math.hypot(dx.toDouble(), dy.toDouble()) > TOUCH_SLOP) {
+                        lpHandler.removeCallbacks(lpRunnable)
+                        noToolDown = false
+                        dragAnn = null
+                        return false
+                    }
+                    return true
+                }
+                MotionEvent.ACTION_UP -> {
+                    lpHandler.removeCallbacks(lpRunnable)
+                    val wasDown = noToolDown
+                    val wasDragging = isDragging
+                    noToolDown = false; isDragging = false
+                    pager.requestDisallowInterceptTouchEvent(false)
+                    scrollView.requestDisallowInterceptTouchEvent(false)
+                    if (!wasDown) { dragAnn = null; return false }
+                    if (wasDragging) {
+                        dragAnn = null
+                        notifyAnnotationChange()
+                    } else {
+                        dragAnn = null
+                        handleTap(event.x, event.y)
+                    }
+                    return true
+                }
+                MotionEvent.ACTION_CANCEL -> {
+                    lpHandler.removeCallbacks(lpRunnable)
+                    if (isDragging) { dragAnn?.bounds = RectF(dragOrigBounds); invalidate() }
+                    noToolDown = false; isDragging = false; dragAnn = null
+                    pager.requestDisallowInterceptTouchEvent(false)
+                    scrollView.requestDisallowInterceptTouchEvent(false)
+                    return false
+                }
+            }
+            return noToolDown
+        }
+
+        /** Returns the first text or note annotation under [pdfPt], or null. */
+        private fun tapTargetAt(pdfPt: PointF): PdfAnnotation? {
+            val pageAnns = annotationMap[pageIndex] ?: return null
+            return pageAnns.firstOrNull { (it.type == "text" || it.type == "note") && it.bounds.contains(pdfPt.x, pdfPt.y) }
+        }
+
+        private fun handleDraw(event: MotionEvent, pdfPt: PointF, tool: String) {
+            when (event.action) {
+                MotionEvent.ACTION_DOWN -> {
+                    drawTool = tool; drawPoints.clear()
+                    drawStart = PointF(pdfPt.x, pdfPt.y); drawPoints.add(PointF(pdfPt.x, pdfPt.y))
+                    invalidate()
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    if (tool == "line") {
+                        drawPoints.clear(); drawStart?.let { drawPoints.add(PointF(it.x, it.y)) }
+                    }
+                    drawPoints.add(PointF(pdfPt.x, pdfPt.y)); invalidate()
+                }
+                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                    if (drawPoints.size >= 2) commitStroke(tool)
+                    drawTool = null; drawPoints.clear(); drawStart = null; invalidate()
+                }
+            }
+        }
+
+        private fun commitStroke(tool: String) {
+            val pad = strokeWidthVal / 2f
+            val ann = PdfAnnotation(
+                type = tool, pageIndex = pageIndex,
+                bounds = RectF(
+                    drawPoints.minOf { it.x } - pad, drawPoints.minOf { it.y } - pad,
+                    drawPoints.maxOf { it.x } + pad, drawPoints.maxOf { it.y } + pad
+                ),
+                color = strokeColorVal, strokeWidth = strokeWidthVal
+            )
+            ann.paths.add(AnnPath(drawPoints.map { PointF(it.x, it.y) }.toMutableList()))
+            addAnnotationAndCommit(ann)
+        }
+
+        private fun eraseAt(pdfPt: PointF) {
+            val pageAnns = annotationMap[pageIndex] ?: return
+            val r = 10f / scale()
+            val hit = RectF(pdfPt.x - r, pdfPt.y - r, pdfPt.x + r, pdfPt.y + r)
+            val toRemove = pageAnns.filter { RectF.intersects(it.bounds, hit) }
+            if (toRemove.isNotEmpty()) {
+                pageAnns.removeAll(toRemove.toSet())
+                toRemove.forEach { ann -> undoStack.removeAll { it.annotation === ann } }
+                invalidate(); notifyAnnotationChange(); notifyUndoRedoState()
+            }
+        }
+
+        private fun addInstantAnnotation(pdfPt: PointF, tool: String) {
+            val s = scale()
+            val ann = if (tool == "note") {
+                PdfAnnotation("note", pageIndex,
+                    RectF(pdfPt.x, pdfPt.y, pdfPt.x + 32f / s, pdfPt.y + 32f / s),
+                    color = noteColorVal, contents = textContentVal.ifBlank { " " })
+            } else {
+                val w = 180f / s; val h = 40f / s
+                PdfAnnotation("text", pageIndex,
+                    RectF(pdfPt.x, pdfPt.y - h, pdfPt.x + w, pdfPt.y),
+                    color = textColorVal, contents = textContentVal.ifBlank { " " },
+                    fontSize = textFontSizeVal, bold = textBoldVal, italic = textItalicVal)
+            }
+            addAnnotationAndCommit(ann)
+        }
+
+        private fun handleTap(screenX: Float, screenY: Float) {
+            val pdfPt = toPdf(screenX, screenY)
+            val pageAnns = annotationMap[pageIndex] ?: return
+
+            pageAnns.filter { it.type == "text" }.forEachIndexed { idx, ann ->
+                if (ann.bounds.contains(pdfPt.x, pdfPt.y)) {
+                    onTextPress(mapOf("page" to pageIndex, "index" to idx,
+                        "bounds" to boundsMap(ann), "contents" to ann.contents)); return
+                }
+            }
+            pageAnns.filter { it.type == "note" }.forEachIndexed { idx, ann ->
+                if (ann.bounds.contains(pdfPt.x, pdfPt.y)) {
+                    onNotePress(mapOf("page" to pageIndex, "index" to idx,
+                        "bounds" to boundsMap(ann), "contents" to ann.contents)); return
+                }
+            }
+        }
+
+        private fun boundsMap(ann: PdfAnnotation) = mapOf(
+            "x" to ann.bounds.left.toDouble(), "y" to ann.bounds.top.toDouble(),
+            "width" to ann.bounds.width().toDouble(), "height" to ann.bounds.height().toDouble()
+        )
+
+        // ── Draw ──────────────────────────────────────────────────────────────
+
+        override fun onDraw(canvas: Canvas) {
+            for (ann in annotationMap[pageIndex] ?: emptyList()) drawAnn(canvas, ann)
+            drawTool?.let { drawActiveStroke(canvas, it) }
+        }
+
+        private fun drawAnn(canvas: Canvas, ann: PdfAnnotation) = when (ann.type) {
+            "pen", "highlighter", "line" -> drawInk(canvas, ann)
+            "text" -> drawTextAnn(canvas, ann)
+            "note" -> drawNoteAnn(canvas, ann)
+            else -> Unit
+        }
+
+        private fun drawInk(canvas: Canvas, ann: PdfAnnotation) {
+            val s = scale(); val base = safeColor(ann.color)
+            inkPaint.strokeWidth = ann.strokeWidth * s
+            inkPaint.color = if (ann.type == "highlighter")
+                Color.argb(102, Color.red(base), Color.green(base), Color.blue(base)) else base
+            for (ap in ann.paths) {
+                if (ap.points.isEmpty()) continue
+                drawPath.reset()
+                ap.points.forEachIndexed { i, pt ->
+                    val sp = toScreen(pt.x, pt.y)
+                    if (i == 0) drawPath.moveTo(sp.x, sp.y) else drawPath.lineTo(sp.x, sp.y)
+                }
+                canvas.drawPath(drawPath, inkPaint)
+            }
+        }
+
+        private fun drawTextAnn(canvas: Canvas, ann: PdfAnnotation) {
+            val text = ann.contents.trim().ifEmpty { return }
+            val rect = toScreenRect(ann.bounds)
+            val s = scale()
+            textPaint.textSize = ann.fontSize * s
+            textPaint.color = safeColor(ann.color)
+            textPaint.typeface = when {
+                ann.bold && ann.italic -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC)
+                ann.bold               -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
+                ann.italic             -> Typeface.create(Typeface.DEFAULT, Typeface.ITALIC)
+                else                   -> Typeface.DEFAULT
+            }
+            // No background — fully transparent
+            val maxW = (rect.width() - 8f).toInt().coerceAtLeast(1)
+            canvas.save()
+            canvas.translate(rect.left + 4f, rect.top + 4f)
+            StaticLayout.Builder.obtain(text, 0, text.length, textPaint, maxW)
+                .setAlignment(Layout.Alignment.ALIGN_NORMAL).build().draw(canvas)
+            canvas.restore()
+        }
+
+        private fun drawNoteAnn(canvas: Canvas, ann: PdfAnnotation) {
+            val rect = toScreenRect(ann.bounds)
+            bgFill.color = try { Color.parseColor(ann.color) } catch (_: Exception) { Color.YELLOW }
+            canvas.drawRect(rect, bgFill); canvas.drawRect(rect, bgStroke)
+            textPaint.textSize = rect.height() * 0.55f; textPaint.color = Color.DKGRAY
+            textPaint.textAlign = Paint.Align.CENTER; textPaint.typeface = Typeface.DEFAULT
+            canvas.drawText("✎", rect.centerX(), rect.centerY() + textPaint.textSize * 0.35f, textPaint)
+            textPaint.textAlign = Paint.Align.LEFT
+        }
+
+        private fun drawActiveStroke(canvas: Canvas, tool: String) {
+            if (drawPoints.isEmpty()) return
+            val s = scale(); val base = safeColor(strokeColorVal)
+            inkPaint.strokeWidth = strokeWidthVal * s
+            inkPaint.color = if (tool == "highlighter")
+                Color.argb(102, Color.red(base), Color.green(base), Color.blue(base)) else base
+            drawPath.reset()
+            drawPoints.forEachIndexed { i, pt ->
+                val sp = toScreen(pt.x, pt.y)
+                if (i == 0) drawPath.moveTo(sp.x, sp.y) else drawPath.lineTo(sp.x, sp.y)
+            }
+            canvas.drawPath(drawPath, inkPaint)
+        }
+
+        private fun safeColor(hex: String): Int =
+            try { Color.parseColor(hex) } catch (_: Exception) { Color.RED }
+    }
+}