Center glyphs vertically when lineSpacing > 1

lineSpacing scales the cell height in computeFontDimensions(), but the
baseline stayed pinned at ceil(descent + leading) from the cell bottom,
so all the added height piled up above the text and lines looked
bottom-heavy at larger values (1.4-1.6).

Introduce a single shared TerminalView.baselineOffset that splits the
extra height evenly above and below the glyph (the half-leading model
iTerm2 and WezTerm use), and make every place that previously computed
its own ceil(descent + leading) read it instead:

- drawTerminalContents (CoreGraphics text path)
- CaretView.drawCursor, so the glyph drawn inside the caret stays on
  the same baseline as the text under it
- MetalTerminalRenderer buildDrawData and buildCursorDrawData (which no
  longer takes lineDescent/lineLeading parameters)
- glyphSlotFit's vertical-centering math for scaled wide glyphs, whose
  dy is applied on top of the draw-time offset and therefore has to
  agree with it

At lineSpacing == 1.0 the extra is zero and baselineOffset reduces to
the classic ceil(descent + leading): offscreen renders of upstream and
this branch are byte-identical. At 1.6 the caret glyph, CG text, and
DECDHL double-height rows were verified against offscreen renders.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Coiggahou2002

Sources/SwiftTerm/Apple/AppleTerminalView.swift

