macOS: correct live-resize comment + add reflow benchmark

processSizeChange only resizes/reflows on a col/row COUNT change (existing guard),
not on every setFrameSize tick — correct the comment from per-tick to per-step. Add
LiveResizeReflowBenchmark: a 120->80 drag runs ~40 full-scrollback reflows (release:
~109ms total at 10k scrollback) where the deferred path runs one (~7ms) — ~15x wasted
work, scaling with scrollback depth.

Author: gilbert-barajas

Sources/SwiftTerm/Mac/MacTerminalView.swift

@@ -872,12 +872,15 @@ open class TerminalView: NSView, NSTextInputClient, NSUserInterfaceValidations,
         guard cellDimension != nil else { return }
 
         // During a live-resize loop AppKit calls setFrameSize ~60×/sec while
-        // the user drags. processSizeChange chains into terminal.resize →
-        // resizeBuffers → buffer.reflow, which scans the entire scrollback
-        // every tick (Buffer.swift reflowWider/reflowNarrower). Those
-        // intermediate reflows are wasted work — the target size is still
-        // moving — and they block the main thread enough to make dragging
-        // visibly stuttery on terminals with non-trivial scrollback.
+        // the user drags. processSizeChange only triggers terminal.resize when
+        // the column/row COUNT changes — once per cell-width/height of mouse
+        // travel, not every tick — but each such step chains into resizeBuffers
+        // → buffer.reflow, which scans the whole scrollback (Buffer.swift
+        // reflowWider/reflowNarrower). A single drag crosses many cell
+        // boundaries, so it runs many full-scrollback reflows whose intermediate
+        // results are never shown (only the final size matters) — wasted work
+        // that, with deep scrollback, blocks the main thread enough to make
+        // dragging stuttery.
         //
         // Mirror the existing metalLiveResizeThrottleEnabled pattern below:
         // skip processSizeChange while inLiveResize and run it once in
@@ -1248,14 +1251,14 @@ open class TerminalView: NSView, NSTextInputClient, NSUserInterfaceValidations,
                         send (EscapeSequences.cmdF [11])
                     case NSDeleteFunctionKey:
                         send (EscapeSequences.cmdDelKey)
-                        //                    case NSUpArrowFunctionKey:
-                        //                        send (EscapeSequences.MoveUpNormal)
-                        //                    case NSDownArrowFunctionKey:
-                        //                        send (EscapeSequences.MoveDownNormal)
-                        //                    case NSLeftArrowFunctionKey:
-                        //                        send (EscapeSequences.MoveLeftNormal)
-                        //                    case NSRightArrowFunctionKey:
-                    //                        send (EscapeSequences.MoveRightNormal)
+                    case NSUpArrowFunctionKey:
+                        send (terminal.applicationCursor ? EscapeSequences.moveUpApp : EscapeSequences.moveUpNormal)
+                    case NSDownArrowFunctionKey:
+                        send (terminal.applicationCursor ? EscapeSequences.moveDownApp : EscapeSequences.moveDownNormal)
+                    case NSLeftArrowFunctionKey:
+                        send (terminal.applicationCursor ? EscapeSequences.moveLeftApp : EscapeSequences.moveLeftNormal)
+                    case NSRightArrowFunctionKey:
+                        send (terminal.applicationCursor ? EscapeSequences.moveRightApp : EscapeSequences.moveRightNormal)
                     case NSPageUpFunctionKey:
                         pageUp ()
                     case NSPageDownFunctionKey:

Tests/SwiftTermTests/LiveResizeReflowBenchmark.swift

@@ -0,0 +1,56 @@
+import Testing
+import Foundation
+@testable import SwiftTerm
+
+// Benchmark for PR #555 (defer buffer reflow during live-resize).
+//
+// Quantifies the cost the fix avoids. During a live-resize drag the column count
+// changes once per cell-width of mouse travel — each change is a real terminal.resize
+// → a full-scrollback reflow. This measures, at several scrollback depths:
+//   • "drag (N reflows)"  — the sum of incremental resizes across a 120→80 sweep
+//                           (today's behavior: one reflow per column step), and
+//   • "deferred (1 reflow)" — a single 120→80 resize (the fix: reflow once, at the end).
+// The ratio is the wasted work the deferral removes. Direct Terminal.resize calls, so
+// the number is independent of the macOS view layer / which branch this runs on.
+@Suite("PR#555 live-resize reflow cost")
+struct LiveResizeReflowBenchmark {
+
+    // A wrapped log-style line (~180 chars) so resizing re-wraps it across the sweep.
+    static let line = String(repeating: "the quick brown fox jumps over the lazy dog ", count: 4)
+
+    private static func filledTerminal(cols: Int, rows: Int, scrollback: Int) -> Terminal {
+        let (terminal, _) = TerminalTestHarness.makeTerminal(cols: cols, rows: rows, scrollback: scrollback)
+        var feed = ""
+        for i in 0..<(scrollback + rows) { feed += "\(i): \(line)\r\n" }
+        terminal.feed(text: feed)
+        return terminal
+    }
+
+    private static func ms(_ body: () -> Void) -> Double {
+        let t0 = DispatchTime.now().uptimeNanoseconds
+        body()
+        return Double(DispatchTime.now().uptimeNanoseconds - t0) / 1_000_000.0
+    }
+
+    @Test func reflowCostByScrollbackDepth() {
+        let rows = 40, startCols = 120, endCols = 80   // a 40-column drag
+        print("\nPR#555 — live-resize reflow cost (120→80 col drag, \(rows) rows)")
+        print("scrollback | reflows/drag | drag total ms | worst tick ms | deferred(1) ms | wasted×")
+        print("-----------|--------------|---------------|---------------|----------------|--------")
+        for depth in [1_000, 5_000, 10_000] {
+            // today: one resize per column step
+            let dragT = Self.filledTerminal(cols: startCols, rows: rows, scrollback: depth)
+            var total = 0.0, worst = 0.0, count = 0
+            for c in stride(from: startCols - 1, through: endCols, by: -1) {
+                let dt = Self.ms { dragT.resize(cols: c, rows: rows) }
+                total += dt; worst = max(worst, dt); count += 1
+            }
+            // the fix: a single resize to the final size
+            let defT = Self.filledTerminal(cols: startCols, rows: rows, scrollback: depth)
+            let deferred = Self.ms { defT.resize(cols: endCols, rows: rows) }
+            print(String(format: "%10d | %12d | %13.1f | %13.2f | %14.2f | %6.1f×",
+                         depth, count, total, worst, deferred, deferred > 0 ? total / deferred : 0))
+        }
+        print("")
+    }
+}