Fix scroll() to respect left/right margins (DECSLRM) (#434)

* Fix scroll() to respect left/right margins (DECSLRM)

When margin mode is active with narrowed left/right margins, the scroll()
function was scrolling entire lines instead of only the columns within
the margin region. This caused display corruption when applications like
tmux use DECSLRM for side-by-side panes - scrolling in one pane would
affect content in adjacent panes.

The fix adds a new code path that detects when:
1. Margin mode is enabled (DECLRMM)
2. Margins are narrower than full width
3. Cursor is within the margin region

In this case, we do in-place column-by-column scrolling within the
margin bounds, similar to how cmdInsertLines/cmdDeleteLines already
handle this scenario. The isWrapped flag is cleared on the bottom line
since partial-line scrolling breaks line continuity.

When margins are full width or cursor is outside margins, normal
scrollback behavior is preserved.

* Add margin checks to cmdIndex and reverseIndex

Both functions now respect left/right margins (DECSLRM) like
cmdLineFeedBasic already does:

- cmdIndex (ESC D): Only scroll if cursor is within margin columns
- reverseIndex (ESC M): Only scroll if cursor is within margin columns,
  and do column-wise scrolling for narrow margins

This fixes intermittent display corruption in tmux side-by-side panes
where Index or Reverse Index commands could affect content outside
their margin boundaries.

---------

Co-authored-by: Mike Manzano <mike@clicketyclacks.co>

Author: leftspin

Sources/SwiftTerm/Terminal.swift

@@ -4959,11 +4959,17 @@ open class Terminal {
     func cmdIndex ()
     {
         restrictCursor()
-        
+
         let buffer = self.buffer
         let newY = buffer.y + 1
+
+        // When left/right margins are active, only scroll if cursor is within margins
+        let canScroll = buffer.x >= buffer.marginLeft && buffer.x <= buffer.marginRight
+
         if newY > buffer.scrollBottom {
-            scroll ()
+            if canScroll {
+                scroll ()
+            }
         } else {
             buffer.y = newY
         }
@@ -4988,7 +4994,45 @@ open class Terminal {
         let topRow = buffer.yBase + buffer.scrollTop
         let bottomRow = buffer.yBase + buffer.scrollBottom
 
-        if buffer.scrollTop == 0 {
+        // When margin mode is active with left/right margins that are narrower than full width,
+        // we cannot use scrollback (can't push partial lines), so we do in-place scrolling
+        // within the margin columns only. This path is unconditional when narrow margins are
+        // active, regardless of cursor position, to ensure consistent behavior.
+        let hasNarrowMargins = marginMode && (buffer.marginLeft > 0 || buffer.marginRight < cols - 1)
+        if hasNarrowMargins {
+            let scrollRegionHeight = bottomRow - topRow + 1
+            let columnCount = buffer.marginRight - buffer.marginLeft + 1
+            let ea = eraseAttr()
+
+            // Shift content up within the margin columns only.
+            //
+            // LIMITATION: Line-level metadata (isWrapped, images, renderMode) cannot be
+            // partially scrolled, so we reset them on all affected lines.
+            //
+            // Ideally, isWrapped would be tracked per-column-range so that triple-click
+            // selection in one pane selects the wrapped logical line within that pane only.
+            // However, isWrapped is currently a per-BufferLine property (spanning all columns),
+            // so there's no way to represent "wrapped in cols 0-39, not wrapped in cols 40-79".
+            // Implementing column-aware wrapping would require architectural changes to the
+            // data model. For now, we clear isWrapped since partial-column scrolling breaks
+            // the line-level wrapping semantic.
+            //
+            for i in 0..<(scrollRegionHeight - 1) {
+                let src = buffer.lines[topRow + i + 1]
+                let dst = buffer.lines[topRow + i]
+                dst.copyFrom(src, srcCol: buffer.marginLeft, dstCol: buffer.marginLeft, len: columnCount)
+                dst.isWrapped = false
+                dst.images = nil
+                dst.renderMode = .single
+            }
+
+            // Clear the bottom row within the margin columns.
+            let bottomLine = buffer.lines[bottomRow]
+            bottomLine.fill(with: CharData(attribute: ea), atCol: buffer.marginLeft, len: columnCount)
+            bottomLine.isWrapped = false
+            bottomLine.images = nil
+            bottomLine.renderMode = .single
+        } else if buffer.scrollTop == 0 {
             // Determine whether the buffer is going to be trimmed after insertion.
             let willBufferBeTrimmed = buffer.lines.isFull
 
@@ -5016,7 +5060,7 @@ open class Terminal {
                 if buffer.hasScrollback {
                     buffer.linesTop += 1
                 }
-                
+
                 // When the buffer is full and the user has scrolled up, keep the text
                 // stable unless ydisp is right at the top
                 if userScrolling {
@@ -5444,25 +5488,59 @@ open class Terminal {
     {
         let buffer = self.buffer
         restrictCursor()
+
+        // When left/right margins are active, only scroll if cursor is within margins
+        let canScroll = buffer.x >= buffer.marginLeft && buffer.x <= buffer.marginRight
+
         if buffer.y == buffer.scrollTop {
-            // possibly move the code below to term.reverseScroll()
-            // test: echo -ne '\e[1;1H\e[44m\eM\e[0m'
-            // blankLine(true) is xterm/linux behavior
-            let startIndex = buffer.y + buffer.yBase
-            let scrollRegionHeight = buffer.scrollBottom - buffer.scrollTop
+            if canScroll {
+                // possibly move the code below to term.reverseScroll()
+                // test: echo -ne '\e[1;1H\e[44m\eM\e[0m'
+                // blankLine(true) is xterm/linux behavior
+                let topRow = buffer.yBase + buffer.scrollTop
+                let bottomRow = buffer.yBase + buffer.scrollBottom
+
+                // Ensure the start index is within bounds to prevent crash (issue #256)
+                // This can happen when the buffer has been trimmed and yBase is stale
+                guard topRow < buffer.lines.count else {
+                    print ("reverseIndex: start index \(topRow) >= lines.count \(buffer.lines.count), state: y=\(buffer.y) yBase=\(buffer.yBase) scrollTop=\(buffer.scrollTop) scrollBottom=\(buffer.scrollBottom) isAlternate=\(isCurrentBufferAlternate)")
+                    return
+                }
 
-            // Ensure the start index is within bounds to prevent crash (issue #256)
-            // This can happen when the buffer has been trimmed and yBase is stale
-            guard startIndex < buffer.lines.count else {
-                print ("reverseIndex: start index \(startIndex) >= lines.count \(buffer.lines.count), state: y=\(buffer.y) yBase=\(buffer.yBase) scrollTop=\(buffer.scrollTop) scrollBottom=\(buffer.scrollBottom) isAlternate=\(isCurrentBufferAlternate)")
-                return
-            }
+                let hasNarrowMargins = marginMode && (buffer.marginLeft > 0 || buffer.marginRight < cols - 1)
+
+                if hasNarrowMargins {
+                    // Do in-place reverse scrolling within margin columns only
+                    let scrollRegionHeight = bottomRow - topRow + 1
+                    let columnCount = buffer.marginRight - buffer.marginLeft + 1
+                    let ea = eraseAttr()
 
-            if !buffer.lines.shiftElements (start: startIndex, count: scrollRegionHeight, offset: 1) {
-                print ("Assertion on reverseIndex, state was: y=\(buffer.y) scrollTop=\(buffer.scrollTop)  yDisp=\(buffer.yDisp) linesTop=\(buffer.linesTop) isAlternate=\(isCurrentBufferAlternate)")
+                    // Shift content down within the margin columns (reverse of scroll)
+                    for i in stride(from: scrollRegionHeight - 1, through: 1, by: -1) {
+                        let src = buffer.lines[topRow + i - 1]
+                        let dst = buffer.lines[topRow + i]
+                        dst.copyFrom(src, srcCol: buffer.marginLeft, dstCol: buffer.marginLeft, len: columnCount)
+                        dst.isWrapped = false
+                        dst.images = nil
+                        dst.renderMode = .single
+                    }
+
+                    // Clear the top row within the margin columns
+                    let topLine = buffer.lines[topRow]
+                    topLine.fill(with: CharData(attribute: ea), atCol: buffer.marginLeft, len: columnCount)
+                    topLine.isWrapped = false
+                    topLine.images = nil
+                    topLine.renderMode = .single
+                } else {
+                    // Full-width scrolling - use original shiftElements approach
+                    let scrollRegionHeight = buffer.scrollBottom - buffer.scrollTop
+                    if !buffer.lines.shiftElements (start: topRow, count: scrollRegionHeight, offset: 1) {
+                        print ("Assertion on reverseIndex, state was: y=\(buffer.y) scrollTop=\(buffer.scrollTop)  yDisp=\(buffer.yDisp) linesTop=\(buffer.linesTop) isAlternate=\(isCurrentBufferAlternate)")
+                    }
+                    buffer.lines [topRow] = buffer.getBlankLine (attribute: eraseAttr ())
+                }
+                updateRange (startLine: buffer.scrollTop, endLine: buffer.scrollBottom)
             }
-            buffer.lines [startIndex] = buffer.getBlankLine (attribute: eraseAttr ())
-            updateRange (startLine: buffer.scrollTop, endLine: buffer.scrollBottom)
         } else if buffer.y > 0 {
             buffer.y -= 1
         }