feat: diff-based granular deltas for Milkdown rich text mode

templates/document_edit.html

···
                 ctx.get(listenerCtx).markdownUpdated((_ctx, markdown, prevMarkdown) => {
                     if (markdown !== prevMarkdown && !applyingRemote) {
                         scheduleAutoSave(markdown);
-                        sendEdit(markdown);
+                        const ops = diffToOps(prevMarkdown || '', markdown);
+                        if (ops.length > 0) {
+                            queueDeltas(ops);
+                        }
                     }
                 });
             })
···
     // Debounce timer for WebSocket sends (50ms batches rapid keystrokes).
     let wsEditTimer = null;
     let pendingDeltas = [];
+
+    /**
+     * Compute the minimal edit operations to transform `oldStr` into `newStr`.
+     * Returns an array of {from, to, insert} suitable for the OT engine.
+     *
+     * Uses a line-level diff for performance, then falls back to a single
+     * full-replacement op if the diff produces more than 20 operations
+     * (pathological case — not worth the complexity).
+     */
+    function diffToOps(oldStr, newStr) {
+        if (oldStr === newStr) return [];
+
+        const oldLines = oldStr.split('\n');
+        const newLines = newStr.split('\n');
+
+        // Build line-level LCS table (Wagner-Fischer).
+        const m = oldLines.length, n = newLines.length;
+        const dp = Array.from({length: m + 1}, () => new Array(n + 1).fill(0));
+        for (let i = m - 1; i >= 0; i--) {
+            for (let j = n - 1; j >= 0; j--) {
+                dp[i][j] = oldLines[i] === newLines[j]
+                    ? dp[i+1][j+1] + 1
+                    : Math.max(dp[i+1][j], dp[i][j+1]);
+            }
+        }
+
+        // Trace back to produce diff hunks.
+        const ops = [];
+        let i = 0, j = 0;
+        // Track character offset into oldStr.
+        let charOffset = 0;
+        // +1 for the \n separator. The last line has no trailing \n, so its
+        // length is exact; however the OT engine clamps out-of-range positions,
+        // so an off-by-one on the final line is safe in practice.
+        const oldLineLengths = oldLines.map(l => l.length + 1);
+
+        while (i < m || j < n) {
+            if (i < m && j < n && oldLines[i] === newLines[j]) {
+                charOffset += oldLineLengths[i];
+                i++; j++;
+            } else if (j < n && (i >= m || dp[i+1][j] <= dp[i][j+1])) {
+                // Insert newLines[j]
+                const insertText = newLines[j] + (j < n - 1 ? '\n' : '');
+                ops.push({ from: charOffset, to: charOffset, insert: insertText });
+                j++;
+            } else {
+                // Delete oldLines[i]
+                const deleteLen = oldLineLengths[i];
+                ops.push({ from: charOffset, to: charOffset + deleteLen, insert: '' });
+                charOffset += deleteLen;
+                i++;
+            }
+        }
+
+        // Fallback: if diff is too fragmented, send a single full replacement.
+        if (ops.length > 20) {
+            return [{ from: 0, to: -1, insert: newStr }];
+        }
+
+        return ops;
+    }
 
     // Queue a set of deltas and flush after a short debounce.
     function queueDeltas(deltas) {