@june24/expo-pdf-reader 0.1.23 → 0.1.25

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

@@ -1,1046 +1,1555 @@
-package expo.modules.pdfreader
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.Paint
-import android.graphics.Path
-import android.graphics.PointF
-import android.graphics.RectF
-import android.graphics.Typeface
-import android.graphics.drawable.BitmapDrawable
-import android.graphics.pdf.PdfRenderer
-import android.os.ParcelFileDescriptor
-import android.view.MotionEvent
-import android.view.View
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import android.widget.ImageView
-import android.widget.LinearLayout
-import android.widget.ScrollView
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.views.ExpoView
-import expo.modules.kotlin.viewevent.ViewEvent
-import java.io.File
-import java.net.URL
-import kotlinx.coroutines.*
-
-/** Annotation type string matching iOS. */
-enum class AnnotationTool { PEN, HIGHLIGHTER, TEXT, NOTE, ERASER, LINE }
-
-/** Single annotation (pen/highlighter/line/text/note). */
-data class Annotation(
-    val type: String,
-    val bounds: RectF,
-    var color: Int,
-    var strokeWidth: Float,
-    val paths: MutableList<MutableList<PointF>>,
-    var contents: String,
-    var fontSize: Float,
-    var bold: Boolean,
-    var italic: Boolean
-)
-
-/** Undo/redo entry. */
-data class UndoEntry(val annotation: Annotation, val pageIndex: Int)
-
-/** ScrollView that respects currentTool: scroll only when no tool selected. */
-@SuppressLint("ViewConstructor")
-private class ToolAwareScrollView(
-    context: Context,
-    private val isScrollEnabledProvider: () -> Boolean
-) : ScrollView(context) {
-    override fun onTouchEvent(ev: MotionEvent): Boolean {
-        if (!isScrollEnabledProvider()) return false
-        return super.onTouchEvent(ev)
-    }
-
-    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-        if (!isScrollEnabledProvider()) return false
-        return super.onInterceptTouchEvent(ev)
-    }
-}
-
-/** Android PDF viewer with full annotation support matching iOS. */
-@SuppressLint("ViewConstructor")
-class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
-
-    private val scrollView = ToolAwareScrollView(context) { currentTool == null }
-    private val container = LinearLayout(context).apply {
-        orientation = LinearLayout.VERTICAL
-    }
-
-    private var pdfRenderer: PdfRenderer? = null
-    private var fileDescriptor: ParcelFileDescriptor? = null
-    private val scope = CoroutineScope(Dispatchers.Main + Job())
-
-    private var initialPage = 0
-    private var pdfUrl: String? = null
-    private var renderPdfRetryCount = 0
-    private val maxRenderPdfRetries = 30
-    private var displayMode = "continuous"
-
-    private val onPageChange = ViewEvent<Map<String, Any>>("onPageChange", this, null)
-    private val onAnnotationChange = ViewEvent<Map<String, Any>>("onAnnotationChange", this, null)
-    private val onUndoRedoStateChange = ViewEvent<Map<String, Any>>("onUndoRedoStateChange", this, null)
-    private val onNotePress = ViewEvent<Map<String, Any>>("onNotePress", this, null)
-    private val onTextPress = ViewEvent<Map<String, Any>>("onTextPress", this, null)
-
-    private var pageHeights = mutableListOf<Int>()
-    private var rowHeights = mutableListOf<Int>()
-    private var pageWidthsPdf = mutableListOf<Float>()
-    private var pageHeightsPdf = mutableListOf<Float>()
-    private var pageViews = mutableListOf<ImageView?>()
-    private var overlayViews = mutableListOf<AnnotationOverlayView?>()
-    private var lastEmittedPageIndex = -1
-    private var totalPageCount = 0
-
-    private val renderWindowBefore = 20
-    private val renderWindowAfter = 25
-
-    // Annotation state
-    private val pageAnnotations = mutableListOf<MutableList<Annotation>>()
-    private var currentTool: AnnotationTool? = null
-    private var strokeColor = Color.RED
-    private var strokeWidth = 2f
-    private var textContent = ""
-    private var textColor = Color.BLACK
-    private var textFontSize = 14f
-    private var textBold = false
-    private var textItalic = false
-    private var noteColor = Color.YELLOW
-
-    private var currentPath: Path? = null
-    private val currentPathPoints = mutableListOf<PointF>()
-    private var activePageIndex = -1
-    private var startPoint: PointF? = null
-    private var draggingAnnotation: Annotation? = null
-    private var draggingPageIndex = -1
-    private var dragStartBounds: RectF? = null
-    private var dragStartTouch: PointF? = null
-
-    private val undoStack = mutableListOf<UndoEntry>()
-    private val redoStack = mutableListOf<UndoEntry>()
-    private var appliedAnnotationsFingerprint: String? = null
-    private var pendingAnnotations: List<Map<String, Any>>? = null
-    private var renderJob: Job? = null
-
-    inner class AnnotationOverlayView(
-        context: Context,
-        val pageIndex: Int
-    ) : View(context) {
-
-        private val pathPaint = Paint().apply {
-            isAntiAlias = true
-            style = Paint.Style.STROKE
-            strokeJoin = Paint.Join.ROUND
-            strokeCap = Paint.Cap.ROUND
-        }
-        private val textPaint = Paint().apply {
-            isAntiAlias = true
-            textAlign = Paint.Align.LEFT
-        }
-        private val noteFillPaint = Paint().apply {
-            style = Paint.Style.FILL
-            isAntiAlias = true
-        }
-        private val noteStrokePaint = Paint().apply {
-            style = Paint.Style.STROKE
-            isAntiAlias = true
-            strokeWidth = 1f
-        }
-
-        fun scale(): Float {
-            val pw = pageWidthsPdf.getOrNull(pageIndex) ?: 1f
-            if (pw <= 0f) return 1f
-            return width / pw
-        }
-
-        override fun onDraw(canvas: Canvas) {
-            super.onDraw(canvas)
-            val s = scale()
-            if (s <= 0f) return
-
-            for (ann in getAnnotationsForPage(pageIndex)) {
-                val left = ann.bounds.left * s
-                val top = ann.bounds.top * s
-                val right = ann.bounds.right * s
-                val bottom = ann.bounds.bottom * s
-                when (ann.type) {
-                    "pen", "highlighter", "line" -> {
-                        pathPaint.color = ann.color
-                        pathPaint.strokeWidth = ann.strokeWidth * s
-                        pathPaint.alpha = if (ann.type == "highlighter") 102 else 255
-                        for (pathPoints in ann.paths) {
-                            if (pathPoints.size < 2) continue
-                            val path = Path()
-                            path.moveTo(pathPoints[0].x * s, pathPoints[0].y * s)
-                            for (i in 1 until pathPoints.size) {
-                                path.lineTo(pathPoints[i].x * s, pathPoints[i].y * s)
-                            }
-                            canvas.drawPath(path, pathPaint)
-                        }
-                    }
-                    "text" -> {
-                        textPaint.color = ann.color
-                        textPaint.textSize = ann.fontSize * s
-                        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
-                        }
-                        val text = ann.contents.ifEmpty { " " }
-                        canvas.drawText(text, left + 4f, top + ann.fontSize * s - 2f, textPaint)
-                    }
-                    "note" -> {
-                        noteFillPaint.color = ann.color
-                        noteStrokePaint.color = Color.BLACK
-                        canvas.drawRect(left, top, right, bottom, noteFillPaint)
-                        canvas.drawRect(left, top, right, bottom, noteStrokePaint)
-                        textPaint.color = Color.BLACK
-                        textPaint.textSize = 10f * s
-                        textPaint.typeface = Typeface.DEFAULT
-                        val text = ann.contents.ifEmpty { " " }
-                        canvas.drawText(text, left + 4f, top + 12f * s, textPaint)
-                    }
-                }
-            }
-
-            // Preview path for current stroke
-            if (activePageIndex == pageIndex && currentPath != null && currentPathPoints.isNotEmpty()) {
-                pathPaint.color = strokeColor
-                pathPaint.strokeWidth = strokeWidth * s
-                pathPaint.alpha = if (currentTool == AnnotationTool.HIGHLIGHTER) 102 else 255
-                val path = Path()
-                path.moveTo(currentPathPoints[0].x * s, currentPathPoints[0].y * s)
-                for (i in 1 until currentPathPoints.size) {
-                    path.lineTo(currentPathPoints[i].x * s, currentPathPoints[i].y * s)
-                }
-                canvas.drawPath(path, pathPaint)
-            }
-        }
-
-        @SuppressLint("ClickableViewAccessibility")
-        override fun onTouchEvent(event: MotionEvent): Boolean {
-            val s = scale()
-            if (s <= 0f) return false
-            val pdfX = event.x / s
-            val pdfY = event.y / s
-
-            if (currentTool != null) {
-                return handleToolTouch(event, pdfX, pdfY, s)
-            }
-            return handleTapAndDrag(event, pdfX, pdfY, s)
-        }
-
-        private fun handleToolTouch(event: MotionEvent, pdfX: Float, pdfY: Float, scale: Float): Boolean {
-            when (event.actionMasked) {
-                MotionEvent.ACTION_DOWN -> {
-                    val tool = currentTool ?: return false
-                    activePageIndex = pageIndex
-                    startPoint = PointF(pdfX, pdfY)
-                    when (tool) {
-                        AnnotationTool.PEN, AnnotationTool.HIGHLIGHTER, AnnotationTool.LINE -> {
-                            currentPath = Path()
-                            currentPathPoints.clear()
-                            currentPathPoints.add(PointF(pdfX, pdfY))
-                            currentPath?.moveTo(pdfX, pdfY)
-                        }
-                        AnnotationTool.TEXT, AnnotationTool.NOTE -> {
-                            addInstantAnnotation(pageIndex, pdfX, pdfY, tool)
-                        }
-                        AnnotationTool.ERASER -> {
-                            eraseAt(pageIndex, pdfX, pdfY)
-                        }
-                    }
-                    invalidate()
-                    return true
-                }
-                MotionEvent.ACTION_MOVE -> {
-                    val tool = currentTool ?: return true
-                    when (tool) {
-                        AnnotationTool.PEN, AnnotationTool.HIGHLIGHTER -> {
-                            currentPathPoints.add(PointF(pdfX, pdfY))
-                            currentPath?.lineTo(pdfX, pdfY)
-                        }
-                        AnnotationTool.LINE -> {
-                            val start = startPoint ?: return true
-                            currentPathPoints.clear()
-                            currentPathPoints.add(PointF(start.x, start.y))
-                            currentPathPoints.add(PointF(pdfX, pdfY))
-                            currentPath?.reset()
-                            currentPath?.moveTo(start.x, start.y)
-                            currentPath?.lineTo(pdfX, pdfY)
-                        }
-                        AnnotationTool.ERASER -> eraseAt(pageIndex, pdfX, pdfY)
-                        else -> {}
-                    }
-                    invalidate()
-                    return true
-                }
-                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
-                    when (currentTool) {
-                        AnnotationTool.PEN, AnnotationTool.HIGHLIGHTER, AnnotationTool.LINE -> {
-                            if (currentPathPoints.size >= 2) {
-                                commitStroke(currentTool!!)
-                            }
-                            currentPath = null
-                            currentPathPoints.clear()
-                        }
-                        else -> {}
-                    }
-                    activePageIndex = -1
-                    startPoint = null
-                    invalidate()
-                    return true
-                }
-            }
-            return false
-        }
-
-        private fun handleTapAndDrag(event: MotionEvent, pdfX: Float, pdfY: Float, scale: Float): Boolean {
-            when (event.actionMasked) {
-                MotionEvent.ACTION_DOWN -> {
-                    val list = getAnnotationsForPage(pageIndex)
-                    for (i in list.indices.reversed()) {
-                        val ann = list[i]
-                        if (!ann.bounds.contains(pdfX, pdfY)) continue
-                        if (ann.type == "text") {
-                            onTextPress(mapOf(
-                                "page" to pageIndex,
-                                "index" to i,
-                                "bounds" to mapOf(
-                                    "x" to ann.bounds.left,
-                                    "y" to ann.bounds.top,
-                                    "width" to ann.bounds.width(),
-                                    "height" to ann.bounds.height()
-                                ),
-                                "contents" to (ann.contents.ifEmpty { " " })
-                            ))
-                            return true
-                        }
-                        if (ann.type == "note") {
-                            onNotePress(mapOf(
-                                "page" to pageIndex,
-                                "index" to i,
-                                "bounds" to mapOf(
-                                    "x" to ann.bounds.left,
-                                    "y" to ann.bounds.top,
-                                    "width" to ann.bounds.width(),
-                                    "height" to ann.bounds.height()
-                                ),
-                                "contents" to (ann.contents.ifEmpty { " " })
-                            ))
-                            return true
-                        }
-                        draggingAnnotation = ann
-                        draggingPageIndex = pageIndex
-                        dragStartBounds = RectF(ann.bounds)
-                        dragStartTouch = PointF(pdfX, pdfY)
-                        return true
-                    }
-                    return false
-                }
-                MotionEvent.ACTION_MOVE -> {
-                    val ann = draggingAnnotation ?: return false
-                    val start = dragStartTouch ?: return true
-                    val startB = dragStartBounds ?: return true
-                    val dx = pdfX - start.x
-                    val dy = pdfY - start.y
-                    ann.bounds.set(
-                        startB.left + dx,
-                        startB.top + dy,
-                        startB.right + dx,
-                        startB.bottom + dy
-                    )
-                    invalidate()
-                    return true
-                }
-                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
-                    if (draggingAnnotation != null) {
-                        notifyAnnotationChange()
-                        notifyUndoRedoStateChange()
-                    }
-                    draggingAnnotation = null
-                    draggingPageIndex = -1
-                    dragStartBounds = null
-                    dragStartTouch = null
-                    return false
-                }
-            }
-            return false
-        }
-    }
-
-    init {
-        setBackgroundColor(Color.WHITE)
-        scrollView.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
-        scrollView.isFillViewport = true
-        container.layoutParams = LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
-        scrollView.addView(container)
-        addView(scrollView)
-        scrollView.viewTreeObserver.addOnScrollChangedListener {
-            notifyPageChange()
-            scrollView.post { updateVisiblePages() }
-        }
-        viewTreeObserver.addOnGlobalLayoutListener {
-            if (width <= 0) {
-                if (pdfUrl != null && pdfRenderer == null) {
-                    loadPdfFromUrl(pdfUrl!!)
-                } else if (pdfRenderer != null && renderPdfRetryCount < maxRenderPdfRetries) {
-                    renderPdfRetryCount++
-                    postDelayed({ renderPdf() }, 50)
-                }
-                return@addOnGlobalLayoutListener
-            }
-            renderPdfRetryCount = 0
-            if (pdfUrl != null && pdfRenderer == null) {
-                loadPdfFromUrl(pdfUrl!!)
-            } else if (pdfRenderer != null) {
-                renderPdf()
-            }
-        }
-    }
-
-    override fun onSizeChanged(w: Int, h: Int, oldW: Int, oldH: Int) {
-        super.onSizeChanged(w, h, oldW, oldH)
-        if (w > 0 && pdfRenderer != null && pageHeights.isEmpty()) {
-            renderPdf()
-        }
-    }
-
-    fun setUrl(url: String?) {
-        val u = url?.takeIf { it.isNotBlank() } ?: return
-        if (pdfUrl == u && pdfRenderer != null) return
-        pdfUrl = u
-        loadPdfFromUrl(u)
-    }
-
-    fun setDisplayMode(mode: String) {
-        if (displayMode == mode) return
-        displayMode = mode
-        pageHeights.clear()
-        pdfRenderer?.let { renderPdf() }
-    }
-
-    fun setInitialPage(page: Int) {
-        initialPage = page.coerceIn(0, (totalPageCount - 1).coerceAtLeast(0))
-        scrollToPage(initialPage)
-    }
-
-    fun setTool(tool: String?) {
-        currentTool = tool?.let { runCatching { AnnotationTool.valueOf(it.uppercase()) }.getOrNull() }
-        // ToolAwareScrollView uses isScrollEnabledProvider { currentTool == null } — no property to set
-    }
-
-    fun setStrokeColor(hex: String) {
-        strokeColor = parseHexColor(hex)
-    }
-
-    fun setStrokeWidth(width: Float) {
-        strokeWidth = width
-    }
-
-    fun setTextContent(text: String) {
-        textContent = text
-    }
-
-    fun setTextColor(hex: String) {
-        textColor = parseHexColor(hex)
-    }
-
-    fun setTextFontSize(size: Float) {
-        textFontSize = size
-    }
-
-    fun setTextBold(value: Boolean) {
-        textBold = value
-    }
-
-    fun setTextItalic(value: Boolean) {
-        textItalic = value
-    }
-
-    fun setNoteColor(hex: String) {
-        noteColor = parseHexColor(hex)
-    }
-
-    fun setInitialAnnotations(annotations: List<Map<String, Any>>) {
-        if (pdfRenderer == null) {
-            pendingAnnotations = annotations
-            return
-        }
-        val fp = fingerprintAnnotations(annotations)
-        if (appliedAnnotationsFingerprint == fp) return
-        appliedAnnotationsFingerprint = fp
-        pageAnnotations.clear()
-        while (pageAnnotations.size < totalPageCount) {
-            pageAnnotations.add(mutableListOf())
-        }
-        for (data in annotations) {
-            val pageIndex = (data["page"] as? Number)?.toInt() ?: continue
-            val typeStr = data["type"] as? String ?: continue
-            val b = data["bounds"] as? Map<*, *> ?: continue
-            val x = (b["x"] as? Number)?.toFloat() ?: 0f
-            val y = (b["y"] as? Number)?.toFloat() ?: 0f
-            val w = (b["width"] as? Number)?.toFloat() ?: 0f
-            val h = (b["height"] as? Number)?.toFloat() ?: 0f
-            val bounds = RectF(x, y, x + w, y + h)
-            val color = (data["color"] as? String)?.let { parseHexColor(it) } ?: Color.BLACK
-            val strokeW = (data["strokeWidth"] as? Number)?.toFloat() ?: 2f
-            val paths = mutableListOf<MutableList<PointF>>()
-            @Suppress("UNCHECKED_CAST")
-            (data["paths"] as? List<*>)?.forEach { pathData ->
-                val points = mutableListOf<PointF>()
-                (pathData as? List<*>)?.forEach { pt ->
-                    val m = pt as? Map<*, *> ?: return@forEach
-                    val px = (m["x"] as? Number)?.toFloat() ?: 0f
-                    val py = (m["y"] as? Number)?.toFloat() ?: 0f
-                    points.add(PointF(px, py))
-                }
-                if (points.isNotEmpty()) paths.add(points)
-            }
-            val contents = data["contents"] as? String ?: ""
-            val fontSize = (data["fontSize"] as? Number)?.toFloat() ?: 14f
-            val bold = data["bold"] as? Boolean ?: false
-            val italic = data["italic"] as? Boolean ?: false
-            val ann = Annotation(typeStr, bounds, color, strokeW, paths, contents, fontSize, bold, italic)
-            if (pageIndex in 0 until pageAnnotations.size) {
-                pageAnnotations[pageIndex].add(ann)
-            }
-        }
-        overlayViews.forEach { it?.invalidate() }
-        notifyAnnotationChange()
-    }
-
-    fun undo() {
-        val entry = undoStack.removeLastOrNull() ?: return
-        redoStack.add(entry)
-        val list = pageAnnotations.getOrNull(entry.pageIndex) ?: return
-        list.remove(entry.annotation)
-        overlayViews.getOrNull(entry.pageIndex)?.invalidate()
-        notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
-    fun redo() {
-        val entry = redoStack.removeLastOrNull() ?: return
-        undoStack.add(entry)
-        while (pageAnnotations.size <= entry.pageIndex) {
-            pageAnnotations.add(mutableListOf())
-        }
-        pageAnnotations[entry.pageIndex].add(entry.annotation)
-        overlayViews.getOrNull(entry.pageIndex)?.invalidate()
-        notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
-    fun updateNote(page: Int, index: Int, contents: String) {
-        val list = pageAnnotations.getOrNull(page) ?: return
-        if (index !in list.indices) return
-        list[index].contents = contents.ifEmpty { " " }
-        overlayViews.getOrNull(page)?.invalidate()
-        notifyAnnotationChange()
-    }
-
-    fun updateText(page: Int, index: Int, contents: String) {
-        val list = pageAnnotations.getOrNull(page) ?: return
-        if (index !in list.indices) return
-        list[index].contents = contents.ifEmpty { " " }
-        overlayViews.getOrNull(page)?.invalidate()
-        notifyAnnotationChange()
-    }
-
-    private fun isTwoUpMode(): Boolean = displayMode == "twoUp" || displayMode == "twoUpContinuous"
-
-    private fun marginBetweenPages(): Int = if (displayMode == "single") 0 else 16
-
-    private fun getFrameForPage(pageIndex: Int): FrameLayout? {
-        if (pageIndex !in pageHeights.indices) return null
-        return if (isTwoUpMode()) {
-            val row = pageIndex / 2
-            val col = pageIndex % 2
-            if (row >= container.childCount) null
-            else (container.getChildAt(row) as? LinearLayout)?.getChildAt(col) as? FrameLayout
-        } else {
-            container.getChildAt(pageIndex) as? FrameLayout
-        }
-    }
-
-    private fun scrollToPage(pageIndex: Int) {
-        if (pageHeights.isEmpty()) return
-        val idx = pageIndex.coerceIn(0, pageHeights.size - 1)
-        val gap = marginBetweenPages()
-        val offset = if (isTwoUpMode() && rowHeights.isNotEmpty()) {
-            var sum = 0
-            for (r in 0 until idx / 2) {
-                sum += rowHeights[r] + gap
-            }
-            sum
-        } else {
-            var sum = 0
-            for (i in 0 until idx) {
-                sum += pageHeights[i] + gap
-            }
-            sum
-        }
-        scrollView.post { scrollView.smoothScrollTo(0, offset) }
-    }
-
-    private fun loadPdfFromUrl(url: String) {
-        scope.launch {
-            try {
-                resetRenderer()
-                val decodedUrl = runCatching { java.net.URLDecoder.decode(url, "UTF-8") }.getOrElse { url }
-                val file = withContext(Dispatchers.IO) {
-                    when {
-                        decodedUrl.startsWith("file://") -> File(decodedUrl.removePrefix("file://"))
-                        decodedUrl.startsWith("/") -> File(decodedUrl)
-                        else -> downloadFile(decodedUrl)
-                    }
-                }
-                if (file.exists()) {
-                    fileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
-                    pdfRenderer = PdfRenderer(fileDescriptor!!)
-                    totalPageCount = pdfRenderer!!.pageCount
-                    renderPdf()
-                    post {
-                        requestLayout()
-                        postDelayed({ renderPdf() }, 100)
-                    }
-                    pendingAnnotations?.let { ann ->
-                        pendingAnnotations = null
-                        setInitialAnnotations(ann)
-                    }
-                }
-            } catch (e: Exception) {
-                android.util.Log.e("ExpoPdfReader", "Error loading PDF", e)
-            }
-        }
-    }
-
-    private fun resetRenderer() {
-        pdfRenderer?.close()
-        pdfRenderer = null
-        fileDescriptor?.close()
-        fileDescriptor = null
-        pageHeights.clear()
-        rowHeights.clear()
-        pageWidthsPdf.clear()
-        pageHeightsPdf.clear()
-        pageViews.clear()
-        overlayViews.clear()
-        container.removeAllViews()
-        pageAnnotations.clear()
-        undoStack.clear()
-        redoStack.clear()
-        appliedAnnotationsFingerprint = null
-        pendingAnnotations = null
-        currentPath = null
-        currentPathPoints.clear()
-        activePageIndex = -1
-        startPoint = null
-        draggingAnnotation = null
-        draggingPageIndex = -1
-        dragStartBounds = null
-        dragStartTouch = null
-    }
-
-    private fun renderPdf() {
-        val renderer = pdfRenderer ?: return
-        if (width <= 0) {
-            if (renderPdfRetryCount < maxRenderPdfRetries) {
-                renderPdfRetryCount++
-                requestLayout()
-                postDelayed({ renderPdf() }, 50)
-            }
-            return
-        }
-        renderPdfRetryCount = 0
-        if (pageHeights.isNotEmpty()) {
-            updateVisiblePages()
-            return
-        }
-        val viewWidth = width.coerceAtLeast(1)
-        val viewHeight = height.coerceAtLeast(1)
-        val isTwoUp = displayMode == "twoUp" || displayMode == "twoUpContinuous"
-        val isSingle = displayMode == "single"
-        val effectiveWidth = if (isTwoUp) viewWidth / 2 else viewWidth
-        scope.launch {
-            val w = effectiveWidth
-            val minSlotHeight = if (isSingle) viewHeight else 0
-            val result = withContext(Dispatchers.Default) {
-                (0 until renderer.pageCount).map { i ->
-                    val page = renderer.openPage(i)
-                    try {
-                        val naturalH = (w.toFloat() * page.height / page.width).toInt()
-                        val pageH = if (isSingle) maxOf(naturalH, minSlotHeight) else naturalH
-                        Triple(
-                            i,
-                            pageH,
-                            Pair(page.width.toFloat(), page.height.toFloat())
-                        )
-                    } finally {
-                        try {
-                            page.close()
-                        } catch (e: Exception) {
-                            // Renderer may have been closed on main thread (e.g. resetRenderer)
-                        }
-                    }
-                }
-            }
-            if (!isActive) return@launch
-            withContext(Dispatchers.Main) {
-                if (pdfRenderer != null) {
-                    pageHeights.clear()
-                    rowHeights.clear()
-                    pageWidthsPdf.clear()
-                    pageHeightsPdf.clear()
-                    for ((_, h, pdfSize) in result) {
-                        pageHeights.add(h)
-                        pageWidthsPdf.add(pdfSize.first)
-                        pageHeightsPdf.add(pdfSize.second)
-                    }
-                    if (isTwoUp) {
-                        val rowCount = (renderer.pageCount + 1) / 2
-                        for (r in 0 until rowCount) {
-                            val h0 = pageHeights.getOrElse(2 * r) { 0 }
-                            val h1 = pageHeights.getOrElse(2 * r + 1) { 0 }
-                            rowHeights.add(maxOf(h0, h1))
-                        }
-                    }
-                    ensurePlaceholders(renderer)
-                    scrollToPage(initialPage.coerceIn(0, (renderer.pageCount - 1).coerceAtLeast(0)))
-                    updateVisiblePages()
-                }
-            }
-        }
-    }
-
-    private fun ensurePlaceholders(renderer: PdfRenderer) {
-        container.removeAllViews()
-        val pageCount = renderer.pageCount
-        val marginBetween = marginBetweenPages()
-        pageViews = MutableList(pageCount) { null }
-        overlayViews = MutableList(pageCount) { null }
-        while (pageAnnotations.size < pageCount) {
-            pageAnnotations.add(mutableListOf())
-        }
-        if (isTwoUpMode() && rowHeights.isNotEmpty()) {
-            val rowCount = rowHeights.size
-            for (r in 0 until rowCount) {
-                val rowLayout = LinearLayout(context).apply {
-                    orientation = LinearLayout.HORIZONTAL
-                    layoutParams = LinearLayout.LayoutParams(
-                        LinearLayout.LayoutParams.MATCH_PARENT,
-                        rowHeights[r]
-                    ).apply { setMargins(0, 0, 0, marginBetween) }
-                }
-                for (col in 0..1) {
-                    val i = 2 * r + col
-                    if (i >= pageCount) break
-                    val frame = FrameLayout(context).apply {
-                        layoutParams = LinearLayout.LayoutParams(
-                            0,
-                            LinearLayout.LayoutParams.MATCH_PARENT,
-                            1f
-                        ).apply { setMargins(0, 0, if (col == 0) 8 else 0, 0) }
-                        setBackgroundColor(Color.LTGRAY)
-                    }
-                    val overlay = AnnotationOverlayView(context, i).apply {
-                        layoutParams = FrameLayout.LayoutParams(
-                            FrameLayout.LayoutParams.MATCH_PARENT,
-                            FrameLayout.LayoutParams.MATCH_PARENT
-                        )
-                    }
-                    frame.addView(overlay)
-                    rowLayout.addView(frame)
-                    overlayViews[i] = overlay
-                }
-                container.addView(rowLayout)
-            }
-        } else {
-            for (i in 0 until pageCount) {
-                val frame = FrameLayout(context).apply {
-                    layoutParams = LinearLayout.LayoutParams(
-                        LinearLayout.LayoutParams.MATCH_PARENT,
-                        pageHeights[i]
-                    ).apply { setMargins(0, 0, 0, marginBetween) }
-                    setBackgroundColor(Color.LTGRAY)
-                }
-                val overlay = AnnotationOverlayView(context, i).apply {
-                    layoutParams = FrameLayout.LayoutParams(
-                        FrameLayout.LayoutParams.MATCH_PARENT,
-                        FrameLayout.LayoutParams.MATCH_PARENT
-                    )
-                }
-                frame.addView(overlay)
-                container.addView(frame)
-                overlayViews[i] = overlay
-            }
-        }
-    }
-
-    private fun currentPageFromScroll(): Int {
-        if (pageHeights.isEmpty()) return 0
-        val scrollY = scrollView.scrollY
-        val gap = marginBetweenPages()
-        if (isTwoUpMode() && rowHeights.isNotEmpty()) {
-            var offset = 0
-            for (r in rowHeights.indices) {
-                val rowH = rowHeights[r]
-                if (scrollY < offset + rowH / 2) return (2 * r).coerceAtMost(pageHeights.size - 1)
-                if (scrollY < offset + rowH) return (2 * r + 1).coerceAtMost(pageHeights.size - 1)
-                offset += rowH + gap
-            }
-            return (pageHeights.size - 1).coerceAtLeast(0)
-        }
-        val viewportCenter = scrollY + scrollView.height / 2
-        var offset = 0
-        for (i in pageHeights.indices) {
-            val pageEnd = offset + pageHeights[i]
-            if (viewportCenter < pageEnd) return i
-            offset = pageEnd + gap
-        }
-        return (pageHeights.size - 1).coerceAtLeast(0)
-    }
-
-    private fun updateVisiblePages() {
-        val renderer = pdfRenderer ?: return
-        val currentPage = currentPageFromScroll()
-        val (from, to) = if (displayMode == "single") {
-            currentPage to currentPage
-        } else {
-            (currentPage - renderWindowBefore).coerceAtLeast(0) to
-                (currentPage + renderWindowAfter).coerceAtMost(renderer.pageCount - 1)
-        }
-
-        for (i in pageViews.indices) {
-            if (i in from..to) continue
-            val iv = pageViews.getOrNull(i) ?: continue
-            val frame = getFrameForPage(i) ?: continue
-            val bmp = (iv.drawable as? BitmapDrawable)?.bitmap
-            iv.setImageBitmap(null)
-            bmp?.recycle()
-            frame.removeView(iv)
-            pageViews[i] = null
-        }
-
-        val order = (from..to).sortedBy { kotlin.math.abs(it - currentPage) }
-        for (i in order) {
-            renderPageToView(i)
-        }
-        container.post { container.invalidate() }
-    }
-
-    private fun renderPageToView(pageIndex: Int) {
-        val renderer = pdfRenderer ?: return
-        val frame = getFrameForPage(pageIndex) ?: return
-        if (pageViews.getOrNull(pageIndex) != null) return
-        val page = renderer.openPage(pageIndex)
-        val w = if (isTwoUpMode()) (width / 2).coerceAtLeast(1) else width.coerceAtLeast(1)
-        val h = pageHeights[pageIndex]
-        val bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
-        page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
-        page.close()
-        val imageView = ImageView(context).apply {
-            setImageBitmap(bitmap)
-            scaleType = ImageView.ScaleType.FIT_XY
-            layoutParams = FrameLayout.LayoutParams(
-                FrameLayout.LayoutParams.MATCH_PARENT,
-                FrameLayout.LayoutParams.MATCH_PARENT
-            )
-        }
-        frame.addView(imageView, 0)
-        pageViews[pageIndex] = imageView
-        overlayViews.getOrNull(pageIndex)?.bringToFront()
-        frame.requestLayout()
-        frame.invalidate()
-    }
-
-    private fun notifyPageChange() {
-        if (pageHeights.isEmpty()) return
-        val detectedPage = currentPageFromScroll()
-        if (detectedPage != lastEmittedPageIndex) {
-            lastEmittedPageIndex = detectedPage
-            onPageChange(mapOf(
-                "currentPage" to detectedPage,
-                "totalPage" to totalPageCount
-            ))
-        }
-        updateVisiblePages()
-    }
-
-    private fun getAnnotationsForPage(pageIndex: Int): List<Annotation> {
-        return pageAnnotations.getOrNull(pageIndex).orEmpty()
-    }
-
-    private fun addAnnotationToPage(pageIndex: Int, ann: Annotation) {
-        while (pageAnnotations.size <= pageIndex) {
-            pageAnnotations.add(mutableListOf())
-        }
-        pageAnnotations[pageIndex].add(ann)
-        overlayViews.getOrNull(pageIndex)?.invalidate()
-    }
-
-    private fun addInstantAnnotation(pageIndex: Int, pdfX: Float, pdfY: Float, tool: AnnotationTool) {
-        val isNote = (tool == AnnotationTool.NOTE)
-        val rect = if (isNote) {
-            RectF(pdfX, pdfY, pdfX + 32, pdfY + 32)
-        } else {
-            RectF(pdfX, pdfY, pdfX + 180, pdfY + 40)
-        }
-        val typeStr = if (isNote) "note" else "text"
-        val contents = if (textContent.isEmpty()) " " else textContent
-        val ann = Annotation(
-            type = typeStr,
-            bounds = rect,
-            color = if (isNote) noteColor else textColor,
-            strokeWidth = 0f,
-            paths = mutableListOf(),
-            contents = contents,
-            fontSize = textFontSize,
-            bold = textBold,
-            italic = textItalic
-        )
-        addAnnotationToPage(pageIndex, ann)
-        undoStack.add(UndoEntry(ann, pageIndex))
-        redoStack.clear()
-        notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
-    private fun eraseAt(pageIndex: Int, pdfX: Float, pdfY: Float) {
-        val list = pageAnnotations.getOrNull(pageIndex) ?: return
-        var erased = false
-        val toRemove = list.filter { it.bounds.contains(pdfX, pdfY) }
-        for (ann in toRemove) {
-            list.remove(ann)
-            undoStack.removeAll { it.annotation == ann }
-            erased = true
-        }
-        if (erased) {
-            overlayViews.getOrNull(pageIndex)?.invalidate()
-            notifyAnnotationChange()
-            notifyUndoRedoStateChange()
-        }
-    }
-
-    private fun commitStroke(tool: AnnotationTool) {
-        if (currentPathPoints.size < 2) return
-        val minX = currentPathPoints.minOf { it.x } - strokeWidth
-        val minY = currentPathPoints.minOf { it.y } - strokeWidth
-        val maxX = currentPathPoints.maxOf { it.x } + strokeWidth
-        val maxY = currentPathPoints.maxOf { it.y } + strokeWidth
-        val bounds = RectF(minX, minY, maxX, maxY)
-        val paths = mutableListOf<MutableList<PointF>>()
-        val points = currentPathPoints.map { PointF(it.x, it.y) }.toMutableList()
-        paths.add(points)
-        val typeStr = when (tool) {
-            AnnotationTool.PEN -> "pen"
-            AnnotationTool.HIGHLIGHTER -> "highlighter"
-            AnnotationTool.LINE -> "line"
-            else -> "pen"
-        }
-        val color = if (tool == AnnotationTool.HIGHLIGHTER) {
-            Color.argb(102, Color.red(strokeColor), Color.green(strokeColor), Color.blue(strokeColor))
-        } else {
-            strokeColor
-        }
-        val ann = Annotation(typeStr, bounds, color, strokeWidth, paths, "", 0f, false, false)
-        addAnnotationToPage(activePageIndex, ann)
-        undoStack.add(UndoEntry(ann, activePageIndex))
-        redoStack.clear()
-        notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
-    private fun notifyAnnotationChange() {
-        val list = mutableListOf<Map<String, Any>>()
-        for (pageIndex in pageAnnotations.indices) {
-            for (ann in getAnnotationsForPage(pageIndex)) {
-                list.add(mapOf(
-                    "page" to pageIndex,
-                    "bounds" to mapOf(
-                        "x" to ann.bounds.left,
-                        "y" to ann.bounds.top,
-                        "width" to ann.bounds.width(),
-                        "height" to ann.bounds.height()
-                    ),
-                    "type" to ann.type,
-                    "color" to colorToHex(ann.color),
-                    "contents" to ann.contents,
-                    "paths" to ann.paths.map { path ->
-                        path.map { p -> mapOf("x" to p.x, "y" to p.y) }
-                    },
-                    "strokeWidth" to ann.strokeWidth,
-                    "fontSize" to ann.fontSize,
-                    "bold" to ann.bold,
-                    "italic" to ann.italic
-                ))
-            }
-        }
-        onAnnotationChange(mapOf("annotations" to list))
-    }
-
-    private fun notifyUndoRedoStateChange() {
-        onUndoRedoStateChange(mapOf(
-            "canUndo" to undoStack.isNotEmpty(),
-            "canRedo" to redoStack.isNotEmpty()
-        ))
-    }
-
-    private fun parseHexColor(hex: String): Int {
-        var s = hex.trim().uppercase()
-        if (s.startsWith("#")) s = s.removePrefix("#")
-        val v = s.toLongOrNull(16) ?: 0L
-        val r = ((v shr 16) and 0xFF).toInt()
-        val g = ((v shr 8) and 0xFF).toInt()
-        val b = (v and 0xFF).toInt()
-        return Color.rgb(r, g, b)
-    }
-
-    private fun fingerprintAnnotations(annotations: List<Map<String, Any>>): String {
-        val items = annotations.mapNotNull { data ->
-            val pageIndex = (data["page"] as? Number)?.toInt() ?: return@mapNotNull null
-            val typeStr = data["type"] as? String ?: return@mapNotNull null
-            val b = data["bounds"] as? Map<*, *> ?: return@mapNotNull null
-            val x = (b["x"] as? Number)?.toDouble() ?: 0.0
-            val y = (b["y"] as? Number)?.toDouble() ?: 0.0
-            val w = (b["width"] as? Number)?.toDouble() ?: 0.0
-            val h = (b["height"] as? Number)?.toDouble() ?: 0.0
-            val color = data["color"] as? String ?: ""
-            val strokeW = data["strokeWidth"] as? Double ?: 0.0
-            val contents = data["contents"] as? String ?: ""
-            var ptsCount = 0
-            (data["paths"] as? List<*>)?.forEach { pathData ->
-                (pathData as? List<*>)?.forEach { ptsCount++ }
-            }
-            "$pageIndex|$typeStr|$x,$y,$w,$h|$color|$strokeW|$contents|pts:$ptsCount"
-        }
-        return items.sorted().joinToString("||")
-    }
-
-    private fun colorToHex(color: Int): String {
-        val r = Color.red(color)
-        val g = Color.green(color)
-        val b = Color.blue(color)
-        return String.format("#%02x%02x%02x", r, g, b)
-    }
-
-    private suspend fun downloadFile(urlStr: String): File = withContext(Dispatchers.IO) {
-        val url = URL(urlStr)
-        val file = File.createTempFile("pdf_", ".pdf", context.cacheDir)
-        url.openStream().use { input -> file.outputStream().use { output -> input.copyTo(output) } }
-        file
-    }
-
-    override fun onDetachedFromWindow() {
-        super.onDetachedFromWindow()
-        scope.cancel()
-        resetRenderer()
-    }
-}
+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
+    // ─────────────────────────────────────────────────────────────────────────
+
+    private fun detectCurrentPage(scrollY: Int) {
+        if (pageEntries.isEmpty()) return
+        val centerY = scrollY + height / 2
+        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
+        // pageEntries[0] нь windowStart-р эхэлдэг тул relative index ашиглана
+        val relativeIndex = (pageIndex - windowStart).coerceIn(0, pageEntries.size - 1)
+        var y = 0
+        for (i in 0 until relativeIndex) {
+            y += (pageEntries[i].bmpHeight.takeIf { it > 0 } ?: 0) + 12
+        }
+        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
+                    pagePdfW = IntArray(totalPages) { i -> r.openPage(i).use { it.width } }
+                    pagePdfH = IntArray(totalPages) { i -> r.openPage(i).use { it.height } }
+                }
+                // 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 -> renderFirstChunk(pdf, pageCount, viewWidth)  // continuous / twoUpContinuous
+        }
+
+        // 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 — эхний PAGE_CHUNK хуудсыг render хийнэ
+    private suspend fun renderFirstChunk(pdf: PdfRenderer, pageCount: Int, viewWidth: Int) {
+        withContext(Dispatchers.Main) {
+            scrollView.visibility = View.VISIBLE
+            pager.visibility = View.GONE
+        }
+        val end = minOf(PAGE_CHUNK, pageCount)
+        if (displayMode == "twoupcontinuous") {
+            renderTwoUpRange(pdf, pageCount, viewWidth, 0, end)
+            // Хос тул renderedUpTo-г тэгш болгоно
+            withContext(Dispatchers.Main) {
+                renderedUpTo = if (end % 2 == 0) end - 1 else end - 2
+                if (renderedUpTo < pageCount - 1) showLoadingFooter()
+                forceLayoutScrollView()
+            }
+        } else {
+            for (i in 0 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
+                if (end < pageCount) showLoadingFooter()
+                forceLayoutScrollView()   // pages-г шууд харагдуулна
+            }
+        }
+    }
+
+    // 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 ачаална
+        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
+        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()
+        }
+    }
+
+    /**
+     * Дээр (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
+                }
+
+                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()
+                    // Layout болсны дараа scroll хийнэ
+                    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 buildPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f): FrameLayout {
+        // MATCH_PARENT нь React Native managed view дотор layout pass болохоос өмнө
+        // width = 0 авдаг тул explicit pixel dimension ашиглана → шууд харагдана
+        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)
+        pageEntries.add(PageEntry(frame, canvasView, bmpH))
+        return frame
+    }
+
+    private suspend fun renderPageBitmap(pdf: PdfRenderer, index: Int, targetWidth: Int): Bitmap =
+        withContext(pdfDispatcher) {
+            pdf.openPage(index).use { page ->
+                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)
+            }
+            val pdfW = pagePdfW.getOrElse(position) { 1 }.toFloat()
+            val pdfH = pagePdfH.getOrElse(position) { 1 }.toFloat()
+            val canvas = AnnotationCanvasView(context, position, pdfW, pdfH).apply {
+                layoutParams = FrameLayout.LayoutParams(
+                    FrameLayout.LayoutParams.WRAP_CONTENT,
+                    FrameLayout.LayoutParams.WRAP_CONTENT,
+                    android.view.Gravity.CENTER
+                )
+                translationZ = 1f
+            }
+            holder.frame.addView(canvas)
+            holder.currentCanvas = canvas
+            singlePageCanvases[position] = canvas
+
+            holder.loadJob = scope.launch {
+                val pdf = renderer ?: return@launch
+                val bmp = renderPageBitmap(pdf, position, this@ExpoPdfReaderView.width)
+                withContext(Dispatchers.Main) {
+                    if (holder.boundPage == position) {
+                        val lp = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
+                        holder.imageView.layoutParams = lp
+                        holder.imageView.setImageBitmap(bmp)
+                        holder.currentCanvas?.layoutParams = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
+                        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 }
+    }
+}