def overlapsByteRange (r : Nat × Nat) (byteStart byteEnd : Nat) : Bool :=
  let (s, e) := r
  byteStart < e && byteEnd > s

def activeMatchRange (hitRanges : Array (Nat × Nat)) (cursorByte : Option Nat) : Option (Nat × Nat) :=
  match cursorByte with
  | none => none
  | some cb =>
      let rec loop (i : Nat) : Option (Nat × Nat) :=
        if i >= hitRanges.size then
          none
        else
          let m := hitRanges[i]!
          let (s, e) := m
          if s <= cb && cb < e then
            some m
          else
            loop (i + 1)
      loop 0

             let activeMatch := activeMatchRange searchMatches cursorByte

                  searchMatches.any (fun (s, e) => byteStart < e && byteEnd > s)
                let isCursorMatch :=
                  match cursorByte with
                  | some cb => searchMatches.any (fun (s, e) => s <= cb && cb < e)

                  searchMatches.any (fun m => overlapsByteRange m byteStart byteEnd)
                let isActiveMatched :=
                  match activeMatch with
                  | some m => overlapsByteRange m byteStart byteEnd

                    if isCursorMatch then

                    if isActiveMatched then

  searchBloomEnabled : Bool
  searchBloomMinBytes : Nat

  searchBloomEnabled := false
  searchBloomMinBytes := 64 * 1024 * 1024

  | none => return state.insertNewline -- Not an explorer, normal behavior

  | none =>
    match state.searchState with
    | some _ => return ViE.findNextMatch state
    | none => return state.moveCursorDown

        let idx := idxStr.toNat!
        some (accFiles.reverse, idx, accCursors.reverse)

        match idxStr.toNat? with
        | some idx => some (accFiles.reverse, idx, accCursors.reverse)
        | none => none

           let cursor := (r.toNat!, c.toNat!)
           parseFiles rest (fname :: accFiles) (cursor :: accCursors)

           match r.toNat?, c.toNat? with
           | some row, some col =>
              let cursor := (row, col)
              parseFiles rest (fname :: accFiles) (cursor :: accCursors)
           | _, _ => none

def clampCursorInBuffer (buffer : FileBuffer) (row col : Nat) : Point :=
  let lineCount := buffer.lineCount
  let clampedRow := if lineCount == 0 then 0 else min row (lineCount - 1)
  let lineLen := ViE.getLineLengthFromBuffer buffer ⟨clampedRow⟩ |>.getD 0
  let clampedCol := if lineLen == 0 then 0 else min col (lineLen - 1)
  { row := ⟨clampedRow⟩, col := ⟨clampedCol⟩ }
