targetWindowId : Option Nat := none

      let (r, c) := newTable.getPointFromOffset off
      let s'' := s'.setCursor { row := ⟨r⟩, col := ⟨c⟩ }

      let p := ViE.getPointFromOffsetInBufferWithTabStop { buf with table := newTable } off tabStop
      let s'' := s'.setCursor p

      let (r, c) := newTable.getPointFromOffset off
      let s'' := s'.setCursor { row := ⟨r⟩, col := ⟨c⟩ }

      let p := ViE.getPointFromOffsetInBufferWithTabStop { buf with table := newTable } off tabStop
      let s'' := s'.setCursor p

              ViE.Feature.openExplorerWithPreview s parentPath explorer.previewWindowId explorer.previewBufferId

              ViE.Feature.openExplorerWithPreview s parentPath explorer.previewWindowId explorer.previewBufferId explorer.targetWindowId

/-- Build line-start offsets by walking the piece tree in document order. -/
private def buildLineIndex (pt : PieceTable) : Array Nat := Id.run do
  let capacity := PieceTree.lineBreaks pt.tree + 1
  let mut starts : Array Nat := (Array.mkEmpty capacity).push 0
  let mut docOff := 0
  let mut stack : List PieceTree := [pt.tree]
  while !stack.isEmpty do
    match stack with
    | [] => pure ()
    | node :: rest =>
        stack := rest
        match node with
        | PieceTree.empty => pure ()
        | PieceTree.leaf pieces _ _ =>
            for p in pieces do
              let buf := PieceTableHelper.getBuffer pt p.source
              let stop := p.start + p.length
              let mut i := p.start
              while i < stop do
                if buf[i]! == 10 then
                  starts := starts.push (docOff + 1)
                i := i + 1
                docOff := docOff + 1
        | PieceTree.internal children _ _ =>
            let mut i := children.size
            while i > 0 do
              let j := i - 1
              stack := children[j]! :: stack
              i := j
  return starts
private def withLineIndexCache (pt : PieceTable) : PieceTable :=
  { pt with lineIndexCache := some (buildLineIndex pt) }

    { original := bytes, addBuffers := #[], tree := PieceTree.empty, bloomBuildLeafBits := buildLeafBits,
      undoStack := [], redoStack := [], undoLimit := 100, lastInsert := none }

    withLineIndexCache {
      original := bytes, addBuffers := #[], tree := PieceTree.empty, bloomBuildLeafBits := buildLeafBits,
      undoStack := [], redoStack := [], undoLimit := 100, lastInsert := none
    }

    { original := bytes, addBuffers := #[], tree := tree, bloomBuildLeafBits := buildLeafBits,
      undoStack := [], redoStack := [], undoLimit := 100, lastInsert := none }

    withLineIndexCache {
      original := bytes, addBuffers := #[], tree := tree, bloomBuildLeafBits := buildLeafBits,
      undoStack := [], redoStack := [], undoLimit := 100, lastInsert := none
    }

