diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4d896f2..eb8264d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -52,6 +52,9 @@ jobs:
       - name: Run selection history regression test
         run: npm run test:native:selection-smoke
 
+      - name: Run drawing snapshot regression test
+        run: npm run test:native:snapshot-smoke
+
       - name: Run zoom surface regression test
         run: npm run test:native:zoom-smoke
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5994af1..e373998 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 All notable changes to `@mathnotes/mobile-ink` will be documented here.
 
+## [0.3.9] - 2026-10-13
+
+- Saving no longer blocks pen input. iOS and Android copy the strokes on the drawing thread and serialize, base64-encode, and wrap the copy on a background thread. Previously the whole document was serialized on the UI (iOS main / Android GL) thread on every autosave, delaying strokes drawn during a save on dense notebooks.
+- Added `captureDocument` (and `NativeInkCanvasRef.captureDocument`): continuous canvases capture page payloads natively by partitioning the stroke copy off the UI thread. `ContinuousDocumentCanvas` uses it, so autosave no longer serializes the whole document, passes it through JavaScript and decodes it again (about 68% less background save CPU on a dense 100-page notebook, simulator).
+- Superseded saves reject with `DocumentChangedDuringCaptureError`; `isDocumentCaptureSuperseded` lets hosts treat them as retries rather than failures.
+- Continuous-document pan and zoom no longer re-render native ink every frame. `resolveDocumentRenderTarget` renders an overscanned crop that is reused until the visible area leaves it, holds the render resolution during a gesture, and settles at the nearest crisp resolution. `ContinuousDocumentCanvas` uses it and no longer re-renders its subtree on each viewport update.
+- Added `npm run test:native:snapshot-smoke`, run in CI.
+
 ## [0.3.8] - 2026-10-12
 
 - Added continuous document drawing across page boundaries, preserving stroke order, eraser targets, undo/redo, and page-local save/export data.
diff --git a/android/src/main/cpp/document_bridge.cpp b/android/src/main/cpp/document_bridge.cpp
index b6329fb..f86f810 100644
--- a/android/src/main/cpp/document_bridge.cpp
+++ b/android/src/main/cpp/document_bridge.cpp
@@ -113,6 +113,19 @@ extern "C" JNIEXPORT jobjectArray JNICALL Java_com_mathnotes_mobileink_DocumentC
     } catch (const std::exception& error) { reject(env, error); return nullptr; }
     catch (...) { reject(env, std::runtime_error("Unknown document codec failure")); return nullptr; }
 }