/-- Build startup workspace from a restored checkpoint session. -/
def buildRestoredWorkspace (settings : EditorConfig) (workspacePath : Option String)
  (files : List String) (activeIdx : Nat) (cursors : List (Nat × Nat)) : IO WorkspaceState := do
  let mut loaded : Array FileBuffer := #[]
  let mut nextId := 0
  for fname in files do
    let buf ← loadBufferByteArrayWithConfig fname settings
    loaded := loaded.push {
      buf with
        id := nextId
        table := { buf.table with undoLimit := settings.historyLimit }
    }
    nextId := nextId + 1

  let wsName := match workspacePath with
    | some path => (System.FilePath.fileName path).getD defaultWorkspaceName
    | none => defaultWorkspaceName
  if loaded.isEmpty then
    let empty : FileBuffer := {
      id := 0
      filename := none
      dirty := false
      table := PieceTable.fromString "" settings.searchBloomBuildLeafBits
      missingEol := false
      cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
    }
    return {
      name := wsName
      rootPath := workspacePath
      buffers := [empty]
      nextBufferId := 1
      layout := .window 0 { initialView with bufferId := 0 }
      activeWindowId := 0
      nextWindowId := 1
    }
  let activeIdx := if activeIdx < loaded.size then activeIdx else 0
  let activeBuf := loaded[activeIdx]!
  let (row, col) := List.getD cursors activeIdx (0, 0)
  let cursor := clampCursorInBuffer activeBuf row col
  return {
    name := wsName
    rootPath := workspacePath
    buffers := loaded.toList
    nextBufferId := loaded.size
    layout := .window 0 { initialView with bufferId := activeBuf.id, cursor := cursor }
    activeWindowId := 0
    nextWindowId := 1
  }

  let (startArgs, _) := match checkpoint with

  let (startArgs, restoreMeta) := match checkpoint with

  -- Load buffer if file exists
  let initialBuffer ← match actualFilename with
    | some fname => loadBufferByteArrayWithConfig fname config.settings
    | none => pure {
        id := 0
        filename := actualFilename
        dirty := false
        table := PieceTable.fromString "" config.settings.searchBloomBuildLeafBits
        missingEol := false
        cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
      }

  let restoreFromCheckpoint := args.isEmpty && restoreMeta.isSome && !startArgs.isEmpty
  let state ←
    if restoreFromCheckpoint then
      match restoreMeta with
      | some (activeIdx, cursors) => do
          let restored ← buildRestoredWorkspace config.settings workspacePath startArgs activeIdx cursors
          let s := { ViE.initialState with
            config := config.settings
            message := s!"Restored {restored.buffers.length} file(s)"
          }
          pure <| s.updateCurrentWorkspace (fun _ => restored)
      | none =>
          pure { ViE.initialState with config := config.settings }
    else do
      -- Load buffer if file exists
      let initialBuffer ← match actualFilename with
        | some fname => loadBufferByteArrayWithConfig fname config.settings
        | none => pure {
            id := 0
            filename := actualFilename
            dirty := false
            table := PieceTable.fromString "" config.settings.searchBloomBuildLeafBits
            missingEol := false
            cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
          }

  -- Check if initial load had an error
  let firstLine := getLineFromBuffer initialBuffer 0 |>.getD ""
  let hasError := firstLine.startsWith "Error loading file:"

      -- Check if initial load had an error
      let firstLine := getLineFromBuffer initialBuffer 0 |>.getD ""
      let hasError := firstLine.startsWith "Error loading file:"

  let state := { ViE.initialState with
    config := config.settings,
    message := if hasError then firstLine
               else match actualFilename with
                 | some f => s!"\"{f}\" [Read]"
                 | none => match workspacePath with
                   | some ws => s!"Workspace: {ws}"
                   | none => "New File"
  }

      let s := { ViE.initialState with
        config := config.settings,
        message := if hasError then firstLine
                   else match actualFilename with
                     | some f => s!"\"{f}\" [Read]"
                     | none => match workspacePath with
                       | some ws => s!"Workspace: {ws}"
                       | none => "New File"
      }

  -- Update the first workspace with the initial buffer and root path
  let state := state.updateCurrentWorkspace fun ws =>
    let wsName := match workspacePath with
      | some path => (System.FilePath.fileName path).getD ws.name
      | none => ws.name
    { ws with
        name := wsName,
        rootPath := workspacePath,
        buffers := [initialBuffer],
        nextBufferId := 1
    }

      -- Update the first workspace with the initial buffer and root path
      pure <| s.updateCurrentWorkspace fun ws =>
        let wsName := match workspacePath with
          | some path => (System.FilePath.fileName path).getD ws.name
          | none => ws.name
        { ws with
            name := wsName,
            rootPath := workspacePath,
            buffers := [initialBuffer],
            nextBufferId := 1
        }

import Test.Checkpoint
import Test.SearchHighlight

  Test.Checkpoint.test
  Test.SearchHighlight.test

import ViE.UI
import Test.Utils
namespace Test.SearchHighlight
open Test.Utils
def test : IO Unit := do
  IO.println "Starting Search Highlight Test..."
  let hitRanges : Array (Nat × Nat) := #[(0, 4), (10, 14), (20, 24)]
  assertEqual "Active match picks cursor candidate" (some (10, 14)) (ViE.UI.activeMatchRange hitRanges (some 11))
  assertEqual "No active match when cursor is outside all matches" none (ViE.UI.activeMatchRange hitRanges (some 5))
  assertEqual "No active match when cursor is none" none (ViE.UI.activeMatchRange hitRanges none)
  let active := ViE.UI.activeMatchRange hitRanges (some 11)
  let activeHead :=
    match active with
    | some m => ViE.UI.overlapsByteRange m 0 1
    | none => false
  let activeBody :=
    match active with
    | some m => ViE.UI.overlapsByteRange m 11 12
    | none => false
  assertEqual "Active candidate does not color other matches" false activeHead
  assertEqual "Active candidate colors only its own range" true activeBody
end Test.SearchHighlight

  let s2e ← runKeys s2 [Key.enter]
  assertCursor "Enter after search jumps to next match" s2e 1 0
  assertBuffer "Enter after search does not insert newline" s2e "hello world\nhello again\n"

import ViE.App
import ViE.Checkpoint
import ViE.State.Config
import Test.Utils
namespace Test.Checkpoint
open Test.Utils
open ViE
def testLoadSessionInvalid : IO Unit := do
  IO.println "Starting Checkpoint Parse Invalid Test..."
  IO.FS.writeFile ViE.Checkpoint.sessionFile "--ACTIVE--\nnot-a-number\n"
  let loaded <- ViE.Checkpoint.loadSession
  assertEqual "Invalid checkpoint parses as none" none loaded
