if breaks == 0 then 1
  -- If the file ends with a newline, Vim doesn't count it as a new empty line
  -- unless it's preceded by another newline (e.g., "a\n\n" is 2 lines).
  else if pt.endsWithNewline then breaks
  else breaks + 1

  -- In editor state, each newline creates a new line slot.
  -- Keep lineCount consistent with getLineRange/getLine and cursor rows.
  breaks + 1

  match PieceTable.findLineForOffset pt offset 0 pt.lineCount with

  let hi := pt.lineCount - 1
  match PieceTable.findLineForOffset pt offset 0 hi with

/-- Flatten a tree into pieces in document order (iterative to avoid deep recursion). -/
def toPieces (t : ViE.PieceTree) : Array ViE.Piece := Id.run do
  let mut out : Array ViE.Piece := #[]
  let mut stack : List ViE.PieceTree := [t]
  while !stack.isEmpty do
    match stack with
    | [] => pure ()
    | node :: rest =>
        stack := rest
        match node with
        | ViE.PieceTree.empty => pure ()
        | ViE.PieceTree.leaf pieces _ _ =>
            out := out ++ pieces
        | ViE.PieceTree.internal children _ _ =>
            let mut i := children.size
            while i > 0 do
              let j := i - 1
              stack := children[j]! :: stack
              i := j
  return out

  | 0 => mkInternal #[l, r]

  | 0 =>
    -- Rebuild into a balanced tree in pathological cases instead of creating deep chains.
    fromPieces (toPieces l ++ toPieces r) pt

  let fuel := (length l + length r + 1) * 4 + 16

  -- Cap recursion depth and rely on balanced fallback when exhausted.
  let rawFuel := (height l + height r + 4) * 8 + 64
  let fuel := min rawFuel 2048

  let fuel := (length t + 1) * 4 + 16

  let fuel := (height t + 4) * 32 + 64

  let fuel := (length t + len + 1) * 4 + 32

  let fuel := (height t + 4) * 32 + 64

  let fuel := (length t + lineBreaks t + 1) * 4 + 16

  let fuel := (height t + 4) * 32 + 64

  let fuel := (length t + pattern.size + 1) * 8 + 64

  let fuel := (height t + 4) * 32 + 64

  let fuel := (length t + pattern.size + 1) * 8 + 64

  let fuel := (height t + 4) * 32 + 64

def newlineCount (s : String) : Nat :=
  s.foldl (fun n c => if c == '\n' then n + 1 else n) 0
def expectedLineCountFromText (s : String) : Nat :=
  let breaks := newlineCount s
  breaks + 1

def testLengthAndLineCountConsistency : IO Unit := do
  IO.println "testLengthAndLineCountConsistency..."
  let mut pt := PieceTable.fromString ""
  for i in [0:1200] do
    let len := pt.length
    let pos := if len == 0 then 0 else (i * 17 + 3) % (len + 1)
    if i % 5 == 0 then
      let txt := if i % 2 == 0 then "\n" else s!"x{i}"
      pt := pt.insert pos txt pos
    else if i % 7 == 0 then
      let delLen := if len == 0 then 0 else min ((i % 4) + 1) (len - (pos % len))
      pt := pt.delete (if len == 0 then 0 else pos % len) delLen 0
    else
      let txt := if i % 3 == 0 then "a\n" else "b"
      pt := pt.insert pos txt pos
    let rendered := pt.toString
    let renderedBytes := rendered.toUTF8.size
    if renderedBytes != pt.length then
      throw <| IO.userError s!"Length mismatch at step {i}: tree={pt.length} rendered={renderedBytes}"
    let expectedLines := expectedLineCountFromText rendered
    if pt.lineCount != expectedLines then
      throw <| IO.userError s!"Line count mismatch at step {i}: tree={pt.lineCount} expected={expectedLines}"
    let h := PieceTree.height pt.tree
    if h > 64 then
      throw <| IO.userError s!"Tree height unexpectedly large at step {i}: height={h}"
  IO.println "[PASS] length/line count remain consistent under mixed edits"

  testLengthAndLineCountConsistency

  -- Scenario: Insert mode transition + single-char delete keeps line count and cursor in sync.
  let s := ViE.initialState
  let s ← runKeys s [Key.char 'i', Key.enter]
  let c1 := s.getCursor
  assert "Enter in insert creates second line" (s.getActiveBuffer.lineCount == 2)
  assert "Enter in insert moves cursor to next line" (c1.row.val == 1 && c1.col.val == 0)
  let s ← runKeys s [Key.esc]
  let c2 := s.getCursor
  assert "Esc from insert keeps valid cursor row" (c2.row.val < s.getActiveBuffer.lineCount)
  assert "Esc from insert keeps row/col at second line head" (c2.row.val == 1 && c2.col.val == 0)
  -- Re-enter insert and delete one char (the previous newline) via Backspace.
  let s ← runKeys s [Key.char 'i', Key.backspace]
  let c3 := s.getCursor
  assert "Backspace at BOL joins lines" (s.getActiveBuffer.lineCount == 1)
  assert "Backspace at BOL moves cursor to joined line end" (c3.row.val == 0 && c3.col.val == 0)
  -- In normal mode x at empty line is a no-op and must keep cursor valid.
  let s ← runKeys s [Key.esc, Key.char 'x']
  let c4 := s.getCursor
  assert "x on empty line keeps line count" (s.getActiveBuffer.lineCount == 1)
  assert "x on empty line keeps cursor in range" (c4.row.val < s.getActiveBuffer.lineCount)