fix: rewrite diffToOps traceback to collect contiguous hunks as single replace ops

templates/document_edit.html

···
         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--) {
···
             }
         }
 
-        // Line lengths in the original document.
-        // All lines except the last have a trailing \n; the last does not.
-        const oldLineLengths = oldLines.map((l, idx) => l.length + (idx < oldLines.length - 1 ? 1 : 0));
+        // Line length in old string. Last line has no trailing \n.
+        const oldLineLengths = oldLines.map((l, idx) =>
+            l.length + (idx < oldLines.length - 1 ? 1 : 0));
 
-        // Trace back to produce raw diff ops.
-        // Traceback preference: insert before delete.  charOffset tracks the
-        // character position in the ORIGINAL document (only advances on matches
-        // and deletes, never on inserts — inserts reference the pre-delete offset).
-        const rawOps = [];
-        let i = 0, j = 0;
-        let charOffset = 0;
+        const ops = [];
+        let i = 0, j = 0, charOffset = 0;
 
         while (i < m || j < n) {
             if (i < m && j < n && oldLines[i] === newLines[j]) {
-                // Matching line — advance both pointers and the offset.
+                // Matching line — advance past it.
                 charOffset += oldLineLengths[i];
                 i++; j++;
-            } else if (j < n && (i >= m || dp[i+1][j] <= dp[i][j+1])) {
-                // Insert newLines[j] at the current position in the old doc.
-                // Append \n if more new lines follow OR if there are still old
-                // lines remaining after this insertion point (line is mid-doc).
-                const insertText = newLines[j] + (j < n - 1 || i < m ? '\n' : '');
-                rawOps.push({ from: charOffset, to: charOffset, insert: insertText });
-                j++;
             } else {
-                // Delete oldLines[i].
-                const deleteLen = oldLineLengths[i];
-                rawOps.push({ from: charOffset, to: charOffset + deleteLen, insert: '' });
-                charOffset += deleteLen;
-                i++;
-            }
-        }
+                // Non-matching run: collect all consecutive deletions and
+                // insertions into a single replace op so positions stay consistent.
+                const hunkFrom = charOffset;
+                let hunkTo = charOffset;
+                let hunkInsert = '';
+
+                while (i < m && (j >= n || dp[i][j] === dp[i+1][j])) {
+                    hunkTo += oldLineLengths[i];
+                    charOffset += oldLineLengths[i];
+                    i++;
+                }
+                while (j < n && (i >= m || dp[i][j] === dp[i][j+1])) {
+                    hunkInsert += newLines[j] + (j < newLines.length - 1 || hunkTo > hunkFrom ? '\n' : '');
+                    j++;
+                }
 
-        // Post-process: merge adjacent insert-at-X + delete-at-X pairs into a
-        // single replace op.  The traceback emits insert before delete for the
-        // same position (insert doesn't advance charOffset, so the delete that
-        // follows still references the same offset).  Merging is required because
-        // the server applies ops sequentially — a separate insert followed by a
-        // separate delete would hit the wrong bytes after the insert shifts things.
-        function mergeOps(raw) {
-            const merged = [];
-            for (let k = 0; k < raw.length; k++) {
-                const op = raw[k];
-                const next = raw[k + 1];
-                // Insert at X (pure insert: to === from) followed immediately by
-                // delete starting at X (pure delete: insert === '').
-                if (op.to === op.from && next && next.insert === '' && next.from === op.from) {
-                    merged.push({ from: op.from, to: next.to, insert: op.insert });
-                    k++; // skip next
-                } else {
-                    merged.push(op);
+                // Only emit if something actually changed.
+                if (hunkTo > hunkFrom || hunkInsert !== '') {
+                    ops.push({ from: hunkFrom, to: hunkTo, insert: hunkInsert });
                 }
             }
-            return merged;
         }
 
-        const ops = mergeOps(rawOps);
-
-        // Fallback: if diff is too fragmented, send a single full replacement.
-        if (ops.length > 20) {
-            return [{ from: 0, to: -1, insert: newStr }];
-        }
-
+        if (ops.length > 20) return [{ from: 0, to: -1, insert: newStr }];
         return ops;
     }