def testLoadSessionValid : IO Unit := do
  IO.println "Starting Checkpoint Parse Valid Test..."
  let content :=
    "/tmp/file-a.txt\n" ++
    "0 0\n" ++
    "/tmp/file-b.txt\n" ++
    "3 4\n" ++
    "--ACTIVE--\n" ++
    "1\n"
  IO.FS.writeFile ViE.Checkpoint.sessionFile content
  let loaded <- ViE.Checkpoint.loadSession
  let expected : Option (List String × Nat × List (Nat × Nat)) :=
    some (["/tmp/file-a.txt", "/tmp/file-b.txt"], 1, [(0, 0), (3, 4)])
  assertEqual "Valid checkpoint parsing" expected loaded
def testBuildRestoredWorkspace : IO Unit := do
  IO.println "Starting Restored Workspace Build Test..."
  let stamp <- IO.monoMsNow
  let root := s!"/tmp/vie-checkpoint-{stamp}"
  IO.FS.createDirAll root
  let f1 := s!"{root}/a.txt"
  let f2 := s!"{root}/b.txt"
  IO.FS.writeFile f1 "alpha\nbeta\n"
  IO.FS.writeFile f2 "line0\nline1\nline2\n"
  let ws <- ViE.buildRestoredWorkspace ViE.defaultConfig (some root) [f1, f2] 1 [(0, 0), (1, 2)]
  assertEqual "Restored workspace buffer count" 2 ws.buffers.length
  assertEqual "Restored workspace nextBufferId" 2 ws.nextBufferId
  let active := ws.layout.findView ws.activeWindowId |>.getD ViE.initialView
  assertEqual "Restored active buffer id" 1 active.bufferId
  assertEqual "Restored cursor row" 1 active.cursor.row.val
  assertEqual "Restored cursor col" 2 active.cursor.col.val
  match ws.buffers with
  | b1 :: b2 :: _ =>
      assertEqual "Restored first file path" (some f1) b1.filename
      assertEqual "Restored second file path" (some f2) b2.filename
  | _ =>
      throw (IO.userError "Expected two restored buffers")
def test : IO Unit := do
  testLoadSessionInvalid
  testLoadSessionValid
  testBuildRestoredWorkspace
end Test.Checkpoint

- `Enter` in Normal mode jumps to next match when a search is active
- `:noh` / `:nohl` clears current search highlight

- Tuning: `searchBloomMinBytes`, `searchBloomCacheMax`, `searchBloomBuildLeafBits`

- Tuning: `searchBloomCacheMax`, `searchBloomBuildLeafBits`

- `:e <file>`: Open file

- `:qa`, `:qa!`: force quit editor

- `:vs`, `:hs`  vertical and horizontal window splitting
- `:wincmd h/j/k/l` change focus select window
- `:wh`, `:wj`, `:wk`, `:wl` change focus select window (alias)
- `:wincmd w`, `:wc` cyclic selection
- `:wg <n>` switch to workgroup <n>

- `:sp`, `:split`, `:hs`, `:hsplit`: Horizontal split
- `:vs`, `:vsplit`: Vertical split
- `:wincmd h/j/k/l`: Switch focused window
- `:wincmd s/v`: Split from `wincmd`
- `:wincmd w`, `:wc`: Cycle focused window
- `:wh`, `:wj`, `:wk`, `:wl`: Window focus aliases
- `:cd [path]`: Set/Clear workspace root
- `:pwd`: Show current workspace root
- `:workspace open <path>`: Set workspace root
- `:workspace rename <name>`: Rename current workspace
- `:ws list`: Open workspace explorer
- `:ws open [--name <name>] <path>`: Create and switch workspace
- `:ws new [name] [path]`: Create and switch workspace
- `:ws close`: Close current workspace
- `:ws rename <name>`: Rename current workspace
- `:ws next`, `:ws prev`, `:ws <index>`: Switch workspace
- `:wg list`: Open workgroup explorer
- `:wg new [name]`: Create and switch workgroup
- `:wg close`: Close current workgroup
- `:wg rename <name>`: Rename current workgroup
- `:wg next`, `:wg prev`, `:wg <index>`: Switch workgroup
- `:ee [path]`: Open file explorer
- `:wgex`: Open workgroup explorer
- `:undo`, `:u`: Undo
- `:redo`: Redo

- `:refresh`: alias for `:reload`
- `:bloom /pattern`, `:bloom ?pattern`: Bloom-assisted search
- `:noh`, `:nohl`: Clear search highlight
- `:s/old/new/[g]`: Substitute on current line
- `:%s/old/new/[g]`: Substitute on all lines
- `:g/pat/ d`: Delete matching lines
- `:g/pat/ s/old/new/[g]`: Substitute on matching lines
- `:v/pat/ d`: Delete non-matching lines