+// `snapshot` is a std::vector<Stroke>* from MobileInkCanvasView.takeDrawingSnapshot;
+// the caller keeps ownership. Partitioning the copy avoids re-decoding a
+// serialized document on every autosave.
+extern "C" JNIEXPORT jobjectArray JNICALL Java_com_mathnotes_mobileink_DocumentCodec_partitionSnapshot(
+    JNIEnv* env, jobject, jlong snapshot, jint count, jfloat height) {
+    try {
+        if (!snapshot) throw std::invalid_argument("Missing drawing snapshot");
+        if (count < 1 || count > 100000) throw std::invalid_argument("Invalid document page count");
+        const auto& strokes = *reinterpret_cast<const std::vector<Stroke>*>(snapshot);
+        return encodePages(env, partitionContinuousDocument(strokes, count, height));
+    } catch (const std::exception& error) { reject(env, error); return nullptr; }
+    catch (...) { reject(env, std::runtime_error("Unknown document codec failure")); return nullptr; }
+}
 extern "C" JNIEXPORT jobjectArray JNICALL Java_com_mathnotes_mobileink_DocumentCodec_project(
     JNIEnv* env, jobject, jobjectArray data, jobjectArray orders, jbooleanArray flags, jfloat height, jintArray requested) {
     try {
diff --git a/android/src/main/cpp/jni_bridge.cpp b/android/src/main/cpp/jni_bridge.cpp
index 0faece8..67b1e9d 100644
--- a/android/src/main/cpp/jni_bridge.cpp
+++ b/android/src/main/cpp/jni_bridge.cpp
@@ -24,6 +24,7 @@
 #include <src/gpu/ganesh/gl/GrGLDefines.h>
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -808,6 +809,7 @@ Java_com_mathnotes_mobileink_MobileInkCanvasView_isEmpty(JNIEnv* env, jobject ob
 }
 
 // Serialization
+// Synchronous GL-thread serialization, used to preserve ink across engine resizes.
 JNIEXPORT jbyteArray JNICALL
 Java_com_mathnotes_mobileink_MobileInkCanvasView_serializeDrawing(JNIEnv* env, jobject obj, jlong contextPtr) {
     auto* ctx = reinterpret_cast<DrawingContext*>(contextPtr);
@@ -821,6 +823,47 @@ Java_com_mathnotes_mobileink_MobileInkCanvasView_serializeDrawing(JNIEnv* env, j
     return nullptr;
 }
 
+// Autosave copies strokes on the GL thread and encodes the copy elsewhere, so
+// neither the UI nor the GL thread waits for serialization.
+JNIEXPORT jlong JNICALL
+Java_com_mathnotes_mobileink_MobileInkCanvasView_snapshotDrawing(JNIEnv* env, jobject obj, jlong contextPtr) {
+    auto* ctx = reinterpret_cast<DrawingContext*>(contextPtr);
+    if (!ctx || !ctx->engine) return 0;
+    try {
+        return reinterpret_cast<jlong>(new std::vector<nativedrawing::Stroke>(ctx->engine->snapshotDrawing()));
+    } catch (...) {
+        LOGE("snapshotDrawing: copy failed");
+        return 0;
+    }
+}
+
+JNIEXPORT jbyteArray JNICALL
+Java_com_mathnotes_mobileink_MobileInkCanvasView_serializeDrawingSnapshot(JNIEnv* env, jobject obj, jlong snapshotPtr) {
+    auto* strokes = reinterpret_cast<std::vector<nativedrawing::Stroke>*>(snapshotPtr);
+    if (!strokes) return nullptr;
+    try {
+        nativedrawing::DrawingSerialization serializer;
+        std::vector<uint8_t> data = serializer.serialize(*strokes);
+        if (data.size() > static_cast<size_t>(std::numeric_limits<jsize>::max())) {
+            LOGE("serializeDrawingSnapshot: payload exceeds JNI array limit");
+            return nullptr;
+        }
+        jbyteArray result = env->NewByteArray(static_cast<jsize>(data.size()));
+        if (!result || env->ExceptionCheck()) return nullptr;
+        env->SetByteArrayRegion(result, 0, static_cast<jsize>(data.size()), reinterpret_cast<const jbyte*>(data.data()));
+        if (env->ExceptionCheck()) return nullptr;
+        return result;
+    } catch (...) {
+        LOGE("serializeDrawingSnapshot: encoding failed");
+        return nullptr;
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_com_mathnotes_mobileink_MobileInkCanvasView_freeDrawingSnapshot(JNIEnv* env, jobject obj, jlong snapshotPtr) {
+    delete reinterpret_cast<std::vector<nativedrawing::Stroke>*>(snapshotPtr);
+}
+
 JNIEXPORT void JNICALL
 Java_com_mathnotes_mobileink_MobileInkCanvasView_deserializeDrawing(
     JNIEnv* env, jobject obj, jlong contextPtr, jbyteArray data) {
diff --git a/android/src/main/java/com/mathnotes/mobileink/MobileInkCanvasView.kt b/android/src/main/java/com/mathnotes/mobileink/MobileInkCanvasView.kt
index 3c984b9..e6dc621 100644
--- a/android/src/main/java/com/mathnotes/mobileink/MobileInkCanvasView.kt
+++ b/android/src/main/java/com/mathnotes/mobileink/MobileInkCanvasView.kt
@@ -1334,10 +1334,39 @@ class MobileInkCanvasView(context: Context) : TextureView(context), TextureView.
         return result
     }
 
+    /**
+     * Copies the committed strokes on the GL thread and returns an owned
+     * native snapshot (0 if unavailable). The caller must pass a nonzero
+     * handle to [releaseDrawingSnapshot]. Encoding the copy off the UI and GL
+     * threads keeps autosave from blocking touch input and rendering.
+     */
+    fun takeDrawingSnapshot(): Long {
+        if (drawingEngine == 0L) return 0L
+        // 0 = pending, CLAIMED = the caller stopped waiting. Whichever side
+        // loses the race frees the snapshot, so a timeout cannot leak it.
+        val slot = java.util.concurrent.atomic.AtomicLong(0L)
+        runOnGlThreadSync<Unit>(3000) {
+            if (drawingEngine != 0L) {
+                val handle = snapshotDrawing(drawingEngine)
+                if (handle != 0L && !slot.compareAndSet(0L, handle)) freeDrawingSnapshot(handle)
+            }
+            Unit
+        }
+        return slot.getAndSet(SNAPSHOT_CLAIMED)
+    }
+
+    fun releaseDrawingSnapshot(snapshot: Long) {
+        if (snapshot != 0L) freeDrawingSnapshot(snapshot)
+    }
+
+    /** Serializes a snapshot on the calling thread; call off the UI thread. */
     fun serializeDrawing(): ByteArray? {
-        if (drawingEngine == 0L) return null
-        return runOnGlThreadSync(3000) {
-            if (drawingEngine != 0L) serializeDrawing(drawingEngine) else null
+        val handle = takeDrawingSnapshot()
+        if (handle == 0L) return null
+        return try {
+            serializeDrawingSnapshot(handle)
+        } finally {
+            releaseDrawingSnapshot(handle)
         }
     }
 
@@ -1467,6 +1496,9 @@ class MobileInkCanvasView(context: Context) : TextureView(context), TextureView.
 
     // Serialization
     private external fun serializeDrawing(engine: Long): ByteArray?
+    private external fun snapshotDrawing(engine: Long): Long
+    private external fun serializeDrawingSnapshot(snapshot: Long): ByteArray?
+    private external fun freeDrawingSnapshot(snapshot: Long)
     private external fun deserializeDrawing(engine: Long, data: ByteArray)
 
     // Rendering
@@ -1475,6 +1507,7 @@ class MobileInkCanvasView(context: Context) : TextureView(context), TextureView.
     private external fun renderToPixelsScaled(engine: Long, bitmap: Bitmap, scale: Float)
 
     companion object {
+        private const val SNAPSHOT_CLAIMED = -1L
         private var libraryLoaded = false
 
         @Synchronized
diff --git a/android/src/main/java/com/mathnotes/mobileink/MobileInkDocumentBridge.kt b/android/src/main/java/com/mathnotes/mobileink/MobileInkDocumentBridge.kt
index 3592ea6..cc10082 100644
--- a/android/src/main/java/com/mathnotes/mobileink/MobileInkDocumentBridge.kt
+++ b/android/src/main/java/com/mathnotes/mobileink/MobileInkDocumentBridge.kt
@@ -121,6 +121,34 @@ class MobileInkDocumentBridge(context: ReactApplicationContext) : ReactContextBa
         }
     }
 
+    /**
+     * Captures the live document as page payloads. Strokes are copied on the
+     * view's GL thread; partitioning and encoding run on the codec worker, so
+     * neither touch input nor rendering waits for a save.
+     */
+    @ReactMethod
+    fun captureDocument(viewTag: Int, pageCount: Double, pageHeight: Double, promise: Promise) {
+        if (!(pageCount.isFinite() && pageCount >= 1 && pageCount <= 100000 && pageCount == kotlin.math.floor(pageCount))) {
+            promise.reject("DOCUMENT_CAPTURE_FAILED", "Invalid document page count"); return
+        }
+        reactApplicationContext.runOnUiQueueThread {
+            val view = MobileInkModule.getView(viewTag)
+            if (view == null) {
+                promise.reject("DOCUMENT_CAPTURE_FAILED", "View not found"); return@runOnUiQueueThread
+            }
+            run(promise, "DOCUMENT_CAPTURE_FAILED") {
+                val snapshot = view.takeDrawingSnapshot()
+                require(snapshot != 0L) { "Unable to snapshot drawing" }
+                try {
+                    val pages = DocumentCodec.partitionSnapshot(snapshot, pageCount.toInt(), pageHeight.toFloat())
+                    Arguments.createArray().apply { pages.forEach { pushString(encode(it, true)) } }
+                } finally {
+                    view.releaseDrawingSnapshot(snapshot)
+                }
+            }
+        }
+    }
+
     @ReactMethod
     fun projectDocumentPages(values: ReadableArray, pageHeight: Double, requested: ReadableArray, promise: Promise) {
         val payloads: List<String>
@@ -151,5 +179,6 @@ internal object DocumentCodec {
     init { System.loadLibrary("mobileink") }
     external fun compose(bytes: Array<ByteArray>, orders: Array<LongArray>, hasOrders: BooleanArray, height: Float): ByteArray
     external fun partition(bytes: ByteArray, order: LongArray, hasOrder: Boolean, count: Int, height: Float): Array<DocumentPageData>
+    external fun partitionSnapshot(snapshot: Long, count: Int, height: Float): Array<DocumentPageData>
     external fun project(bytes: Array<ByteArray>, orders: Array<LongArray>, hasOrders: BooleanArray, height: Float, indices: IntArray): Array<DocumentPageData>
 }
diff --git a/android/src/main/java/com/mathnotes/mobileink/MobileInkModule.kt b/android/src/main/java/com/mathnotes/mobileink/MobileInkModule.kt
index 232c9b8..64d8036 100644
--- a/android/src/main/java/com/mathnotes/mobileink/MobileInkModule.kt
+++ b/android/src/main/java/com/mathnotes/mobileink/MobileInkModule.kt
@@ -114,9 +114,16 @@ class MobileInkModule(private val reactContext: ReactApplicationContext) :
     @ReactMethod
     fun getBase64Data(viewTag: Int, promise: Promise) {
         reactContext.runOnUiQueueThread {
-            try {
-                val view = findDrawingView(viewTag)
-                if (view != null) {
+            val view = findDrawingView(viewTag)
+            if (view == null) {
+                // View not found - likely unmounted during auto-save, return null gracefully
+                android.util.Log.w("MobileInkModule", "getBase64Data: view not found for tag $viewTag")
+                promise.resolve(null)
+                return@runOnUiQueueThread
+            }
+            // Serialization runs off the UI thread so autosave never stalls pen input.
+            executor.execute {
+                try {
                     val data = view.serializeDrawing()
                     if (data != null && data.isNotEmpty()) {
                         val base64 = Base64.encodeToString(data, Base64.NO_WRAP)
@@ -127,15 +134,11 @@ class MobileInkModule(private val reactContext: ReactApplicationContext) :
                         // Empty drawing - return empty JSON like iOS
                         promise.resolve("""{"pages":{}}""")
                     }
-                } else {
-                    // View not found - likely unmounted during auto-save, return null gracefully
-                    android.util.Log.w("MobileInkModule", "getBase64Data: view not found for tag $viewTag")
+                } catch (e: Exception) {
+                    // Don't reject on exceptions either - gracefully return null
+                    android.util.Log.e("MobileInkModule", "getBase64Data: exception", e)
                     promise.resolve(null)
                 }
-            } catch (e: Exception) {
-                // Don't reject on exceptions either - gracefully return null
-                android.util.Log.e("MobileInkModule", "getBase64Data: exception", e)
-                promise.resolve(null)
             }
         }
     }
@@ -319,18 +322,16 @@ class MobileInkModule(private val reactContext: ReactApplicationContext) :
                 return@runOnUiQueueThread
             }
 
-            // Serialize on the UI queue (deserialize/serialize already coordinate
-            // with the GL thread inside the view), then move the file write to a
-            // background executor so it doesn't block the UI thread.
-            val data: ByteArray? = try {
-                view.serializeDrawing()
-            } catch (e: Exception) {
-                android.util.Log.e("MobileInkModule", "persistEngineToFile: serialize exception", e)
-                promise.reject("GET_DATA_ERROR", e.message ?: "serialize failed", e)
-                return@runOnUiQueueThread
-            }
-
+            // Serialization and the file write both run on the background
+            // executor; the view copies strokes on its GL thread first.
             executor.execute {
+                val data: ByteArray? = try {
+                    view.serializeDrawing()
+                } catch (e: Exception) {
+                    android.util.Log.e("MobileInkModule", "persistEngineToFile: serialize exception", e)
+                    promise.reject("GET_DATA_ERROR", e.message ?: "serialize failed", e)
+                    return@execute
+                }
                 try {
                     val body = if (data != null && data.isNotEmpty()) {
                         val base64 = Base64.encodeToString(data, Base64.NO_WRAP)
diff --git a/cpp/SkiaDrawingEngine.cpp b/cpp/SkiaDrawingEngine.cpp
index 7d2a5df..a5a9386 100644
--- a/cpp/SkiaDrawingEngine.cpp
+++ b/cpp/SkiaDrawingEngine.cpp
@@ -852,6 +852,11 @@ void SkiaDrawingEngine::setTool(const char* toolType) {
     }
 }
 
+std::vector<Stroke> SkiaDrawingEngine::snapshotDrawing() {
+    std::lock_guard<std::recursive_mutex> lock(stateMutex_);
+    return strokes_;
+}
+
 std::vector<uint8_t> SkiaDrawingEngine::serializeDrawing() {
     std::lock_guard<std::recursive_mutex> lock(stateMutex_);
 
diff --git a/cpp/SkiaDrawingEngine.h b/cpp/SkiaDrawingEngine.h
index 04091fb..94594c2 100644
--- a/cpp/SkiaDrawingEngine.h
+++ b/cpp/SkiaDrawingEngine.h
@@ -121,6 +121,8 @@ class SkiaDrawingEngine {
 
     // Serialization
     std::vector<uint8_t> serializeDrawing();
+    // Copy committed strokes under the state lock; encode the independent copy off-thread.
+    std::vector<Stroke> snapshotDrawing();
     bool deserializeDrawing(const std::vector<uint8_t>& data);
 
     // State queries
diff --git a/ios/MobileInkModule/MobileInkBridge.mm b/ios/MobileInkModule/MobileInkBridge.mm
index 5c11889..19ed47e 100644
--- a/ios/MobileInkModule/MobileInkBridge.mm
+++ b/ios/MobileInkModule/MobileInkBridge.mm
@@ -27,6 +27,7 @@
 #pragma clang diagnostic pop
 
 #include <algorithm>
+#include <climits>
 #include <cmath>
 #include <unordered_map>
 
@@ -601,24 +602,56 @@ void getSelectionBounds(void* engine, float* outBounds) {
     }
 }
 
-// Serialization operations
-uint8_t* serializeDrawing(void* engine, int* outSize) {
-    if (!engine || !outSize) {
-        *outSize = 0;
+// Copies serialized bytes into a buffer Swift frees with freeSerializedData.
+// Empty data yields nullptr with *outSize == 0; -1 marks a failure.
+static uint8_t* copyToSerializedBuffer(const std::vector<uint8_t>& data, int* outSize) {
+    if (data.size() > INT_MAX) {
+        *outSize = -1;
         return nullptr;
     }
-
-    std::vector<uint8_t> data = static_cast<SkiaDrawingEngine*>(engine)->serializeDrawing();
     *outSize = static_cast<int>(data.size());
+    if (data.empty()) return nullptr;
+    uint8_t* buffer = new uint8_t[data.size()];
+    std::memcpy(buffer, data.data(), data.size());
+    return buffer;
+}
 
-    if (data.empty()) {
+// A snapshot owns its strokes independently of the view/engine lifetime. The UI
+// thread only copies state; serialization must not hold the live engine's lock.
+void* snapshotDrawing(void* engine) {
+    if (!engine) return nullptr;
+    try {
+        return new std::vector<nativedrawing::Stroke>(
+            static_cast<SkiaDrawingEngine*>(engine)->snapshotDrawing());
+    } catch (...) { return nullptr; }
+}
+
+uint8_t* serializeDrawingSnapshot(void* snapshot, int* outSize) {
+    if (!outSize) return nullptr;
+    *outSize = -1;
+    if (!snapshot) return nullptr;
+    try {
+        nativedrawing::DrawingSerialization serializer;
+        return copyToSerializedBuffer(
+            serializer.serialize(*static_cast<std::vector<nativedrawing::Stroke>*>(snapshot)), outSize);
+    } catch (...) {
+        *outSize = -1;
         return nullptr;
     }
+}
 
-    // Allocate buffer that Swift must free using freeSerializedData
-    uint8_t* buffer = new uint8_t[data.size()];
-    std::memcpy(buffer, data.data(), data.size());
-    return buffer;
+void freeDrawingSnapshot(void* snapshot) {
+    delete static_cast<std::vector<nativedrawing::Stroke>*>(snapshot);
+}
+
+// Serialization operations
+uint8_t* serializeDrawing(void* engine, int* outSize) {
+    if (!outSize) return nullptr;
+    if (!engine) {
+        *outSize = 0;
+        return nullptr;
+    }
+    return copyToSerializedBuffer(static_cast<SkiaDrawingEngine*>(engine)->serializeDrawing(), outSize);
 }
 
 void freeSerializedData(uint8_t* data) {
diff --git a/ios/MobileInkModule/MobileInkCanvasCapture.swift b/ios/MobileInkModule/MobileInkCanvasCapture.swift
new file mode 100644
index 0000000..5f53f81
--- /dev/null
+++ b/ios/MobileInkModule/MobileInkCanvasCapture.swift
@@ -0,0 +1,39 @@
+import Foundation
+import React
+
+extension MobileInkCanvasView {
+    /// Copies committed strokes (main thread). The caller owns the result and
+    /// must release it with freeDrawingSnapshot after encoding it elsewhere.
+    func takeDrawingSnapshot() -> OpaquePointer? {
+        guard let engine = drawingEngine else { return nil }
+        return snapshotDrawing(engine)
+    }
+
+    @objc func getBase64Data(_ callback: @escaping RCTResponseSenderBlock) {
+        guard let snapshot = takeDrawingSnapshot() else {
+            callback(["Unable to snapshot drawing", NSNull()])
+            return
+        }
+        // Do not capture self or access the live engine on this queue. A view
+        // can close, receive new strokes, or undo while this snapshot encodes.
+        DispatchQueue.global(qos: .userInitiated).async {
+            defer { freeDrawingSnapshot(snapshot) }
+            var size: Int32 = 0
+            let bytes = serializeDrawingSnapshot(snapshot, &size)
+            guard size >= 0 else {
+                DispatchQueue.main.async { callback(["Unable to serialize drawing snapshot", NSNull()]) }
+                return
+            }
+            guard let bytes, size > 0 else {
+                DispatchQueue.main.async { callback([NSNull(), "{\"pages\":{}}"]) }
+                return
+            }
+            // Base64 text needs no JSON escaping, so the fixed wrapper is built directly.
+            let data = Data(bytesNoCopy: bytes, count: Int(size), deallocator: .custom { pointer, _ in
+                freeSerializedData(pointer.assumingMemoryBound(to: UInt8.self))
+            })
+            let payload = "{\"pages\":{\"0\":\"\(data.base64EncodedString())\"}}"
+            DispatchQueue.main.async { callback([NSNull(), payload]) }
+        }
+    }
+}
diff --git a/ios/MobileInkModule/MobileInkCanvasView.swift b/ios/MobileInkModule/MobileInkCanvasView.swift
index 50f7a2c..f86c5f5 100644
--- a/ios/MobileInkModule/MobileInkCanvasView.swift
+++ b/ios/MobileInkModule/MobileInkCanvasView.swift
@@ -1205,46 +1205,6 @@ class MobileInkCanvasView: MTKView {
         requestDisplay(forceWhenSuspended: true)
     }
 
-    @objc func getBase64Data(_ callback: @escaping RCTResponseSenderBlock) {
-        guard let engine = drawingEngine else {
-            callback(["Engine not initialized", NSNull()])
-            return
-        }
-
-        var size: Int32 = 0
-        guard let dataPtr = serializeDrawing(engine, &size), size > 0 else {
-            // Empty drawing - return empty JSON
-            let emptyJson = "{\"pages\":{}}"
-            callback([NSNull(), emptyJson])
-            return
-        }
-
-        // Convert to Data
-        let data = Data(bytes: dataPtr, count: Int(size))
-        freeSerializedData(dataPtr)
-
-        // Encode as base64
-        let base64String = data.base64EncodedString()
-
-        // Wrap in PencilKit-compatible JSON format
-        let jsonDict: [String: Any] = [
-            "pages": [
-                "0": base64String
-            ]
-        ]
-
-        do {
-            let jsonData = try JSONSerialization.data(withJSONObject: jsonDict, options: [])
-            if let jsonString = String(data: jsonData, encoding: .utf8) {
-                callback([NSNull(), jsonString])
-            } else {
-                callback(["Failed to encode JSON string", NSNull()])
-            }
-        } catch {
-            callback([error.localizedDescription, NSNull()])
-        }
-    }
-
     @objc func loadBase64Data(_ base64String: String, callback: @escaping RCTResponseSenderBlock) {
         // React attaches the native view before its first layout creates the
         // engine. Report retryable readiness without treating valid ink as bad.
diff --git a/ios/MobileInkModule/MobileInkCanvasViewManager.swift b/ios/MobileInkModule/MobileInkCanvasViewManager.swift
index 5bea7b2..93c83ec 100644
--- a/ios/MobileInkModule/MobileInkCanvasViewManager.swift
+++ b/ios/MobileInkModule/MobileInkCanvasViewManager.swift
@@ -297,6 +297,15 @@ class MobileInkCanvasViewManager: RCTViewManager {
     }
   }
 
+  /// Main thread only. Returns an owned std::vector<Stroke>* for
+  /// MobileInkDocumentBridge.captureDocument, or nil if the view is missing.
+  @objc func takeDrawingSnapshot(_ node: NSNumber) -> UnsafeMutableRawPointer? {
+    guard let container = bridge.uiManager.view(forReactTag: node),
+          let view = findDrawingView(container),
+          let snapshot = view.takeDrawingSnapshot() else { return nil }
+    return UnsafeMutableRawPointer(snapshot)
+  }
+
   @objc func loadBase64Data(_ node: NSNumber, base64String: String, callback: @escaping RCTResponseSenderBlock) {
     DispatchQueue.main.async {
       if let container = self.bridge.uiManager.view(forReactTag: node),
diff --git a/ios/MobileInkModule/MobileInkDocumentBridge.mm b/ios/MobileInkModule/MobileInkDocumentBridge.mm
index e72cc15..3051154 100644
--- a/ios/MobileInkModule/MobileInkDocumentBridge.mm
+++ b/ios/MobileInkModule/MobileInkDocumentBridge.mm
@@ -4,6 +4,7 @@
 #include "cpp/ContinuousDocumentPages.h"
 #include "cpp/DrawingSerialization.h"
 #include <cmath>
+#include <memory>
 #include <stdexcept>
 
 namespace {
@@ -69,6 +70,8 @@ ContinuousDocumentPage decodePage(NSString* payload) {
 @protocol MobileInkDocumentLoader <NSObject>
 - (void)loadBase64Data:(NSNumber*)viewTag base64String:(NSString*)payload
              callback:(RCTResponseSenderBlock)callback;
+// Main thread only; returns an owned std::vector<Stroke>* or NULL.
+- (void*)takeDrawingSnapshot:(NSNumber*)viewTag;
 @end
 
 @interface MobileInkDocumentBridge : NSObject <RCTBridgeModule>
@@ -136,6 +139,44 @@ - (dispatch_queue_t)methodQueue { return dispatch_get_global_queue(QOS_CLASS_USE
         reject(@"DOCUMENT_LOAD_FAILED", @"Unable to process drawing data", nil);
     }
 }
+// Copy strokes on the main thread, then partition and encode that copy on this
+// module's background queue. Unlike getBase64Data + partitionDocument, the
+// whole document is never serialized, sent through JavaScript, and decoded.
+RCT_EXPORT_METHOD(captureDocument:(nonnull NSNumber*)viewTag
+                  pageCount:(NSInteger)pageCount
+                  pageHeight:(double)pageHeight
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    if (pageCount <= 0 || pageCount > 100000) {
+        reject(@"DOCUMENT_CAPTURE_FAILED", @"Invalid document page count", nil);
+        return;
+    }
+    dispatch_async(dispatch_get_main_queue(), ^{
+        id<MobileInkDocumentLoader> loader = (id)[self.bridge moduleForName:@"MobileInkCanvasViewManager"];
+        if (![loader respondsToSelector:@selector(takeDrawingSnapshot:)]) {
+            reject(@"DOCUMENT_CAPTURE_FAILED", @"MobileInkCanvasViewManager is unavailable", nil);
+            return;
+        }
+        auto* strokes = static_cast<std::vector<nativedrawing::Stroke>*>([loader takeDrawingSnapshot:viewTag]);
+        if (!strokes) {
+            reject(@"DOCUMENT_CAPTURE_FAILED", @"View not found", nil);
+            return;
+        }
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+            std::unique_ptr<std::vector<nativedrawing::Stroke>> owned(strokes);
+            try {
+                const auto pages = nativedrawing::partitionContinuousDocument(*owned, (int)pageCount, pageHeight);
+                NSMutableArray* result = [NSMutableArray arrayWithCapacity:pages.size()];
+                for (const auto& page : pages) [result addObject:encodePage(page, true)];
+                resolve(result);
+            } catch (const std::exception& error) {
+                reject(@"DOCUMENT_CAPTURE_FAILED", [NSString stringWithUTF8String:error.what()], nil);
+            } catch (...) {
+                reject(@"DOCUMENT_CAPTURE_FAILED", @"Unable to process drawing data", nil);
+            }
+        });
+    });
+}
 RCT_EXPORT_METHOD(partitionDocument:(NSString*)payload
                   pageCount:(NSInteger)pageCount
                   pageHeight:(double)pageHeight
diff --git a/ios/MobileInkModule/SkiaEngineBridge.swift b/ios/MobileInkModule/SkiaEngineBridge.swift
index 2f2287c..2864a30 100644
--- a/ios/MobileInkModule/SkiaEngineBridge.swift
+++ b/ios/MobileInkModule/SkiaEngineBridge.swift
@@ -229,3 +229,10 @@ func commitExternalEdit(_ engine: OpaquePointer, _ before: UnsafePointer<CChar>,
 func undoExternalEdit(_ engine: OpaquePointer) -> UnsafeMutablePointer<CChar>?
 @_silgen_name("redoExternalEdit")
 func redoExternalEdit(_ engine: OpaquePointer) -> UnsafeMutablePointer<CChar>?
+
+@_silgen_name("snapshotDrawing")
+func snapshotDrawing(_ engine: OpaquePointer) -> OpaquePointer?
+@_silgen_name("serializeDrawingSnapshot")
+func serializeDrawingSnapshot(_ snapshot: OpaquePointer, _ outSize: UnsafeMutablePointer<Int32>) -> UnsafeMutablePointer<UInt8>?
+@_silgen_name("freeDrawingSnapshot")
+func freeDrawingSnapshot(_ snapshot: OpaquePointer)
diff --git a/package-lock.json b/package-lock.json
index bf0a81a..05af446 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@mathnotes/mobile-ink",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@mathnotes/mobile-ink",
-      "version": "0.3.8",
+      "version": "0.3.9",
       "license": "Apache-2.0",
       "devDependencies": {
         "@babel/core": "^7.25.2",
diff --git a/package.json b/package.json
index f0d2986..09321e0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@mathnotes/mobile-ink",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Production-grade React Native ink engine with native Skia drawing and continuous canvas primitives.",
   "license": "Apache-2.0",
   "author": "BuilderPro LLC",
@@ -43,11 +43,12 @@
     "test:native:smoke": "clang++ -std=c++20 scripts/drawing_serialization_smoke.cpp cpp/DrawingTypes.cpp cpp/DrawingSerialization.cpp cpp/ShapeRecognition.cpp -I cpp -I node_modules/@shopify/react-native-skia/cpp/skia -I node_modules/@shopify/react-native-skia/cpp/skia/modules/pathops/include node_modules/@shopify/react-native-skia/libs/apple/libskia.xcframework/macos-arm64_x86_64/libskia.a node_modules/@shopify/react-native-skia/libs/apple/libpathops.xcframework/macos-arm64_x86_64/libpathops.a -framework ApplicationServices -framework CoreFoundation -framework CoreGraphics -framework CoreText -framework Foundation -framework QuartzCore -o /tmp/mobile_ink_drawing_serialization_smoke && /tmp/mobile_ink_drawing_serialization_smoke",
     "test:native:eraser-smoke": "clang++ -std=c++20 scripts/eraser_cursor_smoke.cpp cpp/*.cpp -I cpp -I node_modules/@shopify/react-native-skia/cpp/skia -I node_modules/@shopify/react-native-skia/cpp/skia/modules/pathops/include node_modules/@shopify/react-native-skia/libs/apple/libskia.xcframework/macos-arm64_x86_64/libskia.a node_modules/@shopify/react-native-skia/libs/apple/libpathops.xcframework/macos-arm64_x86_64/libpathops.a -framework ApplicationServices -framework CoreFoundation -framework CoreGraphics -framework CoreText -framework Foundation -framework QuartzCore -o /tmp/mobile_ink_eraser_cursor_smoke && /tmp/mobile_ink_eraser_cursor_smoke",
     "test:native:selection-smoke": "clang++ -std=c++20 scripts/selection_history_smoke.cpp cpp/*.cpp -I cpp -I node_modules/@shopify/react-native-skia/cpp/skia -I node_modules/@shopify/react-native-skia/cpp/skia/modules/pathops/include node_modules/@shopify/react-native-skia/libs/apple/libskia.xcframework/macos-arm64_x86_64/libskia.a node_modules/@shopify/react-native-skia/libs/apple/libpathops.xcframework/macos-arm64_x86_64/libpathops.a -framework ApplicationServices -framework CoreFoundation -framework CoreGraphics -framework CoreText -framework Foundation -framework QuartzCore -o /tmp/mobile_ink_selection_history_smoke && /tmp/mobile_ink_selection_history_smoke",
+    "test:native:snapshot-smoke": "clang++ -std=c++20 scripts/drawing_snapshot_smoke.cpp cpp/*.cpp -I cpp -I node_modules/@shopify/react-native-skia/cpp/skia -I node_modules/@shopify/react-native-skia/cpp/skia/modules/pathops/include node_modules/@shopify/react-native-skia/libs/apple/libskia.xcframework/macos-arm64_x86_64/libskia.a node_modules/@shopify/react-native-skia/libs/apple/libpathops.xcframework/macos-arm64_x86_64/libpathops.a -framework ApplicationServices -framework CoreFoundation -framework CoreGraphics -framework CoreText -framework Foundation -framework QuartzCore -o /tmp/mobile_ink_drawing_snapshot_smoke && /tmp/mobile_ink_drawing_snapshot_smoke",
     "test:example:typecheck": "npm --prefix example run typecheck",
     "test:example:export:ios": "npm --prefix example run export:ios",
     "test:example:export:android": "npm --prefix example run export:android",
     "pack:dry-run": "npm pack --dry-run",
-    "validate": "npm run typecheck && npm run test && npm run test:release && npm run test:native:smoke && npm run test:native:eraser-smoke && npm run test:native:selection-smoke && npm run test:native:zoom-smoke && npm run test:native:document-jni && npm run build && npm run pack:dry-run && npm run test:example:typecheck && npm run test:example:export:ios && npm run test:example:export:android",
+    "validate": "npm run typecheck && npm run test && npm run test:release && npm run test:native:smoke && npm run test:native:eraser-smoke && npm run test:native:selection-smoke && npm run test:native:snapshot-smoke && npm run test:native:zoom-smoke && npm run test:native:document-jni && npm run build && npm run pack:dry-run && npm run test:example:typecheck && npm run test:example:export:ios && npm run test:example:export:android",
     "prepack": "npm run build",
     "test:native:zoom-smoke": "clang++ -O2 -std=c++20 -fobjc-arc scripts/zoom_surface_smoke.mm cpp/*.cpp -I cpp -I node_modules/@shopify/react-native-skia/cpp/skia -I node_modules/@shopify/react-native-skia/cpp/skia/modules/pathops/include node_modules/@shopify/react-native-skia/libs/apple/libskia.xcframework/macos-arm64_x86_64/libskia.a node_modules/@shopify/react-native-skia/libs/apple/libpathops.xcframework/macos-arm64_x86_64/libpathops.a -framework Metal -framework ApplicationServices -framework CoreFoundation -framework CoreGraphics -framework CoreText -framework Foundation -framework QuartzCore -o /tmp/mobile_ink_zoom_surface_smoke && /tmp/mobile_ink_zoom_surface_smoke",
     "benchmark:native:zoom": "clang++ -O2 -std=c++20 -fobjc-arc scripts/zoom_render_benchmark.mm cpp/*.cpp -I cpp -I node_modules/@shopify/react-native-skia/cpp/skia -I node_modules/@shopify/react-native-skia/cpp/skia/modules/pathops/include node_modules/@shopify/react-native-skia/libs/apple/libskia.xcframework/macos-arm64_x86_64/libskia.a node_modules/@shopify/react-native-skia/libs/apple/libpathops.xcframework/macos-arm64_x86_64/libpathops.a -framework Metal -framework ApplicationServices -framework CoreFoundation -framework CoreGraphics -framework CoreText -framework Foundation -framework QuartzCore -o /tmp/mobile_ink_zoom_render_benchmark && /tmp/mobile_ink_zoom_render_benchmark",
diff --git a/scripts/drawing_snapshot_smoke.cpp b/scripts/drawing_snapshot_smoke.cpp
new file mode 100644
index 0000000..13080f7
--- /dev/null
+++ b/scripts/drawing_snapshot_smoke.cpp
@@ -0,0 +1,72 @@
+// Autosave copies strokes on the UI thread and encodes the copy off-thread so
+// pen input is never blocked by serialization. The copy must encode exactly
+// like the live engine and must not observe strokes drawn after it was taken.
+
+#include <iostream>
+#include <thread>
+
+#include "../cpp/DrawingSerialization.h"
+#include "../cpp/SkiaDrawingEngine.h"
+
+using namespace nativedrawing;
+
+namespace {
+
+int g_failures = 0;
+
+void check(bool condition, const char* message) {
+  if (!condition) {
+    std::cerr << "FAIL: " << message << std::endl;
+    ++g_failures;
+  }
+}
+
+void drawStroke(SkiaDrawingEngine& engine, float y) {
+  engine.setTool("pen");
+  engine.touchBegan(100.0f, y, 1.0f);
+  for (int i = 1; i <= 20; ++i) {
+    engine.touchMoved(100.0f + i * 10.0f, y + ((i % 2) ? 6.0f : -6.0f), 1.0f);
+  }
+  engine.touchEnded(0);
+}
+
+void snapshotEncodesLikeLiveEngine() {
+  SkiaDrawingEngine engine(820, 1061);
+  drawStroke(engine, 200.0f);
+  drawStroke(engine, 300.0f);
+  engine.setTool("eraser");
+  engine.touchBegan(150.0f, 200.0f, 1.0f);
+  engine.touchMoved(160.0f, 205.0f, 1.0f);
+  engine.touchEnded(0);
+  const auto live = engine.serializeDrawing();
+  const auto snapshot = engine.snapshotDrawing();
+  DrawingSerialization serializer;
+  check(serializer.serialize(snapshot) == live, "snapshot encoding differs from live serialization");
+}
+
+void snapshotIgnoresLaterStrokes() {
+  SkiaDrawingEngine engine(820, 1061);
+  drawStroke(engine, 200.0f);
+  const auto before = engine.serializeDrawing();
+  const auto snapshot = engine.snapshotDrawing();
+  std::vector<uint8_t> encoded;
+  // Encode on another thread while the engine keeps receiving input.
+  std::thread encoder([&] { DrawingSerialization serializer; encoded = serializer.serialize(snapshot); });
+  for (int i = 0; i < 20; ++i) drawStroke(engine, 300.0f + i * 20.0f);
+  encoder.join();
+  check(encoded == before, "snapshot observed strokes drawn after capture");
+  check(engine.serializeDrawing() != before, "live engine lost strokes drawn after capture");
+}
+
+}  // namespace
+
+int main() {
+  snapshotEncodesLikeLiveEngine();
+  snapshotIgnoresLaterStrokes();
+  if (g_failures == 0) {
+    std::cout << "Drawing snapshot smoke tests passed" << std::endl;
+    return 0;
+  }
+  std::cerr << g_failures << " drawing snapshot smoke test(s) failed" << std::endl;
+  return 1;
+}
diff --git a/src/NativeInkCanvas.tsx b/src/NativeInkCanvas.tsx
index a47b119..9e8a382 100644
--- a/src/NativeInkCanvas.tsx
+++ b/src/NativeInkCanvas.tsx
@@ -1,4 +1,4 @@
-import { loadDocument } from './native-ink-canvas/documentBridge';
+import { captureDocument, loadDocument } from './native-ink-canvas/documentBridge';
 import { trimIfNeeded } from './utils/trimIfNeeded';
 import React, {
   useRef,
@@ -206,6 +206,11 @@ export const NativeInkCanvas = forwardRef<
       lastToolSigRef.current = null;
       return loadDocument(node, pagePayloads, pageHeight);
     },
+    captureDocument: async (pageCount: number, pageHeight: number): Promise<string[]> => {
+      const node = findNodeHandle(nativeRef.current);
+      if (!node) throw new Error('View not found');
+      return captureDocument(node, pageCount, pageHeight);
+    },
     loadBase64Data: async (base64String: string): Promise<boolean> => {
       const node = findNodeHandle(nativeRef.current);
       if (!node) {
diff --git a/src/index.ts b/src/index.ts
index 3b189d1..6b7f5ec 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -35,7 +35,7 @@ export type {
   ContinuousEnginePoolToolState,
 } from "./ContinuousEnginePool";
 
-export { ContinuousDocumentCanvas, type ContinuousDocumentCanvasRef, type ContinuousDocumentCanvasProps } from "./infinite-ink-canvas/ContinuousDocumentCanvas";
+export { ContinuousDocumentCanvas, DocumentChangedDuringCaptureError, isDocumentCaptureSuperseded, type ContinuousDocumentCanvasRef, type ContinuousDocumentCanvasProps } from "./infinite-ink-canvas/ContinuousDocumentCanvas";
 export { InfiniteInkCanvas } from "./InfiniteInkCanvas";
 export type {
   InfiniteInkCanvasProps,
@@ -92,3 +92,4 @@ export type {
 export { composeDocument, partitionDocument, projectDocumentPages } from "./native-ink-canvas/documentBridge";
 
 export { getDocumentRenderViewport } from "./utils/documentViewport";
+export { resolveDocumentRenderTarget, MAX_NATIVE_RENDER_SCALE, type DocumentRenderTarget, type DocumentRenderLayout } from "./utils/documentRenderTarget";
diff --git a/src/infinite-ink-canvas/ContinuousDocumentCanvas.tsx b/src/infinite-ink-canvas/ContinuousDocumentCanvas.tsx
index dfd2452..6ceedff 100644
--- a/src/infinite-ink-canvas/ContinuousDocumentCanvas.tsx
+++ b/src/infinite-ink-canvas/ContinuousDocumentCanvas.tsx
@@ -4,14 +4,13 @@ import { GestureHandlerRootView } from 'react-native-gesture-handler';
 import { NativeInkCanvas, type NativeInkCanvasRef } from '../NativeInkCanvas';
 import ZoomableInkViewport, { type ZoomableInkViewportRef, type TouchExclusionRect } from '../ZoomableInkViewport';
 import { waitForNextFrame } from '../continuous-engine-pool/helpers';
-import { partitionDocument } from '../native-ink-canvas/documentBridge';
 import type { NotebookPage, SerializedNotebookData } from '../types';
 import type { InfiniteInkCanvasProps, InfiniteInkCanvasRef, InfiniteInkViewportTransform } from './types';
 import { DEFAULT_CONTENT_PADDING, DEFAULT_PAGE_HEIGHT, DEFAULT_PAGE_WIDTH } from './constants';
 import { clonePage, getVisiblePageIndex, parseNotebookData } from './notebookPages';
 import { createBlankPage, BLANK_PAGE_PAYLOAD, pageHasContent, pageHasPdfBackground } from '../utils/pageGrowth';
-import { getVisibleContentRect, getRevealTranslateY, getRevealTargetScreenY } from '../utils/viewportTransform';
-import { quantizeNativeRenderScale } from '../utils/nativeRenderScale';
+import { getRevealTranslateY, getRevealTargetScreenY } from '../utils/viewportTransform';
+import { resolveDocumentRenderTarget, type DocumentRenderTarget } from '../utils/documentRenderTarget';
 import { computeDataSignature } from '../utils/dataSignature';
 import { PageBackgrounds, PageBreaks } from './PageStack';
 import { selectionBoundsToTouchRect } from './selectionTouchRects';
@@ -27,6 +26,21 @@ export type ContinuousDocumentCanvasProps = InfiniteInkCanvasProps & {
   onHistoryAction?: (action: "undo" | "redo") => void;
 };
 
+/**
+ * A save was superseded: ink or pages changed while it captured. Nothing is
+ * wrong with the document; the change that superseded it should save again.
+ */
+export class DocumentChangedDuringCaptureError extends Error {
+  constructor() {
+    super('Document changed during capture; retry saving its current state');
+    this.name = 'DocumentChangedDuringCaptureError';
+  }
+}
+
+/** Checks by name so it also holds when Error subclasses are transpiled. */
+export const isDocumentCaptureSuperseded = (error: unknown): boolean =>
+  error instanceof Error && error.name === 'DocumentChangedDuringCaptureError';
+
 // Page payloads retain whole crossing strokes and global drawing order. All
 // pages are captured together; committing a dirty subset would corrupt order.
 export const ContinuousDocumentCanvas = forwardRef<ContinuousDocumentCanvasRef, ContinuousDocumentCanvasProps>(function ContinuousDocumentCanvas(props, ref) {
@@ -54,7 +68,14 @@ export const ContinuousDocumentCanvas = forwardRef<ContinuousDocumentCanvasRef,
   const appendAfterStroke = useRef(false);
   const dirtyPages = useRef(new Set<string>());
   const [visiblePage, setVisiblePage] = useState(0);
-  const [transform, setTransform] = useState<InfiniteInkViewportTransform | null>(null);
+  // Viewport updates arrive every frame; only a changed render target may
+  // re-render this tree or the native surface (see resolveDocumentRenderTarget).
+  const transformRef = useRef<InfiniteInkViewportTransform | null>(null);
+  const isMoving = useRef(false);
+  const renderLayout = useCallback(() => ({ pageWidth, pageHeight, pageCount: pagesRef.current.length, contentPadding }),
+    [contentPadding, pageHeight, pageWidth]);
+  const [renderTarget, setRenderTarget] = useState<DocumentRenderTarget>(
+    () => resolveDocumentRenderTarget(null, null, renderLayout(), false));
   const [selectionRects, setSelectionRects] = useState<TouchExclusionRect[]>([]);
   const documentHeight = pages.length * pageHeight;
   const density = PixelRatio.get();
@@ -131,11 +152,9 @@ export const ContinuousDocumentCanvas = forwardRef<ContinuousDocumentCanvasRef,
       return { ...snapshot, pages: snapshot.pages.map(page => ({ ...page })) };
     }
     const source = pagesRef.current;
-    const payload = await native.getBase64Data();
-    if (!payload) throw new Error('Native document serialization returned no data');
-    const partitions = await partitionDocument(payload, source.length, pageHeight * density);
+    const partitions = await native.captureDocument(source.length, pageHeight * density);
     if (!mounted.current || !ready.current || native !== canvas.current || version !== revision.current || source !== pagesRef.current)
-      throw new Error('Document changed during capture; retry saving its current state');
+      throw new DocumentChangedDuringCaptureError();
     if (partitions.length !== source.length) throw new Error('Incomplete document partition');
     const capturedPages = source.map((page, i) => ({ ...page, data: partitions[i], dataSignature: computeDataSignature(partitions[i]),
       previewUri: undefined, previewDataSignature: undefined }));
@@ -188,34 +207,41 @@ export const ContinuousDocumentCanvas = forwardRef<ContinuousDocumentCanvasRef,
       return canvas.current.stopBenchmarkRecording();
     },
   }), [addPage, capture, contentPadding, density, load, pageHeight, scrollToPage]);
+  const updateRenderTarget = useCallback(() => {
+    const layout = renderLayout();
+    setRenderTarget(previous => resolveDocumentRenderTarget(previous, transformRef.current, layout, isMoving.current));
+  }, [renderLayout]);
+  useEffect(updateRenderTarget, [pages.length, updateRenderTarget]);
+  const onMotionStateChange = useCallback((moving: boolean) => {
+    isMoving.current = moving;
+    updateRenderTarget();
+    callbacks.current.onMotionStateChange?.(moving);
+  }, [updateRenderTarget]);
   const onTransform = useCallback((next: InfiniteInkViewportTransform) => {
-    setTransform(next);
+    transformRef.current = next;
+    updateRenderTarget();
     const index = getVisiblePageIndex(next, pageHeight, pagesRef.current.length, contentPadding);
     if (index !== currentPage.current) {
       currentPage.current = index; setVisiblePage(index);
       callbacks.current.onCurrentPageChange?.(index);
     }
     callbacks.current.onTransformChange?.(next);
-  }, [contentPadding, pageHeight]);
-  const rect = transform ? getVisibleContentRect(transform) : { left: 0, top: 0, width: pageWidth, height: pageHeight };
-  const left = Math.max(0, rect.left - ((transform?.containerWidth ?? pageWidth) - pageWidth) / 2);
-  const top = Math.max(0, Math.min(documentHeight - 1, rect.top - contentPadding));
+  }, [contentPadding, pageHeight, updateRenderTarget]);
   return <GestureHandlerRootView style={[styles.root, props.style]}>
     <ZoomableInkViewport ref={viewport} style={styles.viewport} minScale={props.minScale ?? 1} maxScale={props.maxScale ?? 5}
       contentWidth={pageWidth} contentHeight={documentHeight} contentPadding={contentPadding} isLandscape
       fingerDrawingEnabled={props.fingerDrawingEnabled} enableMomentumScroll lockHorizontalPanNearFit
       blockedTouchRects={selectionRects} singleFingerPanBlocked={selectionRects.length > 0}
       transformNotificationMinIntervalMs={props.transformNotificationMinIntervalMs ?? 16}
-      onTransformChange={onTransform} onMotionStateChange={props.onMotionStateChange}>
+      onTransformChange={onTransform} onMotionStateChange={onMotionStateChange}>
       <View style={[styles.canvasShell, { paddingTop: contentPadding, paddingBottom: contentPadding }]}>
         <View testID="continuous-document-input" pointerEvents={inputReady ? "auto" : "none"} style={{ width: pageWidth, height: documentHeight }}>
           <PageBackgrounds pages={pages} pageWidth={pageWidth} pageHeight={pageHeight} backgroundType={props.backgroundType ?? 'plain'}
             pdfBackgroundBaseUri={props.pdfBackgroundBaseUri} visiblePageIndex={visiblePage} showPageLabels={props.showPageLabels ?? true} />
           <NativeInkCanvas ref={canvas} style={StyleSheet.absoluteFillObject} continuousDocument backgroundType="pdf"
-            renderBackend={props.renderBackend} renderScale={quantizeNativeRenderScale(transform?.scale ?? 1, 5)}
-            renderViewportLeftRatio={left / pageWidth} renderViewportTopRatio={top / documentHeight}
-            renderViewportWidthRatio={Math.max(1, Math.min(pageWidth - left, rect.width)) / pageWidth}
-            renderViewportHeightRatio={Math.max(1, Math.min(documentHeight - top, rect.height)) / documentHeight}
+            renderBackend={props.renderBackend} renderScale={renderTarget.renderScale}
+            renderViewportLeftRatio={renderTarget.leftRatio} renderViewportTopRatio={renderTarget.topRatio}
+            renderViewportWidthRatio={renderTarget.widthRatio} renderViewportHeightRatio={renderTarget.heightRatio}
             drawingPolicy={props.fingerDrawingEnabled ? 'anyinput' : 'pencilonly'} onCanvasReady={onReady}
             onDrawingBegin={event => {
               revision.current++;
@@ -245,7 +271,7 @@ export const ContinuousDocumentCanvas = forwardRef<ContinuousDocumentCanvasRef,
             }}
             onSelectionChange={({ nativeEvent: { count, bounds } }) => {
               const touchRect = selectionBoundsToTouchRect({ bounds: bounds ?? null, pageIndex: 0, pageWidth, pageHeight,
-                contentPadding, containerWidth: transform?.containerWidth ?? pageWidth });
+                contentPadding, containerWidth: transformRef.current?.containerWidth ?? pageWidth });
               setSelectionRects(count && touchRect ? [touchRect] : []);
               const index = bounds ? Math.max(0, Math.min(pagesRef.current.length - 1, Math.floor(bounds.y / pageHeight))) : currentPage.current;
               const page = pagesRef.current[index];
diff --git a/src/infinite-ink-canvas/__tests__/ContinuousDocumentCanvas.test.tsx b/src/infinite-ink-canvas/__tests__/ContinuousDocumentCanvas.test.tsx
index 387f0f4..4ad29b7 100644
--- a/src/infinite-ink-canvas/__tests__/ContinuousDocumentCanvas.test.tsx
+++ b/src/infinite-ink-canvas/__tests__/ContinuousDocumentCanvas.test.tsx
@@ -2,15 +2,11 @@ import React from 'react';
 import { act, render } from '@testing-library/react-native';
 import { ContinuousDocumentCanvas, type ContinuousDocumentCanvasRef } from '../ContinuousDocumentCanvas';
 
-const mockPartition = jest.fn(async () => ['first', 'second']);
 const mockLoad = jest.fn(async (_payloads: string[], _height: number) => true);
-const mockCapture = jest.fn(async () => 'document');
+const mockCapture = jest.fn(async (_count: number, _height: number) => ['first', 'second']);
 const mockClear = jest.fn();
 const mockRecordExternal = jest.fn(async () => true);
 let mockProps: any;
-jest.mock('../../native-ink-canvas/documentBridge', () => ({
-  partitionDocument: (...args: unknown[]) => (mockPartition as any)(...args),
-}));
 jest.mock('react-native-gesture-handler', () => ({ GestureHandlerRootView: require('react-native').View }));
 jest.mock('../PageStack', () => ({ PageBackgrounds: () => null, PageBreaks: () => null }));
 jest.mock('../../ZoomableInkViewport', () => ({ __esModule: true,
@@ -22,7 +18,7 @@ jest.mock('../../ZoomableInkViewport', () => ({ __esModule: true,
 jest.mock('../../NativeInkCanvas', () => ({
   NativeInkCanvas: require('react').forwardRef((props: any, ref: any) => {
     mockProps = props;
-    require('react').useImperativeHandle(ref, () => ({ loadDocument: mockLoad, getBase64Data: mockCapture,
+    require('react').useImperativeHandle(ref, () => ({ loadDocument: mockLoad, captureDocument: mockCapture,
       setTool: jest.fn(), clearDocumentPage: mockClear, recordExternalEdit: mockRecordExternal }));
     require('react').useEffect(() => { props.onCanvasReady(); }, [props.onCanvasReady]);
     return null;
@@ -47,18 +43,19 @@ it('retains blank pages and captures the whole document in order', async () => {
   act(() => mockProps.onDrawingChange());
   const result = await ref.current!.getNotebookData();
   expect(result.pages.map(p => p.data)).toEqual(['first', 'second']);
+  expect(mockCapture).toHaveBeenCalledWith(2, 1000 * require('react-native').PixelRatio.get());
   expect(result.originalCanvasWidth).toBe(600);
   tree.unmount();
 });
 it('rejects a save whose document changed during native capture', async () => {
   const { ref, tree } = await setup();
-  let resolve!: (value: string) => void;
-  mockCapture.mockImplementationOnce(() => new Promise<string>(done => { resolve = done; }));
+  let resolve!: (value: string[]) => void;
+  mockCapture.mockImplementationOnce(() => new Promise<string[]>(done => { resolve = done; }));
   act(() => mockProps.onDrawingChange());
   const save = ref.current!.getNotebookData();
   mockProps.onDrawingChange();
-  resolve('document');
-  await expect(save).rejects.toThrow('Document changed');
+  resolve(['first', 'second']);
+  await expect(save).rejects.toBeInstanceOf(require('../ContinuousDocumentCanvas').DocumentChangedDuringCaptureError);
   tree.unmount();
 });
 it('uses point coordinates for the drawing owner and native coordinates for page clear', async () => {
@@ -94,7 +91,7 @@ it('adds one trailing blank page after writing on the last page without growing
     mockProps.onDrawingChange();
     mockProps.onDrawingChange();
   });
-  mockPartition.mockResolvedValueOnce(['first', 'second', '{"pages":{}}']);
+  mockCapture.mockResolvedValueOnce(['first', 'second', '{"pages":{}}']);
   const saved = await ref.current!.getNotebookData();
   expect(saved.pages).toHaveLength(3);
   expect(saved.pages[0].id).toBe('a');
diff --git a/src/native-ink-canvas/documentBridge.ts b/src/native-ink-canvas/documentBridge.ts
index 59c617e..af6511b 100644
--- a/src/native-ink-canvas/documentBridge.ts
+++ b/src/native-ink-canvas/documentBridge.ts
@@ -5,6 +5,7 @@ interface DocumentBridge {
   projectDocumentPages(payloads: string[], pageHeight: number, pageIndices: number[]): Promise<string[]>;
   composeDocument(payloads: string[], pageHeight: number): Promise<string>;
   partitionDocument(payload: string, pageCount: number, pageHeight: number): Promise<string[]>;
+  captureDocument(viewTag: number, pageCount: number, pageHeight: number): Promise<string[]>;
 }
 function bridge(): DocumentBridge {
   const native = NativeModules.MobileInkDocumentBridge as DocumentBridge | undefined;
@@ -18,6 +19,15 @@ export function partitionDocument(payload: string, pageCount: number, pageHeight
   return bridge().partitionDocument(payload, pageCount, pageHeight);
 }
 
+/**
+ * Page payloads of a mounted continuous canvas. Native copies the strokes on
+ * the drawing thread and partitions the copy in the background; the whole
+ * document never crosses into JavaScript.
+ */
+export function captureDocument(viewTag: number, pageCount: number, pageHeight: number): Promise<string[]> {
+  return bridge().captureDocument(viewTag, pageCount, pageHeight);
+}
+
 /** Render-only payloads containing neighboring overflow. Do not save these. */
 export function projectDocumentPages(payloads: string[], pageHeight: number, pageIndices: number[]): Promise<string[]> {
   return bridge().projectDocumentPages(payloads, pageHeight, pageIndices);
diff --git a/src/native-ink-canvas/types.ts b/src/native-ink-canvas/types.ts
index 3a98b72..769d789 100644
--- a/src/native-ink-canvas/types.ts
+++ b/src/native-ink-canvas/types.ts
@@ -46,6 +46,8 @@ export interface NativeInkCanvasRef {
   getBase64Data: () => Promise<string>;
   loadBase64Data: (base64String: string) => Promise<boolean>;
   loadDocument: (pagePayloads: string[], pageHeight: number) => Promise<boolean>;
+  /** Continuous canvases only: persistent page payloads, captured off the UI thread. */
+  captureDocument: (pageCount: number, pageHeight: number) => Promise<string[]>;
   /**
    * Eagerly release the heavy native state (~13 MB pixel buffer + the
    * C++ drawing engine + queued JS callbacks) without waiting for ARC.
diff --git a/src/utils/__tests__/documentRenderTarget.test.ts b/src/utils/__tests__/documentRenderTarget.test.ts
new file mode 100644
index 0000000..0c3fb55
--- /dev/null
+++ b/src/utils/__tests__/documentRenderTarget.test.ts
@@ -0,0 +1,88 @@
+import { resolveDocumentRenderTarget, type DocumentRenderTarget } from '../documentRenderTarget';
+
+const layout = { pageWidth: 800, pageHeight: 1000, pageCount: 100, contentPadding: 16, pixelRatio: 2, maxRenderScale: 5 };
+const at = (translateY: number, scale = 1, translateX = 0) => ({
+  scale, translateX, translateY, containerWidth: 800, containerHeight: 600,
+});
+const rectOf = (t: DocumentRenderTarget, documentHeight = 100000) => ({
+  top: t.topRatio * documentHeight, bottom: (t.topRatio + t.heightRatio) * documentHeight,
+  left: t.leftRatio * 800, right: (t.leftRatio + t.widthRatio) * 800,
+});
+
+describe('continuous document render target', () => {
+  it('renders beyond the visible rows so small pans reuse the same target', () => {
+    const first = resolveDocumentRenderTarget(null, at(-5000), layout, true);
+    const rect = rectOf(first);
+    // Visible document rows are 4984..5584; overscan covers 300pt on each side.
+    expect(rect.top).toBeCloseTo(4684);
+    expect(rect.bottom).toBeCloseTo(5884);
+    expect(resolveDocumentRenderTarget(first, at(-5200), layout, true)).toBe(first);
+    expect(resolveDocumentRenderTarget(first, at(-4800), layout, true)).toBe(first);
+    expect(resolveDocumentRenderTarget(first, at(-5200), layout, false)).toBe(first);
+  });
+
+  it('re-renders once the visible area leaves the rendered target', () => {
+    const first = resolveDocumentRenderTarget(null, at(-5000), layout, true);
+    const next = resolveDocumentRenderTarget(first, at(-5400), layout, true);
+    expect(next).not.toBe(first);
+    const rect = rectOf(next);
+    expect(rect.top).toBeLessThanOrEqual(5384);
+    expect(rect.bottom).toBeGreaterThanOrEqual(5984);
+  });
+
+  it('holds resolution during a pinch and sharpens when motion settles', () => {
+    const settled = resolveDocumentRenderTarget(null, at(-5000), layout, false);
+    expect(settled.renderScale).toBe(1);
+    const pinching = resolveDocumentRenderTarget(settled, at(-10000, 2), layout, true);
+    expect(pinching.renderScale).toBe(1);
+    const released = resolveDocumentRenderTarget(pinching, at(-10000, 2), layout, false);
+    expect(released.renderScale).toBe(2);
+  });
+
+  it('settles at the nearest resolution bucket when it fits the native cap', () => {
+    expect(resolveDocumentRenderTarget(null, at(-10000, 1.4), layout, false).renderScale).toBe(1.5);
+    expect(resolveDocumentRenderTarget(null, at(-10000, 3.6), layout, false).renderScale).toBe(4);
+    expect(resolveDocumentRenderTarget(null, at(-10000, 3.6), { ...layout, maxRenderScale: 3 }, false).renderScale).toBe(3);
+    // A full-height 2600pt view at 1.4x would need 2600 / 1.4 * 2 * 1.5 > 4000 px.
+    const tall = { scale: 1.4, translateX: 0, translateY: -10000, containerWidth: 800, containerHeight: 2600 };
+    expect(resolveDocumentRenderTarget(null, tall, layout, false).renderScale).toBe(1);
+  });
+
+  it('drops a held resolution when zooming out would exceed the native pixel cap', () => {
+    const zoomed = resolveDocumentRenderTarget(null, at(-10000, 5), layout, false);
+    expect(zoomed.renderScale).toBe(5);
+    const out = resolveDocumentRenderTarget(zoomed, at(-5000, 1), layout, true);
+    expect(out.renderScale).toBe(1);
+  });
+
+  it('never exceeds the native per-side pixel cap and stays inside the document', () => {
+    for (const [translateY, scale] of [[0, 1], [-1e6, 1], [1e6, 3], [-50000, 5]] as const) {
+      const target = resolveDocumentRenderTarget(null, at(translateY, scale), layout, false);
+      const rect = rectOf(target);
+      const px = 2 * target.renderScale;
+      expect((rect.bottom - rect.top) * px).toBeLessThanOrEqual(4000.5);
+      expect((rect.right - rect.left) * px).toBeLessThanOrEqual(4000.5);
+      expect(target.topRatio).toBeGreaterThanOrEqual(0);
+      expect(target.topRatio + target.heightRatio).toBeLessThanOrEqual(1 + 1e-9);
+      expect(target.leftRatio + target.widthRatio).toBeLessThanOrEqual(1 + 1e-9);
+    }
+  });
+
+  it('re-resolves when added pages stretch a reused target past the cap', () => {
+    const small = { ...layout, pageCount: 2 };
+    const first = resolveDocumentRenderTarget(null, at(-500), small, false);
+    const grown = resolveDocumentRenderTarget(first, at(-500), { ...small, pageCount: 4 }, false);
+    expect(grown).not.toBe(first);
+    const rect = rectOf(grown, 4000);
+    expect((rect.bottom - rect.top) * 2).toBeLessThanOrEqual(4000.5);
+  });
+
+  it('stays finite and stable for degenerate layout or transform values', () => {
+    const bad = { pageWidth: Number.NaN, pageHeight: 0, pageCount: Number.POSITIVE_INFINITY, contentPadding: Number.NaN,
+      pixelRatio: Number.NaN, maxRenderScale: Number.NaN };
+    const transform = { scale: Number.NaN, translateX: Number.NaN, translateY: Number.NaN, containerWidth: 0, containerHeight: 0 };
+    const first = resolveDocumentRenderTarget(null, transform, bad, false);
+    for (const value of Object.values(first)) expect(Number.isFinite(value)).toBe(true);
+    expect(resolveDocumentRenderTarget(first, transform, bad, false)).toBe(first);
+  });
+});
diff --git a/src/utils/__tests__/nativeRenderScale.test.ts b/src/utils/__tests__/nativeRenderScale.test.ts
index 366bb8c..5aea911 100644
--- a/src/utils/__tests__/nativeRenderScale.test.ts
+++ b/src/utils/__tests__/nativeRenderScale.test.ts
@@ -22,3 +22,14 @@ describe("native render scale budgeting", () => {
     expect(quantizeNativeRenderScale(Number.NaN, 5)).toBe(1);
   });
 });
+
+describe('nearestNativeRenderScale', () => {
+  const { nearestNativeRenderScale } = require('../nativeRenderScale');
+  it('matches the native nearest-bucket choice within the allowed maximum', () => {
+    expect(nearestNativeRenderScale(1.2, 5)).toBe(1);
+    expect(nearestNativeRenderScale(1.3, 5)).toBe(1.5);
+    expect(nearestNativeRenderScale(3.6, 5)).toBe(4);
+    expect(nearestNativeRenderScale(4.9, 3)).toBe(3);
+    expect(nearestNativeRenderScale(Number.NaN, 5)).toBe(1);
+  });
+});
diff --git a/src/utils/documentRenderTarget.ts b/src/utils/documentRenderTarget.ts
new file mode 100644
index 0000000..3cdd98f
--- /dev/null
+++ b/src/utils/documentRenderTarget.ts
@@ -0,0 +1,119 @@
+import { PixelRatio } from 'react-native';
+import { getDocumentRenderViewport } from './documentViewport';
+import { nearestNativeRenderScale, quantizeNativeRenderScale } from './nativeRenderScale';
+import type { ViewportTransformLike } from './viewportTransform';
+
+/** Crop and resolution for a continuous-document native ink surface. */
+export type DocumentRenderTarget = {
+  renderScale: number;
+  leftRatio: number;
+  topRatio: number;
+  widthRatio: number;
+  heightRatio: number;
+};
+
+export type DocumentRenderLayout = {
+  pageWidth: number;
+  pageHeight: number;
+  pageCount: number;
+  contentPadding: number;
+  /** Device pixels per point; defaults to PixelRatio.get(). */
+  pixelRatio?: number;
+  /** Highest native render scale; defaults to MAX_NATIVE_RENDER_SCALE. */
+  maxRenderScale?: number;
+};
+
+/** Native engines clamp render scale to this (kMaximumRenderScale in C++). */
+export const MAX_NATIVE_RENDER_SCALE = 5;
+
+// Native iOS caps a continuous drawable at 4096 px per side; stay below it so
+// the native clamp never truncates the overscan asymmetrically.
+const MAX_TARGET_SIDE_PIXELS = 4000;
+// Fraction of the visible size rendered beyond each visible edge, so a pan
+// re-renders only after it moves this far instead of on every frame.
+const OVERSCAN_FRACTION = 0.5;
+
+type Rect = { left: number; top: number; right: number; bottom: number };
+
+const toRect = (target: Pick<DocumentRenderTarget, 'leftRatio' | 'topRatio' | 'widthRatio' | 'heightRatio'>,
+  width: number, height: number): Rect => ({
+  left: target.leftRatio * width,
+  top: target.topRatio * height,
+  right: (target.leftRatio + target.widthRatio) * width,
+  bottom: (target.topRatio + target.heightRatio) * height,
+});
+
+const contains = (outer: Rect, inner: Rect) => (
+  inner.left >= outer.left - 0.5 && inner.top >= outer.top - 0.5 &&
+  inner.right <= outer.right + 0.5 && inner.bottom <= outer.bottom + 0.5
+);
+
+const fitsPixelCap = (rect: Rect, scale: number, pixelRatio: number) => {
+  const pointsLimit = MAX_TARGET_SIDE_PIXELS / (pixelRatio * scale);
+  return rect.right - rect.left <= pointsLimit && rect.bottom - rect.top <= pointsLimit;
+};
+
+/** Grow a visible span by the overscan, capped and clamped to [0, extent]. */
+const expandSpan = (start: number, end: number, extent: number, limit: number): [number, number] => {
+  const size = end - start;
+  const desired = Math.max(size, Math.min(limit, size * (1 + 2 * OVERSCAN_FRACTION)));
+  const length = Math.min(extent, desired);
+  const center = (start + end) / 2;
+  const from = Math.max(0, Math.min(extent - length, center - length / 2));
+  return [from, from + length];
+};
+
+/**
+ * Returns `previous` unchanged while it still covers the visible document at
+ * the wanted resolution, so a pan or pinch does not re-render native ink every
+ * frame. While `isMoving`, the previous resolution is held (the view transform
+ * scales it) until the visible area no longer fits it; the settled call then
+ * resolves the crisp scale.
+ */
+export function resolveDocumentRenderTarget(
+  previous: DocumentRenderTarget | null,
+  transform: ViewportTransformLike | null,
+  layout: DocumentRenderLayout,
+  isMoving: boolean,
+): DocumentRenderTarget {
+  // Layout can be degenerate before the first native layout; never let NaN or
+  // Infinity reach native frame geometry.
+  const finite = (value: number, fallback: number) => (Number.isFinite(value) ? value : fallback);
+  const pageWidth = Math.max(1, finite(layout.pageWidth, 1));
+  const pageHeight = Math.max(1, finite(layout.pageHeight, 1));
+  const pageCount = Math.max(1, finite(layout.pageCount, 1));
+  const contentPadding = Math.max(0, finite(layout.contentPadding, 0));
+  const width = pageWidth;
+  const height = pageHeight * pageCount;
+  const requestedRatio = layout.pixelRatio ?? PixelRatio.get();
+  const pixelRatio = Math.max(1, Number.isFinite(requestedRatio) ? requestedRatio : 1);
+  const maxRenderScale = layout.maxRenderScale ?? MAX_NATIVE_RENDER_SCALE;
+  const visible = toRect(getDocumentRenderViewport(transform, pageWidth, pageHeight,
+    pageCount, contentPadding), width, height);
+  // Prefer the nearest bucket for crisp settled ink; the lower bucket always
+  // fits because its visible pixels never exceed the screen's.
+  const zoom = transform?.scale ?? 1;
+  const nearestScale = nearestNativeRenderScale(zoom, maxRenderScale);
+  const settledScale = fitsPixelCap(visible, nearestScale, pixelRatio)
+    ? nearestScale : quantizeNativeRenderScale(zoom, maxRenderScale);
+  const scale = isMoving && previous && fitsPixelCap(visible, previous.renderScale, pixelRatio)
+    ? previous.renderScale : settledScale;
+
+  if (previous && previous.renderScale === scale) {
+    // Ratios are relative to the document, so a page added since `previous`
+    // can grow its rect past the native cap; re-resolve in that case.
+    const rendered = toRect(previous, width, height);
+    if (contains(rendered, visible) && fitsPixelCap(rendered, scale, pixelRatio)) return previous;
+  }
+
+  const limit = MAX_TARGET_SIDE_PIXELS / (pixelRatio * scale);
+  const [left, right] = expandSpan(visible.left, visible.right, width, limit);
+  const [top, bottom] = expandSpan(visible.top, visible.bottom, height, limit);
+  return {
+    renderScale: scale,
+    leftRatio: left / width,
+    topRatio: top / height,
+    widthRatio: Math.max(1, right - left) / width,
+    heightRatio: Math.max(1, bottom - top) / height,
+  };
+}
diff --git a/src/utils/nativeRenderScale.ts b/src/utils/nativeRenderScale.ts
index c0087cb..2080baa 100644
--- a/src/utils/nativeRenderScale.ts
+++ b/src/utils/nativeRenderScale.ts
@@ -15,20 +15,28 @@ export const getNativeRenderScaleBudget = (
   return Math.max(1, Math.min(5, Math.sqrt(MAX_NATIVE_DRAWABLE_PIXELS / basePixelArea)));
 };
 
+const finiteOr = (value: number, fallback: number) => (Number.isFinite(value) ? value : fallback);
+const renderScaleLimit = (maxScale: number) => Math.max(1, finiteOr(maxScale, 1));
+const clampRenderScale = (scale: number, maxScale: number) =>
+  Math.max(1, Math.min(renderScaleLimit(maxScale), finiteOr(scale, 1)));
+
+/** The highest bucket at or below `scale`. */
 export const quantizeNativeRenderScale = (scale: number, maxScale: number) => {
-  const targetScale = Math.max(
-    1,
-    Math.min(
-      Number.isFinite(maxScale) ? maxScale : 1,
-      Number.isFinite(scale) ? scale : 1,
-    ),
-  );
+  const target = clampRenderScale(scale, maxScale);
   let selected: number = NATIVE_RENDER_SCALE_BUCKETS[0];
   for (const bucket of NATIVE_RENDER_SCALE_BUCKETS) {
-    if (bucket <= targetScale + 0.001) {
-      selected = bucket;
-    }
+    if (bucket <= target + 0.001) selected = bucket;
   }
+  return selected;
+};
 
+/** The bucket native iOS would choose for `scale` (nearest, ties toward lower). */
+export const nearestNativeRenderScale = (scale: number, maxScale: number) => {
+  const limit = renderScaleLimit(maxScale);
+  const target = clampRenderScale(scale, maxScale);
+  let selected: number = NATIVE_RENDER_SCALE_BUCKETS[0];
+  for (const bucket of NATIVE_RENDER_SCALE_BUCKETS) {
+    if (bucket <= limit + 0.001 && Math.abs(bucket - target) < Math.abs(selected - target)) selected = bucket;
+  }
   return selected;
 };