fix: correct diffToOps traceback — fix last-line length, newline logic, merge replace ops

templates/document_edit.html

···
             }
         }
 
-        // Trace back to produce diff hunks.
-        const ops = [];
+        // 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));
+
+        // 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;
-        // 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]) {
+                // Matching line — advance both pointers and the offset.
                 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 });
+                // 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]
+                // Delete oldLines[i].
                 const deleteLen = oldLineLengths[i];
-                ops.push({ from: charOffset, to: charOffset + deleteLen, insert: '' });
+                rawOps.push({ from: charOffset, to: charOffset + deleteLen, insert: '' });
                 charOffset += deleteLen;
                 i++;
             }
         }
+
+        // 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);
+                }
+            }
+            return merged;
+        }
+
+        const ops = mergeOps(rawOps);
 
         // Fallback: if diff is too fragmented, send a single full replacement.
         if (ops.length > 20) {