private def PieceTable.lineIndex (pt : PieceTable) : Array Nat :=
  match pt.lineIndexCache with
  | some idx => idx
  | none => buildLineIndex pt

    let (pt', newPieces) := PieceTableHelper.appendText pt text

    let (pt', newPieces, appendMeta) := PieceTableHelper.appendText pt text

          (pt.undoStack, pt.undoStackCount, some { docOffset := offset + text.toUTF8.size, bufferIdx := pt.addBuffers.size, bufferOffset := text.toUTF8.size })

          (pt.undoStack, pt.undoStackCount, some { docOffset := offset + text.toUTF8.size, bufferIdx := appendMeta.bufferIdx, bufferOffset := appendMeta.bufferEnd })

          (finalStack, finalCount, some { docOffset := offset + text.toUTF8.size, bufferIdx := pt.addBuffers.size, bufferOffset := text.toUTF8.size })

          (finalStack, finalCount, some { docOffset := offset + text.toUTF8.size, bufferIdx := appendMeta.bufferIdx, bufferOffset := appendMeta.bufferEnd })

          (finalStack, finalCount, some { docOffset := offset + text.toUTF8.size, bufferIdx := pt.addBuffers.size, bufferOffset := text.toUTF8.size })

          (finalStack, finalCount, some { docOffset := offset + text.toUTF8.size, bufferIdx := appendMeta.bufferIdx, bufferOffset := appendMeta.bufferEnd })

    { pt' with

    withLineIndexCache { pt' with

    { pt with

    withLineIndexCache { pt with

    let (pt', newPieces) := PieceTableHelper.appendText pt text

    let (pt', newPieces, _) := PieceTableHelper.appendText pt text

    { pt' with tree := newTree, lastInsert := none }

    { pt' with tree := newTree, lineIndexCache := none, lastInsert := none }

    { pt with tree := newTree, lastInsert := none }

    { pt with tree := newTree, lineIndexCache := none, lastInsert := none }

    { pt' with

    withLineIndexCache { pt' with

    ({ pt with

    (withLineIndexCache { pt with

    ({ pt with

    (withLineIndexCache { pt with

/-- Get line from buffer -/
def PieceTable.getLine (pt : PieceTable) (lineIdx : Nat) : Option String :=
  PieceTree.getLine pt.tree lineIdx pt

  PieceTree.getLineRange pt.tree lineIdx pt

  let idx := pt.lineIndex
  match idx[lineIdx]? with
  | none => none
  | some startOff =>
      let totalLen := pt.tree.length
      match idx[lineIdx + 1]? with
      | some nextStart =>
          let len := if nextStart > startOff then (nextStart - startOff - 1) else 0
          some (startOff, len)
      | none =>
          some (startOff, totalLen - startOff)
/-- Get line from buffer -/
def PieceTable.getLine (pt : PieceTable) (lineIdx : Nat) : Option String :=
  match PieceTable.getLineRange pt lineIdx with
  | some (off, len) => some (PieceTree.getSubstring pt.tree off len pt)
  | none => none

structure AppendMeta where
  bufferIdx : Nat
  bufferEnd : Nat

/-- Append text to add buffer, splitting into chunks if necessary -/
def appendText (pt : ViE.PieceTable) (text : String) : (ViE.PieceTable × Array ViE.Piece) :=

/-- Append text to add buffer, splitting into chunks if necessary. Reuses tail add buffer when possible. -/
def appendText (pt : ViE.PieceTable) (text : String) : (ViE.PieceTable × Array ViE.Piece × AppendMeta) :=

  let bufferIdx := pt.addBuffers.size
  let newAddBuffers := pt.addBuffers.push bytes

  let (bufferIdx, startOff, newAddBuffers) :=
    match pt.addBuffers.back? with
    | some tail =>
        if tail.size + totalSize <= ViE.AddBufferReuseLimit then
          let idx := pt.addBuffers.size - 1
          let startOff := tail.size
          let merged := tail ++ bytes
          let bufs := pt.addBuffers.set! idx merged
          (idx, startOff, bufs)
        else
          let idx := pt.addBuffers.size
          (idx, 0, pt.addBuffers.push bytes)
    | none =>
        (0, 0, #[bytes])

        start := start,

        start := startOff + start,

  ({ pt with addBuffers := newAddBuffers }, ps)

  ({ pt with addBuffers := newAddBuffers }, ps, { bufferIdx := bufferIdx, bufferEnd := startOff + totalSize })

/-- Soft cap for reusing the tail add-buffer to avoid excessive copy amplification. -/
def AddBufferReuseLimit : Nat := 64 * 1024

  lineIndexCache : Option (Array Nat) := none

        ViE.Feature.openExplorerWithPreview state explorer.currentPath explorer.previewWindowId explorer.previewBufferId

        ViE.Feature.openExplorerWithPreview state explorer.currentPath explorer.previewWindowId explorer.previewBufferId explorer.targetWindowId

private def isUsableExplorerTargetWindow (ws : WorkspaceState) (explorerWinId : Nat) (previewWinId : Option Nat)
    (explorerBufIds : List Nat) (previewBufId : Option Nat) (wid : Nat) : Bool :=
  if wid == explorerWinId then
    false
  else if previewWinId == some wid then
    false
  else
    match ws.layout.findView wid with
    | some v =>
        let isExplorerBuf := explorerBufIds.contains v.bufferId
        let isPreviewBuf := match previewBufId with | some pid => v.bufferId == pid | none => false
        !isExplorerBuf && !isPreviewBuf
    | none => false

    let reuseActive := state.explorers.any (fun (id, _) => id == state.getActiveBuffer.id)
    let targetWindowId :=
      if reuseActive then
        match state.explorers.find? (fun (id, _) => id == state.getActiveBuffer.id) with
        | some (_, ex) => ex.targetWindowId
        | none => some ws.activeWindowId
      else
        some ws.activeWindowId

      targetWindowId := targetWindowId

    let reuseActive := state.explorers.any (fun (id, _) => id == state.getActiveBuffer.id)

def openExplorerWithPreview (state : EditorState) (pathArg : String) (previewWindowId : Option Nat) (previewBufferId : Option Nat) : IO EditorState := do

def openExplorerWithPreview (state : EditorState) (pathArg : String) (previewWindowId : Option Nat)
    (previewBufferId : Option Nat) (targetWindowId : Option Nat) : IO EditorState := do

      targetWindowId := targetWindowId

    targetWindowId := some state.getCurrentWorkspace.activeWindowId

    targetWindowId := some state.getCurrentWorkspace.activeWindowId

    targetWindowId := some state.getCurrentWorkspace.activeWindowId

        openExplorerWithPreview state entry.path explorer.previewWindowId explorer.previewBufferId

        openExplorerWithPreview state entry.path explorer.previewWindowId explorer.previewBufferId explorer.targetWindowId

          let ids := ViE.Window.getWindowIds ws0.layout
          ids.find? fun wid =>
            if wid == explorerWinId then
              false
            else if explorer.previewWindowId == some wid then
              false
            else
              match ws0.layout.findView wid with
              | some v =>
                  let isExplorerBuf := explorerBufIds.contains v.bufferId
                  let isPreviewBuf :=
                    match explorer.previewBufferId with
                    | some pid => v.bufferId == pid
                    | none => false
                  !isExplorerBuf && !isPreviewBuf
              | none => false

          let preferred := explorer.targetWindowId
          match preferred with
          | some wid =>
              if isUsableExplorerTargetWindow ws0 explorerWinId explorer.previewWindowId explorerBufIds explorer.previewBufferId wid then
                some wid
              else
                let ids := ViE.Window.getWindowIds ws0.layout
                ids.find? (fun w => isUsableExplorerTargetWindow ws0 explorerWinId explorer.previewWindowId explorerBufIds explorer.previewBufferId w)
          | none =>
              let ids := ViE.Window.getWindowIds ws0.layout
              ids.find? (fun w => isUsableExplorerTargetWindow ws0 explorerWinId explorer.previewWindowId explorerBufIds explorer.previewBufferId w)

              let ids := ViE.Window.getWindowIds ws0.layout
              ids.find? fun wid =>
                if wid == explorerWinId then
                  false
                else if explorer.previewWindowId == some wid then
                  false
                else
                  match ws0.layout.findView wid with
                  | some v =>
                      let isExplorerBuf := explorerBufIds.contains v.bufferId
                      !isExplorerBuf
                  | none => false

              let preferred := explorer.targetWindowId
              let isTarget (wid : Nat) :=
                isUsableExplorerTargetWindow ws0 explorerWinId explorer.previewWindowId explorerBufIds none wid
              match preferred with
              | some wid =>
                  if isTarget wid then
                    some wid
                  else
                    let ids := ViE.Window.getWindowIds ws0.layout
                    ids.find? isTarget
              | none =>
                  let ids := ViE.Window.getWindowIds ws0.layout
                  ids.find? isTarget

def clampCursorToActiveBuffer (state : EditorState) : EditorState :=
  let cursor := state.getCursor
  state.setCursor (ViE.clampPointToActiveBuffer state cursor)

          state.updateActiveBuffer (fun _ => newBuf)

          clampCursorToActiveBuffer (state.updateActiveBuffer (fun _ => newBuf))

                state.updateActiveBuffer (fun _ => newBuf)

                clampCursorToActiveBuffer (state.updateActiveBuffer (fun _ => newBuf))

        state.updateActiveBuffer (fun _ => newBuf)

        clampCursorToActiveBuffer (state.updateActiveBuffer (fun _ => newBuf))

  assert "tree height is at least 2 after workload" (PieceTree.height t >= 2)

  assert "tree height is positive for non-empty tree" (PieceTree.height t >= 1)

  let s9 := ViE.initialState
  let s10 ← runKeys s9 ([Key.char 'i'] ++ keys "a\nfoo1\nb\nfoo2\nc" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char 'j', Key.char 'j', Key.char 'j', Key.char '0'])
  assertCursor ":g/pat/ d precondition cursor on deletable line" s10 3 0
  let s11 ← runKeys s10 ([Key.char ':'] ++ keys "g/foo/ d" ++ [Key.enter])
  assertBuffer ":g/pat/ d keeps expected text when cursor line is deleted" s11 "a\nb\nc"
  assertCursor ":g/pat/ d clamps cursor when current line is deleted" s11 2 0
def testCursorDriftCustomTabStop : IO Unit := do
  IO.println "  Testing Cursor Drift (custom tabStop)..."
  let cfg8 := { ViE.defaultConfig with tabStop := 8 }
  let s0 := { ViE.initialState with config := cfg8 }
  let s1 ← runKeys s0 ([Key.char 'i', Key.char '\t'] ++ keys "foo\n" ++ [Key.esc])
  let s2 ← runKeys s1 [Key.char 'g', Key.char 'g', Key.char '0', Key.char 'l']
  assertCursor "custom tabStop: l moves to first char after tab" s2 0 8
  let s3 ← runKeys s2 ([Key.char ':'] ++ keys "s/foo/bar/" ++ [Key.enter])
  assertBuffer "custom tabStop: :s updates current line" s3 "\tbar\n"
  let s4 ← runKeys s3 [Key.char 'u']
  assertBuffer "custom tabStop: undo restores text after :s" s4 "\tfoo\n"
  assertCursor "custom tabStop: undo restores cursor col after :s" s4 0 8
  let s5 ← runKeys s4 [Key.ctrl 'r']
  assertBuffer "custom tabStop: redo reapplies :s" s5 "\tbar\n"
  assertCursor "custom tabStop: redo restores cursor col after :s" s5 0 8

  let s6 ← runKeys s2 [Key.char 'v', Key.char 'l', Key.char 'd']
  assertBuffer "custom tabStop: visual delete uses configured offsets" s6 "\to\n"
  assertCursor "custom tabStop: visual delete keeps cursor aligned" s6 0 8

def testExplorerOpenUsesFocusedWindow : IO Unit := do
  IO.println "  Testing Explorer Open Target Window..."
  let s0 := { ViE.initialState with windowHeight := 30, windowWidth := 100 }
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-ex-target-{stamp}"
  IO.FS.createDirAll tmpRoot
  let leftPath := s!"{tmpRoot}/left.txt"
  let rightPath := s!"{tmpRoot}/right.txt"
  let targetPath := s!"{tmpRoot}/target.txt"
  IO.FS.writeFile leftPath "left\n"
  IO.FS.writeFile rightPath "right\n"
  IO.FS.writeFile targetPath "target\n"
  let s1 ← runKeys s0 ([Key.char ':'] ++ keys s!"e {leftPath}" ++ [Key.enter])
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let rightWinId := s2.getCurrentWorkspace.activeWindowId
  let s3 ← runKeys s2 ([Key.char ':'] ++ keys s!"e {rightPath}" ++ [Key.enter])
  let s4 ← runKeys s3 ([Key.char ':'] ++ keys "wincmd w" ++ [Key.enter])
  let targetWinId := s4.getCurrentWorkspace.activeWindowId
  assertEqual "wincmd w changes active target window" true (targetWinId != rightWinId)
  let s5 ← runKeys s4 ([Key.char ':'] ++ keys s!"ex list {tmpRoot}" ++ [Key.enter])
  let explorerBufId := s5.getActiveBuffer.id
  let explorerOpt := s5.explorers.find? (fun (id, _) => id == explorerBufId)
  match explorerOpt with
  | none =>
      assertEqual "File explorer registered" true false
  | some (_, explorer) =>
      let targetIdxOpt := findEntryIndex explorer.entries "target.txt"
      assertEqual "Explorer contains target file" true targetIdxOpt.isSome
      let targetIdx := targetIdxOpt.getD 0
      let s6 := s5.updateActiveView fun v => { v with cursor := { row := ⟨2 + targetIdx⟩, col := 0 } }
      let s7 ← runKeys s6 [Key.enter]
      assertEqual "Explorer Enter uses focused window from before open" targetWinId s7.getCurrentWorkspace.activeWindowId
      assertEqual "Selected file opens in focused window" (some targetPath) s7.getActiveBuffer.filename
      let ws7 := s7.getCurrentWorkspace
      match ws7.layout.findView rightWinId with
      | none =>
          assertEqual "Other split window still exists" true false
      | some rightView =>
          let rightBufName := ws7.buffers.find? (fun b => b.id == rightView.bufferId) |>.bind (fun b => b.filename)
          assertEqual "Non-focused split keeps prior buffer" (some rightPath) rightBufName

  testCursorDriftCustomTabStop

  testExplorerOpenUsesFocusedWindow

def testBuildRestoredWorkspaceCustomTabStop : IO Unit := do
  IO.println "Starting Restored Workspace Custom TabStop Test..."
  let stamp <- IO.monoMsNow
  let root := s!"/tmp/vie-checkpoint-tab-{stamp}"
  IO.FS.createDirAll root
  let f1 := s!"{root}/tab.txt"
  IO.FS.writeFile f1 "\talpha\n"
  let settings := { ViE.defaultConfig with tabStop := 8 }
  let ws <- ViE.buildRestoredWorkspace settings (some root) [f1] 0 [(0, 8)]
  let active := ws.layout.findView ws.activeWindowId |>.getD ViE.initialView
  assertEqual "Restored custom tabStop cursor row" 0 active.cursor.row.val
  assertEqual "Restored custom tabStop cursor col" 8 active.cursor.col.val

  testBuildRestoredWorkspaceCustomTabStop