@@ -123,6 +123,8 @@ extension TerminalView {
 
     /// Multiplier for vertical line spacing. 1.0 = default (ascent + descent + leading).
     /// Set to 1.1 for 110% vertical spacing (matches iTerm2's vertical spacing setting).
+    /// The extra height is split evenly above and below each glyph (see
+    /// ``baselineOffset``), so text stays vertically centered within its cell.
     /// Triggers a font reset and terminal resize when changed.
     @objc open var lineSpacing: CGFloat {
         get { _lineSpacing }
@@ -277,6 +279,25 @@ extension TerminalView {
         return CellDimension(width: max(1, snappedWidth), height: max(min(snappedHeight, 8192), 1))
     }
 
+    /// Distance from the bottom of a cell to the glyph baseline.
+    ///
+    /// When `lineSpacing > 1` the cell is taller than the font's natural line
+    /// (ascent + descent + leading); the extra height is split evenly above and
+    /// below the glyph so text is vertically centered in the cell, matching how
+    /// iTerm2 and WezTerm distribute their line spacing. At `lineSpacing == 1`
+    /// this reduces to the classic `ceil(descent + leading)`.
+    ///
+    /// Every renderer (CoreGraphics, Metal, and the caret views) must position
+    /// baselines with this value rather than computing its own offset — local
+    /// copies of this formula are how the renderers drift out of sync.
+    var baselineOffset: CGFloat {
+        let lineDescent = CTFontGetDescent (fontSet.normal)
+        let lineLeading = CTFontGetLeading (fontSet.normal)
+        let naturalHeight = ceil(CTFontGetAscent (fontSet.normal) + lineDescent + lineLeading)
+        let extra = cellDimension == nil ? 0 : max(0, cellDimension.height - naturalHeight)
+        return ceil(lineDescent + lineLeading + extra / 2)
+    }
+
     /// Computes how to center `glyph` within its `columnWidth`-cell slot (and
     /// scale it down if its ink overflows). Returns ``GlyphSlotFit/identity`` for
     /// ordinary single-cell glyphs, so Latin text in a monospace font is rendered
@@ -314,11 +335,12 @@ extension TerminalView {
 
         // Preserve the natural Latin baseline unless the glyph was scaled, in
         // which case center its ink vertically so it doesn't sit too low/high.
+        // `dy` is applied on top of `baselineOffset` at draw time, so the ink
+        // center lands at cellHeight/2 only if both use the same baseline.
         var dy: CGFloat = 0
         if scale < 1, ink.height > 0 {
-            let baselineFromBottom = ceil(CTFontGetDescent(fontSet.normal) + CTFontGetLeading(fontSet.normal))
             let inkCenterFromBaseline = (ink.origin.y + ink.height / 2) * scale
-            dy = (cellHeight / 2 - baselineFromBottom) - inkCenterFromBaseline
+            dy = (cellHeight / 2 - baselineOffset) - inkCenterFromBaseline
         }
 
         return GlyphSlotFit(dx: dx, dy: dy, scale: scale)
@@ -1254,9 +1276,7 @@ extension TerminalView {
     // TODO: this should not render any lines outside the dirtyRect
     func drawTerminalContents (dirtyRect: TTRect, context: CGContext, bufferOffset: Int)
     {
-        let lineDescent = CTFontGetDescent(fontSet.normal)
-        let lineLeading = CTFontGetLeading(fontSet.normal)
-        let yOffset = ceil(lineDescent+lineLeading)
+        let yOffset = baselineOffset
         let displayBuffer = terminal.displayBuffer
 
         func calcLineOffset (forRow: Int) -> CGFloat {

Sources/SwiftTerm/Apple/CaretView.swift

@@ -39,9 +39,9 @@ extension CaretView {
         }
         context.fill([region])
 
-        let lineDescent = CTFontGetDescent(terminal.fontSet.normal)
-        let lineLeading = CTFontGetLeading(terminal.fontSet.normal)
-        let yOffset = ceil(lineDescent+lineLeading)
+        // Must match the offset drawTerminalContents uses, or the glyph drawn
+        // inside the caret lands on a different baseline than the text under it.
+        let yOffset = terminal.baselineOffset
 
         guard style == .steadyBlock || style  == .blinkBlock else {
             return

Sources/SwiftTerm/Apple/Metal/MetalTerminalRenderer.swift

@@ -607,9 +607,7 @@ final class MetalTerminalRenderer: NSObject, MTKViewDelegate {
         let buffer = terminalView.terminal.displayBuffer
         let cellWidth = terminalView.cellDimension.width
         let cellHeight = terminalView.cellDimension.height
-        let lineDescent = CTFontGetDescent(terminalView.fontSet.normal)
-        let lineLeading = CTFontGetLeading(terminalView.fontSet.normal)
-        let yOffset = ceil(lineDescent + lineLeading)
+        let yOffset = terminalView.baselineOffset
         let viewWidthPx = terminalView.bounds.width * scale
 
         let rowInfo = visibleRowRange(buffer: buffer, cellHeight: cellHeight, terminalView: terminalView)
@@ -787,8 +785,6 @@ final class MetalTerminalRenderer: NSObject, MTKViewDelegate {
         let cursorData = buildCursorDrawData(scale: scale,
                                              cellWidth: cellWidth,
                                              cellHeight: cellHeight,
-                                             lineDescent: lineDescent,
-                                             lineLeading: lineLeading,
                                              yDisp: visibleDisp,
                                              firstRow: firstRow,
                                              lastRow: lastRow)
@@ -2124,8 +2120,6 @@ final class MetalTerminalRenderer: NSObject, MTKViewDelegate {
     private func buildCursorDrawData(scale: CGFloat,
                                      cellWidth: CGFloat,
                                      cellHeight: CGFloat,
-                                     lineDescent: CGFloat,
-                                     lineLeading: CGFloat,
                                      yDisp: Int,
                                      firstRow: Int,
                                      lastRow: Int) -> (colorVertices: [ColorVertex],
@@ -2236,7 +2230,7 @@ final class MetalTerminalRenderer: NSObject, MTKViewDelegate {
         guard let runs = CTLineGetGlyphRuns(ctline) as? [CTRun] else {
             return (colorVertices, [], [])
         }
-        let yOffset = ceil(lineDescent + lineLeading)
+        let yOffset = terminalView.baselineOffset
         let textColorSIMD = colorToSIMD(caretTextColor)
 
         for run in runs {