@openeditor/react-native-prose-editor 0.0.7 → 0.0.8

package/ios/RichTextEditorView.swift

@@ -126,7 +126,7 @@ private final class RemoteSelectionOverlayView: UIView {
         let color: UIColor
     }
 
-    weak var textView: EditorTextView?
+    weak var documentSurface: NativeBlockEditorSurface?
     private var editorId: UInt64 = 0
     private var selections: [RemoteSelectionDecoration] = []
     private var selectionViews: [UIView] = []
@@ -143,8 +143,8 @@ private final class RemoteSelectionOverlayView: UIView {
         return nil
     }
 
-    func bind(textView: EditorTextView) {
-        self.textView = textView
+    func bind(documentSurface: NativeBlockEditorSurface) {
+        self.documentSurface = documentSurface
     }
 
     func update(selections: [RemoteSelectionDecoration], editorId: UInt64) {
@@ -155,7 +155,7 @@ private final class RemoteSelectionOverlayView: UIView {
 
     func refresh() {
         guard editorId != 0,
-              let textView
+              let documentSurface
         else {
             syncSelectionViews(with: [])
             syncCaretViews(with: [])
@@ -166,7 +166,7 @@ private final class RemoteSelectionOverlayView: UIView {
         var caretRects: [ColoredRect] = []
 
         for selection in selections {
-            let geometry = geometry(for: selection, in: textView)
+            let geometry = geometry(for: selection, in: documentSurface)
             for rect in geometry.selectionRects {
                 selectionRects.append(
                     ColoredRect(
@@ -209,76 +209,18 @@ private final class RemoteSelectionOverlayView: UIView {
 
     private func geometry(
         for selection: RemoteSelectionDecoration,
-        in textView: EditorTextView
+        in documentSurface: NativeBlockEditorSurface
     ) -> (selectionRects: [CGRect], caretRect: CGRect?) {
-        let startScalar = editorDocToScalar(
-            id: editorId,
-            docPos: min(selection.anchor, selection.head)
-        )
-        let endScalar = editorDocToScalar(
-            id: editorId,
-            docPos: max(selection.anchor, selection.head)
-        )
-
-        let startPosition = PositionBridge.scalarToTextView(startScalar, in: textView)
-        let endPosition = PositionBridge.scalarToTextView(endScalar, in: textView)
-        let caretRect = resolvedCaretRect(
-            for: endPosition,
-            in: textView
-        )
-
-        if startScalar == endScalar {
-            return ([], caretRect)
-        }
-
-        guard let range = textView.textRange(from: startPosition, to: endPosition) else {
-            return ([], caretRect)
-        }
-
-        let selectionRects = textView.selectionRects(for: range)
-            .map(\.rect)
-            .filter { !$0.isEmpty && $0.width > 0 && $0.height > 0 }
-            .map { textView.convert($0, to: self) }
-
+        let selectionRects = documentSurface
+            .selectionRects(anchor: selection.anchor, head: selection.head)
+            .map { documentSurface.convert($0, to: self) }
+        let caretRect = selection.isFocused
+            ? documentSurface.caretRect(forDocPosition: selection.head)
+                .map { documentSurface.convert($0, to: self) }
+            : nil
         return (selectionRects, caretRect)
     }
 
-    private func resolvedCaretRect(
-        for position: UITextPosition,
-        in textView: EditorTextView
-    ) -> CGRect? {
-        let directRect = textView.convert(textView.caretRect(for: position), to: self)
-        if directRect.height > 0, directRect.width >= 0 {
-            return directRect
-        }
-
-        if let previousPosition = textView.position(from: position, offset: -1),
-           let previousRange = textView.textRange(from: previousPosition, to: position),
-           let previousRect = textView.selectionRects(for: previousRange)
-               .map(\.rect)
-               .last(where: { !$0.isEmpty && $0.height > 0 })
-        {
-            let rect = textView.convert(previousRect, to: self)
-            return CGRect(x: rect.maxX, y: rect.minY, width: 2, height: rect.height)
-        }
-
-        if let nextPosition = textView.position(from: position, offset: 1),
-           let nextRange = textView.textRange(from: position, to: nextPosition),
-           let nextRect = textView.selectionRects(for: nextRange)
-               .map(\.rect)
-               .first(where: { !$0.isEmpty && $0.height > 0 })
-        {
-            let rect = textView.convert(nextRect, to: self)
-            return CGRect(x: rect.minX, y: rect.minY, width: 2, height: rect.height)
-        }
-
-        if directRect.isEmpty {
-            return nil
-        }
-
-        return directRect
-    }
-
     private func syncSelectionViews(with rects: [ColoredRect]) {
         syncViews(rects, existingViews: &selectionViews) { view, rect in
             view.frame = rect.frame
@@ -347,15 +289,15 @@ private final class ImageTapOverlayView: UIView {
 
     override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
         guard let editorView else { return false }
-        let pointInTextView = convert(point, to: editorView.textView)
-        return editorView.textView.hasImageAttachment(at: pointInTextView)
+        return editorView.blockSurfaceHasImage(at: convert(point, to: editorView))
     }
 
     @objc
     private func handleTap(_ recognizer: UITapGestureRecognizer) {
         guard recognizer.state == .ended, let editorView else { return }
-        let pointInTextView = convert(recognizer.location(in: self), to: editorView.textView)
-        _ = editorView.textView.selectImageAttachment(at: pointInTextView)
+        _ = editorView.selectBlockSurfaceImage(
+            at: convert(recognizer.location(in: self), to: editorView)
+        )
     }
 
     func interceptsPointForTesting(_ point: CGPoint) -> Bool {
@@ -365,8 +307,7 @@ private final class ImageTapOverlayView: UIView {
     @discardableResult
     func handleTapForTesting(_ point: CGPoint) -> Bool {
         guard let editorView else { return false }
-        let pointInTextView = convert(point, to: editorView.textView)
-        return editorView.textView.selectImageAttachment(at: pointInTextView)
+        return editorView.selectBlockSurfaceImage(at: convert(point, to: editorView))
     }
 }
 
@@ -784,11 +725,11 @@ final class EditorTextViewInternalDelegate: NSObject, UITextViewDelegate {
 /// Instead of letting UITextView's internal text storage handle insertions
 /// and deletions, this class captures the user's intent (typing, deleting,
 /// pasting, autocorrect) and sends it to the Rust editor. The Rust editor
-/// returns render elements, which are converted to NSAttributedString via
-/// RenderBridge and applied back to the text view.
+/// returns a canonical plain-text input snapshot, which is authorized and
+/// applied back to this hidden input adapter.
 ///
 /// This is the "input interception" pattern: the UITextView is effectively
-/// a rendering surface, not a text editing engine.
+/// an IME/selection surface, not the visible block renderer.
 ///
 /// ## Composition (IME) Handling
 ///
@@ -848,25 +789,6 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         let postApplySelectionOrContentCallbackNanos: UInt64
     }
 
-    private struct PatchApplyTrace {
-        let applied: Bool
-        let eligibilityNanos: UInt64
-        let trimNanos: UInt64
-        let metadataNanos: UInt64
-        let buildRenderNanos: UInt64
-        let applyRenderNanos: UInt64
-        let applyRenderReplaceUtf16Length: Int
-        let applyRenderReplacementUtf16Length: Int
-        let applyRenderTextMutationNanos: UInt64
-        let applyRenderBeginEditingNanos: UInt64
-        let applyRenderEndEditingNanos: UInt64
-        let applyRenderStringMutationNanos: UInt64
-        let applyRenderAttributeMutationNanos: UInt64
-        let applyRenderAuthorizedTextNanos: UInt64
-        let applyRenderCacheInvalidationNanos: UInt64
-        let usedSmallPatchTextMutation: Bool
-    }
-
     private struct ApplyRenderTrace {
         let totalNanos: UInt64
         let replaceUtf16Length: Int
@@ -901,17 +823,6 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         let selectionOrContentCallbackNanos: UInt64
     }
 
-    private struct TopLevelChildMetadata {
-        var startOffset: Int
-        var containsAttachment: Bool
-        var containsPositionAdjustments: Bool
-    }
-
-    private struct TopLevelChildMetadataSlice {
-        let startIndex: Int
-        let entries: [TopLevelChildMetadata]
-    }
-
     private struct NativeTextMutation {
         let from: UInt32
         let to: UInt32
@@ -935,13 +846,6 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         case rejected
     }
 
-    private enum PositionCacheUpdate {
-        case scan
-        case invalidate
-        case plainText
-        case attributed
-    }
-
     // MARK: - Properties
 
     /// The Rust editor instance ID (from editor_create / editor_create_with_max_length).
@@ -1027,6 +931,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
 
     /// Delegate for editor events.
     weak var editorDelegate: EditorTextViewDelegate?
+    var onUpdateJSONApplied: ((String) -> Void)?
 
     /// The plain text from the last Rust render, used by the reconciliation
     /// fallback to detect unauthorized text storage mutations.
@@ -1038,8 +943,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
     private(set) var lastRenderAppliedPatchForTesting: Bool = false
     var captureApplyUpdateTraceForTesting = false
     private(set) var lastApplyUpdateTraceForTesting: ApplyUpdateTrace?
-    private var currentRenderBlocks: [[[String: Any]]]? = nil
-    private var currentTopLevelChildMetadata: [TopLevelChildMetadata]? = nil
+    var pasteboardDataForTesting: [String: Data]?
     private var renderAppearanceRevision: UInt64 = 1
     private var lastAppliedRenderAppearanceRevision: UInt64 = 0
 
@@ -1110,7 +1014,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
     private var markedTextCompositionText: String?
     private var markedTextCompositionIsExplicitlyEmpty = false
 
-    private let editorLayoutManager: EditorLayoutManager
+    private let editorLayoutManager: NSLayoutManager
 
     private struct InputTraitState {
         var autoCapitalize: String?
@@ -1156,7 +1060,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
     // MARK: - Initialization
 
     override init(frame: CGRect, textContainer: NSTextContainer?) {
-        let layoutManager = EditorLayoutManager()
+        let layoutManager = NSLayoutManager()
         let container = textContainer ?? NSTextContainer(size: .zero)
         let textStorage = NSTextStorage()
         layoutManager.addTextContainer(container)
@@ -1755,7 +1659,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
             guard value is NSTextAttachment, range.length > 0 else { return }
 
             let attrs = textStorage.attributes(at: range.location, effectiveRange: nil)
-            guard (attrs[RenderBridgeAttributes.voidNodeType] as? String) == "image" else { return }
+            guard (attrs[InputCoordinatorAttributes.voidNodeType] as? String) == "image" else { return }
 
             let glyphRange = layoutManager.glyphRange(
                 forCharacterRange: range,
@@ -1801,15 +1705,15 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
     }
 
     func blockquoteStripeRectsForTesting() -> [CGRect] {
-        editorLayoutManager.blockquoteStripeRectsForTesting(in: textStorage)
+        []
     }
 
     func resetBlockquoteStripeDrawPassesForTesting() {
-        editorLayoutManager.resetBlockquoteStripeDrawPassesForTesting()
+        // Blockquote geometry belongs to the structural surface.
     }
 
     func blockquoteStripeDrawPassesForTesting() -> [[CGRect]] {
-        editorLayoutManager.blockquoteStripeDrawPassesForTesting
+        []
     }
 
     @discardableResult
@@ -1818,16 +1722,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
     }
 
     private func taskListMarkerParagraphStart(at location: CGPoint) -> Int? {
-        guard let layoutManager = layoutManager as? EditorLayoutManager else { return nil }
-        let origin = CGPoint(
-            x: textContainerInset.left - contentOffset.x,
-            y: textContainerInset.top - contentOffset.y
-        )
-        return layoutManager.taskListMarkerParagraphStart(
-            at: location,
-            in: textStorage,
-            textContainerOrigin: origin
-        )
+        nil
     }
 
     func imageSelectionTapWouldHandleForTesting(at location: CGPoint) -> Bool {
@@ -2234,7 +2129,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         }
         let attrs = textStorage.attributes(at: cursorUtf16Offset, effectiveRange: nil)
         guard attrs[.attachment] is NSTextAttachment,
-              attrs[RenderBridgeAttributes.voidNodeType] as? String != nil,
+              attrs[InputCoordinatorAttributes.voidNodeType] as? String != nil,
               cursorScalar < UInt32.max
         else {
             return nil
@@ -2280,7 +2175,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         }
         let attrs = textStorage.attributes(at: utf16Offset, effectiveRange: nil)
         guard attrs[.attachment] is NSTextAttachment,
-              attrs[RenderBridgeAttributes.voidNodeType] as? String != nil
+              attrs[InputCoordinatorAttributes.voidNodeType] as? String != nil
         else {
             return nil
         }
@@ -2643,9 +2538,15 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         )
 
         let pasteboard = UIPasteboard.general
+        let pasteboardData: (String) -> Data? = { [pasteboardDataForTesting] type in
+            if let pasteboardDataForTesting {
+                return pasteboardDataForTesting[type]
+            }
+            return pasteboard.data(forPasteboardType: type)
+        }
 
         // Try HTML first for rich paste.
-        if let htmlData = pasteboard.data(forPasteboardType: "public.html"),
+        if let htmlData = pasteboardData("public.html"),
            let html = String(data: htmlData, encoding: .utf8) {
             performInterceptedInput {
                 pasteHTML(html)
@@ -2654,7 +2555,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         }
 
         // Try attributed string (e.g. from Notes, Pages).
-        if let rtfData = pasteboard.data(forPasteboardType: "public.rtf") {
+        if let rtfData = pasteboardData("public.rtf") {
             if let attrStr = try? NSAttributedString(
                 data: rtfData,
                 options: [.documentType: NSAttributedString.DocumentType.rtf],
@@ -2735,7 +2636,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         }
 
         let attrs = textStorage.attributes(at: characterRange.location, effectiveRange: nil)
-        guard (attrs[RenderBridgeAttributes.voidNodeType] as? String) == "image",
+        guard (attrs[InputCoordinatorAttributes.voidNodeType] as? String) == "image",
               let start = position(from: beginningOfDocument, offset: characterRange.location),
               let end = position(from: start, offset: characterRange.length)
         else {
@@ -2920,6 +2821,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         editorSetSelectionScalar(id: editorId, scalarAnchor: anchor, scalarHead: head)
         recordAuthorizedSelectionIfPossible()
         refreshTypingAttributesForSelection()
+        onSelectionOrContentMayChange?()
         editorDelegate?.editorTextView(self, selectionDidChange: docAnchor, head: docHead)
     }
 
@@ -3321,13 +3223,13 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
 
         let attrs = textStorage.attributes(at: utf16Offset, effectiveRange: nil)
         return attrs[.attachment] is NSTextAttachment
-            && (attrs[RenderBridgeAttributes.voidNodeType] as? String) == "horizontalRule"
+            && (attrs[InputCoordinatorAttributes.voidNodeType] as? String) == "horizontalRule"
     }
 
     private func hardBreakBaselineY(after utf16Offset: Int) -> CGFloat? {
         guard utf16Offset > 0, utf16Offset <= textStorage.length else { return nil }
         let previousVoidType = textStorage.attribute(
-            RenderBridgeAttributes.voidNodeType,
+            InputCoordinatorAttributes.voidNodeType,
             at: utf16Offset - 1,
             effectiveRange: nil
         ) as? String
@@ -4102,14 +4004,14 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         }
 
         let attrs = textStorage.attributes(at: selectedRange.location, effectiveRange: nil)
-        guard (attrs[RenderBridgeAttributes.voidNodeType] as? String) == "image",
+        guard (attrs[InputCoordinatorAttributes.voidNodeType] as? String) == "image",
               attrs[.attachment] is NSTextAttachment
         else {
             return nil
         }
 
-        let docPos = (attrs[RenderBridgeAttributes.docPos] as? NSNumber)?.uint32Value
-            ?? (attrs[RenderBridgeAttributes.docPos] as? UInt32)
+        let docPos = (attrs[InputCoordinatorAttributes.docPos] as? NSNumber)?.uint32Value
+            ?? (attrs[InputCoordinatorAttributes.docPos] as? UInt32)
         guard let docPos else { return nil }
         return (docPos, selectedRange.location)
     }
@@ -4140,9 +4042,9 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         ) { value, range, stop in
             guard let attachment = value as? BlockImageAttachment, range.length > 0 else { return }
             let attrs = textStorage.attributes(at: range.location, effectiveRange: nil)
-            guard (attrs[RenderBridgeAttributes.voidNodeType] as? String) == "image" else { return }
-            let attributeDocPos = (attrs[RenderBridgeAttributes.docPos] as? NSNumber)?.uint32Value
-                ?? (attrs[RenderBridgeAttributes.docPos] as? UInt32)
+            guard (attrs[InputCoordinatorAttributes.voidNodeType] as? String) == "image" else { return }
+            let attributeDocPos = (attrs[InputCoordinatorAttributes.docPos] as? NSNumber)?.uint32Value
+                ?? (attrs[InputCoordinatorAttributes.docPos] as? UInt32)
             guard attributeDocPos == docPos else { return }
             resolved = (range, attachment)
             stop.pointee = true
@@ -4264,270 +4166,10 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
 
     // MARK: - Applying Rust State
 
-    private struct ParsedRenderPatch {
-        let startIndex: Int
-        let deleteCount: Int
-        let renderBlocks: [[[String: Any]]]
-    }
-
-    private enum DerivedRenderPatch {
-        case unchanged
-        case patch(ParsedRenderPatch)
-    }
-
-    private func parseRenderBlocks(_ value: Any?) -> [[[String: Any]]]? {
-        value as? [[[String: Any]]]
-    }
-
-    private func parseRenderPatch(_ value: Any?) -> ParsedRenderPatch? {
-        guard let raw = value as? [String: Any],
-              let startIndex = RenderBridge.jsonInt(raw["startIndex"]),
-              let deleteCount = RenderBridge.jsonInt(raw["deleteCount"]),
-              let renderBlocks = parseRenderBlocks(raw["renderBlocks"])
-        else {
-            return nil
-        }
-
-        return ParsedRenderPatch(
-            startIndex: startIndex,
-            deleteCount: deleteCount,
-            renderBlocks: renderBlocks
-        )
-    }
-
-    private func mergeRenderBlocks(
-        applying patch: ParsedRenderPatch,
-        to current: [[[String: Any]]]
-    ) -> [[[String: Any]]]? {
-        guard patch.startIndex >= 0,
-              patch.deleteCount >= 0,
-              patch.startIndex <= current.count,
-              patch.startIndex + patch.deleteCount <= current.count
-        else {
-            return nil
-        }
-
-        var merged = current
-        merged.replaceSubrange(
-            patch.startIndex..<(patch.startIndex + patch.deleteCount),
-            with: patch.renderBlocks
-        )
-        return merged
-    }
-
-    private func renderBlockEquals(
-        _ lhs: [[String: Any]],
-        _ rhs: [[String: Any]]
-    ) -> Bool {
-        (lhs as NSArray).isEqual(rhs)
-    }
-
-    private func deriveRenderPatch(
-        from current: [[[String: Any]]],
-        to updated: [[[String: Any]]]
-    ) -> DerivedRenderPatch {
-        let sharedCount = min(current.count, updated.count)
-
-        var prefix = 0
-        while prefix < sharedCount, renderBlockEquals(current[prefix], updated[prefix]) {
-            prefix += 1
-        }
-
-        if prefix == current.count, prefix == updated.count {
-            return .unchanged
-        }
-
-        var suffix = 0
-        while suffix < (sharedCount - prefix),
-              renderBlockEquals(
-                  current[current.count - suffix - 1],
-                  updated[updated.count - suffix - 1]
-              )
-        {
-            suffix += 1
-        }
-
-        let startIndex = prefix
-        let deleteCount = current.count - prefix - suffix
-        let endIndex = updated.count - suffix
-        let replacementBlocks = Array(updated[startIndex..<endIndex])
-
-        return .patch(
-            ParsedRenderPatch(
-                startIndex: startIndex,
-                deleteCount: deleteCount,
-                renderBlocks: replacementBlocks
-            )
-        )
-    }
-
-    private func topLevelChildIndex(from value: Any?) -> Int? {
-        if let number = value as? NSNumber {
-            return number.intValue
-        }
-        return value as? Int
-    }
-
-    private func topLevelChildMetadataSlice(
-        from attributedString: NSAttributedString
-    ) -> TopLevelChildMetadataSlice? {
-        guard attributedString.length > 0 else {
-            return TopLevelChildMetadataSlice(startIndex: 0, entries: [])
-        }
-
-        var entriesByIndex: [Int: TopLevelChildMetadata] = [:]
-        var orderedIndexes: [Int] = []
-
-        attributedString.enumerateAttributes(
-            in: NSRange(location: 0, length: attributedString.length),
-            options: []
-        ) { attrs, range, _ in
-            guard let index = topLevelChildIndex(from: attrs[RenderBridgeAttributes.topLevelChildIndex]) else {
-                return
-            }
-            if entriesByIndex[index] == nil {
-                entriesByIndex[index] = TopLevelChildMetadata(
-                    startOffset: range.location,
-                    containsAttachment: false,
-                    containsPositionAdjustments: false
-                )
-                orderedIndexes.append(index)
-            }
-            if attrs[.attachment] != nil {
-                entriesByIndex[index]?.containsAttachment = true
-            }
-            if attrs[RenderBridgeAttributes.syntheticPlaceholder] as? Bool == true
-                || attrs[RenderBridgeAttributes.listMarkerContext] != nil
-            {
-                entriesByIndex[index]?.containsPositionAdjustments = true
-            }
-        }
-
-        guard !orderedIndexes.isEmpty else { return nil }
-        orderedIndexes.sort()
-        guard let startIndex = orderedIndexes.first else { return nil }
-
-        var entries: [TopLevelChildMetadata] = []
-        entries.reserveCapacity(orderedIndexes.count)
-        for (offset, index) in orderedIndexes.enumerated() {
-            guard index == startIndex + offset,
-                  let entry = entriesByIndex[index]
-            else {
-                return nil
-            }
-            entries.append(entry)
-        }
-
-        return TopLevelChildMetadataSlice(startIndex: startIndex, entries: entries)
-    }
-
-    private func refreshTopLevelChildMetadata(
-        from attributedString: NSAttributedString
-    ) {
-        guard let slice = topLevelChildMetadataSlice(from: attributedString),
-              slice.startIndex == 0
-        else {
-            currentTopLevelChildMetadata = nil
-            return
-        }
-        currentTopLevelChildMetadata = slice.entries
-    }
-
-    private func applyTopLevelChildMetadataPatch(
-        _ patch: ParsedRenderPatch,
-        replaceRange: NSRange,
-        renderedPatchMetadata: TopLevelChildMetadataSlice?,
-        renderedPatchLength: Int
-    ) {
-        guard var currentMetadata = currentTopLevelChildMetadata else {
-            currentTopLevelChildMetadata = nil
-            return
-        }
-
-        let newEntries: [TopLevelChildMetadata]
-        if let renderedPatchMetadata,
-           renderedPatchMetadata.entries.isEmpty
-        {
-            newEntries = []
-        } else if let renderedPatchMetadata,
-                  renderedPatchMetadata.startIndex == patch.startIndex
-        {
-            newEntries = renderedPatchMetadata.entries.map { entry in
-                TopLevelChildMetadata(
-                    startOffset: replaceRange.location + entry.startOffset,
-                    containsAttachment: entry.containsAttachment,
-                    containsPositionAdjustments: entry.containsPositionAdjustments
-                )
-            }
-        } else {
-            currentTopLevelChildMetadata = nil
-            return
-        }
-
-        guard patch.startIndex >= 0,
-              patch.deleteCount >= 0,
-              patch.startIndex <= currentMetadata.count,
-              patch.startIndex + patch.deleteCount <= currentMetadata.count
-        else {
-            currentTopLevelChildMetadata = nil
-            return
-        }
-
-        currentMetadata.replaceSubrange(
-            patch.startIndex..<(patch.startIndex + patch.deleteCount),
-            with: newEntries
-        )
-
-        let delta = renderedPatchLength - replaceRange.length
-        if delta != 0 {
-            let shiftStart = patch.startIndex + newEntries.count
-            for index in shiftStart..<currentMetadata.count {
-                currentMetadata[index].startOffset += delta
-            }
-        }
-
-        currentTopLevelChildMetadata = currentMetadata
-    }
-
-    private func hasTopLevelChildMetadata() -> Bool {
-        currentTopLevelChildMetadata != nil
-    }
-
-    private func firstCharacterOffset(forTopLevelChildIndex index: Int) -> Int? {
-        guard let currentTopLevelChildMetadata,
-              index >= 0,
-              index < currentTopLevelChildMetadata.count
-        else {
-            return nil
-        }
-        return currentTopLevelChildMetadata[index].startOffset
-    }
-
-    private func replacementRangeForRenderPatch(
-        startIndex: Int,
-        deleteCount: Int
-    ) -> NSRange? {
-        let startLocation: Int
-        if let resolvedStart = firstCharacterOffset(forTopLevelChildIndex: startIndex) {
-            startLocation = resolvedStart
-        } else if deleteCount == 0 {
-            startLocation = textStorage.length
-        } else {
-            return nil
-        }
-
-        let endIndexExclusive = startIndex + deleteCount
-        let endLocation = firstCharacterOffset(forTopLevelChildIndex: endIndexExclusive)
-            ?? textStorage.length
-        guard startLocation <= endLocation else { return nil }
-        return NSRange(location: startLocation, length: endLocation - startLocation)
-    }
-
     private func applyAttributedRender(
         _ attrStr: NSAttributedString,
         replaceRange: NSRange? = nil,
         usedPatch: Bool,
-        positionCacheUpdate: PositionCacheUpdate = .scan,
         authorizedReplaceRange: NSRange? = nil,
         authorizedReplacementText: String? = nil,
         authorizedReplacementAttributedText: NSAttributedString? = nil
@@ -4604,68 +4246,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         let authorizedTextNanos = DispatchTime.now().uptimeNanoseconds - authorizedTextStartedAt
         let cacheInvalidationStartedAt = DispatchTime.now().uptimeNanoseconds
         lastRenderAppliedPatchForTesting = usedPatch
-        switch positionCacheUpdate {
-        case .plainText:
-            guard let replaceRange else {
-                PositionBridge.invalidateCache(for: self)
-                break
-            }
-            let patchedPositionCache = PositionBridge.applyPlainTextPatchIfPossible(
-                for: self,
-                replaceRange: replaceRange,
-                replacementText: attrStr.string
-            )
-            if !patchedPositionCache {
-                PositionBridge.invalidateCache(for: self)
-            }
-        case .attributed:
-            guard let replaceRange else {
-                PositionBridge.invalidateCache(for: self)
-                break
-            }
-            let patchedPositionCache = PositionBridge.applyAttributedPatchIfPossible(
-                for: self,
-                replaceRange: replaceRange,
-                replacement: attrStr
-            )
-            if !patchedPositionCache {
-                PositionBridge.invalidateCache(for: self)
-            }
-        case .invalidate:
-            PositionBridge.invalidateCache(for: self)
-        case .scan:
-            let canPatchPositionCache = if let replaceRange {
-                replaceRange.location >= 0
-                    && !textStorageRangeContainsAttachment(replaceRange)
-                    && !attributedStringContainsAttachment(attrStr)
-            } else {
-                false
-            }
-            if let replaceRange, canPatchPositionCache {
-                let patchedPositionCache: Bool
-                if !textStorageRangeContainsPositionAdjustments(replaceRange),
-                   !attributedStringContainsPositionAdjustments(attrStr)
-                {
-                    patchedPositionCache = PositionBridge.applyPlainTextPatchIfPossible(
-                        for: self,
-                        replaceRange: replaceRange,
-                        replacementText: attrStr.string
-                    )
-                } else {
-                    patchedPositionCache = PositionBridge.applyAttributedPatchIfPossible(
-                        for: self,
-                        replaceRange: replaceRange,
-                        replacement: attrStr
-                    )
-                }
-
-                if !patchedPositionCache {
-                    PositionBridge.invalidateCache(for: self)
-                }
-            } else {
-                PositionBridge.invalidateCache(for: self)
-            }
-        }
+        PositionBridge.invalidateCache(for: self)
         let cacheInvalidationNanos = DispatchTime.now().uptimeNanoseconds - cacheInvalidationStartedAt
         isApplyingRustState = false
         return ApplyRenderTrace(
@@ -4697,8 +4278,8 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         _ lhs: [NSAttributedString.Key: Any],
         _ rhs: [NSAttributedString.Key: Any]
     ) -> Bool {
-        if let lhsValue = lhs[RenderBridgeAttributes.topLevelChildIndex] as? NSNumber,
-           let rhsValue = rhs[RenderBridgeAttributes.topLevelChildIndex] as? NSNumber,
+        if let lhsValue = lhs[InputCoordinatorAttributes.topLevelChildIndex] as? NSNumber,
+           let rhsValue = rhs[InputCoordinatorAttributes.topLevelChildIndex] as? NSNumber,
            lhsValue == rhsValue
         {
             return NSDictionary(dictionary: lhs).isEqual(to: rhs)
@@ -4706,8 +4287,8 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
 
         var lhsComparable = lhs
         var rhsComparable = rhs
-        lhsComparable.removeValue(forKey: RenderBridgeAttributes.topLevelChildIndex)
-        rhsComparable.removeValue(forKey: RenderBridgeAttributes.topLevelChildIndex)
+        lhsComparable.removeValue(forKey: InputCoordinatorAttributes.topLevelChildIndex)
+        rhsComparable.removeValue(forKey: InputCoordinatorAttributes.topLevelChildIndex)
         return NSDictionary(dictionary: lhsComparable).isEqual(to: rhsComparable)
     }
 
@@ -4767,8 +4348,8 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
             in: NSRange(location: 0, length: attributedString.length),
             options: [.longestEffectiveRangeNotRequired]
         ) { attrs, _, stop in
-            if attrs[RenderBridgeAttributes.syntheticPlaceholder] as? Bool == true
-                || attrs[RenderBridgeAttributes.listMarkerContext] != nil
+            if attrs[InputCoordinatorAttributes.syntheticPlaceholder] as? Bool == true
+                || attrs[InputCoordinatorAttributes.listMarkerContext] != nil
             {
                 hasAdjustments = true
                 stop.pointee = true
@@ -4781,7 +4362,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         guard attributedString.length > 0 else { return false }
         var hasListMarkerContext = false
         attributedString.enumerateAttribute(
-            RenderBridgeAttributes.listMarkerContext,
+            InputCoordinatorAttributes.listMarkerContext,
             in: NSRange(location: 0, length: attributedString.length),
             options: [.longestEffectiveRangeNotRequired]
         ) { value, _, stop in
@@ -4806,8 +4387,8 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
             in: range,
             options: [.longestEffectiveRangeNotRequired]
         ) { attrs, _, stop in
-            if attrs[RenderBridgeAttributes.syntheticPlaceholder] as? Bool == true
-                || attrs[RenderBridgeAttributes.listMarkerContext] != nil
+            if attrs[InputCoordinatorAttributes.syntheticPlaceholder] as? Bool == true
+                || attrs[InputCoordinatorAttributes.listMarkerContext] != nil
             {
                 hasAdjustments = true
                 stop.pointee = true
@@ -4826,7 +4407,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
 
         var hasListMarkerContext = false
         textStorage.enumerateAttribute(
-            RenderBridgeAttributes.listMarkerContext,
+            InputCoordinatorAttributes.listMarkerContext,
             in: range,
             options: [.longestEffectiveRangeNotRequired]
         ) { value, _, stop in
@@ -4860,36 +4441,6 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         return hasAttachment
     }
 
-    private func topLevelChildrenContainAttachment(
-        startIndex: Int,
-        deleteCount: Int
-    ) -> Bool {
-        guard deleteCount > 0,
-              let currentTopLevelChildMetadata,
-              startIndex >= 0,
-              startIndex + deleteCount <= currentTopLevelChildMetadata.count
-        else {
-            return false
-        }
-        return currentTopLevelChildMetadata[startIndex..<(startIndex + deleteCount)]
-            .contains(where: \.containsAttachment)
-    }
-
-    private func topLevelChildrenContainPositionAdjustments(
-        startIndex: Int,
-        deleteCount: Int
-    ) -> Bool {
-        guard deleteCount > 0,
-              let currentTopLevelChildMetadata,
-              startIndex >= 0,
-              startIndex + deleteCount <= currentTopLevelChildMetadata.count
-        else {
-            return false
-        }
-        return currentTopLevelChildMetadata[startIndex..<(startIndex + deleteCount)]
-            .contains(where: \.containsPositionAdjustments)
-    }
-
     private func trimmedAttributedPatch(
         replacing fullReplaceRange: NSRange,
         with replacement: NSAttributedString
@@ -4995,156 +4546,10 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         )
     }
 
-    private func applyRenderPatchIfPossible(_ patch: ParsedRenderPatch) -> PatchApplyTrace {
-        let eligibilityStartedAt = DispatchTime.now().uptimeNanoseconds
-        guard hasTopLevelChildMetadata(),
-              let fullReplaceRange = replacementRangeForRenderPatch(
-                  startIndex: patch.startIndex,
-                  deleteCount: patch.deleteCount
-              )
-        else {
-            return PatchApplyTrace(
-                applied: false,
-                eligibilityNanos: DispatchTime.now().uptimeNanoseconds - eligibilityStartedAt,
-                trimNanos: 0,
-                metadataNanos: 0,
-                buildRenderNanos: 0,
-                applyRenderNanos: 0,
-                applyRenderReplaceUtf16Length: 0,
-                applyRenderReplacementUtf16Length: 0,
-                applyRenderTextMutationNanos: 0,
-                applyRenderBeginEditingNanos: 0,
-                applyRenderEndEditingNanos: 0,
-                applyRenderStringMutationNanos: 0,
-                applyRenderAttributeMutationNanos: 0,
-                applyRenderAuthorizedTextNanos: 0,
-                applyRenderCacheInvalidationNanos: 0,
-                usedSmallPatchTextMutation: false
-            )
-        }
-
-        let buildStartedAt = DispatchTime.now().uptimeNanoseconds
-        let attrStr = RenderBridge.renderBlocks(
-            fromArray: patch.renderBlocks,
-            startIndex: patch.startIndex,
-            includeLeadingInterBlockSeparator: patch.startIndex > 0,
-            baseFont: baseFont,
-            textColor: baseTextColor,
-            theme: theme
-        )
-        let buildRenderNanos = DispatchTime.now().uptimeNanoseconds - buildStartedAt
-        let renderedPatchMetadata = topLevelChildMetadataSlice(from: attrStr)
-        let renderedPatchContainsAttachment =
-            renderedPatchMetadata?.entries.contains(where: \.containsAttachment)
-            ?? attributedStringContainsAttachment(attrStr)
-        let renderedPatchContainsListMarkerContext =
-            attributedStringContainsListMarkerContext(attrStr)
-        let renderedPatchContainsPositionAdjustments =
-            renderedPatchMetadata?.entries.contains(where: \.containsPositionAdjustments)
-            ?? attributedStringContainsPositionAdjustments(attrStr)
-        guard !topLevelChildrenContainAttachment(
-                  startIndex: patch.startIndex,
-                  deleteCount: patch.deleteCount
-              ),
-              !renderedPatchContainsAttachment
-        else {
-            return PatchApplyTrace(
-                applied: false,
-                eligibilityNanos: DispatchTime.now().uptimeNanoseconds - eligibilityStartedAt,
-                trimNanos: 0,
-                metadataNanos: 0,
-                buildRenderNanos: buildRenderNanos,
-                applyRenderNanos: 0,
-                applyRenderReplaceUtf16Length: 0,
-                applyRenderReplacementUtf16Length: 0,
-                applyRenderTextMutationNanos: 0,
-                applyRenderBeginEditingNanos: 0,
-                applyRenderEndEditingNanos: 0,
-                applyRenderStringMutationNanos: 0,
-                applyRenderAttributeMutationNanos: 0,
-                applyRenderAuthorizedTextNanos: 0,
-                applyRenderCacheInvalidationNanos: 0,
-                usedSmallPatchTextMutation: false
-            )
-        }
-        guard !textStorageRangeContainsListMarkerContext(fullReplaceRange),
-              !renderedPatchContainsListMarkerContext
-        else {
-            return PatchApplyTrace(
-                applied: false,
-                eligibilityNanos: DispatchTime.now().uptimeNanoseconds - eligibilityStartedAt,
-                trimNanos: 0,
-                metadataNanos: 0,
-                buildRenderNanos: buildRenderNanos,
-                applyRenderNanos: 0,
-                applyRenderReplaceUtf16Length: 0,
-                applyRenderReplacementUtf16Length: 0,
-                applyRenderTextMutationNanos: 0,
-                applyRenderBeginEditingNanos: 0,
-                applyRenderEndEditingNanos: 0,
-                applyRenderStringMutationNanos: 0,
-                applyRenderAttributeMutationNanos: 0,
-                applyRenderAuthorizedTextNanos: 0,
-                applyRenderCacheInvalidationNanos: 0,
-                usedSmallPatchTextMutation: false
-            )
-        }
-        let eligibilityNanos =
-            DispatchTime.now().uptimeNanoseconds - eligibilityStartedAt - buildRenderNanos
-        let positionCacheUpdate: PositionCacheUpdate =
-            if topLevelChildrenContainPositionAdjustments(
-                startIndex: patch.startIndex,
-                deleteCount: patch.deleteCount
-            ) || renderedPatchContainsPositionAdjustments
-            {
-                .attributed
-            } else {
-                .plainText
-            }
-        let trimStartedAt = DispatchTime.now().uptimeNanoseconds
-        let patchToApply = trimmedAttributedPatch(replacing: fullReplaceRange, with: attrStr)
-        let trimNanos = DispatchTime.now().uptimeNanoseconds - trimStartedAt
-        let applyTrace = applyAttributedRender(
-            patchToApply.replacement,
-            replaceRange: patchToApply.replaceRange,
-            usedPatch: true,
-            positionCacheUpdate: positionCacheUpdate,
-            authorizedReplaceRange: fullReplaceRange,
-            authorizedReplacementText: attrStr.string,
-            authorizedReplacementAttributedText: attrStr
-        )
-        let metadataStartedAt = DispatchTime.now().uptimeNanoseconds
-        applyTopLevelChildMetadataPatch(
-            patch,
-            replaceRange: fullReplaceRange,
-            renderedPatchMetadata: renderedPatchMetadata,
-            renderedPatchLength: attrStr.length
-        )
-        let metadataNanos = DispatchTime.now().uptimeNanoseconds - metadataStartedAt
-        return PatchApplyTrace(
-            applied: true,
-            eligibilityNanos: eligibilityNanos,
-            trimNanos: trimNanos,
-            metadataNanos: metadataNanos,
-            buildRenderNanos: buildRenderNanos,
-            applyRenderNanos: applyTrace.totalNanos,
-            applyRenderReplaceUtf16Length: applyTrace.replaceUtf16Length,
-            applyRenderReplacementUtf16Length: applyTrace.replacementUtf16Length,
-            applyRenderTextMutationNanos: applyTrace.textMutationNanos,
-            applyRenderBeginEditingNanos: applyTrace.beginEditingNanos,
-            applyRenderEndEditingNanos: applyTrace.endEditingNanos,
-            applyRenderStringMutationNanos: applyTrace.stringMutationNanos,
-            applyRenderAttributeMutationNanos: applyTrace.attributeMutationNanos,
-            applyRenderAuthorizedTextNanos: applyTrace.authorizedTextNanos,
-            applyRenderCacheInvalidationNanos: applyTrace.cacheInvalidationNanos,
-            usedSmallPatchTextMutation: applyTrace.usedSmallPatchTextMutation
-        )
-    }
-
-    /// Apply a full render update from Rust to the text view.
+    /// Apply a structural editor update from Rust to the hidden input text view.
     ///
-    /// Parses the update JSON, converts render elements to NSAttributedString
-    /// via RenderBridge, and replaces the text view's content.
+    /// The visible editor surface renders the block tree. This text view keeps a
+    /// plain text snapshot for input, selection, and IME routing only.
     ///
     /// - Parameter updateJSON: The JSON string from editor_insert_text, etc.
     func applyUpdateJSON(_ updateJSON: String, notifyDelegate: Bool = true) {
@@ -5157,94 +4562,97 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         let parseNanos = DispatchTime.now().uptimeNanoseconds - parseStartedAt
         resetPendingNativeTextMutationState()
 
-        let renderElements = update["renderElements"] as? [[String: Any]]
+        let inputSnapshot = update["inputText"] as? String
         let selectionFromUpdate = (update["selection"] as? [String: Any])
             .map(self.selectionSummary(from:)) ?? "none"
         Self.updateLog.debug(
-            "[applyUpdateJSON.begin] renderCount=\(renderElements?.count ?? 0) updateSelection=\(selectionFromUpdate, privacy: .public) before=\(self.textSnapshotSummary(), privacy: .public)"
+            "[applyUpdateJSON.begin] structuralInput=\(inputSnapshot != nil, privacy: .public) updateSelection=\(selectionFromUpdate, privacy: .public) before=\(self.textSnapshotSummary(), privacy: .public)"
         )
-        let resolveRenderBlocksStartedAt = DispatchTime.now().uptimeNanoseconds
-        let renderBlocks = parseRenderBlocks(update["renderBlocks"])
-        let explicitRenderPatch = parseRenderPatch(update["renderPatch"])
-        let resolvedRenderBlocks = renderBlocks
-            ?? explicitRenderPatch.flatMap { patch in
-                currentRenderBlocks.flatMap { mergeRenderBlocks(applying: patch, to: $0) }
-            }
-        let resolveRenderBlocksNanos =
-            DispatchTime.now().uptimeNanoseconds - resolveRenderBlocksStartedAt
-
-        let derivedRenderPatch: DerivedRenderPatch? =
-            if explicitRenderPatch == nil,
-               let currentRenderBlocks,
-               let resolvedRenderBlocks
-            {
-                deriveRenderPatch(from: currentRenderBlocks, to: resolvedRenderBlocks)
-            } else {
-                nil
+        if inputSnapshot == nil, let selection = update["selection"] as? [String: Any] {
+            let selectionTrace = applySelectionFromJSON(selection)
+            let postApplyTrace = performPostApplyMaintenance()
+            if captureApplyUpdateTraceForTesting {
+                lastApplyUpdateTraceForTesting = ApplyUpdateTrace(
+                    attemptedPatch: false,
+                    usedPatch: false,
+                    usedSmallPatchTextMutation: false,
+                    applyRenderReplaceUtf16Length: 0,
+                    applyRenderReplacementUtf16Length: 0,
+                    parseNanos: parseNanos,
+                    resolveRenderBlocksNanos: 0,
+                    patchEligibilityNanos: 0,
+                    patchTrimNanos: 0,
+                    patchMetadataNanos: 0,
+                    buildRenderNanos: 0,
+                    applyRenderNanos: 0,
+                    selectionNanos: selectionTrace.totalNanos,
+                    postApplyNanos: postApplyTrace.totalNanos,
+                    totalNanos: DispatchTime.now().uptimeNanoseconds - totalStartedAt,
+                    applyRenderTextMutationNanos: 0,
+                    applyRenderBeginEditingNanos: 0,
+                    applyRenderEndEditingNanos: 0,
+                    applyRenderStringMutationNanos: 0,
+                    applyRenderAttributeMutationNanos: 0,
+                    applyRenderAuthorizedTextNanos: 0,
+                    applyRenderCacheInvalidationNanos: 0,
+                    selectionResolveNanos: selectionTrace.resolveNanos,
+                    selectionAssignmentNanos: selectionTrace.assignmentNanos,
+                    selectionChromeNanos: selectionTrace.chromeNanos,
+                    postApplyTypingAttributesNanos: postApplyTrace.typingAttributesNanos,
+                    postApplyHeightNotifyNanos: postApplyTrace.heightNotifyNanos,
+                    postApplyHeightNotifyMeasureNanos: postApplyTrace.heightNotifyMeasureNanos,
+                    postApplyHeightNotifyCallbackNanos: postApplyTrace.heightNotifyCallbackNanos,
+                    postApplyHeightNotifyEnsureLayoutNanos: postApplyTrace.heightNotifyEnsureLayoutNanos,
+                    postApplyHeightNotifyUsedRectNanos: postApplyTrace.heightNotifyUsedRectNanos,
+                    postApplyHeightNotifyContentSizeNanos: postApplyTrace.heightNotifyContentSizeNanos,
+                    postApplyHeightNotifySizeThatFitsNanos: postApplyTrace.heightNotifySizeThatFitsNanos,
+                    postApplySelectionOrContentCallbackNanos:
+                        postApplyTrace.selectionOrContentCallbackNanos
+                )
             }
-        let renderPatch = explicitRenderPatch ?? {
-            if case let .patch(patch)? = derivedRenderPatch {
-                return patch
+            if notifyDelegate {
+                editorDelegate?.editorTextView(self, didReceiveUpdate: updateJSON)
             }
-            return nil
-        }()
-        let shouldSkipRender = if case .unchanged? = derivedRenderPatch {
-            textStorage.string == lastAuthorizedText
-                && lastAppliedRenderAppearanceRevision == renderAppearanceRevision
-        } else {
-            false
-        }
-
-        let patchTrace = renderPatch.map(applyRenderPatchIfPossible)
-        let appliedPatch = patchTrace?.applied == true
-        var usedSmallPatchTextMutation = patchTrace?.usedSmallPatchTextMutation ?? false
-        var applyRenderReplaceUtf16Length = patchTrace?.applyRenderReplaceUtf16Length ?? 0
-        var applyRenderReplacementUtf16Length =
-            patchTrace?.applyRenderReplacementUtf16Length ?? 0
-        var buildRenderNanos = patchTrace?.buildRenderNanos ?? 0
-        var applyRenderNanos = patchTrace?.applyRenderNanos ?? 0
-        var applyRenderTextMutationNanos = patchTrace?.applyRenderTextMutationNanos ?? 0
-        var applyRenderBeginEditingNanos = patchTrace?.applyRenderBeginEditingNanos ?? 0
-        var applyRenderEndEditingNanos = patchTrace?.applyRenderEndEditingNanos ?? 0
-        var applyRenderStringMutationNanos = patchTrace?.applyRenderStringMutationNanos ?? 0
-        var applyRenderAttributeMutationNanos =
-            patchTrace?.applyRenderAttributeMutationNanos ?? 0
-        var applyRenderAuthorizedTextNanos = patchTrace?.applyRenderAuthorizedTextNanos ?? 0
-        var applyRenderCacheInvalidationNanos = patchTrace?.applyRenderCacheInvalidationNanos ?? 0
+            onUpdateJSONApplied?(updateJSON)
+            return
+        }
+        let resolveRenderBlocksNanos: UInt64 = 0
+        let shouldSkipRender =
+            inputSnapshot != nil
+            && textStorage.string == inputSnapshot
+            && textStorage.string == lastAuthorizedText
+            && lastAppliedRenderAppearanceRevision == renderAppearanceRevision
+
+        let appliedPatch = false
+        var usedSmallPatchTextMutation = false
+        var applyRenderReplaceUtf16Length = 0
+        var applyRenderReplacementUtf16Length = 0
+        var buildRenderNanos: UInt64 = 0
+        var applyRenderNanos: UInt64 = 0
+        var applyRenderTextMutationNanos: UInt64 = 0
+        var applyRenderBeginEditingNanos: UInt64 = 0
+        var applyRenderEndEditingNanos: UInt64 = 0
+        var applyRenderStringMutationNanos: UInt64 = 0
+        var applyRenderAttributeMutationNanos: UInt64 = 0
+        var applyRenderAuthorizedTextNanos: UInt64 = 0
+        var applyRenderCacheInvalidationNanos: UInt64 = 0
         if shouldSkipRender {
             lastRenderAppliedPatchForTesting = false
-            if let resolvedRenderBlocks {
-                currentRenderBlocks = resolvedRenderBlocks
-            }
-        } else if !appliedPatch {
+        } else {
+            guard let inputSnapshot else { return }
             let buildStartedAt = DispatchTime.now().uptimeNanoseconds
-            let attrStr: NSAttributedString
-            if let resolvedRenderBlocks {
-                attrStr = RenderBridge.renderBlocks(
-                    fromArray: resolvedRenderBlocks,
-                    baseFont: baseFont,
-                    textColor: baseTextColor,
-                    theme: theme
-                )
-                currentRenderBlocks = resolvedRenderBlocks
-            } else if let renderElements {
-                attrStr = RenderBridge.renderElements(
-                    fromArray: renderElements,
-                    baseFont: baseFont,
-                    textColor: baseTextColor,
-                    theme: theme
-                )
-                currentRenderBlocks = nil
-            } else {
-                return
-            }
+            let attrStr = NSAttributedString(
+                string: inputSnapshot,
+                attributes: [
+                    .font: baseFont,
+                    .foregroundColor: baseTextColor
+                ]
+            )
             buildRenderNanos = DispatchTime.now().uptimeNanoseconds - buildStartedAt
             let applyTrace = applyAttributedRender(
                 attrStr,
-                usedPatch: false,
-                positionCacheUpdate: .invalidate
+                usedPatch: false
             )
-            refreshTopLevelChildMetadata(from: attrStr)
             applyRenderReplaceUtf16Length = applyTrace.replaceUtf16Length
             applyRenderReplacementUtf16Length = applyTrace.replacementUtf16Length
             applyRenderNanos = applyTrace.totalNanos
@@ -5257,14 +4665,11 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
             applyRenderCacheInvalidationNanos = applyTrace.cacheInvalidationNanos
             usedSmallPatchTextMutation = applyTrace.usedSmallPatchTextMutation
             lastAppliedRenderAppearanceRevision = renderAppearanceRevision
-        } else if let resolvedRenderBlocks {
-            currentRenderBlocks = resolvedRenderBlocks
-            lastAppliedRenderAppearanceRevision = renderAppearanceRevision
         }
 
         refreshPlaceholderVisibility()
         Self.updateLog.debug(
-            "[applyUpdateJSON.rendered] mode=\(appliedPatch ? "patch" : "full", privacy: .public) after=\(self.textSnapshotSummary(), privacy: .public)"
+            "[applyUpdateJSON.rendered] mode=structuralInput after=\(self.textSnapshotSummary(), privacy: .public)"
         )
 
         // Apply the selection from the update.
@@ -5284,16 +4689,16 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
 
         if captureApplyUpdateTraceForTesting {
             lastApplyUpdateTraceForTesting = ApplyUpdateTrace(
-                attemptedPatch: renderPatch != nil,
+                attemptedPatch: false,
                 usedPatch: appliedPatch,
                 usedSmallPatchTextMutation: usedSmallPatchTextMutation,
                 applyRenderReplaceUtf16Length: applyRenderReplaceUtf16Length,
                 applyRenderReplacementUtf16Length: applyRenderReplacementUtf16Length,
                 parseNanos: parseNanos,
                 resolveRenderBlocksNanos: resolveRenderBlocksNanos,
-                patchEligibilityNanos: patchTrace?.eligibilityNanos ?? 0,
-                patchTrimNanos: patchTrace?.trimNanos ?? 0,
-                patchMetadataNanos: patchTrace?.metadataNanos ?? 0,
+                patchEligibilityNanos: 0,
+                patchTrimNanos: 0,
+                patchMetadataNanos: 0,
                 buildRenderNanos: buildRenderNanos,
                 applyRenderNanos: applyRenderNanos,
                 selectionNanos: selectionTrace.totalNanos,
@@ -5330,34 +4735,60 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate {
         if notifyDelegate {
             editorDelegate?.editorTextView(self, didReceiveUpdate: updateJSON)
         }
+        onUpdateJSONApplied?(updateJSON)
     }
 
-    /// Apply a render JSON string (just render elements, no update wrapper).
-    ///
-    /// Used for initial content loading (set_html / set_json return render
-    /// elements directly, not wrapped in an EditorUpdate).
-    func applyRenderJSON(_ renderJSON: String) {
-        ensureInternalTextViewDelegate()
-        resetPendingNativeTextMutationState()
-        Self.updateLog.debug(
-            "[applyRenderJSON.begin] before=\(self.textSnapshotSummary(), privacy: .public)"
-        )
-        let attrStr = RenderBridge.renderElements(
-            fromJSON: renderJSON,
-            baseFont: baseFont,
-            textColor: baseTextColor,
-            theme: theme
-        )
-        _ = applyAttributedRender(attrStr, usedPatch: false)
-        currentRenderBlocks = nil
-        lastAppliedRenderAppearanceRevision = renderAppearanceRevision
+    private static func plainTextSnapshot(fromRenderTree tree: [String: Any]?) -> String? {
+        guard let root = tree?["root"] as? [String: Any] else { return nil }
+        var text = ""
+        appendInputSnapshotNode(root, to: &text, isRoot: true)
+        return text
+    }
 
-        refreshPlaceholderVisibility()
-        _ = performPostApplyMaintenance()
-        recordAuthorizedSelectionIfPossible()
-        Self.updateLog.debug(
-            "[applyRenderJSON.end] after=\(self.textSnapshotSummary(), privacy: .public)"
-        )
+    private static func appendInputSnapshotNode(
+        _ node: [String: Any],
+        to text: inout String,
+        isRoot: Bool
+    ) {
+        let kind = node["kind"] as? String ?? "block"
+        let nodeType = node["nodeType"] as? String ?? "unknown"
+        if kind == "text" {
+            text += node["text"] as? String ?? ""
+            return
+        }
+        if kind == "inlineAtom" {
+            if nodeType == "hardBreak" || nodeType == "hard_break" {
+                text += "\n"
+            } else {
+                text += node["label"] as? String ?? "\u{FFFC}"
+            }
+            return
+        }
+        if kind == "blockAtom" {
+            if !text.isEmpty && !text.hasSuffix("\n") {
+                text += "\n"
+            }
+            text += node["label"] as? String ?? "\u{FFFC}"
+            text += "\n"
+            return
+        }
+
+        let children = node["children"] as? [[String: Any]] ?? []
+        let startsBlock = !isRoot && isInputSnapshotBlockBoundary(kind: kind)
+        if startsBlock && !text.isEmpty && !text.hasSuffix("\n") {
+            text += "\n"
+        }
+        for child in children {
+            appendInputSnapshotNode(child, to: &text, isRoot: false)
+        }
+        if startsBlock && !text.isEmpty && !text.hasSuffix("\n") {
+            text += "\n"
+        }
+    }
+
+    private static func isInputSnapshotBlockBoundary(kind: String) -> Bool {
+        kind == "textBlock" || kind == "listItem" || kind == "block" ||
+            kind == "tableCell" || kind == "tableRow" || kind == "table"
     }
 
     /// Apply a selection from a parsed JSON selection object.
@@ -5542,7 +4973,6 @@ extension EditorTextView: NSTextStorageDelegate {
         // Compare current text storage content against last authorized snapshot.
         let currentText = textStorage.string
         guard currentText != lastAuthorizedText else { return }
-        currentTopLevelChildMetadata = nil
 
         let allowAfterBlur = canAdoptNativeTextMutationAfterBlur()
         if let mutation = nativeTextMutationFromAuthorizedDiff(currentText: currentText),
@@ -5633,6 +5063,7 @@ final class RichTextEditorView: UIView {
 
     /// The editor text view that handles input interception.
     let textView: EditorTextView
+    private let blockSurface = NativeBlockEditorSurface()
     private let remoteSelectionOverlayView = RemoteSelectionOverlayView()
     private let taskListMarkerTapOverlayView = TaskListMarkerTapOverlayView()
     private let imageTapOverlayView = ImageTapOverlayView()
@@ -5642,6 +5073,7 @@ final class RichTextEditorView: UIView {
     private var cachedAutoGrowMeasuredHeight: CGFloat = 0
     private var remoteSelections: [RemoteSelectionDecoration] = []
     private var overlayRefreshScheduled = false
+    private var isSyncingBlockSurfaceUpdateToInputAdapter = false
     var captureHostedLayoutTraceForTesting = false
     private var hostedLayoutTraceNanos = (
         intrinsicContentSize: UInt64(0),
@@ -5674,6 +5106,8 @@ final class RichTextEditorView: UIView {
         didSet {
             guard oldValue != heightBehavior else { return }
             textView.heightBehavior = heightBehavior
+            blockSurface.isScrollEnabled = heightBehavior == .fixed
+            blockSurface.alwaysBounceVertical = heightBehavior == .fixed
             textView.updateAutoGrowHostHeight(heightBehavior == .autoGrow ? bounds.height : 0)
             if heightBehavior != .autoGrow {
                 cachedAutoGrowMeasuredHeight = 0
@@ -5702,8 +5136,10 @@ final class RichTextEditorView: UIView {
             guard oldValue != editorId else { return }
             textView.discardTransientNativeInputForEditorRebind()
             if editorId != 0 {
+                blockSurface.bind(editorId: editorId)
                 textView.bindEditor(id: editorId)
             } else {
+                blockSurface.bind(editorId: 0)
                 textView.unbindEditor()
             }
             remoteSelectionOverlayView.update(
@@ -5732,7 +5168,7 @@ final class RichTextEditorView: UIView {
     private func setupView() {
         // Add the text view as a subview. These views always track the host bounds,
         // so manual layout is cheaper than driving them through Auto Layout.
-        remoteSelectionOverlayView.bind(textView: textView)
+        remoteSelectionOverlayView.bind(documentSurface: blockSurface)
         taskListMarkerTapOverlayView.bind(editorView: self)
         imageTapOverlayView.bind(editorView: self)
         imageResizeOverlayView.bind(editorView: self)
@@ -5753,9 +5189,46 @@ final class RichTextEditorView: UIView {
             self?.refreshOverlaysIfNeeded()
         }
         textView.onSelectionOrContentMayChange = { [weak self] in
-            self?.scheduleRefreshOverlaysIfNeeded()
+            guard let self else { return }
+            if self.editorId != 0, !self.isSyncingBlockSurfaceUpdateToInputAdapter {
+                self.blockSurface.applyUpdateJSON(
+                    editorGetSelectionState(id: self.editorId),
+                    editorId: self.editorId
+                )
+            }
+            self.scheduleRefreshOverlaysIfNeeded()
+        }
+        textView.onUpdateJSONApplied = { [weak self] updateJSON in
+            guard let self else { return }
+            if self.isSyncingBlockSurfaceUpdateToInputAdapter { return }
+            self.blockSurface.applyUpdateJSON(updateJSON, editorId: self.editorId)
         }
+        blockSurface.onAppliedUpdate = { [weak self] updateJSON in
+            guard let self else { return }
+            self.isSyncingBlockSurfaceUpdateToInputAdapter = true
+            defer { self.isSyncingBlockSurfaceUpdateToInputAdapter = false }
+            self.textView.applyUpdateJSON(updateJSON, notifyDelegate: true)
+        }
+        blockSurface.onRequestTextInput = { [weak self] docPos in
+            guard let self, self.editorId != 0, self.textView.isEditable else { return }
+            editorSetSelection(id: self.editorId, anchor: docPos, head: docPos)
+            self.isSyncingBlockSurfaceUpdateToInputAdapter = true
+            self.textView.applyUpdateJSON(
+                editorGetSelectionState(id: self.editorId),
+                notifyDelegate: true
+            )
+            self.isSyncingBlockSurfaceUpdateToInputAdapter = false
+            self.textView.becomeFirstResponder()
+        }
+        blockSurface.onContentHeightMayChange = { [weak self] measuredHeight in
+            guard let self, self.heightBehavior == .autoGrow else { return }
+            self.cachedAutoGrowMeasuredHeight = measuredHeight
+            self.invalidateIntrinsicContentSize()
+            self.onHeightMayChange?(measuredHeight)
+        }
+        textView.alpha = 0.01
         addSubview(textView)
+        addSubview(blockSurface)
         addSubview(remoteSelectionOverlayView)
         addSubview(taskListMarkerTapOverlayView)
         addSubview(imageTapOverlayView)
@@ -5821,11 +5294,15 @@ final class RichTextEditorView: UIView {
         textView.font = font
         textView.textColor = textColor
         textView.backgroundColor = backgroundColor
+        blockSurface.baseFont = font
+        blockSurface.baseTextColor = textColor
+        blockSurface.baseBackgroundColor = backgroundColor
     }
 
     @discardableResult
     func applyTheme(_ theme: EditorTheme?) -> Bool {
         guard textView.applyTheme(theme) else { return false }
+        blockSurface.applyTheme(theme)
         let cornerRadius = theme?.borderRadius ?? 0
         layer.cornerRadius = cornerRadius
         clipsToBounds = cornerRadius > 0
@@ -5835,22 +5312,31 @@ final class RichTextEditorView: UIView {
 
     func setRemoteSelections(_ selections: [RemoteSelectionDecoration]) {
         remoteSelections = selections
+        layoutManagedSubviews()
+        blockSurface.layoutIfNeeded()
         remoteSelectionOverlayView.update(
             selections: selections,
             editorId: editorId
         )
     }
 
+    func setEditable(_ editable: Bool) {
+        textView.isEditable = editable
+        blockSurface.isEditable = editable
+        if !editable {
+            textView.resignFirstResponder()
+        }
+    }
+
     func refreshRemoteSelections() {
         guard remoteSelectionOverlayView.hasSelectionsOrVisibleDecorations else { return }
         remoteSelectionOverlayView.refresh()
     }
 
     func currentCaretRect() -> CGRect? {
-        guard let selectedTextRange = textView.selectedTextRange else { return nil }
-        let rect = textView.caretRect(for: selectedTextRange.end)
-        guard rect.height > 0 else { return nil }
-        return textView.convert(rect, to: self)
+        blockSurface.isInputFocused = textView.isFirstResponder
+        guard let rect = blockSurface.selectedCaretRect() else { return nil }
+        return blockSurface.convert(rect, to: self)
     }
 
     func remoteSelectionOverlaySubviewsForTesting() -> [UIView] {
@@ -5899,8 +5385,38 @@ final class RichTextEditorView: UIView {
         imageResizeOverlayView.visibleRectForTesting
     }
 
+    func blockSurfaceImageRectForTesting() -> CGRect? {
+        guard let geometry = blockSurface.selectedImageGeometry()
+            ?? blockSurface.firstImageGeometryForTesting()
+        else { return nil }
+        return blockSurface.convert(geometry.rect, to: self)
+    }
+
+    func blockSurfaceTopLevelViewForTesting(at index: Int) -> UIView? {
+        blockSurface.topLevelViewForTesting(at: index)
+    }
+
+    func blockSurfaceTopLevelViewCountForTesting() -> Int {
+        blockSurface.topLevelViewCountForTesting
+    }
+
+    func blockSurfaceFirstTextAttributesForTesting() -> [NSAttributedString.Key: Any]? {
+        blockSurface.firstTextAttributesForTesting()
+    }
+
+    func blockSurfaceCaretRectForTesting(docPosition: UInt32) -> CGRect? {
+        guard let rect = blockSurface.caretRect(forDocPosition: docPosition) else { return nil }
+        return blockSurface.convert(rect, to: self)
+    }
+
+    func blockSurfaceTopLevelRectForTesting(at index: Int) -> CGRect? {
+        guard let child = blockSurface.topLevelViewForTesting(at: index) else { return nil }
+        return child.convert(child.bounds, to: self)
+    }
+
     func imageTapOverlayInterceptsPointForTesting(_ point: CGPoint) -> Bool {
-        imageTapOverlayView.interceptsPointForTesting(convert(point, to: imageTapOverlayView))
+        !imageTapOverlayView.isHidden
+            && imageTapOverlayView.interceptsPointForTesting(convert(point, to: imageTapOverlayView))
     }
 
     func taskListMarkerTapOverlayInterceptsPointForTesting(_ point: CGPoint) -> Bool {
@@ -5934,7 +5450,7 @@ final class RichTextEditorView: UIView {
     }
 
     func maximumImageWidthForTesting() -> CGFloat {
-        textView.maximumRenderableImageWidth()
+        blockSurface.maximumImageWidth()
     }
 
     func resizeSelectedImageForTesting(width: CGFloat, height: CGFloat) {
@@ -5955,7 +5471,7 @@ final class RichTextEditorView: UIView {
     func setContent(html: String) {
         guard editorId != 0 else { return }
         _ = editorSetHtml(id: editorId, html: html)
-        textView.applyUpdateJSON(editorGetCurrentState(id: editorId), notifyDelegate: false)
+        applyFullStateToInputAndSurface(editorGetCurrentState(id: editorId))
     }
 
     /// Set initial content from ProseMirror JSON.
@@ -5964,7 +5480,14 @@ final class RichTextEditorView: UIView {
     func setContent(json: String) {
         guard editorId != 0 else { return }
         _ = editorSetJson(id: editorId, json: json)
-        textView.applyUpdateJSON(editorGetCurrentState(id: editorId), notifyDelegate: false)
+        applyFullStateToInputAndSurface(editorGetCurrentState(id: editorId))
+    }
+
+    private func applyFullStateToInputAndSurface(_ stateJSON: String) {
+        isSyncingBlockSurfaceUpdateToInputAdapter = true
+        textView.applyUpdateJSON(stateJSON, notifyDelegate: false)
+        isSyncingBlockSurfaceUpdateToInputAdapter = false
+        blockSurface.applyUpdateJSON(stateJSON, editorId: editorId)
     }
 
     private func measuredEditorHeight() -> CGFloat {
@@ -6002,6 +5525,9 @@ final class RichTextEditorView: UIView {
         if textView.frame != managedFrame {
             textView.frame = managedFrame
         }
+        if blockSurface.frame != managedFrame {
+            blockSurface.frame = managedFrame
+        }
         if remoteSelectionOverlayView.frame != managedFrame {
             remoteSelectionOverlayView.frame = managedFrame
         }
@@ -6017,19 +5543,21 @@ final class RichTextEditorView: UIView {
     }
 
     fileprivate func selectedImageGeometry() -> (docPos: UInt32, rect: CGRect)? {
-        guard let geometry = textView.selectedImageGeometry() else { return nil }
+        guard allowImageResizing, textView.isFirstResponder,
+              let geometry = blockSurface.selectedImageGeometry()
+        else { return nil }
         return (
             docPos: geometry.docPos,
-            rect: textView.convert(geometry.rect, to: imageResizeOverlayView)
+            rect: blockSurface.convert(geometry.rect, to: imageResizeOverlayView)
         )
     }
 
     fileprivate func setImageResizePreviewActive(_ active: Bool) {
-        textView.setImageResizePreviewActive(active)
+        blockSurface.setImagePreviewActive(active)
     }
 
     fileprivate func imagePreviewForResize(docPos: UInt32) -> UIImage? {
-        textView.imagePreviewForDocPos(docPos)
+        blockSurface.imagePreview(docPos: docPos)
     }
 
     fileprivate func imageResizePreviewBackgroundColor() -> UIColor {
@@ -6037,12 +5565,12 @@ final class RichTextEditorView: UIView {
     }
 
     fileprivate func maximumImageWidthForResizeGesture() -> CGFloat {
-        textView.maximumRenderableImageWidth()
+        blockSurface.maximumImageWidth()
     }
 
     fileprivate func clampedImageSize(_ size: CGSize, maximumWidth: CGFloat? = nil) -> CGSize {
         let aspectRatio = max(size.width / max(size.height, 1), 0.1)
-        let maxWidth = max(48, maximumWidth ?? textView.maximumRenderableImageWidth())
+        let maxWidth = max(48, maximumWidth ?? blockSurface.maximumImageWidth())
         let clampedWidth = min(maxWidth, max(48, size.width))
         let clampedHeight = max(48, clampedWidth / aspectRatio)
         return CGSize(width: clampedWidth, height: clampedHeight)
@@ -6052,7 +5580,7 @@ final class RichTextEditorView: UIView {
         let clampedSize = clampedImageSize(size)
         let width = max(48, Int(clampedSize.width.rounded()))
         let height = max(48, Int(clampedSize.height.rounded()))
-        textView.resizeImageAtDocPos(docPos, width: UInt32(width), height: UInt32(height))
+        blockSurface.resizeImage(docPos: docPos, width: UInt32(width), height: UInt32(height))
     }
 
     private func refreshOverlays() {
@@ -6063,6 +5591,10 @@ final class RichTextEditorView: UIView {
                 keyPath: .refreshOverlays
             )
         }
+        blockSurface.isInputFocused = textView.isFirstResponder
+        // Overlay geometry must observe the structural surface's final width;
+        // otherwise a first-pass caret can be cached before text wraps.
+        blockSurface.layoutIfNeeded()
         remoteSelectionOverlayView.refresh()
         imageResizeOverlayView.refresh()
     }
@@ -6105,12 +5637,27 @@ final class RichTextEditorView: UIView {
         if imageResizeOverlayView.isOverlayVisible {
             return true
         }
-        if textView.selectedImageGeometry() != nil {
+        if blockSurface.selectedImageGeometry() != nil {
             return true
         }
         return false
     }
 
+    fileprivate func blockSurfaceHasImage(at point: CGPoint) -> Bool {
+        blockSurface.hasImage(at: convert(point, to: blockSurface))
+    }
+
+    @discardableResult
+    fileprivate func selectBlockSurfaceImage(at point: CGPoint) -> Bool {
+        guard allowImageResizing else { return false }
+        _ = textView.becomeFirstResponder()
+        let didSelect = blockSurface.selectImage(at: convert(point, to: blockSurface))
+        if didSelect {
+            refreshOverlays()
+        }
+        return didSelect
+    }
+
     private enum HostedLayoutTraceKey {
         case intrinsicContentSize
         case measuredEditorHeight