4kusto/vie - Change KK6O2B6FHJHMRVSE3N54S47OY4TWV2UGI53CYLYSWAL6WSACFEBAC

test: rename Test modules to ViETest and remove dead code

Created by 4kusto on March 7, 2026

KK6O2B6FHJHMRVSE3N54S47OY4TWV2UGI53CYLYSWAL6WSACFEBAC

Dependencies

In channels

main

Change contents

File deletion: Test.lean
BF:BFD[6.1] → [7.10057:10090]
BF:BFD[7.10090] → [7.10091:10091]
B:BD[7.10091] → [5.10104:10186]
∅:D[5.10186] → [7.10092:10171]
B:BD[7.10091] → [7.10092:10171]
B:BD[7.10171] → [8.29762:29800]
∅:D[9.23205] → [10.4004:4127]
∅:D[11.35645] → [10.4004:4127]
B:BD[8.29828] → [10.4004:4127]
B:BD[10.4127] → [12.22949:23002]
∅:D[12.23002] → [13.7713:7732]
B:BD[10.4127] → [13.7713:7732]
B:BD[13.7732] → [14.5779:5830]
B:BD[14.5830] → [15.90697:90719]
B:BD[15.90719] → [16.22989:23017]
B:BD[16.23017] → [17.34351:34372]
B:BD[17.34372] → [18.3453:3469]
B:BD[8.29800] → [9.23144:23205]
B:BD[9.23205] → [11.35541:35645]
∅:D[18.3469] → [7.10171:10172]
∅:D[10.4127] → [7.10171:10172]
∅:D[14.5830] → [7.10171:10172]
∅:D[13.7732] → [7.10171:10172]
∅:D[16.23017] → [7.10171:10172]
∅:D[8.29828] → [7.10171:10172]
∅:D[17.34372] → [7.10171:10172]
∅:D[15.90719] → [7.10171:10172]
B:BD[7.10171] → [7.10171:10172]
∅:D[10.4153] → [7.10197:10312]
B:BD[7.10197] → [7.10197:10312]
B:BD[7.10312] → [8.29829:29867]
∅:D[13.7752] → [10.4154:4277]
∅:D[9.23267] → [10.4154:4277]
∅:D[11.35750] → [10.4154:4277]
B:BD[8.29895] → [10.4154:4277]
B:BD[10.4277] → [12.23003:23056]
B:BD[12.23056] → [14.5831:5882]
B:BD[14.5882] → [15.90720:90742]
B:BD[15.90742] → [16.23018:23046]
B:BD[16.23046] → [17.34373:34394]
B:BD[17.34394] → [18.3470:3486]
B:BD[8.29867] → [9.23206:23267]
B:BD[9.23267] → [11.35646:35750]
B:BD[11.35750] → [13.7733:7752]
∅:D[18.3486] → [7.10312:10347]
∅:D[10.4277] → [7.10312:10347]
∅:D[14.5882] → [7.10312:10347]
∅:D[16.23046] → [7.10312:10347]
∅:D[12.23056] → [7.10312:10347]
∅:D[8.29895] → [7.10312:10347]
∅:D[17.34394] → [7.10312:10347]
∅:D[15.90742] → [7.10312:10347]
B:BD[7.10312] → [7.10312:10347]
B:BD[7.10347] → [10.4278:4311]
B:BD[7.10172] → [10.4128:4153]
```
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import Test.Undo
import Test.Buffer
import Test.Layout
import Test.Integration
import Test.Keybinds
import Test.Mode
import Test.PieceTable.Basic
import Test.PieceTable.UndoRedo
import Test.PieceTable.Appended
import Test.PieceTable.Stress
import Test.PieceTable.Search
import Test.MissingEol
import Test.Scroll
import Test.Checkpoint
import Test.SearchHighlight
import Test.TreeStats
import Test.SyntaxHighlight
import Test.InfoView
import Test.Lsp
import Test.CursorReproduction
import Test.PasteReproduction
import Test.Workspace
import Test.PreviewData
import Test.WorkgroupExplorer
import Test.ExplorerPreview
  IO.println "Running all tests..."
  Test.Undo.test
  Test.Buffer.test
  Test.Layout.test
  Test.Integration.test
  Test.Keybinds.test
  Test.Mode.test
  Test.PieceTable.Basic.test
  Test.PieceTable.UndoRedo.test
  Test.PieceTable.Appended.test
  Test.PieceTable.Stress.test
  Test.PieceTable.Search.test
  Test.MissingEol.test
  Test.Checkpoint.test
  Test.SearchHighlight.test
  Test.TreeStats.test
  Test.SyntaxHighlight.test
  Test.InfoView.test
  Test.Lsp.test
  Test.CursorReproduction.test
  Test.PasteReproduction.test
  Test.Workspace.test
  Test.PreviewData.test
  Test.WorkgroupExplorer.test
  Test.ExplorerPreview.test
  Test.Scroll.test
  IO.println "All tests finished."
def main : IO Unit := do
  test
def test : IO Unit := do
```
File deletion: Test
BF:BFD[6.1] → [7.10348:10363]
BF:BFD[7.10363] → [7.10364:10364]
File deletion: TreeStatsMain.lean
BF:BFD[7.10364] → [15.92899:92941]
BF:BFD[15.92941] → [15.92942:92942]
∅:D[5.10601] → [15.92943:93036]
B:BD[15.92942] → [15.92943:93036]
B:BD[15.92942] → [5.10519:10601]
```
import Test.TreeStats
def main (args : List String) : IO Unit :=
  Test.TreeStats.main args
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
```

File deletion: ExplorerPreview.lean

BF:BFD[7.10364] → [11.80452:80496]

BF:BFD[11.80496] → [11.80497:80497]

∅:D[5.12190] → [11.80498:80603]

B:BD[11.80497] → [11.80498:80603]

∅:D[19.11609] → [11.80603:81059]

B:BD[11.80603] → [11.80603:81059]

∅:D[15.118696] → [11.81088:81208]

B:BD[11.81088] → [11.81088:81208]

B:BD[11.81208] → [15.118697:118733]

∅:D[19.12093] → [15.118825:119472]

B:BD[15.118825] → [15.118825:119472]

B:BD[15.118733] → [19.11610:12093]

∅:D[15.119472] → [11.81208:82030]

B:BD[11.81208] → [11.81208:82030]

∅:D[19.12122] → [15.119502:119544]

B:BD[15.119502] → [15.119502:119544]

∅:D[19.12190] → [15.119610:119634]

B:BD[15.119610] → [15.119610:119634]

∅:D[19.12260] → [15.119705:119797]

B:BD[15.119705] → [15.119705:119797]

∅:D[19.12665] → [15.120000:120123]

B:BD[15.120000] → [15.120000:120123]

B:BD[15.120123] → [19.12666:12734]

B:BD[15.119797] → [19.12261:12665]

B:BD[15.119634] → [19.12191:12260]

B:BD[15.119544] → [19.12123:12190]

∅:D[19.12734] → [11.82030:84435]

∅:D[15.120200] → [11.82030:84435]

B:BD[11.82030] → [11.82030:84435]

B:BD[11.84435] → [15.120201:120267]

∅:D[15.120267] → [11.84435:84489]

B:BD[11.84435] → [11.84435:84489]

B:BD[11.84489] → [15.120268:120310]

∅:D[19.12844] → [15.120433:120677]

B:BD[15.120433] → [15.120433:120677]

B:BD[15.120310] → [19.12735:12844]

∅:D[15.120677] → [11.84489:84570]

B:BD[11.84489] → [11.84489:84570]

B:BD[11.84570] → [15.120678:120769]

∅:D[15.120769] → [11.84570:85724]

B:BD[11.84570] → [11.84570:85724]

B:BD[11.82030] → [19.12094:12122]

B:BD[11.81059] → [15.118619:118696]

B:BD[11.80603] → [19.11585:11609]

B:BD[11.80497] → [5.12108:12190]

import ViE.State.Config
import ViE.Command.Explorer
import ViE.Window.Analysis
import ViE.Window.Actions
import Test.Utils
namespace Test.ExplorerPreview
open Test.Utils
open ViE
def findEntryIndex (entries : List FileEntry) (name : String) : Option Nat :=
  let rec loop (list : List FileEntry) (idx : Nat) : Option Nat :=
    match list with
    | [] => none
    | e :: rest =>
      if e.name == name then
        some idx
      else
        loop rest (idx + 1)
  loop entries 0
def test : IO Unit := do
  IO.println "Starting Explorer Preview Test..."
  let path := "Test/test_paths/dir0/dir1"
  let s1 ← ViE.Feature.openExplorer s0 path
  let buf := s1.getActiveBuffer
  let ws1 := s1.getCurrentWorkspace
  let baseBufId := s0.getActiveBuffer.id
  let baseWinId :=
    (ViE.Window.getWindowIds ws1.layout).find? (fun wid =>
      if wid == ws1.activeWindowId then
        false
      else
        match ws1.layout.findView wid with
        | some v => v.bufferId == baseBufId
        | none => false)
  let baseWindowStillExists :=
    (ViE.Window.getWindowIds ws1.layout).any (fun wid =>
      if wid == ws1.activeWindowId then
        false
      else
        match ws1.layout.findView wid with
        | some v => v.bufferId == baseBufId
        | none => false)
  assert "Opening explorer keeps original buffer window intact" baseWindowStillExists
  assert "File explorer opens in regular window" (!ws1.isFloatingWindow ws1.activeWindowId)
  let model1 := ViE.BlikuAdapter.toModel s1
  let explorerClustered :=
    match model1.workspace.floatingClusters[0]? with
    | some cluster =>
        match cluster.root, cluster.sizePolicy with
        | .group gid, .multiPane => gid == buf.id
        | _, _ => false
    | none => false
  assert "Bliku adapter lifts explorer/preview into floating multi-pane cluster" explorerClustered
  let explorerOpt := s1.explorers.find? (fun (id, _) => id == buf.id)
  match explorerOpt with
  | none =>
    throw (IO.userError "Explorer buffer not registered")
  | some (_, explorer) =>
    let idx1 := findEntryIndex explorer.entries "file1.txt"
    let idx2 := findEntryIndex explorer.entries "file2.txt"
    assert "file1.txt exists in explorer entries" idx1.isSome
    assert "file2.txt exists in explorer entries" idx2.isSome
    let row1 : Row := ⟨2 + idx1.get!⟩
    let row2 : Row := ⟨2 + idx2.get!⟩
    let exAfterOpen := s1.explorers.find? (fun (id, _) => id == buf.id) |>.map (fun (_, ex) => ex)
    match exAfterOpen with
    | none => throw (IO.userError "Explorer buffer not registered after open")
    | some exOpen =>
      assert "Preview window created on open" exOpen.previewWindowId.isSome
        match exOpen.previewWindowId with
        | none => false
      let pairSideBySide :=
        match exOpen.previewWindowId with
        | some wid =>
            et == pt && eh == ph && ((el + ew <= pl) || (pl + pw <= el))
          | _, _ => false
        | none => false
      assert "Explorer/preview pair is side-by-side" pairSideBySide
          let bounds := ViE.Window.getAllWindowBounds s1.getCurrentWorkspace.layout
            (if s1.windowHeight > 0 then s1.windowHeight - 1 else 0) s1.windowWidth
          match bounds.find? (fun (id, _, _, _, _) => id == s1.getCurrentWorkspace.activeWindowId),
                bounds.find? (fun (id, _, _, _, _) => id == wid) with
          | some (_, et, el, eh, ew), some (_, pt, pl, ph, pw) =>
      assert "Preview window opens in regular window" previewRegular
        | some wid => !s1.getCurrentWorkspace.isFloatingWindow wid
    let s2 := s1.updateActiveView fun v => { v with cursor := { row := row1, col := 0 } }
    let s3 ← ViE.Feature.refreshExplorerPreview s2
    let exAfterOpt := s3.explorers.find? (fun (id, _) => id == buf.id)
    match exAfterOpt with
    | none =>
      throw (IO.userError "Explorer buffer not registered after preview")
    | some (_, exAfter) =>
      assert "Preview window created" exAfter.previewWindowId.isSome
      assert "Preview buffer created" exAfter.previewBufferId.isSome
      let ws := s3.getCurrentWorkspace
      let previewWinId := exAfter.previewWindowId.get!
      let previewView := ws.layout.findView previewWinId |>.getD initialView
      let previewBuf := ws.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
      assert "Preview filename has prefix" ((previewBuf.filename.getD "").startsWith "preview://")
      assert "Preview filename contains file1.txt" ((previewBuf.filename.getD "").contains "file1.txt")
      let dirIdx := findEntryIndex exAfter.entries "dir0"
      assert "dir0 exists in explorer entries" dirIdx.isSome
      let dirRow : Row := ⟨2 + dirIdx.get!⟩
      let s3a := s3.updateActiveView fun v => { v with cursor := { row := dirRow, col := 0 } }
      let s3b ← ViE.Feature.handleExplorerEnter s3a
      let idsAfterDir := ViE.Window.getWindowIds s3b.getCurrentWorkspace.layout
      assert "Preview window kept on directory navigation" (idsAfterDir.contains previewWinId)
      let newExplorerOpt := s3b.explorers.find? (fun (id, _) => id == s3b.getActiveBuffer.id)
      match newExplorerOpt with
      | none => throw (IO.userError "Explorer buffer not registered after directory nav")
      | some (_, exAfterDir) =>
        assert "Preview window id preserved on directory nav" (exAfterDir.previewWindowId == exAfter.previewWindowId)
      let s4 := s3.updateActiveView fun v => { v with cursor := { row := row2, col := 0 } }
      let s5 ← ViE.Feature.refreshExplorerPreview s4
      let ws5 := s5.getCurrentWorkspace
      let previewView2 := ws5.layout.findView previewWinId |>.getD initialView
      let previewBuf2 := ws5.buffers.find? (fun b => b.id == previewView2.bufferId) |>.getD initialBuffer
      assert "Preview filename updates to file2.txt" ((previewBuf2.filename.getD "").contains "file2.txt")
      let s5a := s5.updateActiveView fun v => { v with cursor := { row := row2, col := 0 } }
      let explorerWinId := s5a.getCurrentWorkspace.activeWindowId
      let s5b ← ViE.Feature.handleExplorerEnter s5a
      let ws5b := s5b.getCurrentWorkspace
      match baseWinId with
      | some wid =>
          assert "Opening file from explorer uses original buffer window" (ws5b.activeWindowId == wid)
      | none =>
          throw (IO.userError "Base window id not found after explorer open")
      assert "Opening file from explorer leaves regular window" (!ws5b.isFloatingWindow ws5b.activeWindowId)
      let idsAfterOpen := ViE.Window.getWindowIds s5b.getCurrentWorkspace.layout
      assert "Explorer window removed on file open" (!idsAfterOpen.contains explorerWinId)
      assert "Preview window removed on file open" (!idsAfterOpen.contains previewWinId)
      let bufIdsAfterOpen := s5b.getCurrentWorkspace.buffers.map (fun b => b.id)
      let previewBufId := exAfter.previewBufferId.getD 0
      assert "Preview buffer removed on file open" (!bufIdsAfterOpen.contains previewBufId)
      let sClose := ViE.Window.closeActiveWindow s5
      let idsAfter := ViE.Window.getWindowIds sClose.getCurrentWorkspace.layout
      assert "Preview window removed on explorer close" (!idsAfter.contains previewWinId)
      let bufIdsAfterClose := sClose.getCurrentWorkspace.buffers.map (fun b => b.id)
      assert "Preview buffer removed on explorer close" (!bufIdsAfterClose.contains previewBufId)
      let s6 ← ViE.Feature.toggleExplorerPreview s5
      let exAfterClose := s6.explorers.find? (fun (id, _) => id == buf.id) |>.map (fun (_, ex) => ex)
      match exAfterClose with
      | none => throw (IO.userError "Explorer buffer missing after close")
      | some exClose =>
        assert "Preview window cleared" exClose.previewWindowId.isNone
  IO.println "Explorer Preview Test passed!"
end Test.ExplorerPreview
      let previewRegular :=
  let s0 := { ViE.initialState with windowHeight := 40, windowWidth := 120 }
import ViE.BlikuAdapter
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: PreviewData.lean

BF:BFD[7.10364] → [11.78874:78914]

BF:BFD[11.78914] → [11.78915:78915]

∅:D[5.11016] → [11.78916:80115]

B:BD[11.78915] → [11.78916:80115]

B:BD[11.78915] → [5.10934:11016]

import ViE.Buffer.LowIO
import ViE.State.Config
import ViE.State.Layout
import Test.Utils
namespace Test.PreviewData
open Test.Utils
def basePath : String := "Test/test_paths"
def testFiles : List String := [
  s!"{basePath}/file0.txt",
  s!"{basePath}/dir0/file0.txt",
  s!"{basePath}/dir0/file1.txt",
  s!"{basePath}/dir0/file2.txt",
  s!"{basePath}/dir0/file3.txt",
  s!"{basePath}/dir0/dir0/file0.txt",
  s!"{basePath}/dir0/dir1/file1.txt",
  s!"{basePath}/dir0/dir1/file2.txt",
  s!"{basePath}/dir0/dir1/file3.txt",
  s!"{basePath}/dir0/dir1/file4.txt",
  s!"{basePath}/dir0/dir1/file5.txt"
]
def test : IO Unit := do
  IO.println "Starting Preview Data Test..."
  for path in testFiles do
    let buf ← ViE.loadBufferByteArray path
    let content := buf.table.toString
    let byteLen := content.toUTF8.size
    assertEqual s!"{path} has content" true (content.length > 0)
    assertEqual s!"{path} has bytes" true (byteLen > 0)
    assertEqual s!"{path} has lines" true (buf.lineCount > 0)
    let firstLine := ViE.getLineFromBuffer buf 0 |>.getD ""
    assertEqual s!"{path} has first line" true (firstLine.length > 0)
  IO.println "PreviewDataTest passed!"
end Test.PreviewData
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: WorkgroupExplorer.lean

BF:BFD[7.10364] → [11.75729:75775]

BF:BFD[11.75775] → [11.75776:75776]

∅:D[5.10352] → [11.75777:76691]

B:BD[11.75776] → [11.75777:76691]

∅:D[15.91901] → [11.76720:77134]

B:BD[11.76720] → [11.76720:77134]

B:BD[11.77134] → [15.91902:91938]

B:BD[15.91938] → [19.9797:9904]

∅:D[19.9904] → [11.77134:77704]

∅:D[15.92045] → [11.77134:77704]

B:BD[11.77134] → [11.77134:77704]

∅:D[13.10173] → [11.77704:77782]

B:BD[11.77704] → [11.77704:77782]

∅:D[15.92709] → [11.77936:78018]

B:BD[11.77936] → [11.77936:78018]

∅:D[15.92898] → [11.78201:78873]

B:BD[11.78201] → [11.78201:78873]

B:BD[11.78018] → [15.92710:92898]

B:BD[11.77782] → [15.92532:92709]

B:BD[11.77704] → [13.9353:9749]

∅:D[19.10013] → [15.92154:92180]

B:BD[15.92154] → [15.92154:92180]

∅:D[19.10453] → [15.92343:92436]

B:BD[15.92343] → [15.92343:92436]

B:BD[15.92436] → [19.10454:10540]

B:BD[15.92180] → [19.10014:10453]

B:BD[13.9749] → [19.9905:10013]

∅:D[19.10540] → [13.9749:10173]

∅:D[15.92531] → [13.9749:10173]

B:BD[13.9749] → [13.9749:10173]

B:BD[11.76691] → [15.91824:91901]

B:BD[11.75776] → [5.10270:10352]

import ViE.State.Config
import ViE.State.Layout
import ViE.Command.Explorer
import ViE.State.Config
import ViE.Command.Impl
import Test.Utils
namespace Test.WorkgroupExplorer
open Test.Utils
open ViE
def addWorkspace (state : EditorState) (ws : WorkspaceState) : EditorState :=
  state.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := wg.workspaces.push ws }
def addWorkgroup (state : EditorState) (name : String) : EditorState :=
  let nextBufId := state.workgroups.foldl (fun m g =>
    g.workspaces.foldl (fun m2 ws => max m2 ws.nextBufferId) m) 0
  let newWg := createEmptyWorkgroup name nextBufId
  { state with workgroups := state.workgroups.push newWg }
def setCursorRow (state : EditorState) (row : Nat) : EditorState :=
  state.updateActiveView fun v => { v with cursor := { v.cursor with row := ⟨row⟩ } }
def test : IO Unit := do
  IO.println "Starting Workgroup Explorer Test..."
  let ws1 := makeWorkspaceState "Project A" (some "/tmp/project-a") 10
  let ws2 := makeWorkspaceState "Project B" (some "/tmp/project-b") 20
  let s1 := addWorkspace (addWorkspace s0 ws1) ws2
  let s1 := addWorkgroup s1 "Group B"
  let s1 := addWorkgroup s1 "Group C"
  let s2 ← ViE.Command.cmdWg ["list"] s1
  assertEqual "Explorer buffer is active" (some "explorer://workgroups") s2.getActiveBuffer.filename
  let ws2 := s2.getCurrentWorkspace
  assertEqual "Workgroup explorer opens in regular window" false (ws2.isFloatingWindow ws2.activeWindowId)
  let bufText := s2.getActiveBuffer.table.toString
  assertEqual "Explorer contains Workgroup header" true (bufText.contains "Workgroup Explorer")
  assertEqual "Explorer contains New Workgroup entry" true (bufText.contains "[New Workgroup]")
  assertEqual "Explorer contains Rename Workgroup entry" true (bufText.contains "[Rename Workgroup]")
  assertEqual "Explorer contains Group 0" true (bufText.contains "0")
  assertEqual "Explorer contains Group B" true (bufText.contains "Group B")
  assertEqual "Explorer marks current workgroup" true (bufText.contains "*")
  let s3 := setCursorRow s2 2
  let s4 ← ViE.Feature.handleExplorerEnter s3
  let s3b := setCursorRow s2 3
  let s4b ← ViE.Feature.handleExplorerEnter s3b
  let s4c ← ViE.Command.cmdWg ["rename", ""] s2
  assertEqual "Rename workgroup rejects empty" "Workgroup name cannot be empty" s4c.message
  let s4d ← ViE.Command.cmdWg ["rename", "Group B"] s2
  assertEqual "Rename workgroup rejects duplicate" true (s4d.message.contains "already exists")
  let s5 ← ViE.Command.cmdWg ["list"] s1
  let s6 := setCursorRow s5 5
  let s7 ← ViE.Feature.handleExplorerEnter s6
  assertEqual "Switched to workgroup index 1" 1 s7.currentGroup
  assertEqual "Switch restores workgroup layout" true (s7.getActiveBuffer.filename != some "explorer://workgroup")
  IO.println "WorkgroupExplorerTest passed!"
end Test.WorkgroupExplorer
  assertEqual "Rename workgroup opens floating input" true s4b.floatingOverlay.isSome
  assertEqual "Rename workgroup floating command prefix" (some "wg rename ") s4b.floatingInputCommand
  assertEqual "New workgroup opens floating input" true s4.floatingOverlay.isSome
  assertEqual "New workgroup floating command prefix" (some "wg new ") s4.floatingInputCommand
  let explorerOpt := s2.explorers.find? (fun (id, _) => id == s2.getActiveBuffer.id)
  match explorerOpt with
  | none => throw (IO.userError "Workgroup explorer not registered")
  | some (_, explorer) =>
    assertEqual "Workgroup explorer preview window exists" true explorer.previewWindowId.isSome
    let previewWinId := explorer.previewWindowId.get!
    let wsPrev := s2.getCurrentWorkspace
    let pairSideBySide :=
          et == pt && eh == ph && ((el + ew <= pl) || (pl + pw <= el))
      | _, _ => false
    assertEqual "Workgroup explorer/preview pair is side-by-side" true pairSideBySide
      match (ViE.Window.getAllWindowBounds wsPrev.layout (if s2.windowHeight > 0 then s2.windowHeight - 1 else 0) s2.windowWidth).find? (fun (id, _, _, _, _) => id == wsPrev.activeWindowId),
            (ViE.Window.getAllWindowBounds wsPrev.layout (if s2.windowHeight > 0 then s2.windowHeight - 1 else 0) s2.windowWidth).find? (fun (id, _, _, _, _) => id == previewWinId) with
      | some (_, et, el, eh, ew), some (_, pt, pl, ph, pw) =>
    assertEqual "Workgroup explorer preview window is regular" false (wsPrev.isFloatingWindow previewWinId)
    let previewView := wsPrev.layout.findView previewWinId |>.getD initialView
    let previewBuf := wsPrev.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
    let previewText := previewBuf.table.toString
    assertEqual "Workgroup preview includes Project A" true (previewText.contains "Project A")
    assertEqual "Workgroup preview includes Project B" true (previewText.contains "Project B")
  let s0 := { ViE.initialState with windowHeight := 40, windowWidth := 120 }
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Workspace.lean

BF:BFD[7.10364] → [11.62891:62929]

BF:BFD[11.62929] → [11.62930:62930]

∅:D[5.10269] → [11.62931:63100]

B:BD[11.62930] → [11.62931:63100]

∅:D[13.7782] → [11.63100:63603]

B:BD[11.63100] → [11.63100:63603]

∅:D[15.90820] → [11.63632:65688]

B:BD[11.63632] → [11.63632:65688]

B:BD[11.65688] → [15.90821:90857]

B:BD[15.90857] → [19.9041:9148]

∅:D[19.9148] → [11.65688:66276]

∅:D[15.90964] → [11.65688:66276]

B:BD[11.65688] → [11.65688:66276]

∅:D[15.91144] → [11.66432:66573]

B:BD[11.66432] → [11.66432:66573]

∅:D[15.91333] → [11.66756:67885]

B:BD[11.66756] → [11.66756:67885]

∅:D[3.2560] → [11.67885:68026]

B:BD[11.67885] → [11.67885:68026]

∅:D[13.9352] → [11.68026:74521]

B:BD[11.68026] → [11.68026:74521]

∅:D[3.2613] → [11.74521:74555]

B:BD[11.74521] → [11.74521:74555]

∅:D[3.2672] → [11.74555:74630]

B:BD[11.74555] → [11.74555:74630]

∅:D[3.2746] → [11.74700:74816]

B:BD[11.74700] → [11.74700:74816]

∅:D[3.2931] → [11.74816:74900]

B:BD[11.74816] → [11.74816:74900]

∅:D[3.3095] → [11.75073:75112]

B:BD[11.75073] → [11.75073:75112]

∅:D[3.3154] → [11.75112:75187]

B:BD[11.75112] → [11.75112:75187]

∅:D[3.3813] → [11.75336:75394]

B:BD[11.75336] → [11.75336:75394]

∅:D[3.3868] → [11.75394:75444]

B:BD[11.75394] → [11.75394:75444]

∅:D[3.4303] → [11.75670:75728]

B:BD[11.75670] → [11.75670:75728]

B:BD[11.75444] → [3.3869:4303]

B:BD[11.75394] → [3.3814:3868]

B:BD[11.75187] → [3.3155:3813]

B:BD[11.75112] → [3.3096:3154]

B:BD[11.74900] → [3.2932:3095]

B:BD[11.74816] → [3.2747:2931]

B:BD[11.74630] → [3.2673:2746]

B:BD[11.74555] → [3.2614:2672]

B:BD[11.74521] → [3.2561:2613]

B:BD[11.68026] → [13.7783:8935]

∅:D[19.9257] → [15.91442:91468]

B:BD[15.91442] → [15.91442:91468]

∅:D[19.9709] → [15.91635:91728]

B:BD[15.91635] → [15.91635:91728]

B:BD[15.91728] → [19.9710:9796]

B:BD[15.91468] → [19.9258:9709]

B:BD[13.8935] → [19.9149:9257]

∅:D[19.9796] → [13.8935:9352]

∅:D[15.91823] → [13.8935:9352]

B:BD[13.8935] → [13.8935:9352]

B:BD[11.67885] → [3.1600:2560]

B:BD[11.66573] → [15.91145:91333]

B:BD[11.66276] → [15.90965:91144]

B:BD[11.63603] → [15.90743:90820]

B:BD[11.63100] → [13.7753:7782]

B:BD[11.62930] → [5.10187:10269]

import ViE.State.Config
import ViE.State.Layout
import ViE.Workspace
import ViE.Command.Impl
import ViE.App
import ViE.Buffer.Content
import ViE.Basic
import Test.Utils
namespace Test.Workspace
open Test.Utils
open ViE
def addWorkspace (state : EditorState) (ws : WorkspaceState) : EditorState :=
  state.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := wg.workspaces.push ws }
def switchWorkspace (state : EditorState) (idx : Nat) : EditorState :=
  state.updateCurrentWorkgroup fun wg =>
    if idx < wg.workspaces.size then
      { wg with currentWorkspace := idx }
    else
      wg
def test : IO Unit := do
  IO.println "Starting Workspace Test..."
  let wg0 := s0.getCurrentWorkgroup
  assertEqual "Initial workgroups size" 10 s0.workgroups.size
  assertEqual "Initial workgroup count" 1 wg0.workspaces.size
  assertEqual "Initial workspace index" 0 wg0.currentWorkspace
  assertEqual "Initial workspace name" "ViE" s0.getCurrentWorkspace.name
  let ws1 := makeWorkspaceState "Project A" (some "/tmp/project-a") 10
  let s1 := addWorkspace s0 ws1
  let wg1 := s1.getCurrentWorkgroup
  assertEqual "Workgroup has 2 workspaces" 2 wg1.workspaces.size
  let s2 := switchWorkspace s1 1
  assertEqual "Switched to workspace 1" "Project A" s2.getCurrentWorkspace.name
  assertEqual "Active buffer comes from workspace 1" 10 (s2.getActiveBuffer.id)
  let resolved := s2.getCurrentWorkspace.resolvePath "file.txt"
  assertEqual "ResolvePath uses workspace root" "/tmp/project-a/file.txt" resolved
  let resolvedAbs := s2.getCurrentWorkspace.resolvePath "/abs/file.txt"
  assertEqual "ResolvePath keeps absolute path" "/abs/file.txt" resolvedAbs
  IO.println "Starting Workspace Command Test..."
  let s3 ← ViE.Command.cmdWs ["new", "Project B", "/tmp/project-b"] s2
  assertEqual "Workspace created and switched" "Project B" s3.getCurrentWorkspace.name
  assertEqual "Workspace rootPath set" (some "/tmp/project-b") s3.getCurrentWorkspace.rootPath
  assertEqual "Active buffer id is new workspace buffer" 11 s3.getActiveBuffer.id
  let s4 ← ViE.Command.cmdWs ["rename", "Project B2"] s3
  assertEqual "Workspace rename applied" "Project B2" s4.getCurrentWorkspace.name
  let s5 ← ViE.Command.cmdWs ["new", "Project C"] s4
  assertEqual "Workspace C created" "Project C" s5.getCurrentWorkspace.name
  let s6 ← ViE.Command.cmdWs ["prev"] s5
  assertEqual "Workspace prev switches back" "Project B2" s6.getCurrentWorkspace.name
  let s7 ← ViE.Command.cmdWs ["0"] s6
  assertEqual "Workspace switch by index" "ViE" s7.getCurrentWorkspace.name
  let s8 ← ViE.Command.cmdWs ["list"] s7
  assertEqual "Workspace list opens explorer buffer" (some "explorer://workgroup") s8.getActiveBuffer.filename
  let ws8 := s8.getCurrentWorkspace
  assertEqual "Workspace explorer opens in regular window" false (ws8.isFloatingWindow ws8.activeWindowId)
  let wsListText := s8.getActiveBuffer.table.toString
  assertEqual "Workspace list contains New Workspace entry" true (wsListText.contains "[New Workspace]")
  assertEqual "Workspace list contains Rename Workspace entry" true (wsListText.contains "[Rename Workspace]")
  assertEqual "Workspace list contains Project B2" true (wsListText.contains "Project B2")
  assertEqual "Workspace list marks current workspace" true (wsListText.contains "*")
  let s8a := s8.updateActiveView fun v => { v with cursor := {row := ⟨2⟩, col := 0} }
  let s8b ← ViE.Feature.handleExplorerEnter s8a
  let s8c := s8.updateActiveView fun v => { v with cursor := {row := ⟨3⟩, col := 0} }
  let s8d ← ViE.Feature.handleExplorerEnter s8c
  let s8e ← ViE.Command.cmdWorkspace ["rename", ""] s8
  assertEqual "Rename workspace rejects empty" "Workspace name cannot be empty" s8e.message
  let s8f ← ViE.Command.cmdWorkspace ["rename", "Project B2"] s8
  assertEqual "Rename workspace rejects duplicate" true (s8f.message.contains "already exists")
  let s9 ← ViE.Command.cmdWs ["open", "/tmp/project-d"] s8
  assertEqual "Workspace open uses path name" "project-d" s9.getCurrentWorkspace.name
  assertEqual "Workspace open rootPath set" (some "/tmp/project-d") s9.getCurrentWorkspace.rootPath
  let s10 ← ViE.Command.cmdWs ["open", "--name", "Project E", "/tmp/project-e"] s9
  assertEqual "Workspace open --name prefix" "Project E" s10.getCurrentWorkspace.name
  assertEqual "Workspace open --name prefix rootPath" (some "/tmp/project-e") s10.getCurrentWorkspace.rootPath
  let s11 ← ViE.Command.cmdWs ["open", "/tmp/project-f", "--name", "Project F"] s10
  assertEqual "Workspace open --name suffix" "Project F" s11.getCurrentWorkspace.name
  assertEqual "Workspace open --name suffix rootPath" (some "/tmp/project-f") s11.getCurrentWorkspace.rootPath
  let s12 ← ViE.Command.cmdWs ["close"] s11
  assertEqual "Workspace close switches to previous" "Project E" s12.getCurrentWorkspace.name
  IO.println "Starting Workspace Restore Test..."
  let bufA : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 0 none #[stringToLine "WS-A"]
  let bufB : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 10 none #[stringToLine "WS-B"]
  let wsA : WorkspaceState := {
    name := "WS-A"
    rootPath := none
    buffers := [bufA]
    nextBufferId := 1
    layout := .window 0 { initialView with bufferId := 0 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let wsB : WorkspaceState := {
    name := "WS-B"
    rootPath := none
    buffers := [bufB]
    nextBufferId := 11
    layout := .window 0 { initialView with bufferId := 10 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let s12a := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsB], currentWorkspace := 0 }
  let s12b ← ViE.Feature.openWorkspaceExplorer s12a
  let s12c := s12b.updateActiveView fun v => { v with cursor := {row := ⟨5⟩, col := 0} }
  let s12d ← ViE.Feature.handleExplorerEnter s12c
  assertEqual "Workspace selection switches current workspace" "WS-B" s12d.getCurrentWorkspace.name
  assertEqual "Workspace selection restores active buffer" "WS-B" s12d.getActiveBuffer.table.toString
  IO.println "Starting Workspace Restore Layout Test..."
  let bufC : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 20 none #[stringToLine "WS-C1"]
  let bufD : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 21 none #[stringToLine "WS-C2"]
  let layoutC : Layout :=
    .hsplit
      (.window 0 { initialView with bufferId := 20 })
      (.window 1 { initialView with bufferId := 21, cursor := ⟨⟨0⟩, ⟨2⟩⟩ })
      0.3
  let wsC : WorkspaceState := {
    name := "WS-C"
    rootPath := none
    buffers := [bufC, bufD]
    nextBufferId := 22
    layout := layoutC
    activeWindowId := 1
    nextWindowId := 2
  }
  let s12e := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsC], currentWorkspace := 0 }
  let s12f ← ViE.Feature.openWorkspaceExplorer s12e
  let s12g := s12f.updateActiveView fun v => { v with cursor := {row := ⟨5⟩, col := 0} }
  let s12h ← ViE.Feature.handleExplorerEnter s12g
  assertEqual "Workspace layout restore (active buffer)" "WS-C2" s12h.getActiveBuffer.table.toString
  let ratio := match s12h.getCurrentWorkspace.layout with
    | .hsplit _ _ r => r
    | _ => 0.0
  assertEqual "Workspace layout restore (ratio)" 0.3 ratio
  let cursor := s12h.getCursor
  assertEqual "Workspace layout restore (cursor row)" 0 cursor.row.val
  assertEqual "Workspace layout restore (cursor col)" 2 cursor.col.val
  IO.println "Starting Workspace Restore VSplit Test..."
  let bufE : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 30 none #[stringToLine "WS-D1"]
  let bufF : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 31 none #[stringToLine "WS-D2"]
  let layoutD : Layout :=
    .vsplit
      (.window 0 { initialView with bufferId := 30, cursor := ⟨⟨1⟩, ⟨0⟩⟩, scrollRow := ⟨1⟩, scrollCol := ⟨2⟩ })
      (.window 1 { initialView with bufferId := 31, cursor := ⟨⟨2⟩, ⟨3⟩⟩, scrollRow := ⟨0⟩, scrollCol := ⟨1⟩ })
      0.7
  let wsD : WorkspaceState := {
    name := "WS-D"
    rootPath := none
    buffers := [bufE, bufF]
    nextBufferId := 32
    layout := layoutD
    activeWindowId := 1
    nextWindowId := 2
  }
  let s12i := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsC, wsD], currentWorkspace := 0 }
  let s12j ← ViE.Feature.openWorkspaceExplorer s12i
  let s12k := s12j.updateActiveView fun v => { v with cursor := {row := ⟨6⟩, col := 0} }
  let s12l ← ViE.Feature.handleExplorerEnter s12k
  assertEqual "Workspace vsplit restore (active buffer)" "WS-D2" s12l.getActiveBuffer.table.toString
  let ratio2 := match s12l.getCurrentWorkspace.layout with
    | .vsplit _ _ r => r
    | _ => 0.0
  assertEqual "Workspace vsplit restore (ratio)" 0.7 ratio2
  let cursor2 := s12l.getCursor
  assertEqual "Workspace vsplit restore (cursor row)" 2 cursor2.row.val
  assertEqual "Workspace vsplit restore (cursor col)" 3 cursor2.col.val
  let (sRow, sCol) := s12l.getScroll
  assertEqual "Workspace vsplit restore (scroll row)" 0 sRow.val
  assertEqual "Workspace vsplit restore (scroll col)" 1 sCol.val
  IO.println "Starting Workspace Multi-View Restore Test..."
  let bufG : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 40 none #[stringToLine "WS-E1"]
  let bufH : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 41 none #[stringToLine "WS-E2"]
  let bufI : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 42 none #[stringToLine "WS-E3"]
  let layoutE : Layout :=
    .hsplit
      (.vsplit
        (.window 0 { initialView with bufferId := 40, cursor := ⟨⟨0⟩, ⟨1⟩⟩, scrollRow := ⟨0⟩, scrollCol := ⟨0⟩ })
        (.window 1 { initialView with bufferId := 41, cursor := ⟨⟨2⟩, ⟨2⟩⟩, scrollRow := ⟨1⟩, scrollCol := ⟨1⟩ })
        0.4)
      (.window 2 { initialView with bufferId := 42, cursor := ⟨⟨3⟩, ⟨0⟩⟩, scrollRow := ⟨2⟩, scrollCol := ⟨2⟩ })
      0.6
  let wsE : WorkspaceState := {
    name := "WS-E"
    rootPath := none
    buffers := [bufG, bufH, bufI]
    nextBufferId := 43
    layout := layoutE
    activeWindowId := 1
    nextWindowId := 3
  }
  let s12m := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsC, wsD, wsE], currentWorkspace := 0 }
  let s12n ← ViE.Feature.openWorkspaceExplorer s12m
  let s12o := s12n.updateActiveView fun v => { v with cursor := {row := ⟨7⟩, col := 0} }
  let s12p ← ViE.Feature.handleExplorerEnter s12o
  assertEqual "Multi-view restore (active buffer)" "WS-E2" s12p.getActiveBuffer.table.toString
  let (sr2, sc2) := s12p.getScroll
  assertEqual "Multi-view restore (scroll row)" 1 sr2.val
  assertEqual "Multi-view restore (scroll col)" 1 sc2.val
  let cursor3 := s12p.getCursor
  assertEqual "Multi-view restore (cursor row)" 2 cursor3.row.val
  assertEqual "Multi-view restore (cursor col)" 2 cursor3.col.val
  assertEqual "Multi-view restore (layout hsplit ratio)" 0.6 (match s12p.getCurrentWorkspace.layout with | .hsplit _ _ r => r | _ => 0.0)
  let subRatio := match s12p.getCurrentWorkspace.layout with
    | .hsplit left _ _ =>
        match left with
        | .vsplit _ _ r => r
        | _ => 0.0
    | _ => 0.0
  assertEqual "Multi-view restore (layout vsplit ratio)" 0.4 subRatio
  IO.println "Starting Workspace Startup Target Test..."
  let base := "Test/test_paths"
  let dirOnly := s!"{base}/dir0"
  let (wsDirOnly, fileDirOnly) ← ViE.resolveStartupTarget (some dirOnly)
  assertEqual "Directory arg has no file" none fileDirOnly
  let fileNested := s!"{base}/dir0/dir1/dir2/file0.txt"
  let (wsFileNested, fileFileNested) ← ViE.resolveStartupTarget (some fileNested)
  let fileTop := s!"{base}/file0.txt"
  let (wsFileTop, fileFileTop) ← ViE.resolveStartupTarget (some fileTop)
  IO.println "Starting Explorer Path Resolution Test..."
  let s13 := s12.updateCurrentWorkspace fun ws =>
  IO.println "WorkspaceTest passed!"
end Test.Workspace
    { ws with rootPath := some absTest, name := "Test" }
  let s14 ← ViE.Feature.openExplorer s13 "."
  assertEqual "Explorer opens absolute workspace root from dot" (some s!"explorer://{absTest}") s14.getActiveBuffer.filename
  let s15 ← ViE.Feature.openExplorer s13 "test_paths"
  assertEqual "Explorer resolves relative path from absolute workspace root" (some s!"explorer://{absTest}/test_paths") s15.getActiveBuffer.filename
  let absTest ← ViE.resolveAbsolutePath none "Test"
  assertEqual "Top-level file sets workspace to base" (some absBase) wsFileTop
  assertEqual "Top-level file keeps filename" (some absFileTop) fileFileTop
  let newNested := s!"{base}/newdir/newfile.txt"
  let absNewNested ← ViE.resolveAbsolutePath none newNested
  let newNestedParent := match (System.FilePath.mk absNewNested).parent with
    | some p => p.toString
    | none => "/"
  let (wsNewNested, fileNewNested) ← ViE.resolveStartupTarget (some newNested)
  assertEqual "Nonexistent file sets workspace to parent dir" (some newNestedParent) wsNewNested
  assertEqual "Nonexistent file keeps absolute filename" (some absNewNested) fileNewNested
  let absFileTop ← ViE.resolveAbsolutePath none fileTop
  assertEqual "File arg sets workspace to parent dir" (some nestedParent) wsFileNested
  assertEqual "File arg keeps filename" (some absFileNested) fileFileNested
  let absFileNested ← ViE.resolveAbsolutePath none fileNested
  let nestedParent := match (System.FilePath.mk absFileNested).parent with
    | some p => p.toString
    | none => "/"
  assertEqual "Directory arg sets workspace" (some absDirOnly) wsDirOnly
  let absDirOnly ← ViE.resolveAbsolutePath none dirOnly
  let absBase ← ViE.resolveAbsolutePath none base
  IO.println "Starting Workspace Explorer Preview Test..."
  let bufP1 : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 1 (some "/tmp/a.txt") #[stringToLine "A"]
  let bufP2 : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 2 (some "/tmp/b.txt") #[stringToLine "B"]
  let wsP : WorkspaceState := {
    name := "WS-P"
    rootPath := none
    buffers := [bufP1, bufP2]
    nextBufferId := 3
    layout := .window 0 { initialView with bufferId := 1 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let s12a := addWorkspace s12 wsP
  let wgP := s12a.getCurrentWorkgroup
  let idxP := if wgP.workspaces.size == 0 then 0 else wgP.workspaces.size - 1
  let s12b := switchWorkspace s12a idxP
  let s12c ← ViE.Feature.openWorkspaceExplorer s12b
  let explorerOpt := s12c.explorers.find? (fun (id, _) => id == s12c.getActiveBuffer.id)
  match explorerOpt with
  | none => throw (IO.userError "Workspace explorer not registered")
  | some (_, explorer) =>
    assertEqual "Workspace explorer preview window exists" true explorer.previewWindowId.isSome
    let previewWinId := explorer.previewWindowId.get!
    let wsPrev := s12c.getCurrentWorkspace
    let pairSideBySide :=
          et == pt && eh == ph && ((el + ew <= pl) || (pl + pw <= el))
      | _, _ => false
    assertEqual "Workspace explorer/preview pair is side-by-side" true pairSideBySide
      match (ViE.Window.getAllWindowBounds wsPrev.layout (if s12c.windowHeight > 0 then s12c.windowHeight - 1 else 0) s12c.windowWidth).find? (fun (id, _, _, _, _) => id == wsPrev.activeWindowId),
            (ViE.Window.getAllWindowBounds wsPrev.layout (if s12c.windowHeight > 0 then s12c.windowHeight - 1 else 0) s12c.windowWidth).find? (fun (id, _, _, _, _) => id == previewWinId) with
      | some (_, et, el, eh, ew), some (_, pt, pl, ph, pw) =>
    assertEqual "Workspace explorer preview window is regular" false (wsPrev.isFloatingWindow previewWinId)
    let previewView := wsPrev.layout.findView previewWinId |>.getD initialView
    let previewBuf := wsPrev.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
    let previewText := previewBuf.table.toString
    assertEqual "Workspace preview includes a.txt" true (previewText.contains "/tmp/a.txt")
    assertEqual "Workspace preview includes b.txt" true (previewText.contains "/tmp/b.txt")
  IO.println "Starting Workspace Relative Path Resolution Test..."
  let stamp ← IO.monoMsNow
  let relBase := s!"/tmp/vie-ws-rel-{stamp}"
  IO.FS.createDirAll (System.FilePath.mk relBase)
  let sRel0 := s11.updateCurrentWorkspace fun ws =>
    { ws with rootPath := some relBase, name := "RelBase" }
  let sRel1 ← ViE.Command.cmdCd ["child"] sRel0
  assertEqual "cd relative resolves from workspace root" (some s!"{relBase}/child") sRel1.getCurrentWorkspace.rootPath
  let sRel2 ← ViE.Command.cmdWs ["open", "nested"] sRel0
  assertEqual "ws open relative resolves from workspace root" (some s!"{relBase}/nested") sRel2.getCurrentWorkspace.rootPath
  assertEqual "ws open relative uses basename from absolute path" "nested" sRel2.getCurrentWorkspace.name
  let sRel3 ← ViE.Command.cmdWs ["new", "RelChild", "child2"] sRel0
  assertEqual "ws new relative resolves from workspace root" (some s!"{relBase}/child2") sRel3.getCurrentWorkspace.rootPath
  assertEqual "Rename workspace opens floating input" true s8d.floatingOverlay.isSome
  assertEqual "Rename workspace floating command prefix" (some "ws rename ") s8d.floatingInputCommand
  assertEqual "New workspace opens floating input" true s8b.floatingOverlay.isSome
  assertEqual "New workspace floating command prefix" (some "ws new ") s8b.floatingInputCommand
  let s0 := { ViE.initialState with windowHeight := 40, windowWidth := 120 }
set_option maxRecDepth 2048
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: test_paths
BF:BFD[7.10364] → [11.35751:35772]
BF:BFD[11.35772] → [11.35773:35773]
File deletion: dir0
BF:BFD[11.35773] → [11.37603:37618]
BF:BFD[11.37618] → [11.37619:37619]
File deletion: dir0
BF:BFD[11.37619] → [11.58281:58296]
BF:BFD[11.58296] → [11.58297:58297]
File deletion: dir0
BF:BFD[11.58297] → [11.61045:61060]
BF:BFD[11.61060] → [11.61061:61061]

File deletion: file0.txt

BF:BFD[11.61061] → [11.61063:61096]

BF:BFD[11.61096] → [11.61097:61097]

B:BD[11.61097] → [11.61098:62890]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File deletion: file0.txt

BF:BFD[11.58297] → [11.60127:60160]

BF:BFD[11.60160] → [11.60161:60161]

B:BD[11.60161] → [11.60162:61044]

(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)

File deletion: file1.txt

BF:BFD[11.58297] → [11.58299:58332]

BF:BFD[11.58332] → [11.58333:58333]

B:BD[11.58333] → [11.58334:60126]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File deletion: dir1
BF:BFD[11.37619] → [11.43783:43798]
BF:BFD[11.43798] → [11.43799:43799]
File deletion: dir0
BF:BFD[11.43799] → [11.57345:57360]
BF:BFD[11.57360] → [11.57361:57361]

File deletion: file0.txt

BF:BFD[11.57361] → [11.57363:57396]

BF:BFD[11.57396] → [11.57397:57397]

B:BD[11.57397] → [11.57398:58280]

(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)

File deletion: dir1
BF:BFD[11.43799] → [11.55499:55514]
BF:BFD[11.55514] → [11.55515:55515]

File deletion: file0.txt

BF:BFD[11.55515] → [11.55517:55550]

BF:BFD[11.55550] → [11.55551:55551]

B:BD[11.55551] → [11.55552:57344]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File deletion: dir2
BF:BFD[11.43799] → [11.53375:53390]
BF:BFD[11.53390] → [11.53391:53391]

File deletion: file0.txt

BF:BFD[11.53391] → [11.53393:53426]

BF:BFD[11.53426] → [11.53427:53427]

B:BD[11.53427] → [11.53428:55498]

import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample

File deletion: dir3
BF:BFD[11.43799] → [11.51773:51788]
BF:BFD[11.51788] → [11.51789:51789]

File deletion: file0.txt

BF:BFD[11.51789] → [11.51791:51824]

BF:BFD[11.51824] → [11.51825:51825]

B:BD[11.51825] → [11.51826:53374]

#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}

File deletion: file1.txt

BF:BFD[11.43799] → [11.49945:49978]

BF:BFD[11.49978] → [11.49979:49979]

B:BD[11.49979] → [11.49980:51772]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File deletion: file2.txt

BF:BFD[11.43799] → [11.47839:47872]

BF:BFD[11.47872] → [11.47873:47873]

B:BD[11.47873] → [11.47874:49944]

import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample

File deletion: file3.txt

BF:BFD[11.43799] → [11.46255:46288]

BF:BFD[11.46288] → [11.46289:46289]

B:BD[11.46289] → [11.46290:47838]

#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}

File deletion: file4.txt

BF:BFD[11.43799] → [11.45061:45094]

BF:BFD[11.45094] → [11.45095:45095]

B:BD[11.45095] → [11.45096:46254]

module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values

File deletion: file5.txt

BF:BFD[11.43799] → [11.43801:43834]

BF:BFD[11.43834] → [11.43835:43835]

B:BD[11.43835] → [11.43836:45060]

let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))

File deletion: dir2
BF:BFD[11.37619] → [11.43765:43780]
BF:BFD[11.43780] → [11.43781:43781]

File deletion: file0.txt

BF:BFD[11.37619] → [11.41659:41692]

BF:BFD[11.41692] → [11.41693:41693]

B:BD[11.41693] → [11.41694:43764]

import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample

File deletion: file1.txt

BF:BFD[11.37619] → [11.40075:40108]

BF:BFD[11.40108] → [11.40109:40109]

B:BD[11.40109] → [11.40110:41658]

#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}

File deletion: file2.txt

BF:BFD[11.37619] → [11.38881:38914]

BF:BFD[11.38914] → [11.38915:38915]

B:BD[11.38915] → [11.38916:40074]

module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values

File deletion: file3.txt

BF:BFD[11.37619] → [11.37621:37654]

BF:BFD[11.37654] → [11.37655:37655]

B:BD[11.37655] → [11.37656:38880]

let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))

File deletion: file0.txt

BF:BFD[11.35773] → [11.35775:35808]

BF:BFD[11.35808] → [11.35809:35809]

B:BD[11.35809] → [11.35810:37602]

B:BD[11.37602] → [20.63108:63109]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File deletion: InfoView.lean

BF:BFD[7.10364] → [17.34395:34432]

BF:BFD[17.34432] → [17.34433:34433]

∅:D[5.12107] → [17.34434:37438]

B:BD[17.34433] → [17.34434:37438]

∅:D[2.2590] → [17.37438:37495]

B:BD[17.37438] → [17.37438:37495]

B:BD[17.37438] → [2.2173:2590]

B:BD[17.34433] → [5.12025:12107]

import ViE
import Test.Utils
namespace Test.InfoView
open Test.Utils
def makeTestConfig : ViE.Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
def test : IO Unit := do
  IO.println "Starting InfoView Test..."
  let s0 : ViE.EditorState :=
    ({ ViE.initialState with message := "", floatingOverlay := none, mode := .normal, infoViewRequested := false }).updateActiveBuffer fun b =>
      { b with filename := some "Main.lean" }
  let s0' ← ViE.Lsp.Lean.syncInfoViewWindow s0
  let ws0 := s0'.getCurrentWorkspace
  assertEqual "InfoView hidden when not requested" 1 (ViE.Window.getWindowIds ws0.layout |>.length)
  let sNonLean := ({ s0 with infoViewRequested := true }).updateActiveBuffer fun b =>
    { b with filename := some "note.md" }
  let sNonLean' ← ViE.Lsp.Lean.syncInfoViewWindow sNonLean
  let wsNonLean := sNonLean'.getCurrentWorkspace
  assertEqual "InfoView hidden for non-Lean buffer" 1 (ViE.Window.getWindowIds wsNonLean.layout |>.length)
  let sLean := ({ s0 with infoViewRequested := true }).updateActiveBuffer fun b =>
    { b with table := ViE.PieceTable.fromString "abc\n" }
  let sLean' ← ViE.Lsp.Lean.syncInfoViewWindow sLean
  let wsLean := sLean'.getCurrentWorkspace
  assertEqual "InfoView split creates second window" 2 (ViE.Window.getWindowIds wsLean.layout |>.length)
  let infoBufOpt := wsLean.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)
  assertEqual "InfoView buffer exists" true infoBufOpt.isSome
  match infoBufOpt with
  | none =>
      assertEqual "InfoView content check skipped unexpectedly" true false
  | some infoBuf =>
      let line0 := ViE.getLineFromBuffer infoBuf 0 |>.getD ""
      let line1 := ViE.getLineFromBuffer infoBuf 1 |>.getD ""
      assert "InfoView includes file line" (line0.startsWith "File: Main.lean")
      assertEqual "InfoView position line" "Position: 1:1  Byte: 0" line1
  let cfg := makeTestConfig
  let sMoved ← ViE.update cfg sLean' (ViE.Key.char 'l')
  let wsMoved := sMoved.getCurrentWorkspace
  let movedInfoBufOpt := wsMoved.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)
  assertEqual "InfoView buffer exists after cursor move" true movedInfoBufOpt.isSome
  match movedInfoBufOpt with
  | none =>
      assertEqual "InfoView cursor move check skipped unexpectedly" true false
  | some infoBuf =>
      let line1 := ViE.getLineFromBuffer infoBuf 1 |>.getD ""
      assertEqual "InfoView position updates on cursor move" "Position: 1:2  Byte: 1" line1
  let sOff := { sLean' with infoViewRequested := false }
  let sOff' ← ViE.Lsp.Lean.syncInfoViewWindow sOff
  let wsOff := sOff'.getCurrentWorkspace
  assertEqual "InfoView off closes split window" 1 (ViE.Window.getWindowIds wsOff.layout |>.length)
  assertEqual "InfoView off removes buffer" true ((wsOff.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)).isNone)
  IO.println "InfoView Test passed!"
end Test.InfoView
  let sInfoOnly := ViE.Window.closeActiveWindow sLean'
  let sInfoOnly' ← ViE.Lsp.Lean.syncInfoViewWindow sInfoOnly
  let wsInfoOnly := sInfoOnly'.getCurrentWorkspace
  assertEqual "InfoView-only fallback requests quit" true sInfoOnly'.shouldQuit
  assertEqual "InfoView-only fallback removes InfoView buffer" true ((wsInfoOnly.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)).isNone)
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Keybinds.lean

BF:BFD[7.10364] → [8.32048:32085]

BF:BFD[8.32085] → [8.32086:32086]

∅:D[5.11941] → [8.32087:32239]

B:BD[8.32086] → [8.32087:32239]

∅:D[10.11285] → [8.32239:32274]

B:BD[8.32239] → [8.32239:32274]

∅:D[10.11302] → [8.32274:32708]

B:BD[8.32274] → [8.32274:32708]

B:BD[8.32708] → [15.97740:98052]

∅:D[15.98052] → [8.32834:32835]

B:BD[8.32834] → [8.32834:32835]

B:BD[8.32835] → [15.98053:98371]

∅:D[15.98371] → [8.32835:33124]

B:BD[8.32835] → [8.32835:33124]

∅:D[10.11342] → [8.33124:33125]

B:BD[8.33124] → [8.33124:33125]

B:BD[8.33528] → [8.33528:33570]

B:BD[8.33570] → [10.11343:11382]

∅:D[10.11382] → [8.33629:33680]

B:BD[8.33629] → [8.33629:33680]

B:BD[8.33680] → [10.11383:11422]

∅:D[10.11422] → [8.33738:33780]

B:BD[8.33738] → [8.33738:33780]

B:BD[8.33780] → [10.11423:11460]

∅:D[10.11460] → [8.33837:33848]

B:BD[8.33837] → [8.33837:33848]

B:BD[8.33858] → [8.33858:33900]

B:BD[8.33900] → [10.11461:11523]

∅:D[10.11523] → [8.33981:34028]

B:BD[8.33981] → [8.33981:34028]

B:BD[8.34028] → [10.11524:11570]

∅:D[10.11570] → [8.34094:34250]

B:BD[8.34094] → [8.34094:34250]

B:BD[8.34250] → [10.11571:11618]

∅:D[10.11618] → [8.34316:34360]

B:BD[8.34316] → [8.34316:34360]

B:BD[8.34360] → [10.11619:11668]

∅:D[10.11668] → [8.34428:34470]

B:BD[8.34428] → [8.34428:34470]

B:BD[8.34470] → [10.11669:11726]

∅:D[10.11726] → [8.34546:34590]

B:BD[8.34546] → [8.34546:34590]

B:BD[8.34590] → [10.11727:11779]

∅:D[10.11779] → [8.34662:34714]

B:BD[8.34662] → [8.34662:34714]

B:BD[8.34714] → [10.11780:11827]

∅:D[10.11827] → [8.34771:34827]

B:BD[8.34771] → [8.34771:34827]

B:BD[8.34827] → [10.11828:11877]

∅:D[10.11877] → [8.34887:34969]

B:BD[8.34887] → [8.34887:34969]

B:BD[8.34969] → [10.11878:11954]

∅:D[10.11954] → [8.35056:35231]

B:BD[8.35056] → [8.35056:35231]

B:BD[8.35231] → [10.11955:11991]

∅:D[10.11991] → [8.35296:35360]

B:BD[8.35296] → [8.35296:35360]

B:BD[8.35360] → [10.11992:12029]

∅:D[10.12029] → [8.35426:35504]

B:BD[8.35426] → [8.35426:35504]

B:BD[8.35504] → [10.12030:12074]

∅:D[21.2521] → [22.37353:37354]

∅:D[4.4377] → [22.37353:37354]

B:BD[10.12074] → [22.37353:37354]

∅:D[21.2645] → [22.37354:37738]

B:BD[22.37354] → [22.37354:37738]

B:BD[22.37354] → [21.2522:2645]

B:BD[10.12074] → [21.2314:2463]

B:BD[21.2463] → [4.4310:4377]

∅:D[10.12074] → [8.35578:35579]

∅:D[22.37738] → [8.35578:35579]

B:BD[8.35578] → [8.35578:35579]

B:BD[8.35579] → [22.37739:38142]

∅:D[22.38142] → [8.35579:35653]

B:BD[8.35579] → [8.35579:35653]

B:BD[8.35653] → [10.12075:12125]

∅:D[10.12125] → [8.35732:35810]

B:BD[8.35732] → [8.35732:35810]

B:BD[8.35810] → [10.12126:12178]

∅:D[10.12178] → [8.35892:35941]

B:BD[8.35892] → [8.35892:35941]

B:BD[8.35941] → [10.12179:12218]

B:BD[10.12218] → [20.63110:63321]

∅:D[10.12218] → [8.36010:36270]

∅:D[20.63321] → [8.36010:36270]

B:BD[8.36010] → [8.36010:36270]

B:BD[8.36270] → [10.12219:12265]

B:BD[10.12265] → [20.63322:63542]

∅:D[10.12265] → [8.36346:36447]

∅:D[20.63542] → [8.36346:36447]

B:BD[8.36346] → [8.36346:36447]

B:BD[8.36447] → [10.12266:12315]

∅:D[10.12315] → [8.36526:36698]

B:BD[8.36526] → [8.36526:36698]

B:BD[8.36698] → [10.12316:12377]

B:BD[10.12377] → [20.63543:63764]

∅:D[10.12377] → [8.36789:36948]

∅:D[20.63764] → [8.36789:36948]

B:BD[8.36789] → [8.36789:36948]

B:BD[8.36948] → [10.12378:12446]

∅:D[10.12446] → [8.37248:37318]

B:BD[8.37248] → [8.37248:37318]

B:BD[8.37318] → [10.12447:12512]

B:BD[10.12512] → [20.63765:64553]

∅:D[10.12512] → [8.37413:37414]

∅:D[20.64553] → [8.37413:37414]

B:BD[8.37413] → [8.37413:37414]

B:BD[8.37414] → [20.64554:65134]

∅:D[20.65134] → [8.37414:37688]

B:BD[8.37414] → [8.37414:37688]

B:BD[8.37688] → [10.12513:12574]

B:BD[10.12574] → [20.65135:65368]

∅:D[10.12574] → [8.37779:37920]

∅:D[20.65368] → [8.37779:37920]

B:BD[8.37779] → [8.37779:37920]

B:BD[8.37920] → [20.65369:65442]

∅:D[4.5150] → [20.65442:66136]

B:BD[20.65442] → [20.65442:66136]

∅:D[21.2749] → [20.66239:66824]

B:BD[20.66239] → [20.66239:66824]

∅:D[21.2854] → [20.66928:67601]

B:BD[20.66928] → [20.66928:67601]

∅:D[10.12649] → [8.38024:38025]

∅:D[20.67601] → [8.38024:38025]

B:BD[8.38024] → [8.38024:38025]

B:BD[8.38025] → [20.67602:67743]

∅:D[20.67743] → [8.38025:38286]

B:BD[8.38025] → [8.38025:38286]

B:BD[8.38286] → [10.12650:12693]

∅:D[10.12693] → [8.38393:38394]

B:BD[8.38393] → [8.38393:38394]

B:BD[8.38394] → [10.12694:12702]

∅:D[10.12702] → [8.38403:38515]

B:BD[8.38403] → [8.38403:38515]

B:BD[8.38726] → [8.38726:38786]

B:BD[8.38786] → [10.12703:12751]

B:BD[10.12751] → [23.24773:26652]

∅:D[10.12751] → [8.38845:38846]

∅:D[23.26652] → [8.38845:38846]

B:BD[8.38845] → [8.38845:38846]

∅:D[23.27433] → [11.80116:80427]

B:BD[8.38846] → [11.80116:80427]

∅:D[20.69314] → [11.80427:80428]

B:BD[11.80427] → [11.80427:80428]

B:BD[11.80428] → [20.69315:70237]

∅:D[24.9931] → [20.70237:70238]

B:BD[20.70237] → [20.70237:70238]

∅:D[24.10157] → [20.70238:70744]

B:BD[20.70238] → [20.70238:70744]

B:BD[20.70744] → [15.98372:111866]

∅:D[15.111866] → [20.70744:70745]

B:BD[20.70744] → [20.70744:70745]

B:BD[20.70745] → [15.111867:115066]

∅:D[21.2952] → [15.115163:118542]

B:BD[15.115163] → [15.115163:118542]

∅:D[25.7579] → [15.118542:118543]

∅:D[24.12505] → [15.118542:118543]

B:BD[15.118542] → [15.118542:118543]

B:BD[15.118543] → [25.7580:8069]

B:BD[15.118542] → [24.10158:12505]

B:BD[24.12505] → [25.6980:7579]

B:BD[15.115066] → [21.2855:2952]

B:BD[20.70238] → [24.9932:10157]

B:BD[20.70237] → [24.8443:9931]

B:BD[11.80427] → [20.67744:68053]

∅:D[14.7145] → [20.68053:69314]

B:BD[20.68053] → [20.68053:69314]

B:BD[20.68053] → [14.6950:6951]

B:BD[14.6951] → [23.27434:27676]

∅:D[23.27676] → [14.6951:7145]

B:BD[14.6951] → [14.6951:7145]

∅:D[25.8069] → [8.38846:38992]

∅:D[20.70745] → [8.38846:38992]

∅:D[11.80428] → [8.38846:38992]

∅:D[15.118543] → [8.38846:38992]

B:BD[8.38846] → [8.38846:38992]

∅:D[23.27700] → [11.80429:80451]

B:BD[8.38992] → [11.80429:80451]

B:BD[11.80451] → [20.70746:70803]

∅:D[24.12537] → [20.70803:70822]

B:BD[20.70803] → [20.70803:70822]

B:BD[20.70822] → [15.118544:118618]

B:BD[15.118618] → [24.12538:12574]

B:BD[24.12574] → [25.8070:8104]

B:BD[20.70803] → [24.12506:12537]

∅:D[25.8104] → [8.38992:39061]

∅:D[24.12574] → [8.38992:39061]

∅:D[20.70822] → [8.38992:39061]

∅:D[11.80451] → [8.38992:39061]

∅:D[15.118618] → [8.38992:39061]

B:BD[8.38992] → [8.38992:39061]

B:BD[8.38992] → [23.27677:27700]

B:BD[8.38846] → [23.26653:27433]

B:BD[20.66824] → [21.2750:2854]

B:BD[20.66136] → [21.2646:2749]

B:BD[20.65442] → [4.4378:5150]

B:BD[8.33124] → [10.11303:11342]

B:BD[8.32274] → [10.11286:11302]

B:BD[8.32239] → [10.11267:11285]

B:BD[8.32086] → [5.11859:11941]

import ViE.State.Movement
import ViE.State.Edit
import ViE.Key.Map
import ViE.Types
import ViE.Buffer.Content
import ViE.Config
import ViE.Command.Impl
namespace Test.Keybinds
open ViE
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
def keys (s : String) : List Key :=
  s.toList.map fun c =>
    if c == '\n' then Key.enter else Key.char c
def runKeys (s : EditorState) (ks : List Key) : IO EditorState := do
  let config := makeTestConfig
  ks.foldlM (fun s k => ViE.update config s k) s
def findEntryIndex (entries : List FileEntry) (name : String) : Option Nat :=
  let rec loop (rest : List FileEntry) (idx : Nat) : Option Nat :=
    match rest with
    | [] => none
    | e :: tail =>
        if e.name == name then
          some idx
        else
          loop tail (idx + 1)
  loop entries 0
def findEntryIndexByPath (entries : List FileEntry) (path : String) : Option Nat :=
  let rec loop (rest : List FileEntry) (idx : Nat) : Option Nat :=
    match rest with
    | [] => none
    | e :: tail =>
        if e.path == path then
          some idx
        else
          loop tail (idx + 1)
  loop entries 0
def testMotions : IO Unit := do
  IO.println "  Testing Motions..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "line1\nline2\nline3" ++ [Key.esc] ++ keys "gg0")
  -- "line1\nline2\nline3" cursor at (0,0)
  -- l, h
  let s_l ← runKeys s1 [Key.char 'l']
  let s_lh ← runKeys s_l [Key.char 'h']
  assertCursor "h moves left" s_lh 0 0
  -- j, k
  let s_j ← runKeys s1 [Key.char 'j']
  assertCursor "j moves down" s_j 1 0
  let s_jk ← runKeys s_j [Key.char 'k']
  assertCursor "k moves up" s_jk 0 0
  -- 0, $
  let s_end ← runKeys s1 [Key.char '$']
  assertCursor "$ moves to end" s_end 0 4 -- '1' is at col 4
  let s_start ← runKeys s_end [Key.char '0']
  assertCursor "0 moves to start" s_start 0 0
  -- w, b, e
  let s_text ← runKeys s0 ([Key.char 'i'] ++ keys "word1 word2" ++ [Key.esc] ++ [Key.char '0'])
  let s_w ← runKeys s_text [Key.char 'w']
  assertCursor "w moves to next word" s_w 0 6
  let s_e ← runKeys s_text [Key.char 'e']
  assertCursor "e moves to end of word" s_e 0 4
  let s_we ← runKeys s_w [Key.char 'e']
  assertCursor "we moves to end of next word" s_we 0 10
  let s_web ← runKeys s_we [Key.char 'b']
  assertCursor "b moves to start of word" s_web 0 6
  -- gg, G
  let s_G ← runKeys s1 [Key.char 'G']
  assertCursor "G moves to last line" s_G 2 0
  let s_gg ← runKeys s_G [Key.char 'g', Key.char 'g']
  assertCursor "gg moves to first line" s_gg 0 0
  -- | (jump to column)
  let s_pipe ← runKeys s1 [Key.char '3', Key.char '|']
  assertCursor "| jumps to column" s_pipe 0 2 -- 1-indexed count 3 -> col 2
def testEditing : IO Unit := do
  IO.println "  Testing Editing..."
  let s0 := ViE.initialState
  -- i, a, A
  let s_i ← runKeys s0 [Key.char 'i', Key.char 'x', Key.esc]
  assertBuffer "i inserts" s_i "x"
  let s_a ← runKeys s_i [Key.char 'a', Key.char 'y', Key.esc]
  assertBuffer "a appends" s_a "xy"
  let s_A ← runKeys s_a [Key.char '0', Key.char 'A', Key.char 'z', Key.esc]
  assertBuffer "A appends at end" s_A "xyz"
  let s_tab_insert ← runKeys s0 [Key.char 'i', Key.char '\t']
  assertCursor "Tab advances cursor to next tab stop in insert mode" s_tab_insert 0 4
  let s_tab_backspace ← runKeys s0 [Key.char 'i', Key.char '\t', Key.backspace]
  assertBuffer "Tab backspace deletes tab in insert mode" s_tab_backspace ""
  assertCursor "Tab backspace restores cursor column" s_tab_backspace 0 0
  let s_ctrlV ← runKeys s0 [Key.ctrl 'v']
  assertEqual "Ctrl-v enters visual block mode" Mode.visualBlock s_ctrlV.mode
  let s_q ← runKeys s0 [Key.char 'q']
  assertEqual "q does not enter command mode" Mode.normal s_q.mode
  let s_V ← runKeys s0 [Key.char 'V']
  assertEqual "V enters visual line mode" Mode.visualLine s_V.mode
  let s_tab ← runKeys s0 [Key.char 'i', Key.char '\t', Key.esc]
  assertBuffer "Tab inserts in insert mode" s_tab "\t"
  assertCursor "Esc after tab returns to tab char in normal mode" s_tab 0 0
  let s0_tab8 := { s0 with config := { s0.config with tabStop := 8 } }
  let s_tab8 ← runKeys s0_tab8 [Key.char 'i', Key.char '\t']
  assertCursor "Tab follows custom tabStop in insert mode" s_tab8 0 8
  -- o, O
  let s_o ← runKeys s_i [Key.char 'o', Key.char 'y', Key.esc]
  assertBuffer "o inserts line below" s_o "x\ny"
  let s_O ← runKeys s_o [Key.char 'k', Key.char 'O', Key.char 'z', Key.esc]
  assertBuffer "O inserts line above" s_O "z\nx\ny"
  -- x
  let s_x ← runKeys s_i [Key.char 'x']
  assertBuffer "x deletes char" s_x ""
  match s_x.clipboard with
  | some reg =>
      assertEqual "x register kind" RegisterKind.charwise reg.kind
      assertEqual "x register text" "x" reg.text
  | none => assertEqual "x register set" true false
def testOperators : IO Unit := do
  IO.println "  Testing Operators..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "hello world" ++ [Key.esc] ++ [Key.char '0'])
  -- dw
  let s_dw ← runKeys s1 [Key.char 'd', Key.char 'w']
  assertBuffer "dw deletes word" s_dw "world"
  match s_dw.clipboard with
  | some reg =>
      assertEqual "dw register kind" RegisterKind.charwise reg.kind
      assertEqual "dw register text" "hello " reg.text
  | none => assertEqual "dw register set" true false
  -- cw
  let s_cw ← runKeys s1 [Key.char 'c', Key.char 'w', Key.char 'h', Key.char 'i', Key.esc]
  assertBuffer "cw changes word" s_cw "hi world"
  -- dd
  let s_lines ← runKeys s0 ([Key.char 'i'] ++ keys "line1\nline2\nline3" ++ [Key.esc] ++ keys "ggj")
  let s_dd ← runKeys s_lines [Key.char 'd', Key.char 'd']
  assertBuffer "dd deletes current line" s_dd "line1\nline3"
  match s_dd.clipboard with
  | some reg =>
      assertEqual "dd register kind" RegisterKind.linewise reg.kind
      assertEqual "dd register text" "line2\n" reg.text
  | none => assertEqual "dd register set" true false
  -- yy, p, P
  let s_yy ← runKeys s_lines [Key.char 'g', Key.char 'g', Key.char 'y', Key.char 'y']
  let s_p ← runKeys s_yy [Key.char 'G', Key.char 'p']
  assertBuffer "p pastes below" s_p "line1\nline2\nline3\nline1\n"
  let s_P ← runKeys s_yy [Key.char 'g', Key.char 'g', Key.char 'P']
  assertBuffer "P pastes above" s_P "line1\nline1\nline2\nline3"
  let s_indent ← runKeys s0 ([Key.char 'i'] ++ keys "  indented\nx" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char 'y', Key.char 'y', Key.char 'j', Key.char 'p'])
  assertCursor "linewise paste moves to first non-blank" s_indent 2 2
  -- paste should not overwrite register
  let s_reg0 ← runKeys s0 ([Key.char 'i'] ++ keys "one\ntwo" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char 'y', Key.char 'y'])
  let regBefore := s_reg0.clipboard
  let s_regP ← runKeys s_reg0 [Key.char 'j', Key.char 'p']
  match (regBefore, s_regP.clipboard) with
  | (some before, some after) =>
      assertEqual "paste keeps register kind" before.kind after.kind
      assertEqual "paste keeps register text" before.text after.text
  | _ => assertEqual "paste keeps register" true false
  -- charwise y/p from normal mode
  let s_char0 ← runKeys s0 ([Key.char 'i'] ++ keys "hello" ++ [Key.esc] ++ [Key.char '0'])
  let s_charY ← runKeys s_char0 [Key.char 'v', Key.char 'l', Key.char 'y']
  let s_charP ← runKeys s_charY [Key.char '$', Key.char 'p']
  assertBuffer "charwise paste in normal mode" s_charP "hellohe"
  assertCursor "charwise paste cursor at end" s_charP 0 6
  let s_charP2 ← runKeys s_charY [Key.char '0', Key.char 'P']
  assertBuffer "charwise P pastes before cursor" s_charP2 "hehello"
  assertCursor "charwise P cursor at end" s_charP2 0 1
def testVisual : IO Unit := do
  IO.println "  Testing Visual Mode..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "highlight me" ++ [Key.esc] ++ [Key.char '0'])
  -- v, d
  let s_v ← runKeys s1 [Key.char 'v', Key.char 'l', Key.char 'd']
  assertBuffer "visual d deletes selection" s_v "ghlight me"
  match s_v.clipboard with
  | some reg =>
      assertEqual "visual d register kind" RegisterKind.charwise reg.kind
      assertEqual "visual d register text" "hi" reg.text
  | none => assertEqual "visual d register set" true false
  -- v, y, p
  let s_vy ← runKeys s1 [Key.char 'v', Key.char 'e', Key.char 'y']
  let s_vyp ← runKeys s_vy [Key.char '$', Key.char 'p']
  assertBuffer "visual y yanks selection" s_vyp "highlight mehighlight"
  let s_char0 ← runKeys s0 ([Key.char 'i'] ++ keys "abc" ++ [Key.esc] ++ [Key.char '0'])
  let s_charY ← runKeys s_char0 [Key.char 'l', Key.char 'v', Key.char 'y']
  let s_charP ← runKeys s_charY [Key.char '$', Key.char 'p']
  assertBuffer "charwise paste appends" s_charP "abcb"
  assertCursor "charwise paste cursor at end" s_charP 0 3
  let s_charP2 ← runKeys s_charY [Key.char '0', Key.char 'P']
  assertBuffer "charwise P inserts before" s_charP2 "babc"
  assertCursor "charwise P cursor at end" s_charP2 0 0
  -- visual block yank/paste cursor position
  let s_blk0 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\nefgh" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char '0'])
  let s_blkP ← runKeys s_blkY [Key.char 'g', Key.char 'g', Key.char '0', Key.char 'p']
  assertBuffer "visual block y/p inserts block" s_blkP "abcbcd\nefgfgh"
  assertCursor "visual block paste cursor at block start" s_blkP 0 1
  let s_blkP2 ← runKeys s_blkY [Key.char 'g', Key.char 'g', Key.char '0', Key.char 'P']
  assertBuffer "visual block P inserts block" s_blkP2 "bcabcd\nfgefgh"
  assertCursor "visual block P cursor at block start" s_blkP2 0 0
  let s_blkD0 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\nefgh" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char '0'])
  assertBuffer "visual block d deletes block" s_blkD "ad\neh"
  match s_blkD.clipboard with
  | some reg =>
      assertEqual "visual block d register kind" RegisterKind.blockwise reg.kind
      assertEqual "visual block d register text" "bc\nfg" reg.text
  | none => assertEqual "visual block d register set" true false
  -- linewise yank/paste (via yy + P)
  let s_line0 ← runKeys s0 ([Key.char 'i'] ++ keys "aa\nbb\ncc" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g'])
  let s_lineY ← runKeys s_line0 [Key.char 'y', Key.char 'y']
  let s_lineP ← runKeys s_lineY [Key.char 'j', Key.char 'P']
  assertBuffer "linewise paste above keeps lines" s_lineP "aa\naa\nbb\ncc"
  let s_lineP2 ← runKeys s_lineY [Key.char 'j', Key.char 'p']
  assertBuffer "linewise paste below keeps lines" s_lineP2 "aa\nbb\naa\ncc"
def testCounted : IO Unit := do
  IO.println "  Testing Counted Actions..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "a b c d e" ++ [Key.esc] ++ [Key.char '0'])
  -- 3w
  let s_3w ← runKeys s1 [Key.char '3', Key.char 'w']
  assertCursor "3w moves 3 words" s_3w 0 6
  -- 2j
  let s_lines ← runKeys s0 ([Key.char 'i'] ++ keys "1\n2\n3\n4" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g'])
  let s_2j ← runKeys s_lines [Key.char '2', Key.char 'j']
  assertCursor "2j moves 2 lines down" s_2j 2 0
def testVimCompatMotions : IO Unit := do
  IO.println "  Testing Vim Compatibility Motions..."
  let s0 := { ViE.initialState with windowHeight := 12, windowWidth := 80 }
  let lines := String.intercalate "\n" ((List.range 30).map (fun i => s!"  line{i}")) ++ "\n"
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys lines ++ [Key.esc] ++ keys "gg0")
  let sCd ← runKeys s1 [Key.ctrl 'd']
  assertCursor "Ctrl-d scrolls half page down" sCd 5 0
  let sCu ← runKeys sCd [Key.ctrl 'u']
  assertCursor "Ctrl-u scrolls half page up" sCu 0 0
  let sCf ← runKeys s1 [Key.ctrl 'f']
  assertCursor "Ctrl-f scrolls one page down" sCf 10 0
  let sCb ← runKeys sCf [Key.ctrl 'b']
  assertCursor "Ctrl-b scrolls one page up" sCb 0 0
  let sCe ← runKeys s1 [Key.ctrl 'e']
  let (ceRow, _) := sCe.getScroll
  assertEqual "Ctrl-e scrolls window down by one line" 1 ceRow.val
  let sCy ← runKeys sCe [Key.ctrl 'y']
  let (cyRow, _) := sCy.getScroll
  assertEqual "Ctrl-y scrolls window up by one line" 0 cyRow.val
  let sH ← runKeys sCf [Key.char 'H']
  assertCursor "H moves to top line of screen" sH 10 2
  let sM ← runKeys sCf [Key.char 'M']
  assertCursor "M moves to middle line of screen" sM 15 2
  let sL ← runKeys sCf [Key.char 'L']
  assertCursor "L moves to bottom line of screen" sL 19 2
  let sF0 ← runKeys s0 ([Key.char 'i'] ++ keys "abcaXcaYca" ++ [Key.esc] ++ [Key.char '0'])
  let sF1 ← runKeys sF0 [Key.char 'f', Key.char 'a']
  assertCursor "fa finds next character" sF1 0 3
  let sF2 ← runKeys sF1 [Key.char ';']
  assertCursor "; repeats last f motion" sF2 0 6
  let sF3 ← runKeys sF2 [Key.char ',']
  assertCursor ", reverses last f motion" sF3 0 3
  let sT1 ← runKeys sF3 [Key.char 't', Key.char 'a']
  assertCursor "ta moves before target" sT1 0 5
  let sT2 ← runKeys sT1 [Key.char ';']
  assertCursor "; repeats last t motion" sT2 0 8
def testWorkgroupSwitch : IO Unit := do
  IO.println "  Testing Workgroup Switching..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 [Key.alt '3']
  assertEqual "Alt-3 switches workgroup" 3 s1.currentGroup
  let s2 ← runKeys s1 [Key.alt '0']
  assertEqual "Alt-0 switches workgroup" 0 s2.currentGroup
def testCommandGlobal : IO Unit := do
  IO.println "  Testing Command Global..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "a\nfoo1\nb\nfoo2\n" ++ [Key.esc] ++ keys "gg0")
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "g/foo/ d" ++ [Key.enter])
  assertBuffer ":g/pat/ d deletes matching lines" s2 "a\nb\n"
  let s3 := ViE.initialState
  let s4 ← runKeys s3 ([Key.char 'i'] ++ keys "foo foo\nbar foo\nfoo bar\n" ++ [Key.esc] ++ keys "gg0")
  let s5 ← runKeys s4 ([Key.char ':'] ++ keys "g/foo/ s/foo/xxx/" ++ [Key.enter])
  assertBuffer ":g/pat/ s replaces first match per line" s5 "xxx foo\nbar xxx\nxxx bar\n"
  let s6 := ViE.initialState
  let s7 ← runKeys s6 ([Key.char 'i'] ++ keys "keep1\nfoo\nkeep2\n" ++ [Key.esc] ++ keys "gg0")
  let s8 ← runKeys s7 ([Key.char ':'] ++ keys "v/foo/ d" ++ [Key.enter])
  assertBuffer ":v/pat/ d deletes non-matching lines" s8 "foo\n"
def testCommandBloom : IO Unit := do
  IO.println "  Testing Command Bloom..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "hello bloom\nbloom hello\n" ++ [Key.esc] ++ keys "gg0")
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "bloom /bloom" ++ [Key.enter])
  assertCursor ":bloom moves to first match" s2 0 6
  let s3 ← runKeys s2 ([Key.char ':'] ++ keys "bloom /nomatch" ++ [Key.enter])
  assertEqual ":bloom not found message" "Pattern not found: nomatch" s3.message
def testUiCommands : IO Unit := do
  IO.println "  Testing UI Commands..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char ':'] ++ keys "float hello" ++ [Key.enter])
  assertEqual ":float shows overlay" true s1.floatingOverlay.isSome
  let s2 ← runKeys s1 [Key.esc]
  assertEqual "Esc closes overlay" false s2.floatingOverlay.isSome
  let s3 ← runKeys s0 ([Key.char ':'] ++ keys "float alpha\\nbeta" ++ [Key.enter])
  match s3.floatingOverlay with
  | some overlay =>
      assertEqual ":float parses newline escape (line count)" 2 overlay.lines.size
      assertEqual ":float parses newline escape (line 1)" "alpha" overlay.lines[0]!
      assertEqual ":float parses newline escape (line 2)" "beta" overlay.lines[1]!
  | none =>
      assertEqual ":float newline overlay exists" true false
  let s4 ← runKeys s3 ([Key.char ':'] ++ keys "nofloat" ++ [Key.enter])
  assertEqual ":nofloat clears overlay" false s4.floatingOverlay.isSome
  let s5 ← runKeys s0 ([Key.char ':'] ++ keys "redraw" ++ [Key.enter])
  assertEqual ":redraw sets message" "redraw" s5.message
  assertEqual ":redraw marks dirty" true s5.dirty
  let s6 ← runKeys s0 ([Key.char ':'] ++ keys "redraw!" ++ [Key.enter])
  assertEqual ":redraw! alias works" "redraw" s6.message
  let s7 ← runKeys s0 [Key.ctrl 'l']
  assertEqual "Ctrl-l redraw marks dirty" true s7.dirty
  let s8 ← runKeys s0 ([Key.char ':'] ++ keys "float --title Note --width 32 hello world" ++ [Key.enter])
  match s8.floatingOverlay with
  | some overlay =>
      assertEqual ":float --title sets title" "Note" overlay.title
      assertEqual ":float --width sets width" 32 overlay.maxWidth
      assertEqual ":float with options keeps text" "hello world" overlay.lines[0]!
  | none =>
      assertEqual ":float with options shows overlay" true false
  let s9 ← runKeys s0 ([Key.char ':'] ++ keys "float --title=Panel --width=28 hi" ++ [Key.enter])
  match s9.floatingOverlay with
  | some overlay =>
      assertEqual ":float --title= sets title" "Panel" overlay.title
      assertEqual ":float --width= sets width" 28 overlay.maxWidth
  | none =>
      assertEqual ":float with inline options shows overlay" true false
  let s10 ← runKeys s0 ([Key.char ':'] ++ keys "float --width nope hi" ++ [Key.enter])
  assertEqual ":float invalid width message" "Invalid float width: nope" s10.message
  let s11 ← runKeys s0 ([Key.char 'i'] ++ keys "abc" ++ [Key.esc] ++ [Key.char ':'] ++ keys "float guard" ++ [Key.enter])
  let s12 ← runKeys s11 [Key.char 'i']
  assertEqual "floating overlay enters insert mode" Mode.insert s12.mode
  let s13 ← runKeys s12 (keys "X" ++ [Key.enter] ++ keys "Y")
  match s13.floatingOverlay with
  | some overlay =>
      assertEqual "floating overlay writes text" "guardX" overlay.lines[0]!
      assertEqual "floating overlay writes next line" "Y" overlay.lines[1]!
  | none =>
      assertEqual "floating overlay remains open while editing" true false
  let s14 ← runKeys s13 [Key.esc]
  assertEqual "Esc exits floating overlay insert mode" Mode.normal s14.mode
  let s15 ← runKeys s14 [Key.enter]
  assertEqual "Enter closes floating overlay" false s15.floatingOverlay.isSome
  let sMsg0 := { s0 with message := "Error: sample message", dirty := true }
  let sMsg1 ← runKeys sMsg0 [Key.enter]
  assertEqual "Enter closes message float" "" sMsg1.message
  let sMsg2 := { s0 with message := "Cannot write preview buffer", dirty := true }
  let sMsg3 ← runKeys sMsg2 [Key.esc]
  assertEqual "Esc closes message float" "" sMsg3.message
  let sPrompt0 ← runKeys s0 ([Key.char ':'] ++ keys "ws list" ++ [Key.enter])
  let sPrompt1 := sPrompt0.updateActiveView fun v => { v with cursor := { row := ⟨2⟩, col := 0 } }
  let sPrompt2 ← runKeys sPrompt1 [Key.enter]
  assertEqual "Workspace explorer New opens floating input" true sPrompt2.floatingOverlay.isSome
  assertEqual "Workspace explorer New sets floating command prefix" (some "ws new ") sPrompt2.floatingInputCommand
  let sPrompt3 ← runKeys sPrompt2 (keys "TmpWS" ++ [Key.enter])
  assertEqual "Workspace explorer floating input submits with Enter" "TmpWS" sPrompt3.getCurrentWorkspace.name
  assertEqual "Workspace explorer floating input closes after submit" false sPrompt3.floatingOverlay.isSome
  let sWsCmd0 ← runKeys s0 ([Key.char ':'] ++ keys "ws new" ++ [Key.enter])
  assertEqual ":ws new opens floating input" true sWsCmd0.floatingOverlay.isSome
  assertEqual ":ws new floating command prefix" (some "ws new ") sWsCmd0.floatingInputCommand
  let sWsCmd1 ← runKeys sWsCmd0 (keys "CmdWorkspace" ++ [Key.enter])
  assertEqual ":ws new floating input submits name" "CmdWorkspace" sWsCmd1.getCurrentWorkspace.name
  let sWgCmd0 ← runKeys s0 ([Key.char ':'] ++ keys "wg new" ++ [Key.enter])
  assertEqual ":wg new opens floating input" true sWgCmd0.floatingOverlay.isSome
  assertEqual ":wg new floating command prefix" (some "wg new ") sWgCmd0.floatingInputCommand
  let sWgCmd1 ← runKeys sWgCmd0 (keys "CmdGroup" ++ [Key.enter])
  assertEqual ":wg new floating input submits name" "CmdGroup" sWgCmd1.getCurrentWorkgroup.name
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-explorer-create-{stamp}"
  IO.FS.createDirAll tmpRoot
  let sExp0 := { s0 with windowHeight := 30, windowWidth := 100 }
  let sExp1 ← runKeys sExp0 ([Key.char ':'] ++ keys s!"ex list {tmpRoot}" ++ [Key.enter])
  let explorerOpt := sExp1.explorers.find? (fun (id, _) => id == sExp1.getActiveBuffer.id)
  match explorerOpt with
  | none =>
      assertEqual "Explorer create test has active explorer" true false
  | some (_, explorer) =>
      let newFileIdx := (findEntryIndex explorer.entries "[New File]").getD 0
      let sExp2 := sExp1.updateActiveView fun v => { v with cursor := { row := ⟨2 + newFileIdx⟩, col := 0 } }
      let sExp3 ← runKeys sExp2 [Key.enter]
      assertEqual "Explorer [New File] opens floating input" true sExp3.floatingOverlay.isSome
      assertEqual "Explorer [New File] sets command prefix" (some s!"mkfile {tmpRoot}/") sExp3.floatingInputCommand
      let sExp4 ← runKeys sExp3 (keys "alpha.txt" ++ [Key.enter])
      let fileCreated ← (System.FilePath.mk s!"{tmpRoot}/alpha.txt").pathExists
      assertEqual "Explorer [New File] creates file" true fileCreated
      let explorerOpt2 := sExp4.explorers.find? (fun (id, _) => id == sExp4.getActiveBuffer.id)
      match explorerOpt2 with
      | none =>
          assertEqual "Explorer refreshed after file create" true false
      | some (_, explorer2) =>
          assertEqual "Explorer list includes created file" true (findEntryIndex explorer2.entries "alpha.txt").isSome
      let newDirIdx := (findEntryIndex explorer.entries "[New Directory]").getD 1
      let sExp5 := sExp4.updateActiveView fun v => { v with cursor := { row := ⟨2 + newDirIdx⟩, col := 0 } }
      let sExp6 ← runKeys sExp5 [Key.enter]
      assertEqual "Explorer [New Directory] opens floating input" true sExp6.floatingOverlay.isSome
      assertEqual "Explorer [New Directory] sets command prefix" (some s!"mkdir {tmpRoot}/") sExp6.floatingInputCommand
      let sExp7 ← runKeys sExp6 (keys "subdir" ++ [Key.enter])
      let createdDirPath := System.FilePath.mk s!"{tmpRoot}/subdir"
      let dirExists ← createdDirPath.pathExists
      let dirIsDir ← if dirExists then createdDirPath.isDir else pure false
      assertEqual "Explorer [New Directory] creates directory" true dirIsDir
      let explorerOpt3 := sExp7.explorers.find? (fun (id, _) => id == sExp7.getActiveBuffer.id)
      match explorerOpt3 with
      | none =>
          assertEqual "Explorer refreshed after directory create" true false
      | some (_, explorer3) =>
          assertEqual "Explorer list includes created directory" true (findEntryIndex explorer3.entries "subdir").isSome
  let s16 ← runKeys s0 ([Key.char ':'] ++ keys "vs" ++ [Key.enter])
  let ws16 := s16.getCurrentWorkspace
  assertEqual "split creates second window" true (ws16.nextWindowId >= 2)
  let s17 ← runKeys s16 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let ws17 := s17.getCurrentWorkspace
  assertEqual ":floatwin on marks active window floating" true (ws17.isFloatingWindow ws17.activeWindowId)
  let s18 ← runKeys s17 ([Key.char ':'] ++ keys "floatwin off" ++ [Key.enter])
  let ws18 := s18.getCurrentWorkspace
  assertEqual ":floatwin off clears floating flag" false (ws18.isFloatingWindow ws18.activeWindowId)
  let s19 ← runKeys s18 ([Key.char ':'] ++ keys "floatwin" ++ [Key.enter])
  let ws19 := s19.getCurrentWorkspace
  assertEqual ":floatwin toggles floating flag" true (ws19.isFloatingWindow ws19.activeWindowId)
  let sFloatMove0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatMove1 ← runKeys sFloatMove0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let floatMoveId := sFloatMove1.getCurrentWorkspace.activeWindowId
  let beforeFloatMove := sFloatMove1.getFloatingWindowBounds floatMoveId
  let sFloatMove2 ← runKeys sFloatMove1 [Key.alt 'L']
  let afterFloatMove := sFloatMove2.getFloatingWindowBounds floatMoveId
  match beforeFloatMove, afterFloatMove with
  | some (_, left0, _, _), some (_, left1, _, _) =>
      assertEqual "Alt-Shift-l moves floating window right" (left0 + 1) left1
  | _, _ =>
      assertEqual "Alt-Shift-l moves floating window right" true false
  let sFloatMoveGrp0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatMoveGrp1 ← runKeys sFloatMoveGrp0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatMoveGrp2 ← runKeys sFloatMoveGrp1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let moveGrpIds := sFloatMoveGrp2.getCurrentWorkspace.getFloatingWindowIds.toList
  let beforeGrp := moveGrpIds.filterMap (fun wid => (sFloatMoveGrp2.getFloatingWindowBounds wid).map (fun b => (wid, b)))
  let sFloatMoveGrp3 ← runKeys sFloatMoveGrp2 [Key.alt 'J']
  let afterGrp := moveGrpIds.filterMap (fun wid => (sFloatMoveGrp3.getFloatingWindowBounds wid).map (fun b => (wid, b)))
  let movedAllDown :=
    moveGrpIds.all (fun wid =>
      match beforeGrp.find? (fun (id, _) => id == wid), afterGrp.find? (fun (id, _) => id == wid) with
      | some (_, (top0, _, _, _)), some (_, (top1, _, _, _)) => top1 == top0 + 1
      | _, _ => false)
  assertEqual "Alt-Shift-j moves all panes in active floating subtree down" true movedAllDown
  let sFloatVs0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatVs1 ← runKeys sFloatVs0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatVs2 ← runKeys sFloatVs1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let wsFloatVs2 := sFloatVs2.getCurrentWorkspace
  let floatingIdsVs := wsFloatVs2.getFloatingWindowIds.toList
  assertEqual "vsplit in floating window keeps new pane floating" true (floatingIdsVs.length >= 2)
  match floatingIdsVs with
  | a :: b :: _ =>
      let sideBySide :=
        match sFloatVs2.getFloatingWindowBounds a, sFloatVs2.getFloatingWindowBounds b with
        | some (t1, l1, h1, w1), some (t2, l2, h2, w2) =>
            t1 == t2 && h1 == h2 && ((l1 + w1 == l2) || (l2 + w2 == l1))
        | _, _ => false
      assertEqual "vsplit in floating window keeps pair side-by-side" true sideBySide
  | _ =>
      assertEqual "vsplit in floating window keeps pair side-by-side" true false
  let sFloatSp0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatSp1 ← runKeys sFloatSp0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatSp2 ← runKeys sFloatSp1 ([Key.char ':'] ++ keys "split" ++ [Key.enter])
  let wsFloatSp2 := sFloatSp2.getCurrentWorkspace
  let floatingIdsSp := wsFloatSp2.getFloatingWindowIds.toList
  assertEqual "split in floating window keeps new pane floating" true (floatingIdsSp.length >= 2)
  match floatingIdsSp with
  | a :: b :: _ =>
      let stacked :=
        match sFloatSp2.getFloatingWindowBounds a, sFloatSp2.getFloatingWindowBounds b with
        | some (t1, l1, h1, w1), some (t2, l2, h2, w2) =>
            l1 == l2 && w1 == w2 && ((t1 + h1 == t2) || (t2 + h2 == t1))
        | _, _ => false
      assertEqual "split in floating window keeps pair stacked" true stacked
  | _ =>
      assertEqual "split in floating window keeps pair stacked" true false
  let sFloatMix0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatMix1 ← runKeys sFloatMix0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatMix2 ← runKeys sFloatMix1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let sFloatMix3 ← runKeys sFloatMix2 ([Key.char ':'] ++ keys "split" ++ [Key.enter])
  let wsFloatMix3 := sFloatMix3.getCurrentWorkspace
  let floatingIdsMix := wsFloatMix3.getFloatingWindowIds.toList
  assertEqual "vsplit then split in floating window keeps three panes floating" 3 floatingIdsMix.length
  let boundsMix := floatingIdsMix.filterMap (fun wid => sFloatMix3.getFloatingWindowBounds wid)
  assertEqual "vsplit then split in floating window resolves bounds for all panes" 3 boundsMix.length
  let overlaps (a b : Nat × Nat × Nat × Nat) : Bool :=
    let (ta, la, ha, wa) := a
    let (tb, lb, hb, wb) := b
    la < lb + wb && lb < la + wa && ta < tb + hb && tb < ta + ha
  let rec hasOverlap (xs : List (Nat × Nat × Nat × Nat)) : Bool :=
    match xs with
    | [] => false
    | x :: rest => rest.any (fun y => overlaps x y) || hasOverlap rest
  assertEqual "vsplit then split in floating window panes do not overlap" false (hasOverlap boundsMix)
  let sFloatDeep0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatDeep1 ← runKeys sFloatDeep0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatDeep2 ← runKeys sFloatDeep1 ([Key.char ':'] ++ keys "vs" ++ [Key.enter])
  let sFloatDeep3 ← runKeys sFloatDeep2 ([Key.char ':'] ++ keys "hs" ++ [Key.enter])
  let sFloatDeep4 ← runKeys sFloatDeep3 ([Key.char ':'] ++ keys "vs" ++ [Key.enter])
  let wsFloatDeep4 := sFloatDeep4.getCurrentWorkspace
  let floatingIdsDeep := wsFloatDeep4.getFloatingWindowIds.toList
  assertEqual "vs -> hs -> vs in floating window creates four panes" 4 floatingIdsDeep.length
  let boundsDeep := floatingIdsDeep.filterMap (fun wid => sFloatDeep4.getFloatingWindowBounds wid)
  assertEqual "vs -> hs -> vs in floating window resolves bounds for all panes" 4 boundsDeep.length
  assertEqual "vs -> hs -> vs in floating window panes do not overlap" false (hasOverlap boundsDeep)
  let sideBySideTouch (a b : Nat × Nat × Nat × Nat) : Bool :=
    let (t1, l1, h1, w1) := a
    let (t2, l2, h2, w2) := b
    ((l1 + w1 == l2) || (l2 + w2 == l1)) && (t1 < t2 + h2 && t2 < t1 + h1)
  let stackedTouch (a b : Nat × Nat × Nat × Nat) : Bool :=
    let (t1, l1, h1, w1) := a
    let (t2, l2, h2, w2) := b
    ((t1 + h1 == t2) || (t2 + h2 == t1)) && (l1 < l2 + w2 && l2 < l1 + w1)
  let rec hasPairWith
      (pred : (Nat × Nat × Nat × Nat) → (Nat × Nat × Nat × Nat) → Bool)
      (xs : List (Nat × Nat × Nat × Nat)) : Bool :=
    match xs with
    | [] => false
    | x :: rest => rest.any (fun y => pred x y) || hasPairWith pred rest
  assertEqual "vs -> hs -> vs in floating window keeps horizontal adjacency" true (hasPairWith sideBySideTouch boundsDeep)
  assertEqual "vs -> hs -> vs in floating window keeps vertical adjacency" true (hasPairWith stackedTouch boundsDeep)
  let longLine := "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  let longText := String.intercalate "\n" [longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine] ++ "\n"
  let s20 := { s0 with windowHeight := 14, windowWidth := 40 }
  let s21 ← runKeys s20 ([Key.char 'i'] ++ keys longText ++ [Key.esc] ++ keys "gg0")
  let s22 ← runKeys s21 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let s23 ← runKeys s22 [Key.char '1', Key.char '0', Key.char 'j']
  let (sRow23, _) := s23.getScroll
  assertEqual "floating window vertical scroll follows cursor" true (sRow23.val > 0)
  let s24 ← runKeys s23 [Key.char '3', Key.char '5', Key.char 'l']
  let (_, sCol24) := s24.getScroll
  assertEqual "floating window horizontal scroll follows cursor" true (sCol24.val > 0)
  let s25 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\n" ++ [Key.esc] ++ keys "gg0")
  let s26 ← runKeys s25 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let s27 ← runKeys s26 [Key.char 'v', Key.char 'l', Key.char 'd']
  assertBuffer "visual mode edits active floating window buffer" s27 "cd\n"
  let s28 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\nefgh\n" ++ [Key.esc] ++ keys "gg0")
  let s29 ← runKeys s28 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  assertBuffer "visual block edits active floating window buffer" s30 "ad\neh\n"
def testBufferExplorerCommand : IO Unit := do
  IO.println "  Testing Buffer Explorer..."
  let s0 := ViE.initialState
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-buffer-explorer-{stamp}"
  IO.FS.createDirAll tmpRoot
  let bufAPath := s!"{tmpRoot}/bufA.txt"
  let bufBPath := s!"{tmpRoot}/bufB.txt"
  IO.FS.writeFile bufAPath "alpha\n"
  IO.FS.writeFile bufBPath "beta\n"
  let sBuf0 := { s0 with windowHeight := 30, windowWidth := 100 }
  let sBuf1 ← runKeys sBuf0 ([Key.char ':'] ++ keys s!"e {bufAPath}" ++ [Key.enter])
  let sBuf2 ← runKeys sBuf1 ([Key.char ':'] ++ keys s!"e {bufBPath}" ++ [Key.enter])
  let targetBufIdOpt := sBuf2.getCurrentWorkspace.buffers.find? (fun b => b.filename == some bufAPath) |>.map (fun b => b.id)
  assertEqual "Buffer explorer target buffer exists" true targetBufIdOpt.isSome
  let targetBufId := targetBufIdOpt.getD 0
  let sBuf3 ← runKeys sBuf2 ([Key.char ':'] ++ keys "buf list" ++ [Key.enter])
  assertEqual ":buf list opens buffer explorer" true ((sBuf3.getActiveBuffer.filename.getD "").startsWith "explorer://buffers")
  let explorerBufId := sBuf3.getActiveBuffer.id
  let explorerBufOpt := sBuf3.explorers.find? (fun (id, _) => id == explorerBufId)
  match explorerBufOpt with
  | none =>
      assertEqual "Buffer explorer registered" true false
  | some (_, explorerBuf) =>
      let targetPath := s!"buffer://{targetBufId}"
      let targetIdxOpt := findEntryIndexByPath explorerBuf.entries targetPath
      assertEqual "Buffer explorer contains target buffer entry" true targetIdxOpt.isSome
      let targetIdx := targetIdxOpt.getD 0
      let sBuf4 := sBuf3.updateActiveView fun v => { v with cursor := { row := ⟨2 + targetIdx⟩, col := 0 } }
      let sBuf5 ← runKeys sBuf4 [Key.enter]
      assertEqual "Buffer explorer Enter switches active buffer" (some bufAPath) sBuf5.getActiveBuffer.filename
      assertEqual "Buffer explorer closes after selection" false (sBuf5.explorers.any (fun (id, _) => id == explorerBufId))
  let sBufCompat ← runKeys sBuf2 ([Key.char ':'] ++ keys "buffers" ++ [Key.enter])
  assertEqual ":buffers alias opens buffer explorer" true ((sBufCompat.getActiveBuffer.filename.getD "").startsWith "explorer://buffers")
  let sBufAlias ← runKeys sBuf2 ([Key.char ':'] ++ keys "ls" ++ [Key.enter])
  assertEqual ":ls alias opens buffer explorer" true ((sBufAlias.getActiveBuffer.filename.getD "").startsWith "explorer://buffers")
def testExplorerCommandAliases : IO Unit := do
  IO.println "  Testing Explorer Command Names..."
  let s0 := ViE.initialState
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-ex-alias-{stamp}"
  IO.FS.createDirAll tmpRoot
  IO.FS.writeFile s!"{tmpRoot}/x.txt" "x\n"
  let s1 ← runKeys s0 ([Key.char ':'] ++ keys s!"ex list {tmpRoot}" ++ [Key.enter])
  assertEqual ":ex list opens file explorer" true ((s1.getActiveBuffer.filename.getD "").startsWith "explorer://")
  let s2 ← runKeys s0 ([Key.char ':'] ++ keys s!"ee {tmpRoot}" ++ [Key.enter])
  assertEqual ":ee alias opens file explorer" true ((s2.getActiveBuffer.filename.getD "").startsWith "explorer://")
  let s3 ← runKeys s0 ([Key.char ':'] ++ keys "wgex" ++ [Key.enter])
  assertEqual ":wgex alias opens workgroup explorer" (some "explorer://workgroups") s3.getActiveBuffer.filename
  let s1 ← runKeys s0 [Key.char 'c']
  assertBuffer "completion popup keeps showing on char insert" s1 "abc"
  assertEqual "completion popup remains visible after char insert" true s1.completionPopup.isSome
  let s2 ← runKeys s1 [Key.enter]
  assertBuffer "Enter inserts newline instead of accepting completion" s2 "abc\n"
  assertCursor "Enter moves cursor to next line head with completion popup" s2 1 0
  assertEqual "Enter closes completion popup" true s2.completionPopup.isNone
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
def testLeanCompletionPopupBehavior : IO Unit := do
  IO.println "  Testing Lean Completion Popup..."
  let popup : CompletionPopup := {
    items := #[
      { label := "foo", insertText := "foo" },
      { label := "foobar", insertText := "foobar" }
    ]
    selected := 0
    anchorRow := 0
    anchorCol := 2
  }
  let s0 : EditorState :=
    ({ ViE.initialState with mode := .insert, completionPopup := some popup }).updateActiveBuffer fun b =>
      { b with filename := some "Main.lean", table := ViE.PieceTable.fromString "ab" }
  let s0 := s0.setCursor { row := ⟨0⟩, col := ⟨2⟩ }
  let s30 ← runKeys s29 [Key.char 'l', Key.ctrl 'v', Key.char 'l', Key.char 'j', Key.char 'd']
  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
  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
def testSearch : IO Unit := do
  IO.println "  Testing Search..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "hello world\nhello again\n" ++ [Key.esc])
  let s2 ← runKeys s1 ([Key.char '/'] ++ keys "hello" ++ [Key.enter])
  assertCursor "/hello finds first match" s2 0 0
  let s3 ← runKeys s2 [Key.char 'n']
  assertCursor "n finds next match" s3 1 0
  let s4 ← runKeys s3 [Key.char 'N']
  assertCursor "N finds previous match" s4 0 0
  let s5 ← runKeys s4 ([Key.char '?'] ++ keys "world" ++ [Key.enter])
  assertCursor "?world searches backward" s5 0 6
def testCommandSubstitute : IO Unit := do
  IO.println "  Testing Command Substitute..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "foo bar\nfoo baz\nbar foo\n" ++ [Key.esc] ++ keys "gg0")
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "s/foo/xxx/" ++ [Key.enter])
  assertBuffer ":s replaces first match on current line" s2 "xxx bar\nfoo baz\nbar foo\n"
  let s3 := ViE.initialState
  let s4 ← runKeys s3 ([Key.char 'i'] ++ keys "foo foo\nfoo foo\n" ++ [Key.esc] ++ keys "gg0")
  let s5 ← runKeys s4 ([Key.char ':'] ++ keys "%s/foo/yyy/" ++ [Key.enter])
  assertBuffer ":%s replaces first match per line" s5 "yyy foo\nyyy foo\n"
  let s6 := ViE.initialState
  let s7 ← runKeys s6 ([Key.char 'i'] ++ keys "foo bar\nfoo baz\nbar foo\n" ++ [Key.esc] ++ keys "gg0")
  let s8 ← runKeys s7 ([Key.char ':'] ++ keys "%s/foo/yyy/g" ++ [Key.enter])
  assertBuffer ":%s with g replaces all matches" s8 "yyy bar\nyyy baz\nbar yyy\n"
  let s2Prompt ← runKeys s2 [Key.char '/']
  let promptCleared :=
    match s2Prompt.searchState with
    | none => true
    | some _ => false
  assertEqual "Starting new search prompt clears old search highlight state" true promptCleared
  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"
def test : IO Unit := do
  IO.println "Starting Expanded Keybind Tests..."
  testMotions
  testEditing
  testOperators
  testVisual
  testCounted
  testWorkgroupSwitch
  testSearch
  testCommandSubstitute
  testCommandGlobal
  testCommandBloom
  testUiCommands
  testBufferExplorerCommand
  testExplorerCommandAliases
  testExplorerOpenUsesFocusedWindow
  testLeanCompletionPopupBehavior
  testCursorDriftCustomTabStop
  IO.println "All Expanded Keybind Tests passed!"
end Test.Keybinds
  testVimCompatMotions
  let sPct0 ← runKeys s0 ([Key.char 'i'] ++ keys "(a[b]c)" ++ [Key.esc] ++ [Key.char '0'])
  let sPct1 ← runKeys sPct0 [Key.char '%']
  assertCursor "% jumps to matching bracket" sPct1 0 6
  let sPct2 ← runKeys sPct1 [Key.ctrl 'o']
  assertCursor "Ctrl-o jumps back in jump list" sPct2 0 0
  let sPct3 ← runKeys sPct2 [Key.char '\t']
  assertCursor "Ctrl-i (Tab) jumps forward in jump list" sPct3 0 6
  let sStar0 := ViE.initialState
  let sStar1 ← runKeys sStar0 ([Key.char 'i'] ++ keys "foo bar\nfoo baz\nbar foo\n" ++ [Key.esc] ++ keys "gg0")
  let sStar2 ← runKeys sStar1 [Key.char '*']
  assertCursor "* searches next word under cursor" sStar2 1 0
  let sStar3 ← runKeys sStar2 [Key.char '#']
  assertCursor "# searches previous word under cursor" sStar3 0 0
  let s_blkD ← runKeys s_blkD0 [Key.char 'l', Key.ctrl 'v', Key.char 'l', Key.char 'j', Key.char 'd']
  let s_blkY ← runKeys s_blk0 [Key.char 'l', Key.ctrl 'v', Key.char 'l', Key.char 'j', Key.char 'y']
  let s_linewise0 ← runKeys s0 ([Key.char 'i'] ++ keys "aa\nbb\ncc" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g'])
  let s_linewiseD ← runKeys s_linewise0 [Key.char 'V', Key.char 'j', Key.char 'd']
  assertBuffer "visual line d deletes full lines" s_linewiseD "cc"
  match s_linewiseD.clipboard with
  | some reg =>
      assertEqual "visual line d register kind" RegisterKind.linewise reg.kind
      assertEqual "visual line d register text" "aa\nbb\n" reg.text
  | none => assertEqual "visual line d register set" true false
  let s_linewiseY ← runKeys s_linewise0 [Key.char 'V', Key.char 'j', Key.char 'y']
  let s_linewiseP ← runKeys s_linewiseY [Key.char 'G', Key.char 'p']
  assertBuffer "visual line y/p pastes linewise" s_linewiseP "aa\nbb\ncc\naa\nbb\n"
  assertCursor "l moves right" s_l 0 1
open Test.Utils
import Test.Utils
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Mode.lean

BF:BFD[7.10364] → [8.29896:29929]

BF:BFD[8.29929] → [8.29930:29930]

∅:D[5.11411] → [8.29931:30064]

B:BD[8.29930] → [8.29931:30064]

∅:D[5.11432] → [8.30064:30096]

B:BD[8.30064] → [8.30064:30096]

∅:D[5.11609] → [8.30096:32047]

B:BD[8.30096] → [8.30096:32047]

B:BD[8.30096] → [5.11433:11609]

B:BD[8.30064] → [5.11412:11432]

B:BD[8.29930] → [5.11329:11411]

import ViE.State.Config
import ViE.Config
import ViE.Command.Impl
import ViE.Key.Map
import ViE.State.Edit
import ViE.State.Movement
namespace Test.Mode
open ViE
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
-- Helper to construct a full Config
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
-- Run a sequence of keys
def runKeys (startState : EditorState) (keys : List Key) : IO EditorState := do
  let config := makeTestConfig
  let mut s := startState
  for k in keys do
    s ← ViE.update config s k
  return s
def test : IO Unit := do
  IO.println "Starting Mode Test..."
  let s := ViE.initialState
  -- Scenario: Insert 'abc' then Esc.
  -- Initial: (0,0)
  -- 'i' -> Insert Mode
  -- 'a' -> "a", (0,1)
  -- 'b' -> "ab", (0,2)
  -- 'c' -> "abc", (0,3)
  -- Esc -> Normal Mode.
  -- Expected Vim behavior: Cursor should move left to (0,2) 'c'.
  -- If empty line "insert a then esc", "a" (0,1) -> (0,0).
  let keys := [Key.char 'i', Key.char 'a', Key.char 'b', Key.char 'c', Key.esc]
  let sEnd ← runKeys s keys
  -- Check Mode
  if sEnd.mode != Mode.normal then
    IO.println s!"[FAIL] Mode mismatch. Expected Normal, got {sEnd.mode}"
    assert "Mode is Normal" false
  else
    IO.println "[PASS] Mode is Normal"
  -- Check Text
  let text := getLineFromBuffer sEnd.getActiveBuffer 0 |>.getD ""
  if text != "abc" then
    IO.println s!"[FAIL] Text mismatch. Expected 'abc', got '{text}'"
    assert "Text is 'abc'" false
  else
     IO.println "[PASS] Text is 'abc'"
  -- Check Cursor
  -- Expect (0, 2)
  let cursor := sEnd.getCursor
  if cursor.col.val != 2 then
    IO.println s!"[FAIL] Cursor mismatch. Expected (0, 2), got ({cursor.row.val}, {cursor.col.val})"
    assert "Cursor moved left on Esc" false
  else
    IO.println "[PASS] Cursor moved left on Esc"
  IO.println "ModeTest passed!"
end Test.Mode
private theorem visualLineProofWitness :
    (ViE.initialState.startVisualLineMode).mode = .visualLine := by
  simpa using Proof.startVisualLineMode_setsMode ViE.initialState
import Proof.Visual
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Benchmark.lean

BF:BFD[7.10364] → [9.29216:29254]

BF:BFD[9.29254] → [9.29255:29255]

∅:D[5.12522] → [9.29256:29363]

B:BD[9.29255] → [9.29256:29363]

∅:D[12.27311] → [9.29363:29449]

B:BD[9.29363] → [9.29363:29449]

∅:D[12.30359] → [9.29624:29625]

B:BD[9.29624] → [9.29624:29625]

∅:D[12.30461] → [9.29750:29782]

B:BD[9.29750] → [9.29750:29782]

B:BD[9.29883] → [9.29883:29988]

∅:D[12.30643] → [9.30077:30129]

B:BD[9.30077] → [9.30077:30129]

B:BD[9.30129] → [12.30644:30671]

∅:D[12.30671] → [9.30129:30130]

B:BD[9.30129] → [9.30129:30130]

∅:D[12.30851] → [9.30237:30287]

B:BD[9.30237] → [9.30237:30287]

∅:D[12.31002] → [9.30404:30491]

B:BD[9.30404] → [9.30404:30491]

B:BD[9.30491] → [12.31003:31079]

∅:D[12.31079] → [9.30491:30492]

B:BD[9.30491] → [9.30491:30492]

∅:D[12.31199] → [9.30535:30568]

B:BD[9.30535] → [9.30535:30568]

∅:D[12.31279] → [9.30913:30973]

B:BD[9.30913] → [9.30913:30973]

∅:D[12.31313] → [9.31026:31067]

B:BD[9.31026] → [9.31026:31067]

∅:D[12.31565] → [9.31167:31183]

B:BD[9.31167] → [9.31167:31183]

B:BD[9.31183] → [12.31566:31614]

∅:D[12.31614] → [9.31183:31184]

B:BD[9.31183] → [9.31183:31184]

∅:D[26.2666] → [9.31345:31346]

∅:D[16.28237] → [9.31345:31346]

∅:D[12.32544] → [9.31345:31346]

B:BD[9.31345] → [9.31345:31346]

∅:D[16.31512] → [12.32545:32581]

B:BD[9.31346] → [12.32545:32581]

∅:D[16.31777] → [12.32693:34394]

B:BD[12.32693] → [12.32693:34394]

∅:D[16.33374] → [12.34394:34463]

B:BD[12.34394] → [12.34394:34463]

B:BD[12.34394] → [16.31778:33374]

B:BD[12.32581] → [16.31513:31777]

∅:D[12.34463] → [9.31346:31402]

B:BD[9.31346] → [9.31346:31402]

B:BD[9.31402] → [12.34464:34487]

∅:D[12.34487] → [9.31402:31448]

B:BD[9.31402] → [9.31402:31448]

B:BD[9.31448] → [12.34488:34702]

B:BD[9.31346] → [16.28238:31512]

B:BD[9.31184] → [12.31615:32543]

∅:D[16.28014] → [12.32543:32544]

B:BD[12.32543] → [12.32543:32544]

B:BD[12.32544] → [16.28015:28237]

B:BD[12.32543] → [16.27252:28014]

B:BD[9.31067] → [12.31314:31565]

B:BD[9.30973] → [12.31280:31313]

B:BD[9.30568] → [12.31200:31279]

B:BD[9.30492] → [12.31080:31199]

B:BD[9.30287] → [12.30852:31002]

B:BD[9.30130] → [12.30672:30851]

B:BD[9.29988] → [12.30462:30643]

B:BD[9.29625] → [12.30360:30461]

B:BD[9.29449] → [12.27312:29113]

B:BD[12.29140] → [12.29140:30359]

B:BD[9.29363] → [12.27255:27311]

B:BD[9.29255] → [5.12440:12522]

import ViE.State.Config
import ViE.Config
import ViE.Command.Impl
import ViE.Key.Map
import ViE.State.Edit
import ViE.UI
namespace ViE.Benchmark
open ViE
/-- Mock Config for Benchmarking -/
  let mut s := ViE.initialState
  for i in [0:iterations] do
    s := s.insertChar 'a'
    if i % 100 == 0 then
      s := s.commitEdit
    s := s.moveCursorLeft
    s := s.insertChar 'b'
    s := s.moveCursorRight
    s := s.yankCurrentLine
    s := s.pasteBelow
    s := ← ViE.Command.cmdWg ["new", s!"BenchGroup {i}"] s
    s := s.insertChar 'w'
  for _ in [0:iterations/200] do
    s := ← ViE.Command.cmdWg ["close"] s
  for _ in [0:iterations/500] do
    s := s.insertChar 'v'
    s := ViE.Window.cycleWindow s
    s := ViE.Window.closeActiveWindow s
    s := s.undo
  for _ in [0:iterations/10] do
    s := s.redo
def availableCases : List String :=
/-- Run benchmark cases. -/
def runBenchmark (opts : BenchOptions) : IO Unit := do
  let buildLeafBits := opts.buildLeafBits.getD ViE.defaultConfig.searchBloomBuildLeafBits
  let config := makeBenchConfig (some buildLeafBits)
  let cacheMax := config.settings.searchBloomCacheMax
  let cases := if opts.cases.isEmpty then availableCases else opts.cases
  IO.println s!"Starting benchmark: iter={opts.iterations}, render={opts.render}"
  if opts.warmup > 0 then
    IO.println s!"Warmup: {opts.warmup} iterations"
    for _ in [0:opts.warmup] do
      let mut s := ViE.initialState
      s := s.insertChar 'a'
      let _ ← pure s
  for c in cases do
    match c with
    | "insert" => timeCase "insert" opts.iterations (benchInsert opts.iterations)
    | "edit" => timeCase "edit" opts.iterations (benchEditMix opts.iterations)
    | "clipboard" => timeCase "clipboard" opts.iterations (benchClipboard opts.iterations)
    | "workgroups" => timeCase "workgroups" opts.iterations (benchWorkgroups opts.iterations)
    | "windows" => timeCase "windows" opts.iterations (benchWindows opts.iterations)
    | "undo" => timeCase "undo/redo" opts.iterations (benchUndoRedo opts.iterations)
    | "search-bloom" =>
        timeCase "search-bloom" opts.iterations (benchSearch opts.iterations true opts.textLines opts.lineLen buildLeafBits cacheMax)
    | "search-linear" =>
        timeCase "search-linear" opts.iterations (benchSearch opts.iterations false opts.textLines opts.lineLen buildLeafBits cacheMax)
    | "render" =>
        if opts.render then
          timeCase "render" opts.iterations (benchRender opts.iterations)
        else
          IO.println "[bench] render skipped (--no-render)"
    | other =>
        IO.println s!"[bench] Unknown case: {other}"
    | "load-1mb" =>
        let text := buildLargeText (1024 * 1024)
        timeCase "load-1mb" opts.iterations (for _ in [0:opts.iterations] do
          let pt := PieceTable.fromString text buildLeafBits
          if pt.tree.stats.bytes == 0 then IO.println "Zero bytes?" -- force usage
        )
    | "load-10mb" =>
        let text := buildLargeText (10 * 1024 * 1024)
        timeCase "load-10mb" opts.iterations (for _ in [0:opts.iterations] do
          let pt := PieceTable.fromString text buildLeafBits
          if pt.tree.stats.bytes == 0 then IO.println "Zero bytes?"
        )
    | "load-100mb" =>
        let text := buildLargeText (100 * 1024 * 1024)
        timeCase "load-100mb" opts.iterations (for _ in [0:opts.iterations] do
          let pt := PieceTable.fromString text buildLeafBits
          if pt.tree.stats.bytes == 0 then IO.println "Zero bytes?"
        )
    | "insert-mid-1mb" => timeCase "insert-mid-1mb" opts.iterations (benchInsertMidLarge1MB opts.iterations buildLeafBits)
    | "insert-mid-10mb" => timeCase "insert-mid-10mb" opts.iterations (benchInsertMidLarge10MB opts.iterations buildLeafBits)
    | "split-1mb" => timeCase "split-1mb" opts.iterations (benchSplitLarge1MB opts.iterations buildLeafBits)
    | "split-10mb" => timeCase "split-10mb" opts.iterations (benchSplitLarge10MB opts.iterations buildLeafBits)
    | "getbytes-1mb" => timeCase "getbytes-1mb" opts.iterations (benchGetBytesLarge1MB opts.iterations buildLeafBits)
    | "getbytes-10mb" => timeCase "getbytes-10mb" opts.iterations (benchGetBytesLarge10MB opts.iterations buildLeafBits)
  [ "insert", "edit", "clipboard", "workgroups", "windows", "undo", "search-bloom", "search-linear", "render",
    "load-1mb", "load-10mb", "load-100mb",
    "insert-mid-1mb", "insert-mid-10mb",
    "split-1mb", "split-10mb",
    "getbytes-1mb", "getbytes-10mb" ]
  IO.println "Benchmark completed."
end ViE.Benchmark
/-- CLI entrypoint. -/
def main (args : List String) : IO Unit := do
  let opts := ViE.Benchmark.parseArgs args
  if opts.listOnly then
    IO.println "Available cases:"
    IO.println (String.intercalate ", " ViE.Benchmark.availableCases)
  else
    ViE.Benchmark.runBenchmark opts
/-- Case: Insert at middle of large file (1MB). -/
def benchInsertMidLarge1MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  -- Consume split results so optimizer cannot erase this loop.
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Insert at middle of large file (10MB). -/
def benchInsertMidLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  -- Consume split results so optimizer cannot erase this loop.
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Split operation on large file (1MB). -/
def benchSplitLarge1MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Split operation on large file (10MB). -/
def benchSplitLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: GetBytes operation on large file (1MB). -/
def benchGetBytesLarge1MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let chunkSize := 1024  -- 1KB chunks
  let mut checksum := 0
  for i in [0:iterations] do
    let offset := (i * chunkSize) % pt.tree.stats.bytes.toNat
    let bytes := PieceTree.getBytes pt.tree offset chunkSize pt
    checksum := checksum + bytes.size
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: GetBytes operation on large file (10MB). -/
def benchGetBytesLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let chunkSize := 1024  -- 1KB chunks
  let mut checksum := 0
  for i in [0:iterations] do
    let offset := (i * chunkSize) % pt.tree.stats.bytes.toNat
    let bytes := PieceTree.getBytes pt.tree offset chunkSize pt
    checksum := checksum + bytes.size
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Search workload (PieceTable). -/
def benchSearch (iterations : Nat) (useBloom : Bool) (lines lineLen : Nat) (buildLeafBits : Bool) (cacheMax : Nat) : IO Unit := do
  let needle := "needle"
  let text := buildSearchText lines lineLen needle
  let pt := PieceTable.fromString text buildLeafBits
  let pattern := needle.toUTF8
  let mut offset := 0
  let mut cache : Lean.RBMap Nat ByteArray compare := Lean.RBMap.empty
  let mut order : Array Nat := #[]
  for _ in [0:iterations] do
    let (res, cache', order') := PieceTree.searchNext pt.tree pt pattern offset searchChunkSize useBloom cache order cacheMax
    cache := cache'
    order := order'
    offset := match res with
      | some r => r + 1
      | none => 0
/-- Case: Render workload. -/
def benchRender (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for _ in [0:iterations/20] do
    s := s.insertChar 'a'
  let _ ← ViE.UI.render s
/-- Case: Load large file (100MB). -/
def benchLoadLarge100MB (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (100 * 1024 * 1024)  -- 100MB
  let _ := PieceTable.fromString text buildLeafBits
  pure ()
/-- Generate large text content of specified size (in bytes). -/
def buildLargeText (sizeBytes : Nat) : String :=
  let lineLen := 80
  let line := String.ofList (List.replicate lineLen 'a') ++ "\n"
  let lineBytes := line.utf8ByteSize
  let numLines := sizeBytes / lineBytes
  String.intercalate "" (List.replicate numLines line)
/-- Case: Load large file (1MB). -/
def benchLoadLarge1MB (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)  -- 1MB
  let _ := PieceTable.fromString text buildLeafBits
  pure ()
/-- Case: Load large file (10MB). -/
def benchLoadLarge10MB (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)  -- 10MB
  let _ := PieceTable.fromString text buildLeafBits
  pure ()
/-- Case: Undo/Redo stress. -/
def benchUndoRedo (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for i in [0:iterations] do
    s := s.insertChar 'a'
    if i % 50 == 0 then
      s := s.commitEdit
  for _ in [0:iterations/10] do
  for _ in [0:iterations/200] do
    s := ViE.Window.splitWindow s true
    s := ViE.Window.splitWindow s false
/-- Case: Window splits/cycles. -/
def benchWindows (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
/-- Case: Workgroup churn. -/
def benchWorkgroups (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for i in [0:iterations/200] do
/-- Case: Clipboard (yank/paste). -/
def benchClipboard (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  s := s.insertChar 'x'
  for _ in [0:iterations/50] do
/-- Case: Mixed small edits/movements. -/
def benchEditMix (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for _ in [0:iterations] do
    s := s.insertChar 'a'
/-- Case: Large insert workload (EditorState). -/
def benchInsert (iterations : Nat) : IO Unit := do
def makeBenchConfig (buildLeafBits : Option Bool := none) : Config :=
  let base := ViE.defaultConfig
  let settings :=
    match buildLeafBits with
    | some v => { base with searchBloomBuildLeafBits := v }
    | none => base
  {
    settings := settings
    commands := ViE.Command.defaultCommandMap
    bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
  }
structure BenchOptions where
  iterations : Nat := 1000
  render : Bool := true
  cases : List String := []
  textLines : Nat := 200
  lineLen : Nat := 80
  warmup : Nat := 0
  buildLeafBits : Option Bool := none
  listOnly : Bool := false
def parseArgs (args : List String) : BenchOptions :=
  let rec loop (opts : BenchOptions) (args : List String) : BenchOptions :=
    match args with
    | [] => opts
    | "--no-render" :: rest => loop { opts with render := false } rest
    | "--case" :: name :: rest => loop { opts with cases := opts.cases ++ [name] } rest
    | "--lines" :: n :: rest =>
        match n.toNat? with
        | some v => loop { opts with textLines := v } rest
        | none => loop opts rest
    | "--line-len" :: n :: rest =>
        match n.toNat? with
        | some v => loop { opts with lineLen := v } rest
        | none => loop opts rest
    | "--warmup" :: n :: rest =>
        match n.toNat? with
        | some v => loop { opts with warmup := v } rest
        | none => loop opts rest
    | "--bloom-leaf-bits" :: rest => loop { opts with buildLeafBits := some true } rest
    | "--no-bloom-leaf-bits" :: rest => loop { opts with buildLeafBits := some false } rest
    | "--list" :: rest => loop { opts with listOnly := true } rest
    | arg :: rest =>
        match arg.toNat? with
        | some v => loop { opts with iterations := v } rest
        | none => loop opts rest
  loop {} args
def timeCase (label : String) (iterations : Nat) (f : IO Unit) : IO Unit := do
  let t0 ← IO.monoMsNow
  f
  let t1 ← IO.monoMsNow
  let ms := t1 - t0
  let opsPerSec := if ms == 0 then 0 else (iterations * 1000) / ms
  IO.println s!"[bench] {label}: {ms} ms ({opsPerSec} ops/s)"
/-- Build a simple multi-line ASCII buffer for search benchmarks. -/
def buildText (lines : Nat) (lineLen : Nat) : String :=
  let line := String.ofList (List.replicate lineLen 'a')
  String.intercalate "\n" (List.replicate lines line)
/-- Insert a needle in the middle of text for search benchmarks. -/
def buildSearchText (lines : Nat) (lineLen : Nat) (needle : String) : String :=
  let baseLine := String.ofList (List.replicate lineLen 'a')
  let mid := lines / 2
  let leftLen := lineLen / 2
  let rightLen := if lineLen > leftLen + needle.length then lineLen - leftLen - needle.length else 0
  let needleLine :=
    (String.ofList (List.replicate leftLen 'a')) ++
    needle ++
    (String.ofList (List.replicate rightLen 'a'))
  let linesArr := Id.run do
    let mut arr := Array.replicate lines baseLine
    if mid < arr.size then
      arr := arr.set! mid needleLine
    return arr
  String.intercalate "\n" linesArr.toList
import ViE.State.Search
import ViE.Data.PieceTable.Tree
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: CursorReproduction.lean

BF:BFD[7.10364] → [9.26386:26433]

BF:BFD[9.26433] → [9.26434:26434]

∅:D[5.12273] → [9.26435:27797]

B:BD[9.26434] → [9.26435:27797]

∅:D[12.27254] → [9.27797:29136]

B:BD[9.27797] → [9.27797:29136]

∅:D[27.4242] → [9.29136:29215]

B:BD[9.29136] → [9.29136:29215]

B:BD[9.29136] → [27.2980:4242]

B:BD[9.27797] → [12.26837:27254]

B:BD[9.26434] → [5.12191:12273]

import ViE.State.Config
import ViE.Config
import ViE.Command.Impl
import ViE.Key.Map
import ViE.State.Edit
namespace Test.CursorReproduction
open ViE
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
-- Helper to construct a full Config
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
-- Run a sequence of keys
def runKeys (startState : EditorState) (keys : List Key) : IO EditorState := do
  let config := makeTestConfig
  let mut s := startState
  for k in keys do
    s ← ViE.update config s k
  return s
def test : IO Unit := do
  IO.println "Starting Cursor Reproduction Test..."
  let s := ViE.initialState
  -- Scenario: Insert, Undo, Insert
  let s1 := s.insertChar 'a'
  let s1 := s1.commitEdit -- Force separate undo group
  let s2 := s1.insertChar 'b'
  -- Text: 'ab', Cursor: (0, 2)
  let s3 := s2.undo
  -- Text: 'a', Cursor should be (0, 1)
  let cursor := s3.getCursor
  if cursor.col.val != 1 then
     IO.println s!"[FAIL] Undo cursor mismatch. Expected 1, got {cursor.col.val}"
     assert "Undo cursor" false
  else
     IO.println "[PASS] Undo cursor correct"
  let s4 := s3.insertChar 'c'
  -- Text: 'ac'
  let text := getLineFromBuffer s4.getActiveBuffer 0 |>.getD ""
  if text != "ac" then
      IO.println s!"[FAIL] Insert after undo failed. Expected 'ac', got '{text}'"
      assert "Insert after undo" false
  else
      IO.println "[PASS] Insert after undo works"
  -- Scenario: Paste, Undo, Paste (checking grouping too, but focusing on cursor)
  -- Reset
  let s := ViE.initialState
  let s := s.insertChar 'x'
  let s := s.yankCurrentLine -- Yank 'x\n'
  let _s := s.pasteBelow -- Paste 'x\n' -> 'x\nx\n' ??
  -- PasteBelow pastes line.
  -- Scenario: x command
  let s := ViE.initialState
  let s := s.insertChar 'h'
  let s := s.insertChar 'e'
  let s := s.insertChar 'y'
  -- "hey"
  let s := (s.moveCursorLeft).moveCursorLeft -- At 'h' (0,0)? No: 3 -> 2 -> 1. 'e'
  -- "hey" cursor at 2 ('y'). Left -> 1 ('e'). Left -> 0 ('h').
  -- Actually moveCursorLeft from (0,3) -> (0,2) 'y'.
  -- Let's use setCursor
  let s := s.setCursor (Point.make 0 1) -- 'e'
  let s := s.deleteCharAfterCursor -- Should delete 'e' -> "hy"
  let text := getLineFromBuffer s.getActiveBuffer 0 |>.getD ""
  if text != "hy" then
     IO.println s!"[FAIL] 'x' command (deleteCharAfterCursor) failed. Expected 'hy', got '{text}'"
     assert "x command" false
  else
     IO.println "[PASS] 'x' command works"
  IO.println "Cursor Reproduction Test Finished"
end Test.CursorReproduction
  -- 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)
  -- Scenario: Wide character insert moves cursor by display width
  let s := ViE.initialState
  let wide := Char.ofNat 0x3042 -- Hiragana A (wide)
  let s := s.insertChar wide
  let cursor := s.getCursor
  if cursor.col.val != 2 then
     IO.println s!"[FAIL] Wide char cursor mismatch. Expected 2, got {cursor.col.val}"
     assert "Wide char cursor" false
  else
     IO.println "[PASS] Wide char cursor correct"
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: MissingEol.lean

BF:BFD[7.10364] → [12.25428:25467]

BF:BFD[12.25467] → [12.25468:25468]

∅:D[5.11692] → [12.25469:26836]

B:BD[12.25468] → [12.25469:26836]

B:BD[12.25468] → [5.11610:11692]

import ViE.State.Config
import ViE.State.Layout
import ViE.Data.PieceTable
import Test.Utils
open ViE
namespace Test.MissingEol
open Test.Utils
def testMissingEol : IO Unit := do
  IO.println "testMissingEol..."
  let s := ViE.initialState
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := PieceTable.fromString "abc\n", dirty := true }
  let buf := s.getActiveBuffer
  assert "missingEol false with trailing newline" (!buf.missingEol)
  let len := buf.table.length
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := buffer.table.delete (len - 1) 1 (len - 1), dirty := true }
  let buf2 := s.getActiveBuffer
  assert "missingEol true after deleting newline" buf2.missingEol
  let s := ViE.initialState
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := PieceTable.fromString "abc", dirty := true }
  let buf3 := s.getActiveBuffer
  assert "missingEol true without newline" buf3.missingEol
  let len2 := buf3.table.length
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := buffer.table.insert len2 "\n" len2, dirty := true }
  let buf4 := s.getActiveBuffer
  assert "missingEol false after adding newline" (!buf4.missingEol)
def test : IO Unit := do
  IO.println "Starting MissingEol Test..."
  testMissingEol
  IO.println "MissingEol Test passed!"
end Test.MissingEol
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: PasteReproduction.lean

BF:BFD[7.10364] → [9.24495:24541]

BF:BFD[9.24541] → [9.24542:24542]

∅:D[5.11328] → [9.24543:26333]

B:BD[9.24542] → [9.24543:26333]

B:BD[9.24542] → [5.11246:11328]

import ViE.Data.PieceTable
namespace Test.PasteReproduction
def test : IO Unit := do
  IO.println "--- Test 1: Paste below last line (no trailing newline) ---"
  let pt := ViE.PieceTable.fromString "line 1"
  IO.println s!"Initial: [{pt.toString}]"
  -- Yank line 1 (manually simulating EditorState.yankCurrentLine)
  let line1 := pt.getLine 0 |>.getD ""
  let yanked := if line1.endsWith "\n" then line1 else line1 ++ "\n"
  IO.println s!"Yanked: [{yanked}]"
  -- Paste below line 0 (simulating EditorState.pasteBelow)
  let (off, text) := match pt.getOffsetFromPoint 1 0 with
    | some o => (o, yanked)
    | none =>
        let len := pt.length
        if len > 0 then
           if !pt.endsWithNewline then (len, "\n" ++ yanked) else (len, yanked)
        else (0, yanked)
  let pt2 := pt.insert off text off
  IO.println s!"After paste:\n[{pt2.toString}]"
  IO.println s!"Line count: {pt2.lineCount}"
  for i in [:pt2.lineCount] do
    IO.println s!"Line {i}: [{pt2.getLine i |>.getD "NONE"}]"
  IO.println "\n--- Test 2: Paste below last line (with trailing newline) ---"
  let ptB := ViE.PieceTable.fromString "line 1\n"
  IO.println s!"Initial: [{ptB.toString}]"
  let line1B := ptB.getLine 0 |>.getD ""
  let yankedB := if line1B.endsWith "\n" then line1B else line1B ++ "\n"
  let (offB, textB) := match ptB.getOffsetFromPoint 1 0 with
    | some o => (o, yankedB)
    | none =>
        let len := ptB.length
        if len > 0 then
           if !ptB.endsWithNewline then (len, "\n" ++ yankedB) else (len, yankedB)
        else (0, yankedB)
  let ptB2 := ptB.insert offB textB offB
  IO.println s!"After paste:\n[{ptB2.toString}]"
  IO.println s!"Line count: {ptB2.lineCount}"
  for i in [:ptB2.lineCount] do
    IO.println s!"Line {i}: [{ptB2.getLine i |>.getD "NONE"}]"
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: SyntaxHighlight.lean

BF:BFD[7.10364] → [16.23321:23365]

BF:BFD[16.23365] → [16.23366:23366]

∅:D[5.10767] → [16.23388:23427]

B:BD[16.23388] → [16.23388:23427]

∅:D[19.10565] → [16.23427:23685]

B:BD[16.23427] → [16.23427:23685]

∅:D[19.10636] → [16.23752:23938]

B:BD[16.23752] → [16.23752:23938]

∅:D[19.11164] → [16.24305:24382]

B:BD[16.24305] → [16.24305:24382]

∅:D[19.11235] → [16.24449:24584]

B:BD[16.24449] → [16.24449:24584]

∅:D[19.11584] → [16.24838:25008]

B:BD[16.24838] → [16.24838:25008]

B:BD[16.24584] → [19.11236:11584]

B:BD[16.24382] → [19.11165:11235]

B:BD[16.23938] → [19.10637:11164]

B:BD[16.23685] → [19.10566:10636]

B:BD[16.23427] → [19.10541:10565]

B:BD[16.23366] → [5.10685:10767]

import ViE.UI.Search
import Test.Utils
open Test.Utils
namespace Test.SyntaxHighlight
private def firstRangeOf (line : String) (pat : String) : Option (Nat × Nat) :=
  (ViE.UI.findAllMatchesBytes line.toUTF8 pat.toUTF8)[0]?
def testLean : IO Unit := do
  let line := "def x := 42 -- comment"
  let (defS, defE) := (firstRangeOf line "def").getD (0, 0)
  let (numS, numE) := (firstRangeOf line "42").getD (0, 0)
  let (comS, comE) := (firstRangeOf line "-- comment").getD (0, 0)
def testMarkdown : IO Unit := do
  let line := "Use `code` and [link](url)"
  let (codeS, codeE) := (firstRangeOf line "`code`").getD (0, 0)
  let (linkS, linkE) := (firstRangeOf line "[link](url)").getD (0, 0)
def test : IO Unit := do
  IO.println "Starting SyntaxHighlight Test..."
  testLean
  testMarkdown
  IO.println "SyntaxHighlight Test passed!"
end Test.SyntaxHighlight
  assertEqual "Markdown code style" (Bliku.Tui.Syntax.defaultPalette.faceFor .code)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans codeS codeE)
  assertEqual "Markdown link style" (Bliku.Tui.Syntax.defaultPalette.faceFor .link)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans linkS linkE)
  let spans := Bliku.Tui.Syntax.highlightLine (some "README.md") line
  assertEqual "Lean keyword style" (Bliku.Tui.Syntax.defaultPalette.faceFor .keyword)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans defS defE)
  assertEqual "Lean number style" (Bliku.Tui.Syntax.defaultPalette.faceFor .numberLiteral)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans numS numE)
  assertEqual "Lean comment style" (Bliku.Tui.Syntax.defaultPalette.faceFor .comment)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans comS comE)
  let spans := Bliku.Tui.Syntax.highlightLine (some "Main.lean") line
import Bliku.Tui.Syntax
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: TreeStats.lean

BF:BFD[7.10364] → [9.23268:23306]

BF:BFD[9.23306] → [9.23307:23307]

∅:D[5.10684] → [9.23308:23335]

B:BD[9.23307] → [9.23308:23335]

B:BD[9.23335] → [15.93037:93055]

∅:D[15.93055] → [9.23335:23336]

B:BD[9.23335] → [9.23335:23336]

∅:D[15.93081] → [9.23449:23450]

B:BD[9.23449] → [9.23449:23450]

∅:D[15.93229] → [9.23505:23599]

B:BD[9.23505] → [9.23505:23599]

∅:D[15.94221] → [9.23663:23664]

B:BD[9.23663] → [9.23663:23664]

B:BD[9.23664] → [15.94222:94286]

∅:D[15.94286] → [9.23664:23686]

B:BD[9.23664] → [9.23664:23686]

B:BD[9.23686] → [15.94287:94697]

∅:D[15.94697] → [9.23686:23704]

B:BD[9.23686] → [9.23686:23704]

∅:D[16.23320] → [9.23955:23956]

∅:D[15.94870] → [9.23955:23956]

B:BD[9.23955] → [9.23955:23956]

B:BD[9.24284] → [9.24284:24389]

B:BD[9.24389] → [15.94871:95367]

∅:D[24.8442] → [15.95445:95931]

B:BD[15.95445] → [15.95445:95931]

B:BD[15.95367] → [24.8362:8442]

B:BD[9.23704] → [15.94698:94798]

B:BD[15.94798] → [16.23246:23320]

B:BD[9.23599] → [15.93230:93243]

∅:D[16.23104] → [15.93416:93417]

∅:D[28.38694] → [15.93416:93417]

B:BD[15.93416] → [15.93416:93417]

∅:D[28.38837] → [15.93588:93589]

B:BD[15.93588] → [15.93588:93589]

∅:D[16.23159] → [15.93775:93776]

∅:D[28.38998] → [15.93775:93776]

B:BD[15.93775] → [15.93775:93776]

∅:D[28.39849] → [15.93979:94221]

B:BD[15.93979] → [15.93979:94221]

B:BD[15.93776] → [28.38999:39262]

∅:D[16.23216] → [28.39316:39591]

B:BD[28.39316] → [28.39316:39591]

∅:D[16.23245] → [28.39617:39849]

B:BD[28.39617] → [28.39617:39849]

B:BD[28.39591] → [16.23217:23245]

B:BD[28.39262] → [16.23160:23216]

B:BD[15.93589] → [28.38838:38946]

B:BD[28.38946] → [16.23105:23159]

B:BD[15.93417] → [28.38695:38837]

B:BD[15.93243] → [28.38532:38639]

B:BD[28.38639] → [16.23047:23104]

B:BD[9.23450] → [15.93082:93229]

B:BD[9.23336] → [15.93056:93081]

B:BD[9.23307] → [5.10602:10684]

import ViE.Data.PieceTable
import Test.Utils
  for i in [0:iterations] do
    pt := pt.insert pt.tree.length s!"line {i}\n" pt.tree.length
def report (pt : PieceTable) (iterations : Nat) : IO Unit := do
  let tree := pt.tree
  let h := PieceTree.height tree
  let nodes := countNodes tree
  let leaves := countLeaves tree
  let maxLeaf := maxLeafPieces tree
  let maxChildren := maxInternalChildren tree
  IO.println s!"iterations={iterations}"
  IO.println s!"bytes={PieceTree.length tree} lines={PieceTree.lineBreaks tree} height={h}"
  IO.println s!"nodes={nodes} leaves={leaves} maxLeafPieces={maxLeaf} maxChildren={maxChildren}"
  match tree with
  if iterations > 0 then
    let start := ← IO.monoMsNow
    let _ := pt.getLineRange (iterations - 1)
    let stop := ← IO.monoMsNow
    IO.println s!"getLineRange(last)={stop - start}ms"
def test : IO Unit := do
  IO.println "Starting TreeStats Test..."
  let iterations := 3000
  let pt := buildWorkload iterations
  let t := pt.tree
  let bytes := PieceTree.length t
  let textBytes := pt.toString.toUTF8.size
  let isNonEmpty :=
    match t with
    | .empty => false
    | _ => true
  assertEqual "tree length equals rendered bytes" textBytes bytes
  assert "tree is non-empty" isNonEmpty
  assert "leaf piece count stays within node capacity" (maxLeafPieces t <= NodeCapacity)
  assert "internal children stay within node capacity" (maxInternalChildren t <= NodeCapacity)
  assert "line range for last inserted line exists" ((pt.getLineRange (iterations - 1)).isSome)
  IO.println "TreeStats Test passed!"
def main (args : List String) : IO Unit := do
  let iterations := parseIterations args
  let pt := buildWorkload iterations
  report pt iterations
end Test.TreeStats
  assert "tree height is positive for non-empty tree" (PieceTree.height t >= 1)
  | .empty => IO.println "root=empty"
  | .leaf ps _ _ => IO.println s!"root=leaf pieces={ps.size}"
  | .internal cs _ _ _ => IO.println s!"root=internal children={cs.size}"
  return pt
def parseIterations (args : List String) : Nat :=
  let args :=
    match args with
    | "--" :: rest => rest
    | _ => args
  match args with
  | a :: _ =>
      match a.toNat? with
      | some n => n
      | none => 5000
  | [] => 5000
  def countLeavesList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => countLeaves t + countLeavesList rest
end
mutual
  def maxLeafPieces (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf ps _ _ => ps.size
  def maxLeafPiecesList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => max (maxLeafPieces t) (maxLeafPiecesList rest)
end
mutual
  def maxInternalChildren (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf _ _ _ => 0
        max cs.size (maxInternalChildrenList cs.toList)
  def maxInternalChildrenList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => max (maxInternalChildren t) (maxInternalChildrenList rest)
end
    | .internal cs _ _ _ =>
    | .internal cs _ _ _ => maxLeafPiecesList cs.toList
mutual
  def countLeaves (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf _ _ _ => 1
    | .internal cs _ _ _ => countLeavesList cs.toList
  def countNodesList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => countNodes t + countNodesList rest
end
mutual
  def countNodes (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf _ _ _ => 1
    | .internal cs _ _ _ => 1 + countNodesList cs.toList
open ViE
open Test.Utils
def buildWorkload (iterations : Nat) : PieceTable := Id.run do
  let mut pt := PieceTable.fromString "Initial content\n"
namespace Test.TreeStats
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Buffer.lean

BF:BFD[7.10364] → [7.19044:19079]

BF:BFD[7.19079] → [7.19080:19080]

∅:D[5.12439] → [7.19081:19161]

B:BD[7.19080] → [7.19081:19161]

B:BD[7.19181] → [7.19181:19182]

∅:D[10.13056] → [7.19182:20748]

B:BD[7.19182] → [7.19182:20748]

B:BD[7.19182] → [10.13055:13056]

B:BD[7.19080] → [5.12357:12439]

import ViE.Buffer.Content
import ViE.Types
import ViE.Data.PieceTable
open ViE
namespace Test.Buffer
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  IO.println "Starting Buffer Test..."
  -- 1. Test fromString and getLine
  let text := "Hello\nWorld"
  let pt := PieceTable.fromString text
  let buf : FileBuffer := { initialFileBuffer with table := pt }
  -- Check lines
  match getLineFromBuffer buf 0 with
  | some l => assert "Line 0 is Hello" (l == "Hello")
  | none => assert "Line 0 missing" false
  match getLineFromBuffer buf 1 with
  | some l => assert "Line 1 is World" (l == "World")
  | none => assert "Line 1 missing" false
  match getLineFromBuffer buf 2 with
  | some _ => assert "Line 2 should be missing" false
  | none => assert "Line 2 correctly missing" true
  -- 2. Test FileBuffer <-> TextBuffer conversion
  let tb : TextBuffer := #[ #['A', 'B'], #['C'] ] -- "AB\nC"
  let buf2 := ViE.Buffer.fileBufferFromTextBuffer 1 (some "test.txt") tb
  assert "Buffer created from TextBuffer id" (buf2.id == 1)
  assert "Buffer created from TextBuffer filename" (buf2.filename == some "test.txt")
  let tb2 := ViE.Buffer.fileBufferToTextBuffer buf2
  assert "Roundtrip TextBuffer size" (tb2.size == 2)
  if tb2.size == 2 then
    let l0 := tb2[0]!
    let l1 := tb2[1]!
    assert "Roundtrip Line 0" (String.ofList l0.toList == "AB")
    assert "Roundtrip Line 1" (String.ofList l1.toList == "C")
  IO.println "BufferTest passed!"
end Test.Buffer
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Integration.lean

BF:BFD[7.10364] → [7.16875:16915]

BF:BFD[7.16915] → [7.16916:16916]

∅:D[5.12024] → [7.16917:17019]

B:BD[7.16916] → [7.16917:17019]

∅:D[10.12770] → [7.17019:17029]

B:BD[7.17019] → [7.17019:17029]

∅:D[10.12787] → [7.17029:17058]

B:BD[7.17029] → [7.17029:17058]

B:BD[7.17254] → [7.17254:18192]

∅:D[10.12836] → [7.18293:18353]

B:BD[7.18293] → [7.18293:18353]

∅:D[10.12934] → [7.18634:18729]

B:BD[7.18634] → [7.18634:18729]

B:BD[7.18780] → [7.18780:18781]

∅:D[10.13054] → [7.18981:19043]

∅:D[8.39196] → [7.18981:19043]

B:BD[7.18981] → [7.18981:19043]

B:BD[7.18781] → [10.12935:13054]

B:BD[7.18353] → [10.12837:12934]

B:BD[7.18192] → [10.12788:12836]

B:BD[7.17029] → [10.12771:12787]

B:BD[7.17019] → [10.12752:12770]

B:BD[7.16916] → [5.11942:12024]

import ViE.Types
import ViE.State.Config
import ViE.Config
import ViE.Key.Map
import ViE.Command.Impl
open ViE
namespace Test.Integration
-- Helper to construct a full Config
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
-- Run a sequence of keys
def runKeys (startState : EditorState) (keys : List Key) : IO EditorState := do
  let config := makeTestConfig
  let mut s := startState
  for k in keys do
    s ← ViE.update config s k
  return s
-- Helper: Convert string to list of char keys
def keys (s : String) : List Key :=
  s.toList.map Key.char
def test : IO Unit := do
  IO.println "Starting Integration Test..."
  -- Test 1: Typing "abc" -> Undo -> Insert "d"
  -- Expected: "abc" -> "" -> "d"
  -- Bug Report: After Undo, Insert mode might fail or buffer might be corrupted
  let s0 := ViE.initialState
  -- 1. Insert "abc"
  -- i a b c Esc
  let input1 := [Key.char 'i'] ++ keys "abc" ++ [Key.esc]
  let s1 ← runKeys s0 input1
  -- 2. Undo
  -- u
  let s2 ← runKeys s1 [Key.char 'u']
  -- 3. Insert "d"
  -- i d Esc
  let s3 ← runKeys s2 [Key.char 'i', Key.char 'd', Key.esc]
  IO.println "IntegrationTest passed!"
end Test.Integration
  assertBuffer "Text after re-insert d" s3 "d"
  assertCursor "Cursor after insert 'd' and Esc should be (0,0)" s3 0 0
  assertBuffer "Text after undo" s2 ""
  assertCursor "Cursor after undo should be (0,0)" s2 0 0
  assertBuffer "Text after insert abc" s1 "abc"
open Test.Utils
import Test.Utils
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Layout.lean

BF:BFD[7.10364] → [7.15575:15610]

BF:BFD[7.15610] → [7.15611:15611]

∅:D[5.11858] → [7.15612:16323]

B:BD[7.15611] → [7.15612:16323]

∅:D[9.26359] → [7.16348:16542]

B:BD[7.16348] → [7.16348:16542]

∅:D[9.26385] → [7.16567:16874]

B:BD[7.16567] → [7.16567:16874]

B:BD[7.16542] → [9.26360:26385]

B:BD[7.16323] → [9.26334:26359]

B:BD[7.15611] → [5.11776:11858]

import ViE.Types
open ViE
namespace Test.Layout
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  IO.println "Starting Layout Test..."
  -- 1. Construct Layouts
  let view1 : ViewState := { bufferId := 1, cursor := {row:=0, col:=0}, scrollRow:=0, scrollCol:=0 }
  let win1 := Layout.window 1 view1
  let view2 : ViewState := { bufferId := 2, cursor := {row:=0, col:=0}, scrollRow:=0, scrollCol:=0 }
  let win2 := Layout.window 2 view2
  -- 2. Test Split Construction
  let hsplit := Layout.hsplit win1 win2 0.5
  match hsplit with
      assert "HSplit match" true
      assert "HSplit ratio" (ratio == 0.5)
  | _ => assert "HSplit construction failed" false
  let vsplit := Layout.vsplit hsplit win1 0.3
  match vsplit with
      assert "VSplit match" true
      assert "VSplit ratio" (ratio == 0.3)
      match t with
      | .hsplit _ _ _ => assert "VSplit top is HSplit" true
      | _ => assert "VSplit top incorrect" false
  | _ => assert "VSplit construction failed" false
  IO.println "LayoutTest passed!"
end Test.Layout
  | .vsplit t _ ratio =>
  | .hsplit _ _ ratio =>
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

File deletion: Undo.lean

BF:BFD[7.10364] → [7.10366:10399]

BF:BFD[7.10399] → [7.10400:10400]

B:BD[7.10400] → [5.10436:10518]

∅:D[5.10518] → [7.10401:10428]

B:BD[7.10400] → [7.10401:10428]

∅:D[10.6055] → [7.10448:14409]

B:BD[7.10448] → [7.10448:14409]

B:BD[7.14485] → [7.14485:15574]

B:BD[7.10428] → [10.6045:6055]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Data.PieceTable
namespace Test.Undo
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  IO.println "Starting Undo/Redo Test..."
  -- 1. Create initial buffer
  let initialText := "Hello, World!"
  let pt0 := PieceTable.fromString initialText
  assert "Initial text correct" (pt0.toString == initialText)
  assert "Initial undo stack empty" (pt0.undoStack.isEmpty)
  -- 2. Insert " New" at end
  -- "Hello, World! New"
  let pt1 := pt0.insert 13 " New" 13
  assert "Text after insert" (pt1.toString == "Hello, World! New")
  assert "Undo stack has 1 item" (pt1.undoStack.length == 1)
  -- 3. Delete ", World"
  -- "Hello! New"
  -- "Hello, World!" -> offset 5, delete 7 (", World")
  let pt2 := pt1.delete 5 7 5
  assert "Text after delete" (pt2.toString == "Hello! New")
  assert "Undo stack has 2 items" (pt2.undoStack.length == 2)
  -- 4. Undo Modify (Delete)
  -- Should revert to "Hello, World! New"
  let (pt3, _) := pt2.undo 0
  assert "Text after undo delete" (pt3.toString == "Hello, World! New")
  assert "Undo stack has 1 item" (pt3.undoStack.length == 1)
  assert "Redo stack has 1 item" (pt3.redoStack.length == 1)
  -- 5. Undo Insert
  -- Should revert to "Hello, World!"
  let (pt4, _) := pt3.undo 0
  assert "Text after undo insert" (pt4.toString == "Hello, World!")
  assert "Undo stack has 0 items" (pt4.undoStack.isEmpty)
  assert "Redo stack has 2 items" (pt4.redoStack.length == 2)
  -- 6. Redo Insert
  -- Should go to "Hello, World! New"
  let (pt5, _) := pt4.redo 0
  assert "Text after redo insert" (pt5.toString == "Hello, World! New")
  assert "Undo stack has 1 item" (pt5.undoStack.length == 1)
  assert "Redo stack has 1 item" (pt5.redoStack.length == 1)
  -- 7. Redo Delete
  -- Should go to "Hello! New"
  let (pt6, _) := pt5.redo 0
  assert "Text after redo delete" (pt6.toString == "Hello! New")
  assert "Undo stack has 2 items" (pt6.undoStack.length == 2)
  assert "Redo stack empty" (pt6.redoStack.isEmpty)
  -- 8. Test Redo clearing on new edit
  let (pt7, _) := pt6.undo 0 -- "Hello, World! New"
  -- Insert " Again" at end -> "Hello, World! New Again"
  let pt8 := pt7.insert 17 " Again" 17
  assert "Text after new insert" (pt8.toString == "Hello, World! New Again")
  assert "Redo stack cleared" (pt8.redoStack.isEmpty)
  -- 9. Test Optimization (Grouping)
  -- Force break merge chain from previous step to ensure " 1" starts a new group
  let pt8_clean := { pt8 with lastInsert := none }
  let pt9 := pt8_clean.insert 23 " 1" 23 -- "Hello, World! New Again 1"
  let pt10 := pt9.insert 25 "2" 25 -- "Hello, World! New Again 12"
  let pt11 := pt10.insert 26 "3" 26 -- "Hello, World! New Again 123"
  assert "Text after group insert" (pt11.toString == "Hello, World! New Again 123")
  -- Should have only 1 new undo item for " 123" because they overlap
  -- pt8 had some undo stack. pt9 added 1. pt10 merged. pt11 merged.
  -- So pt11.undoStack.length should be pt8.undoStack.length + 1
  assert "Undo stack grouped" (pt11.undoStack.length == pt8.undoStack.length + 1)
  let (pt12, _) := pt11.undo 0
  assert "Undo removes group" (pt12.toString == "Hello, World! New Again")
  -- 10. Test Limit
  -- Force a small limit
  let ptLimit := { pt12 with undoLimit := 2 }
  let ptL1 := (ptLimit.insert 0 "A" 0) -- Stack: 1
  let ptL2 := (ptL1.insert 0 "B" 0) -- Stack: 2
  -- Previous insert was "A" at 0. LastInsert = (0 + 1, addOffset + 1).
  -- Current insert at 0. 0 != 1. So NOT contiguous. Correct.
  let ptL3 := (ptL2.insert 0 "C" 0) -- Stack: 3 -> capped to 2
  assert "Undo limit respected" (ptL3.undoStack.length == 2)
  -- The oldest undo (for "A") should be dropped. The remaining undos are "C" -> "B", and "B" -> "A".
  -- So undoing twice should start with "CBA..." -> "BA..." -> "A..."
  let (u1, _) := ptL3.undo 0
  let (u2, _) := u1.undo 0
  assert "Oldest undo dropped" (u2.toString == "AHello, World! New Again")
  -- 11. Test Paste Undo Grouping (Reproduction)
  -- Scenario: Paste "P1" then Paste "P2". They should NOT merge if we signal a break,
  -- OR if we consider pastes as distinct operations that shouldn't auto-merge like typing.
  -- Currently PieceTable merges ANY contiguous insert.
  let ptBase := PieceTable.fromString ""
  let ptP1 := ptBase.insert 0 "P1" 0 -- Simulate Paste 1
  -- Simulate EditorState.paste calling commit before next insert
  let ptP1_committed := ptP1.commit
  let ptP2 := ptP1_committed.insert 2 "P2" 2 -- Simulate Paste 2 (contiguous)
  assert "Text is P1P2" (ptP2.toString == "P1P2")
  -- Expectation: 2 undo items (one for P1, one for P2).
  -- Bug: they merge into 1 item because offset 2 == lastInsert end.
  if ptP2.undoStack.length == 1 then
     IO.println "[FAIL] Paste operations merged (expected 2 undo items)"
     assert "Paste should not merge" false
  else
     IO.println "[PASS] Paste operations distinct (2 undo items)"
  IO.println "TestUndo passed!"
end Test.Undo
open ViE

File deletion: Scroll.lean

BF:BFD[7.10364] → [13.10174:10209]

BF:BFD[13.10209] → [13.10210:10210]

B:BD[13.10210] → [5.10851:10933]

∅:D[5.10933] → [13.10211:10544]

B:BD[13.10210] → [13.10211:10544]

B:BD[13.10578] → [13.10578:12567]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Window.Actions
import ViE.State
import ViE.Types
import ViE.Config
namespace Test.Scroll
open ViE
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  let state := ViE.initialState
  -- Set window size (e.g., 10 lines)
  let state := { state with windowHeight := 10, windowWidth := 80 }
  -- Move cursor to line 100
  let state := state.setCursor { row := ⟨100⟩, col := ⟨0⟩ }
  -- Enforce scroll
  let state := ViE.Window.enforceScroll state
  let (sRow, _) := state.getScroll
  IO.println s!"Cursor Row: 100, Scroll Row: {sRow.val}, Window Height: 10"
  -- View range is [sRow, sRow + 9] (10 lines)
  -- We expect 100 to be in [sRow, sRow + 9]
  -- So sRow <= 100 AND 100 < sRow + 10  => sRow > 90
  let visible := sRow.val <= 100 && 100 < sRow.val + 10
  assert "Cursor is visible" visible
  -- Upper boundary: cursor above scroll should pull scroll up
  let state2 := { state with
    mode := .normal
  }
  let state2 := state2.setScroll ⟨10⟩ ⟨0⟩
  let state2 := state2.setCursor { row := ⟨2⟩, col := ⟨0⟩ }
  let state2 := ViE.Window.enforceScroll state2
  let (sRow2, _) := state2.getScroll
  assert "Scroll moves up to include cursor" (sRow2.val == 2)
  -- Horizontal right boundary: cursor beyond view should scroll right
  let state3 := { state with windowHeight := 5, windowWidth := 20 }
  let state3 := state3.setScroll ⟨0⟩ ⟨0⟩
  let state3 := state3.setCursor { row := ⟨0⟩, col := ⟨30⟩ }
  let state3 := ViE.Window.enforceScroll state3
  let (_, sCol3) := state3.getScroll
  let colsInView := 20 -- showLineNumbers is false by default
  let visible3 := sCol3.val <= 30 && 30 < sCol3.val + colsInView
  assert "Horizontal scroll keeps cursor visible" visible3
  -- Horizontal left boundary: cursor before scroll should pull scroll left
  let state4 := { state with windowHeight := 5, windowWidth := 20 }
  let state4 := state4.setScroll ⟨0⟩ ⟨10⟩
  let state4 := state4.setCursor { row := ⟨0⟩, col := ⟨2⟩ }
  let state4 := ViE.Window.enforceScroll state4
  let (_, sCol4) := state4.getScroll
  assert "Horizontal scroll moves left to include cursor" (sCol4.val == 2)

File deletion: Checkpoint.lean

BF:BFD[7.10364] → [14.7146:7185]

BF:BFD[14.7185] → [14.7186:7186]

B:BD[14.7186] → [5.12274:12356]

∅:D[5.12356] → [14.7187:7202]

B:BD[14.7186] → [14.7187:7202]

∅:D[29.4696] → [14.7202:9139]

B:BD[14.7202] → [14.7202:9139]

∅:D[29.4834] → [14.9139:9207]

B:BD[14.9139] → [14.9139:9207]

B:BD[14.9207] → [24.12575:12576]

∅:D[29.5339] → [24.12576:13233]

B:BD[24.12576] → [24.12576:13233]

B:BD[24.12576] → [29.4835:5339]

∅:D[24.13233] → [14.9207:9310]

B:BD[14.9207] → [14.9207:9310]

B:BD[14.9310] → [24.13234:13276]

∅:D[24.13276] → [14.9310:9331]

B:BD[14.9310] → [14.9310:9331]

B:BD[14.9139] → [29.4697:4834]

B:BD[14.7202] → [29.4670:4696]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
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 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
  let s0 := ({ ViE.initialState with config := ViE.defaultConfig }).updateCurrentWorkspace (fun _ => ws)
  let s1 := s0.updateCurrentWorkspace fun ws =>
    { ws with layout := ws.layout.updateView ws.activeWindowId (fun v => { v with bufferId := 0 }) }
  let s2 ← ViE.Buffer.ensureActiveBufferLoaded s1
  let activeLoaded := s2.getActiveBuffer
  assertEqual "Lazy buffer loads on activation" true activeLoaded.loaded
  assertEqual "Lazy loaded buffer keeps file path" (some f1) activeLoaded.filename
def test : IO Unit := do
  testLoadSessionInvalid
  testLoadSessionValid
  testBuildRestoredWorkspace
  testBuildRestoredWorkspaceCustomTabStop
end Test.Checkpoint
      assertEqual "Restored inactive buffer is lazy" false b1.loaded
      assertEqual "Restored active buffer is loaded" true b2.loaded
import ViE.Buffer.Manager

File deletion: PieceTable
BF:BFD[7.10364] → [10.6098:6119]
BF:BFD[10.6119] → [10.6120:6120]

File deletion: Search.lean

BF:BFD[10.6120] → [12.23057:23092]

BF:BFD[12.23092] → [12.23093:23093]

B:BD[12.23093] → [12.23094:23139]

∅:D[5.11055] → [12.23139:23201]

B:BD[12.23139] → [12.23139:23201]

∅:D[5.11245] → [12.23201:23628]

B:BD[12.23201] → [12.23201:23628]

∅:D[16.27251] → [12.23708:25427]

B:BD[12.23708] → [12.23708:25427]

B:BD[12.23628] → [16.27129:27251]

B:BD[12.23201] → [5.11056:11245]

B:BD[12.23139] → [5.11017:11055]

import ViE.Data.PieceTable
import Test.Utils
open ViE
namespace Test.PieceTable.Search
open Test.Utils
def makeBoundaryTable : PieceTable :=
  let n := ViE.NodeCapacity + 1
  let startIdx := n / 2 - 1
  let chars := Id.run do
    let mut cs := Array.replicate n 'x'
    cs := cs.set! startIdx 'a'
    cs := cs.set! (startIdx + 1) 'b'
    cs := cs.set! (startIdx + 2) 'c'
    return cs
  let s := String.ofList chars.toList
  let bytes := s.toUTF8
  let pieces := (Array.range n).map fun i =>
    { source := BufferSource.original
  let tmp : PieceTable := {
    original := bytes
    addBuffers := #[]
    tree := PieceTree.empty
    undoStack := []
    redoStack := []
    undoStackCount := 0
    redoStackCount := 0
    undoLimit := 100
    lastInsert := none
  }
  let tree := PieceTree.fromPieces pieces tmp
  { tmp with tree := tree }
def testCrossLeafSearch : IO Unit := do
  IO.println "testCrossLeafSearch..."
  let pt := makeBoundaryTable
  let n := ViE.NodeCapacity + 1
  let startIdx := n / 2 - 1
  let pattern := "abc".toUTF8
  let (r1, _, _) := PieceTree.searchNext pt.tree pt pattern 0 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchNext bloom across leaf" (some startIdx) r1
  let total := pt.tree.length
  let (r2, _, _) := PieceTree.searchPrev pt.tree pt pattern total 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchPrev bloom across leaf" (some startIdx) r2
def testCrossLeafSearchNearBoundary : IO Unit := do
  IO.println "testCrossLeafSearchNearBoundary..."
  let pt := makeBoundaryTable
  let n := ViE.NodeCapacity + 1
  let startIdx := n / 2 - 1
  let pattern := "abc".toUTF8
  let startOffset := startIdx - 1
  let (r1, _, _) := PieceTree.searchNext pt.tree pt pattern startOffset 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchNext from near boundary" (some startIdx) r1
  let startExclusive := startIdx + pattern.size
  let (r2, _, _) := PieceTree.searchPrev pt.tree pt pattern startExclusive 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchPrev to near boundary" (some startIdx) r2
def test : IO Unit := do
  IO.println "Starting PieceTable Search Test..."
  testCrossLeafSearch
  testCrossLeafSearchNearBoundary
  IO.println "PieceTable Search Test passed!"
end Test.PieceTable.Search
      start := i.toUInt64
      length := (1 : UInt64)
      lineBreaks := (0 : UInt64)
      charCount := (1 : UInt64) }
private theorem twoWayBoundaryWitness :
    ViE.PieceTree.twoWaySearch "abc".toUTF8 ByteArray.empty 1 = some 1 := by
  simp using Proof.PieceTable.Search.twoWaySearch_empty "abc".toUTF8 1
import Proof.PieceTable.Search.TwoWay

File deletion: Appended.lean

BF:BFD[10.6120] → [10.10580:10617]

BF:BFD[10.10617] → [10.10618:10618]

B:BD[10.10618] → [10.10619:11266]

import ViE.Data.PieceTable
import Test.Utils
open ViE
namespace Test.PieceTable.Appended
open Test.Utils
def testAppends : IO Unit := do
  IO.println "testAppends..."
  let pt := PieceTable.fromString "Line1\n"
  -- Append Line 2
  let pt1 := pt.insert pt.length "Line2\n" pt.length
  assertEqual "Append 1" "Line1\nLine2\n" pt1.toString
  -- Append Line 3
  let pt2 := pt1.insert pt1.length "Line3" pt1.length
  assertEqual "Append 2" "Line1\nLine2\nLine3" pt2.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Appended Test..."
  testAppends
  IO.println "PieceTable Appended Test passed!"
end Test.PieceTable.Appended

File deletion: Basic.lean

BF:BFD[10.6120] → [10.9393:9427]

BF:BFD[10.9427] → [10.9428:9428]

B:BD[10.9428] → [10.9429:10579]

import ViE.Data.PieceTable
import Test.Utils
open ViE
namespace Test.PieceTable.Basic
open Test.Utils
def testInsert : IO Unit := do
  IO.println "testInsert..."
  let pt := PieceTable.fromString "Hello"
  -- Insert at end
  let pt1 := pt.insert 5 " World" 5
  assertEqual "Insert at end" "Hello World" pt1.toString
  -- Insert at middle
  let pt2 := pt1.insert 5 "," 5
  assertEqual "Insert at middle" "Hello, World" pt2.toString
  -- Insert at start
  let pt3 := pt2.insert 0 "Say: " 0
  assertEqual "Insert at start" "Say: Hello, World" pt3.toString
def testDelete : IO Unit := do
  IO.println "testDelete..."
  let pt := PieceTable.fromString "Hello, World!"
  -- Delete "World" (offset 7, len 5)
  let pt1 := pt.delete 7 5 7
  assertEqual "Delete middle" "Hello, !" pt1.toString
  -- Delete start
  let pt2 := pt1.delete 0 7 0
  assertEqual "Delete start" "!" pt2.toString
  -- Delete end
  let pt3 := pt2.delete 0 1 0
  assertEqual "Delete end" "" pt3.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Basic Test..."
  testInsert
  testDelete
  IO.println "PieceTable Basic Test passed!"
end Test.PieceTable.Basic

File deletion: Stress.lean

BF:BFD[10.6120] → [10.7904:7939]

BF:BFD[10.7939] → [10.7940:7940]

B:BD[10.7940] → [10.7941:8472]

∅:D[27.1642] → [10.8472:9225]

B:BD[10.8472] → [10.8472:9225]

∅:D[27.2942] → [10.9225:9318]

∅:D[16.27103] → [10.9225:9318]

B:BD[10.9225] → [10.9225:9318]

∅:D[27.2979] → [10.9318:9392]

∅:D[16.27128] → [10.9318:9392]

B:BD[10.9318] → [10.9318:9392]

B:BD[10.9318] → [27.2943:2979]

B:BD[27.2979] → [16.27104:27128]

B:BD[10.9225] → [27.1643:2941]

B:BD[27.2941] → [16.25009:25375]

∅:D[16.25375] → [27.2941:2942]

B:BD[27.2941] → [27.2941:2942]

B:BD[27.2942] → [16.25376:27103]

B:BD[10.8472] → [27.1449:1642]

import ViE.Data.PieceTable
import Test.Utils
open ViE
namespace Test.PieceTable.Stress
open Test.Utils
/-- Naive string manipulation for verification -/
def naiveInsert (s : String) (idx : Nat) (content : String) : String :=
  let lst := s.toList
  let pre := lst.take idx
  let post := lst.drop idx
  String.ofList (pre ++ content.toList ++ post)
def naiveDelete (s : String) (idx : Nat) (len : Nat) : String :=
  let lst := s.toList
  let pre := lst.take idx
  let post := lst.drop (idx + len)
  String.ofList (pre ++ post)
def testConsistency : IO Unit := do
  IO.println "testConsistency (Small Stress)..."
  let mut pt := PieceTable.fromString ""
  let mut mirror := ""
  -- 1. Insert Hello
  pt := pt.insert 0 "Hello" 0
  mirror := naiveInsert mirror 0 "Hello"
  assertEqual "Step 1" mirror pt.toString
  -- 2. Insert World
  pt := pt.insert 5 " World" 5
  mirror := naiveInsert mirror 5 " World"
  assertEqual "Step 2" mirror pt.toString
  -- 3. Delete space at 5
  -- "Hello World" -> "HelloWorld"
  pt := pt.delete 5 1 5
  mirror := naiveDelete mirror 5 1
  assertEqual "Step 3" mirror pt.toString
  -- 4. Insert comma at 5
  -- "HelloWorld" -> "Hello,World"
  pt := pt.insert 5 "," 5
  mirror := naiveInsert mirror 5 ","
  assertEqual "Step 4" mirror pt.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Stress Test..."
  testConsistency
  IO.println "PieceTable Stress Test passed!"
end Test.PieceTable.Stress
  testLengthAndLineCountConsistency
  testYankPasteClearing
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"
def testYankPasteClearing : IO Unit := do
  IO.println "testYankPasteClearing (yy+p reproduction)..."
  -- Simulate: insert 25 'i' chars + newline, then yy+p 4000 times
  let initLine := String.ofList (List.replicate 25 'i') ++ "\n"
  let lineBytes := initLine.toUTF8.size  -- 26 bytes
  let mut pt := PieceTable.fromString initLine
  let mut cursorLine : Nat := 0
  for step in [0:4000] do
    -- 1. yy: read current line content via getLineRange + getBytes (like real editor)
    let range := PieceTree.getLineRange pt.tree cursorLine pt
    match range with
    | none =>
        throw <| IO.userError s!"[YankPaste] getLineRange returned none at step {step}, line {cursorLine}"
    | some (off, len) =>
        let yankedBytes := PieceTree.getBytes pt.tree off len pt
        if yankedBytes.size == 0 then
          throw <| IO.userError s!"[YankPaste] Empty yank at step {step}, line {cursorLine}, off={off} len={len}"
        -- 2. p: paste below current line.
        -- Insert after end of current line (off + len + 1 for newline)
        let insertOffset := off + len + 1
        let insertOffset := min insertOffset pt.length
        let yankStr := (String.fromUTF8! yankedBytes) ++ "\n"
        pt := pt.insert insertOffset yankStr insertOffset
        -- 3. Move cursor to pasted line
        cursorLine := cursorLine + 1
    -- 4. Verify tree length
    let expectedLen := lineBytes * (step + 2)
    let actualLen := pt.length
    if actualLen != expectedLen then
      throw <| IO.userError s!"[YankPaste] Length mismatch at step {step}: expected={expectedLen} actual={actualLen}"
    -- 5. Full consistency check every 500 steps
    if step % 500 == 0 then
      let rendered := pt.toString.toUTF8.size
      if rendered != expectedLen then
        throw <| IO.userError s!"[YankPaste] Rendered mismatch at step {step}: expected={expectedLen} rendered={rendered}"
      IO.println s!"  step {step}: length={actualLen} lines={PieceTree.lineBreaks pt.tree} height={PieceTree.height pt.tree} OK"
  IO.println "[PASS] yank+paste 4000 iterations with getLineRange consistent"
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

File deletion: UndoRedo.lean

BF:BFD[10.6120] → [10.6122:6159]

BF:BFD[10.6159] → [10.6160:6160]

B:BD[10.6160] → [10.6161:7903]

import ViE.Data.PieceTable
import Test.Utils
open ViE
namespace Test.PieceTable.UndoRedo
open Test.Utils
def testUndoRedo : IO Unit := do
  IO.println "testUndoRedo..."
  let pt := PieceTable.fromString ""
  -- Insert "A" at 0
  let pt1 := pt.insert 0 "A" 0
  -- Insert "B" at 0 (Prepend) -> "BA"
  let pt2 := pt1.insert 0 "B" 0
  assertEqual "Initial state" "BA" pt2.toString
  -- Undo B (restores to "A")
  let (pt3, _) := pt2.undo 0
  assertEqual "After Undo 1" "A" pt3.toString
  -- Undo A
  let (pt4, _) := pt3.undo 0
  assertEqual "After Undo 2" "" pt4.toString
  -- Redo A
  let (pt5, _) := pt4.redo 0
  assertEqual "After Redo 1" "A" pt5.toString
  -- Redo B
  let (pt6, _) := pt5.redo 0
  assertEqual "After Redo 2" "BA" pt6.toString
def testComplexUndo : IO Unit := do
  IO.println "testComplexUndo..."
  let pt := PieceTable.fromString "Base"
  let pt1 := pt.insert 4 "1" 4 -- Base1
  let pt1 := pt1.commit -- Prevent merge
  let pt2 := pt1.insert 5 "2" 5 -- Base12
  let pt3 := pt2.delete 5 1 5 -- Base1
  let pt4 := pt3.insert 5 "3" 5 -- Base13
  assertEqual "State before undo" "Base13" pt4.toString
  -- Undo insert "3" -> Base1
  let (u1, _) := pt4.undo 0
  assertEqual "Undo 3" "Base1" u1.toString
  -- Undo delete "2" -> Base12
  let (u2, _) := u1.undo 0
  assertEqual "Undo delete 2" "Base12" u2.toString
  -- Undo insert "2" -> Base1
  let (u3, _) := u2.undo 0
  assertEqual "Undo insert 2" "Base1" u3.toString
  -- Undo insert "1" -> Base
  let (u4, _) := u3.undo 0
  assertEqual "Undo insert 1" "Base" u4.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Undo/Redo Test..."
  testUndoRedo
  testComplexUndo
  IO.println "PieceTable Undo/Redo Test passed!"
end Test.PieceTable.UndoRedo

File deletion: SearchHighlight.lean

BF:BFD[7.10364] → [14.5883:5927]

BF:BFD[14.5927] → [14.5928:5928]

B:BD[14.5928] → [5.10768:10850]

∅:D[5.10850] → [14.5929:5943]

B:BD[14.5928] → [14.5929:5943]

B:BD[14.5943] → [15.95932:95950]

∅:D[15.95950] → [14.5943:6010]

B:BD[14.5943] → [14.5943:6010]

B:BD[14.6010] → [15.95951:95960]

∅:D[15.95960] → [14.6010:6923]

B:BD[14.6010] → [14.6010:6923]

B:BD[14.6923] → [15.95961:96678]

∅:D[23.24772] → [15.96678:97240]

B:BD[15.96678] → [15.96678:97240]

B:BD[15.96678] → [23.24330:24772]

∅:D[15.97240] → [14.6923:6924]

B:BD[14.6923] → [14.6923:6924]

B:BD[14.6924] → [15.97241:97739]

B:BD[15.97739] → [22.37219:37352]

∅:D[22.37352] → [14.6924:6949]

∅:D[15.97739] → [14.6924:6949]

B:BD[14.6924] → [14.6924:6949]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.UI
import ViE.Config
import Test.Utils
namespace Test.SearchHighlight
open Test.Utils
open ViE
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
  let s0 := ViE.startOrUpdateSearch ViE.initialState "abc" .forward false
  let (m1, s1) := ViE.UI.getLineSearchMatches s0 s0.getActiveBuffer.id 0 "abc abc"
  assertEqual "Line search cache computes matches" true (m1.size > 0)
  let cachedBeforeSwitch :=
    match s1.searchState with
    | some ss => ss.lineMatches.contains 0
    | none => false
  assertEqual "Line search cache populated" true cachedBeforeSwitch
  let s2 := ViE.UI.ensureSearchLineCacheForBuffer s1 9999
  let cacheClearedOnSwitch :=
    match s2.searchState with
    | some ss => ss.lineMatches.isEmpty && ss.lineCacheBufferId == some 9999
    | none => false
  assertEqual "Line search cache resets on buffer switch" true cacheClearedOnSwitch
  let t0 := 1000
  let (p0, k0) := ViE.parseKey ViE.initialState '\x1b' t0
  let (p1, k1) := ViE.parseKey p0 '[' (t0 + 1)
  let (p2, k2) := ViE.parseKey p1 '1' (t0 + 2)
  let (p3, k3) := ViE.parseKey p2 ';' (t0 + 3)
  let (p4, k4) := ViE.parseKey p3 '2' (t0 + 4)
  let (p5, k5) := ViE.parseKey p4 'X' (t0 + 5)
  assertEqual "Unknown CSI emits no keys while pending" ([] : List Key) (k0 ++ k1 ++ k2 ++ k3 ++ k4)
  assertEqual "Unknown CSI final emits Key.unknown" [Key.unknown 'X'] k5
  assertEqual "Unknown CSI clears pending state" "" p5.inputState.pendingKeys
  let sInc0 := ViE.startOrUpdateSearch ViE.initialState "abc" .forward false
  let sInc1 := {
    sInc0 with
      mode := .searchForward
      inputState := { sInc0.inputState with commandBuffer := "" }
  }
  let sInc2 := ViE.runIncrementalSearch sInc1
  let incCleared :=
    match sInc2.searchState with
    | none => true
    | some _ => false
  assertEqual "Incremental search with empty pattern clears highlight state" true incCleared
  let chars : List Char := ['\x1b', '[', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3']
  let (pLong, emitted) := chars.foldl
    (fun (acc : EditorState × List Key) ch =>
      let (st, out) := acc
      let (st', keys) := ViE.parseKey st ch (t0 + 20)
      (st', out ++ keys))
    (ViE.initialState, [])
  assertEqual "Overlong unknown CSI flushes emitted keys" true (!emitted.isEmpty)
  assertEqual "Overlong unknown CSI clears pending state" "" pLong.inputState.pendingKeys
  let (_, tabKeys) := ViE.parseKey ViE.initialState '\x09' (t0 + 30)
  assertEqual "Tab parses as char tab" [Key.char '\t'] tabKeys
end Test.SearchHighlight

File deletion: Utils.lean

BF:BFD[7.10364] → [10.4312:4346]

BF:BFD[10.4346] → [10.4347:4347]

B:BD[10.4347] → [5.10353:10435]

∅:D[5.10435] → [10.4348:6044]

B:BD[10.4347] → [10.4348:6044]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Types
import ViE.Buffer.Content
import ViE.State.Layout
import ViE.State.Movement
namespace Test.Utils
/-- Assert condition is true, throw error if false -/
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
/-- Assert equality with debug output -/
def assertEqual [Repr α] [BEq α] (msg : String) (expected actual : α) : IO Unit := do
  if expected == actual then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    IO.println s!"  Expected: {repr expected}"
    IO.println s!"  Actual:   {repr actual}"
    throw (IO.userError s!"Assertion failed: {msg}")
/-- Assert EditorState buffer content matches expected string -/
def assertBuffer (msg : String) (est : ViE.EditorState) (expected : String) : IO Unit := do
  let actual := est.getActiveBuffer.table.toString
  if actual == expected then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    IO.println s!"  Expected: '{expected}'"
    IO.println s!"  Actual:   '{actual}'"
    throw (IO.userError s!"Buffer content assertion failed: {msg}")
/-- Assert EditorState cursor position matches expected row/col -/
def assertCursor (msg : String) (est : ViE.EditorState) (r c : Nat) : IO Unit := do
  let cursor := est.getCursor
  if cursor.row.val == r && cursor.col.val == c then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    IO.println s!"  Expected: ({r}, {c})"
    IO.println s!"  Actual:   ({cursor.row.val}, {cursor.col.val})"
    throw (IO.userError s!"Cursor assertion failed: {msg}")
end Test.Utils

File deletion: Lsp.lean

BF:BFD[7.10364] → [18.3487:3519]

BF:BFD[18.3519] → [18.3520:3520]

B:BD[18.3520] → [5.11693:11775]

∅:D[5.11775] → [18.3521:4274]

B:BD[18.3520] → [18.3521:4274]

∅:D[21.2313] → [18.4274:5514]

B:BD[18.4274] → [18.4274:5514]

B:BD[18.4274] → [21.1925:2313]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE
import Test.Utils
namespace Test.Lsp
open Test.Utils
def test : IO Unit := do
  IO.println "Starting LSP Test..."
  let leanBuf := { ViE.initialBuffer with filename := some "Main.lean" }
  let txtBuf := { ViE.initialBuffer with filename := some "notes.txt" }
  assertEqual "isLeanBuffer true for .lean" true (ViE.Lsp.Lean.isLeanBuffer leanBuf)
  assertEqual "isLeanBuffer false for non-.lean" false (ViE.Lsp.Lean.isLeanBuffer txtBuf)
  let uriAbs := ViE.Lsp.Lean.fileUri "/tmp/a b#c%.lean"
  assertEqual "fileUri percent-encodes reserved bytes" "file:///tmp/a%20b%23c%25.lean" uriAbs
  let uriRel := ViE.Lsp.Lean.fileUri "tmp/test.lean"
  assertEqual "fileUri normalizes relative path with leading slash" "file:///tmp/test.lean" uriRel
  let okResp : Lean.Json := Lean.Json.mkObj [("id", (12 : Lean.Json)), ("result", Lean.Json.null)]
  let errResp : Lean.Json := Lean.Json.mkObj [("id", (13 : Lean.Json)), ("error", Lean.Json.mkObj [("code", (1 : Lean.Json))])]
  let notif : Lean.Json := Lean.Json.mkObj [("method", .str "textDocument/publishDiagnostics"), ("params", Lean.Json.mkObj [])]
  assertEqual "responseId? parses result response id" (some 12) (ViE.Lsp.Lean.responseId? okResp)
  assertEqual "responseId? parses error response id" (some 13) (ViE.Lsp.Lean.responseId? errResp)
  assertEqual "responseId? is none for notifications" (none : Option Nat) (ViE.Lsp.Lean.responseId? notif)
  assertEqual "isResponseForRequest true for same id" true (ViE.Lsp.Lean.isResponseForRequest okResp 12)
  assertEqual "isResponseForRequest false for different id" false (ViE.Lsp.Lean.isResponseForRequest okResp 99)
  let s0 := ViE.initialState
  let sStatus ← ViE.Lsp.Lean.cmdLsp ["status"] s0
  assertEqual "lsp status reports stopped when no session" "LSP: stopped" sStatus.message
  let sStop ← ViE.Lsp.Lean.cmdLsp ["stop"] s0
  assertEqual "lsp stop reports not running when no session" "LSP is not running" sStop.message
  IO.println "LSP Test passed!"
end Test.Lsp
  let uriWs ← ViE.Lsp.Lean.fileUriWithWorkspace (some "/tmp/ws") "dir/a b.lean"
  assertEqual "fileUriWithWorkspace resolves relative path from workspace root" "file:///tmp/ws/dir/a%20b.lean" uriWs
  let uriWsAbs ← ViE.Lsp.Lean.fileUriWithWorkspace (some "/tmp/ws") "/tmp/alt/x.lean"
  assertEqual "fileUriWithWorkspace keeps absolute path priority" "file:///tmp/alt/x.lean" uriWsAbs

Replacement in lakefile.lean at line 14 [30.38]
B:BD[30.236] → [30.236:250]
```
lean_lib Test
```
[30.236]
[5.350]
```
lean_lib ViETest
```
Replacement in lakefile.lean at line 23 [30.38]
B:BD[30.325] → [30.325:341]
```
  root := `Test
```
[30.325]
[30.341]
```
  root := `ViETest
```
Replacement in lakefile.lean at line 26 [30.38]
B:BD[30.363] → [30.363:389]
```
  root := `Test.Benchmark
```
[30.363]
[5.367]
```
  root := `ViETest.Benchmark
```
File addition: ViETest (d--x------)
[6.1]
File addition: test_paths (d--x------)
[0.87]

File addition: file0.txt (----------)

[0.111]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File addition: dir0 (d--x------)
[0.111]

File addition: file3.txt (----------)

[0.1958]

let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))

File addition: file2.txt (----------)

[0.1958]

module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values

File addition: file1.txt (----------)

[0.1958]

#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}

File addition: file0.txt (----------)

[0.1958]

import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample

File addition: dir2 (d--x------)
[0.1958]
File addition: dir1 (d--x------)
[0.1958]

File addition: file5.txt (----------)

[0.8138]

let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))
let rec fib n =
  if n <= 1 then n
  else fib (n - 1) + fib (n - 2)
let () =
  let values = List.init 16 fib in
  Printf.printf "fib(0..15) = %s\n" (String.concat ", " (List.map string_of_int values))

File addition: file4.txt (----------)

[0.8138]

module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values
module Main where
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
main :: IO ()
main = do
  let values = map fib [0..15]
  putStrLn $ "fib(0..15) = " ++ show values

File addition: file3.txt (----------)

[0.8138]

#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}

File addition: file2.txt (----------)

[0.8138]

import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample

File addition: file1.txt (----------)

[0.8138]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File addition: dir3 (d--x------)
[0.8138]

File addition: file0.txt (----------)

[0.16128]

#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}
#include <stdio.h>
#include <stdlib.h>
static int is_even(int n) {
  return n % 2 == 0;
}
int main(void) {
  int sum = 0;
  for (int i = 0; i < 100; i++) {
    if (is_even(i)) sum += i;
  }
  printf("sum of even numbers < 100: %d\n", sum);
  return 0;
}

File addition: dir2 (d--x------)
[0.8138]

File addition: file0.txt (----------)

[0.17730]

import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample
import Std
namespace Sample
def fib : Nat → Nat
  | 0 => 0
  | 1 => 1
  | n + 2 => fib (n + 1) + fib n
def isEven : Nat → Bool
  | 0 => true
  | 1 => false
  | n + 2 => isEven n
def main : IO Unit := do
  let values := (List.range 20).map fib
  IO.println s!"fib(0..19) = {values}"
  IO.println s!"isEven 42 = {isEven 42}"
end Sample

File addition: dir1 (d--x------)
[0.8138]

File addition: file0.txt (----------)

[0.19854]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File addition: dir0 (d--x------)
[0.8138]

File addition: file0.txt (----------)

[0.21700]

(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)

File addition: dir0 (d--x------)
[0.1958]

File addition: file1.txt (----------)

[0.22636]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File addition: file0.txt (----------)

[0.22636]

(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))
(display "fib(0..10) = ")
(display (map fib (iota 11)))
(newline)

File addition: dir0 (d--x------)
[0.22636]

File addition: file0.txt (----------)

[0.25400]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

File addition: Workspace.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.State.Layout
import ViE.Workspace
import ViE.Command.Impl
import ViE.App
import ViE.Buffer.Content
import ViE.Basic
import ViETest.Utils
set_option maxRecDepth 2048
namespace ViETest.Workspace
open ViETest.Utils
open ViE
def addWorkspace (state : EditorState) (ws : WorkspaceState) : EditorState :=
  state.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := wg.workspaces.push ws }
def switchWorkspace (state : EditorState) (idx : Nat) : EditorState :=
  state.updateCurrentWorkgroup fun wg =>
    if idx < wg.workspaces.size then
      { wg with currentWorkspace := idx }
    else
      wg
def test : IO Unit := do
  IO.println "Starting Workspace ViETest..."
  let s0 := { ViE.initialState with windowHeight := 40, windowWidth := 120 }
  let wg0 := s0.getCurrentWorkgroup
  assertEqual "Initial workgroups size" 10 s0.workgroups.size
  assertEqual "Initial workgroup count" 1 wg0.workspaces.size
  assertEqual "Initial workspace index" 0 wg0.currentWorkspace
  assertEqual "Initial workspace name" "ViE" s0.getCurrentWorkspace.name
  let ws1 := makeWorkspaceState "Project A" (some "/tmp/project-a") 10
  let s1 := addWorkspace s0 ws1
  let wg1 := s1.getCurrentWorkgroup
  assertEqual "Workgroup has 2 workspaces" 2 wg1.workspaces.size
  let s2 := switchWorkspace s1 1
  assertEqual "Switched to workspace 1" "Project A" s2.getCurrentWorkspace.name
  assertEqual "Active buffer comes from workspace 1" 10 (s2.getActiveBuffer.id)
  let resolved := s2.getCurrentWorkspace.resolvePath "file.txt"
  assertEqual "ResolvePath uses workspace root" "/tmp/project-a/file.txt" resolved
  let resolvedAbs := s2.getCurrentWorkspace.resolvePath "/abs/file.txt"
  assertEqual "ResolvePath keeps absolute path" "/abs/file.txt" resolvedAbs
  IO.println "Starting Workspace Command ViETest..."
  let s3 ← ViE.Command.cmdWs ["new", "Project B", "/tmp/project-b"] s2
  assertEqual "Workspace created and switched" "Project B" s3.getCurrentWorkspace.name
  assertEqual "Workspace rootPath set" (some "/tmp/project-b") s3.getCurrentWorkspace.rootPath
  assertEqual "Active buffer id is new workspace buffer" 11 s3.getActiveBuffer.id
  let s4 ← ViE.Command.cmdWs ["rename", "Project B2"] s3
  assertEqual "Workspace rename applied" "Project B2" s4.getCurrentWorkspace.name
  let s5 ← ViE.Command.cmdWs ["new", "Project C"] s4
  assertEqual "Workspace C created" "Project C" s5.getCurrentWorkspace.name
  let s6 ← ViE.Command.cmdWs ["prev"] s5
  assertEqual "Workspace prev switches back" "Project B2" s6.getCurrentWorkspace.name
  let s7 ← ViE.Command.cmdWs ["0"] s6
  assertEqual "Workspace switch by index" "ViE" s7.getCurrentWorkspace.name
  let s8 ← ViE.Command.cmdWs ["list"] s7
  assertEqual "Workspace list opens explorer buffer" (some "explorer://workgroup") s8.getActiveBuffer.filename
  let ws8 := s8.getCurrentWorkspace
  assertEqual "Workspace explorer opens in regular window" false (ws8.isFloatingWindow ws8.activeWindowId)
  let wsListText := s8.getActiveBuffer.table.toString
  assertEqual "Workspace list contains New Workspace entry" true (wsListText.contains "[New Workspace]")
  assertEqual "Workspace list contains Rename Workspace entry" true (wsListText.contains "[Rename Workspace]")
  assertEqual "Workspace list contains Project B2" true (wsListText.contains "Project B2")
  assertEqual "Workspace list marks current workspace" true (wsListText.contains "*")
  let s8a := s8.updateActiveView fun v => { v with cursor := {row := ⟨2⟩, col := 0} }
  let s8b ← ViE.Feature.handleExplorerEnter s8a
  assertEqual "New workspace opens floating input" true s8b.floatingOverlay.isSome
  assertEqual "New workspace floating command prefix" (some "ws new ") s8b.floatingInputCommand
  let s8c := s8.updateActiveView fun v => { v with cursor := {row := ⟨3⟩, col := 0} }
  let s8d ← ViE.Feature.handleExplorerEnter s8c
  assertEqual "Rename workspace opens floating input" true s8d.floatingOverlay.isSome
  assertEqual "Rename workspace floating command prefix" (some "ws rename ") s8d.floatingInputCommand
  let s8e ← ViE.Command.cmdWorkspace ["rename", ""] s8
  assertEqual "Rename workspace rejects empty" "Workspace name cannot be empty" s8e.message
  let s8f ← ViE.Command.cmdWorkspace ["rename", "Project B2"] s8
  assertEqual "Rename workspace rejects duplicate" true (s8f.message.contains "already exists")
  let s9 ← ViE.Command.cmdWs ["open", "/tmp/project-d"] s8
  assertEqual "Workspace open uses path name" "project-d" s9.getCurrentWorkspace.name
  assertEqual "Workspace open rootPath set" (some "/tmp/project-d") s9.getCurrentWorkspace.rootPath
  let s10 ← ViE.Command.cmdWs ["open", "--name", "Project E", "/tmp/project-e"] s9
  assertEqual "Workspace open --name prefix" "Project E" s10.getCurrentWorkspace.name
  assertEqual "Workspace open --name prefix rootPath" (some "/tmp/project-e") s10.getCurrentWorkspace.rootPath
  let s11 ← ViE.Command.cmdWs ["open", "/tmp/project-f", "--name", "Project F"] s10
  assertEqual "Workspace open --name suffix" "Project F" s11.getCurrentWorkspace.name
  assertEqual "Workspace open --name suffix rootPath" (some "/tmp/project-f") s11.getCurrentWorkspace.rootPath
  IO.println "Starting Workspace Relative Path Resolution ViETest..."
  let stamp ← IO.monoMsNow
  let relBase := s!"/tmp/vie-ws-rel-{stamp}"
  IO.FS.createDirAll (System.FilePath.mk relBase)
  let sRel0 := s11.updateCurrentWorkspace fun ws =>
    { ws with rootPath := some relBase, name := "RelBase" }
  let sRel1 ← ViE.Command.cmdCd ["child"] sRel0
  assertEqual "cd relative resolves from workspace root" (some s!"{relBase}/child") sRel1.getCurrentWorkspace.rootPath
  let sRel2 ← ViE.Command.cmdWs ["open", "nested"] sRel0
  assertEqual "ws open relative resolves from workspace root" (some s!"{relBase}/nested") sRel2.getCurrentWorkspace.rootPath
  assertEqual "ws open relative uses basename from absolute path" "nested" sRel2.getCurrentWorkspace.name
  let sRel3 ← ViE.Command.cmdWs ["new", "RelChild", "child2"] sRel0
  assertEqual "ws new relative resolves from workspace root" (some s!"{relBase}/child2") sRel3.getCurrentWorkspace.rootPath
  let s12 ← ViE.Command.cmdWs ["close"] s11
  assertEqual "Workspace close switches to previous" "Project E" s12.getCurrentWorkspace.name
  IO.println "Starting Workspace Explorer Preview ViETest..."
  let bufP1 : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 1 (some "/tmp/a.txt") #[stringToLine "A"]
  let bufP2 : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 2 (some "/tmp/b.txt") #[stringToLine "B"]
  let wsP : WorkspaceState := {
    name := "WS-P"
    rootPath := none
    buffers := [bufP1, bufP2]
    nextBufferId := 3
    layout := .window 0 { initialView with bufferId := 1 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let s12a := addWorkspace s12 wsP
  let wgP := s12a.getCurrentWorkgroup
  let idxP := if wgP.workspaces.size == 0 then 0 else wgP.workspaces.size - 1
  let s12b := switchWorkspace s12a idxP
  let s12c ← ViE.Feature.openWorkspaceExplorer s12b
  let explorerOpt := s12c.explorers.find? (fun (id, _) => id == s12c.getActiveBuffer.id)
  match explorerOpt with
  | none => throw (IO.userError "Workspace explorer not registered")
  | some (_, explorer) =>
    assertEqual "Workspace explorer preview window exists" true explorer.previewWindowId.isSome
    let previewWinId := explorer.previewWindowId.get!
    let wsPrev := s12c.getCurrentWorkspace
    assertEqual "Workspace explorer preview window is regular" false (wsPrev.isFloatingWindow previewWinId)
    let pairSideBySide :=
      match (ViE.Window.getAllWindowBounds wsPrev.layout (if s12c.windowHeight > 0 then s12c.windowHeight - 1 else 0) s12c.windowWidth).find? (fun (id, _, _, _, _) => id == wsPrev.activeWindowId),
            (ViE.Window.getAllWindowBounds wsPrev.layout (if s12c.windowHeight > 0 then s12c.windowHeight - 1 else 0) s12c.windowWidth).find? (fun (id, _, _, _, _) => id == previewWinId) with
      | some (_, et, el, eh, ew), some (_, pt, pl, ph, pw) =>
          et == pt && eh == ph && ((el + ew <= pl) || (pl + pw <= el))
      | _, _ => false
    assertEqual "Workspace explorer/preview pair is side-by-side" true pairSideBySide
    let previewView := wsPrev.layout.findView previewWinId |>.getD initialView
    let previewBuf := wsPrev.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
    let previewText := previewBuf.table.toString
    assertEqual "Workspace preview includes a.txt" true (previewText.contains "/tmp/a.txt")
    assertEqual "Workspace preview includes b.txt" true (previewText.contains "/tmp/b.txt")
  IO.println "Starting Workspace Restore ViETest..."
  let bufA : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 0 none #[stringToLine "WS-A"]
  let bufB : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 10 none #[stringToLine "WS-B"]
  let wsA : WorkspaceState := {
    name := "WS-A"
    rootPath := none
    buffers := [bufA]
    nextBufferId := 1
    layout := .window 0 { initialView with bufferId := 0 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let wsB : WorkspaceState := {
    name := "WS-B"
    rootPath := none
    buffers := [bufB]
    nextBufferId := 11
    layout := .window 0 { initialView with bufferId := 10 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let s12a := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsB], currentWorkspace := 0 }
  let s12b ← ViE.Feature.openWorkspaceExplorer s12a
  let s12c := s12b.updateActiveView fun v => { v with cursor := {row := ⟨5⟩, col := 0} }
  let s12d ← ViE.Feature.handleExplorerEnter s12c
  assertEqual "Workspace selection switches current workspace" "WS-B" s12d.getCurrentWorkspace.name
  assertEqual "Workspace selection restores active buffer" "WS-B" s12d.getActiveBuffer.table.toString
  IO.println "Starting Workspace Restore Layout ViETest..."
  let bufC : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 20 none #[stringToLine "WS-C1"]
  let bufD : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 21 none #[stringToLine "WS-C2"]
  let layoutC : Layout :=
    .hsplit
      (.window 0 { initialView with bufferId := 20 })
      (.window 1 { initialView with bufferId := 21, cursor := ⟨⟨0⟩, ⟨2⟩⟩ })
      0.3
  let wsC : WorkspaceState := {
    name := "WS-C"
    rootPath := none
    buffers := [bufC, bufD]
    nextBufferId := 22
    layout := layoutC
    activeWindowId := 1
    nextWindowId := 2
  }
  let s12e := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsC], currentWorkspace := 0 }
  let s12f ← ViE.Feature.openWorkspaceExplorer s12e
  let s12g := s12f.updateActiveView fun v => { v with cursor := {row := ⟨5⟩, col := 0} }
  let s12h ← ViE.Feature.handleExplorerEnter s12g
  assertEqual "Workspace layout restore (active buffer)" "WS-C2" s12h.getActiveBuffer.table.toString
  let ratio := match s12h.getCurrentWorkspace.layout with
    | .hsplit _ _ r => r
    | _ => 0.0
  assertEqual "Workspace layout restore (ratio)" 0.3 ratio
  let cursor := s12h.getCursor
  assertEqual "Workspace layout restore (cursor row)" 0 cursor.row.val
  assertEqual "Workspace layout restore (cursor col)" 2 cursor.col.val
  IO.println "Starting Workspace Restore VSplit ViETest..."
  let bufE : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 30 none #[stringToLine "WS-D1"]
  let bufF : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 31 none #[stringToLine "WS-D2"]
  let layoutD : Layout :=
    .vsplit
      (.window 0 { initialView with bufferId := 30, cursor := ⟨⟨1⟩, ⟨0⟩⟩, scrollRow := ⟨1⟩, scrollCol := ⟨2⟩ })
      (.window 1 { initialView with bufferId := 31, cursor := ⟨⟨2⟩, ⟨3⟩⟩, scrollRow := ⟨0⟩, scrollCol := ⟨1⟩ })
      0.7
  let wsD : WorkspaceState := {
    name := "WS-D"
    rootPath := none
    buffers := [bufE, bufF]
    nextBufferId := 32
    layout := layoutD
    activeWindowId := 1
    nextWindowId := 2
  }
  let s12i := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsC, wsD], currentWorkspace := 0 }
  let s12j ← ViE.Feature.openWorkspaceExplorer s12i
  let s12k := s12j.updateActiveView fun v => { v with cursor := {row := ⟨6⟩, col := 0} }
  let s12l ← ViE.Feature.handleExplorerEnter s12k
  assertEqual "Workspace vsplit restore (active buffer)" "WS-D2" s12l.getActiveBuffer.table.toString
  let ratio2 := match s12l.getCurrentWorkspace.layout with
    | .vsplit _ _ r => r
    | _ => 0.0
  assertEqual "Workspace vsplit restore (ratio)" 0.7 ratio2
  let cursor2 := s12l.getCursor
  assertEqual "Workspace vsplit restore (cursor row)" 2 cursor2.row.val
  assertEqual "Workspace vsplit restore (cursor col)" 3 cursor2.col.val
  let (sRow, sCol) := s12l.getScroll
  assertEqual "Workspace vsplit restore (scroll row)" 0 sRow.val
  assertEqual "Workspace vsplit restore (scroll col)" 1 sCol.val
  IO.println "Starting Workspace Multi-View Restore ViETest..."
  let bufG : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 40 none #[stringToLine "WS-E1"]
  let bufH : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 41 none #[stringToLine "WS-E2"]
  let bufI : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 42 none #[stringToLine "WS-E3"]
  let layoutE : Layout :=
    .hsplit
      (.vsplit
        (.window 0 { initialView with bufferId := 40, cursor := ⟨⟨0⟩, ⟨1⟩⟩, scrollRow := ⟨0⟩, scrollCol := ⟨0⟩ })
        (.window 1 { initialView with bufferId := 41, cursor := ⟨⟨2⟩, ⟨2⟩⟩, scrollRow := ⟨1⟩, scrollCol := ⟨1⟩ })
        0.4)
      (.window 2 { initialView with bufferId := 42, cursor := ⟨⟨3⟩, ⟨0⟩⟩, scrollRow := ⟨2⟩, scrollCol := ⟨2⟩ })
      0.6
  let wsE : WorkspaceState := {
    name := "WS-E"
    rootPath := none
    buffers := [bufG, bufH, bufI]
    nextBufferId := 43
    layout := layoutE
    activeWindowId := 1
    nextWindowId := 3
  }
  let s12m := s12.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := #[wsA, wsC, wsD, wsE], currentWorkspace := 0 }
  let s12n ← ViE.Feature.openWorkspaceExplorer s12m
  let s12o := s12n.updateActiveView fun v => { v with cursor := {row := ⟨7⟩, col := 0} }
  let s12p ← ViE.Feature.handleExplorerEnter s12o
  assertEqual "Multi-view restore (active buffer)" "WS-E2" s12p.getActiveBuffer.table.toString
  let (sr2, sc2) := s12p.getScroll
  assertEqual "Multi-view restore (scroll row)" 1 sr2.val
  assertEqual "Multi-view restore (scroll col)" 1 sc2.val
  let cursor3 := s12p.getCursor
  assertEqual "Multi-view restore (cursor row)" 2 cursor3.row.val
  assertEqual "Multi-view restore (cursor col)" 2 cursor3.col.val
  assertEqual "Multi-view restore (layout hsplit ratio)" 0.6 (match s12p.getCurrentWorkspace.layout with | .hsplit _ _ r => r | _ => 0.0)
  let subRatio := match s12p.getCurrentWorkspace.layout with
    | .hsplit left _ _ =>
        match left with
        | .vsplit _ _ r => r
        | _ => 0.0
    | _ => 0.0
  assertEqual "Multi-view restore (layout vsplit ratio)" 0.4 subRatio
  IO.println "Starting Workspace Startup Target ViETest..."
  let base := "ViETest/test_paths"
  let absBase ← ViE.resolveAbsolutePath none base
  let dirOnly := s!"{base}/dir0"
  let absDirOnly ← ViE.resolveAbsolutePath none dirOnly
  let (wsDirOnly, fileDirOnly) ← ViE.resolveStartupTarget (some dirOnly)
  assertEqual "Directory arg sets workspace" (some absDirOnly) wsDirOnly
  assertEqual "Directory arg has no file" none fileDirOnly
  let fileNested := s!"{base}/dir0/dir1/dir2/file0.txt"
  let absFileNested ← ViE.resolveAbsolutePath none fileNested
  let nestedParent := match (System.FilePath.mk absFileNested).parent with
    | some p => p.toString
    | none => "/"
  let (wsFileNested, fileFileNested) ← ViE.resolveStartupTarget (some fileNested)
  assertEqual "File arg sets workspace to parent dir" (some nestedParent) wsFileNested
  assertEqual "File arg keeps filename" (some absFileNested) fileFileNested
  let fileTop := s!"{base}/file0.txt"
  let absFileTop ← ViE.resolveAbsolutePath none fileTop
  let (wsFileTop, fileFileTop) ← ViE.resolveStartupTarget (some fileTop)
  assertEqual "Top-level file sets workspace to base" (some absBase) wsFileTop
  assertEqual "Top-level file keeps filename" (some absFileTop) fileFileTop
  let newNested := s!"{base}/newdir/newfile.txt"
  let absNewNested ← ViE.resolveAbsolutePath none newNested
  let newNestedParent := match (System.FilePath.mk absNewNested).parent with
    | some p => p.toString
    | none => "/"
  let (wsNewNested, fileNewNested) ← ViE.resolveStartupTarget (some newNested)
  assertEqual "Nonexistent file sets workspace to parent dir" (some newNestedParent) wsNewNested
  assertEqual "Nonexistent file keeps absolute filename" (some absNewNested) fileNewNested
  IO.println "Starting Explorer Path Resolution ViETest..."
  let absTest ← ViE.resolveAbsolutePath none "ViETest"
  let s13 := s12.updateCurrentWorkspace fun ws =>
    { ws with rootPath := some absTest, name := "Test" }
  let s14 ← ViE.Feature.openExplorer s13 "."
  assertEqual "Explorer opens absolute workspace root from dot" (some s!"explorer://{absTest}") s14.getActiveBuffer.filename
  let s15 ← ViE.Feature.openExplorer s13 "test_paths"
  assertEqual "Explorer resolves relative path from absolute workspace root" (some s!"explorer://{absTest}/test_paths") s15.getActiveBuffer.filename
  IO.println "WorkspaceTest passed!"
end ViETest.Workspace

File addition: WorkgroupExplorer.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.State.Layout
import ViE.Command.Explorer
import ViE.State.Config
import ViE.Command.Impl
import ViETest.Utils
namespace ViETest.WorkgroupExplorer
open ViETest.Utils
open ViE
def addWorkspace (state : EditorState) (ws : WorkspaceState) : EditorState :=
  state.updateCurrentWorkgroup fun wg =>
    { wg with workspaces := wg.workspaces.push ws }
def addWorkgroup (state : EditorState) (name : String) : EditorState :=
  let nextBufId := state.workgroups.foldl (fun m g =>
    g.workspaces.foldl (fun m2 ws => max m2 ws.nextBufferId) m) 0
  let newWg := createEmptyWorkgroup name nextBufId
  { state with workgroups := state.workgroups.push newWg }
def setCursorRow (state : EditorState) (row : Nat) : EditorState :=
  state.updateActiveView fun v => { v with cursor := { v.cursor with row := ⟨row⟩ } }
def test : IO Unit := do
  IO.println "Starting Workgroup Explorer ViETest..."
  let s0 := { ViE.initialState with windowHeight := 40, windowWidth := 120 }
  let ws1 := makeWorkspaceState "Project A" (some "/tmp/project-a") 10
  let ws2 := makeWorkspaceState "Project B" (some "/tmp/project-b") 20
  let s1 := addWorkspace (addWorkspace s0 ws1) ws2
  let s1 := addWorkgroup s1 "Group B"
  let s1 := addWorkgroup s1 "Group C"
  let s2 ← ViE.Command.cmdWg ["list"] s1
  assertEqual "Explorer buffer is active" (some "explorer://workgroups") s2.getActiveBuffer.filename
  let ws2 := s2.getCurrentWorkspace
  assertEqual "Workgroup explorer opens in regular window" false (ws2.isFloatingWindow ws2.activeWindowId)
  let bufText := s2.getActiveBuffer.table.toString
  assertEqual "Explorer contains Workgroup header" true (bufText.contains "Workgroup Explorer")
  assertEqual "Explorer contains New Workgroup entry" true (bufText.contains "[New Workgroup]")
  assertEqual "Explorer contains Rename Workgroup entry" true (bufText.contains "[Rename Workgroup]")
  assertEqual "Explorer contains Group 0" true (bufText.contains "0")
  assertEqual "Explorer contains Group B" true (bufText.contains "Group B")
  assertEqual "Explorer marks current workgroup" true (bufText.contains "*")
  let explorerOpt := s2.explorers.find? (fun (id, _) => id == s2.getActiveBuffer.id)
  match explorerOpt with
  | none => throw (IO.userError "Workgroup explorer not registered")
  | some (_, explorer) =>
    assertEqual "Workgroup explorer preview window exists" true explorer.previewWindowId.isSome
    let previewWinId := explorer.previewWindowId.get!
    let wsPrev := s2.getCurrentWorkspace
    assertEqual "Workgroup explorer preview window is regular" false (wsPrev.isFloatingWindow previewWinId)
    let pairSideBySide :=
      match (ViE.Window.getAllWindowBounds wsPrev.layout (if s2.windowHeight > 0 then s2.windowHeight - 1 else 0) s2.windowWidth).find? (fun (id, _, _, _, _) => id == wsPrev.activeWindowId),
            (ViE.Window.getAllWindowBounds wsPrev.layout (if s2.windowHeight > 0 then s2.windowHeight - 1 else 0) s2.windowWidth).find? (fun (id, _, _, _, _) => id == previewWinId) with
      | some (_, et, el, eh, ew), some (_, pt, pl, ph, pw) =>
          et == pt && eh == ph && ((el + ew <= pl) || (pl + pw <= el))
      | _, _ => false
    assertEqual "Workgroup explorer/preview pair is side-by-side" true pairSideBySide
    let previewView := wsPrev.layout.findView previewWinId |>.getD initialView
    let previewBuf := wsPrev.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
    let previewText := previewBuf.table.toString
    assertEqual "Workgroup preview includes Project A" true (previewText.contains "Project A")
    assertEqual "Workgroup preview includes Project B" true (previewText.contains "Project B")
  let s3 := setCursorRow s2 2
  let s4 ← ViE.Feature.handleExplorerEnter s3
  assertEqual "New workgroup opens floating input" true s4.floatingOverlay.isSome
  assertEqual "New workgroup floating command prefix" (some "wg new ") s4.floatingInputCommand
  let s3b := setCursorRow s2 3
  let s4b ← ViE.Feature.handleExplorerEnter s3b
  assertEqual "Rename workgroup opens floating input" true s4b.floatingOverlay.isSome
  assertEqual "Rename workgroup floating command prefix" (some "wg rename ") s4b.floatingInputCommand
  let s4c ← ViE.Command.cmdWg ["rename", ""] s2
  assertEqual "Rename workgroup rejects empty" "Workgroup name cannot be empty" s4c.message
  let s4d ← ViE.Command.cmdWg ["rename", "Group B"] s2
  assertEqual "Rename workgroup rejects duplicate" true (s4d.message.contains "already exists")
  let s5 ← ViE.Command.cmdWg ["list"] s1
  let s6 := setCursorRow s5 5
  let s7 ← ViE.Feature.handleExplorerEnter s6
  assertEqual "Switched to workgroup index 1" 1 s7.currentGroup
  assertEqual "Switch restores workgroup layout" true (s7.getActiveBuffer.filename != some "explorer://workgroup")
  IO.println "WorkgroupExplorerTest passed!"
end ViETest.WorkgroupExplorer

File addition: Utils.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Types
import ViE.Buffer.Content
import ViE.State.Layout
import ViE.State.Movement
namespace ViETest.Utils
/-- Assert condition is true, throw error if false -/
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
/-- Assert equality with debug output -/
def assertEqual [Repr α] [BEq α] (msg : String) (expected actual : α) : IO Unit := do
  if expected == actual then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    IO.println s!"  Expected: {repr expected}"
    IO.println s!"  Actual:   {repr actual}"
    throw (IO.userError s!"Assertion failed: {msg}")
/-- Assert EditorState buffer content matches expected string -/
def assertBuffer (msg : String) (est : ViE.EditorState) (expected : String) : IO Unit := do
  let actual := est.getActiveBuffer.table.toString
  if actual == expected then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    IO.println s!"  Expected: '{expected}'"
    IO.println s!"  Actual:   '{actual}'"
    throw (IO.userError s!"Buffer content assertion failed: {msg}")
/-- Assert EditorState cursor position matches expected row/col -/
def assertCursor (msg : String) (est : ViE.EditorState) (r c : Nat) : IO Unit := do
  let cursor := est.getCursor
  if cursor.row.val == r && cursor.col.val == c then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    IO.println s!"  Expected: ({r}, {c})"
    IO.println s!"  Actual:   ({cursor.row.val}, {cursor.col.val})"
    throw (IO.userError s!"Cursor assertion failed: {msg}")
end ViETest.Utils

File addition: Undo.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Data.PieceTable
open ViE
namespace ViETest.Undo
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  IO.println "Starting Undo/Redo ViETest..."
  -- 1. Create initial buffer
  let initialText := "Hello, World!"
  let pt0 := PieceTable.fromString initialText
  assert "Initial text correct" (pt0.toString == initialText)
  assert "Initial undo stack empty" (pt0.undoStack.isEmpty)
  -- 2. Insert " New" at end
  -- "Hello, World! New"
  let pt1 := pt0.insert 13 " New" 13
  assert "Text after insert" (pt1.toString == "Hello, World! New")
  assert "Undo stack has 1 item" (pt1.undoStack.length == 1)
  -- 3. Delete ", World"
  -- "Hello! New"
  -- "Hello, World!" -> offset 5, delete 7 (", World")
  let pt2 := pt1.delete 5 7 5
  assert "Text after delete" (pt2.toString == "Hello! New")
  assert "Undo stack has 2 items" (pt2.undoStack.length == 2)
  -- 4. Undo Modify (Delete)
  -- Should revert to "Hello, World! New"
  let (pt3, _) := pt2.undo 0
  assert "Text after undo delete" (pt3.toString == "Hello, World! New")
  assert "Undo stack has 1 item" (pt3.undoStack.length == 1)
  assert "Redo stack has 1 item" (pt3.redoStack.length == 1)
  -- 5. Undo Insert
  -- Should revert to "Hello, World!"
  let (pt4, _) := pt3.undo 0
  assert "Text after undo insert" (pt4.toString == "Hello, World!")
  assert "Undo stack has 0 items" (pt4.undoStack.isEmpty)
  assert "Redo stack has 2 items" (pt4.redoStack.length == 2)
  -- 6. Redo Insert
  -- Should go to "Hello, World! New"
  let (pt5, _) := pt4.redo 0
  assert "Text after redo insert" (pt5.toString == "Hello, World! New")
  assert "Undo stack has 1 item" (pt5.undoStack.length == 1)
  assert "Redo stack has 1 item" (pt5.redoStack.length == 1)
  -- 7. Redo Delete
  -- Should go to "Hello! New"
  let (pt6, _) := pt5.redo 0
  assert "Text after redo delete" (pt6.toString == "Hello! New")
  assert "Undo stack has 2 items" (pt6.undoStack.length == 2)
  assert "Redo stack empty" (pt6.redoStack.isEmpty)
  -- 8. Test Redo clearing on new edit
  let (pt7, _) := pt6.undo 0 -- "Hello, World! New"
  -- Insert " Again" at end -> "Hello, World! New Again"
  let pt8 := pt7.insert 17 " Again" 17
  assert "Text after new insert" (pt8.toString == "Hello, World! New Again")
  assert "Redo stack cleared" (pt8.redoStack.isEmpty)
  -- 9. Test Optimization (Grouping)
  -- Force break merge chain from previous step to ensure " 1" starts a new group
  let pt8_clean := { pt8 with lastInsert := none }
  let pt9 := pt8_clean.insert 23 " 1" 23 -- "Hello, World! New Again 1"
  let pt10 := pt9.insert 25 "2" 25 -- "Hello, World! New Again 12"
  let pt11 := pt10.insert 26 "3" 26 -- "Hello, World! New Again 123"
  assert "Text after group insert" (pt11.toString == "Hello, World! New Again 123")
  -- Should have only 1 new undo item for " 123" because they overlap
  -- pt8 had some undo stack. pt9 added 1. pt10 merged. pt11 merged.
  -- So pt11.undoStack.length should be pt8.undoStack.length + 1
  assert "Undo stack grouped" (pt11.undoStack.length == pt8.undoStack.length + 1)
  let (pt12, _) := pt11.undo 0
  assert "Undo removes group" (pt12.toString == "Hello, World! New Again")
  -- 10. Test Limit
  -- Force a small limit
  let ptLimit := { pt12 with undoLimit := 2 }
  let ptL1 := (ptLimit.insert 0 "A" 0) -- Stack: 1
  let ptL2 := (ptL1.insert 0 "B" 0) -- Stack: 2
  -- Previous insert was "A" at 0. LastInsert = (0 + 1, addOffset + 1).
  -- Current insert at 0. 0 != 1. So NOT contiguous. Correct.
  let ptL3 := (ptL2.insert 0 "C" 0) -- Stack: 3 -> capped to 2
  assert "Undo limit respected" (ptL3.undoStack.length == 2)
  -- The oldest undo (for "A") should be dropped. The remaining undos are "C" -> "B", and "B" -> "A".
  -- So undoing twice should start with "CBA..." -> "BA..." -> "A..."
  let (u1, _) := ptL3.undo 0
  let (u2, _) := u1.undo 0
  assert "Oldest undo dropped" (u2.toString == "AHello, World! New Again")
  -- 11. Test Paste Undo Grouping (Reproduction)
  -- Scenario: Paste "P1" then Paste "P2". They should NOT merge if we signal a break,
  -- OR if we consider pastes as distinct operations that shouldn't auto-merge like typing.
  -- Currently PieceTable merges ANY contiguous insert.
  let ptBase := PieceTable.fromString ""
  let ptP1 := ptBase.insert 0 "P1" 0 -- Simulate Paste 1
  -- Simulate EditorState.paste calling commit before next insert
  let ptP1_committed := ptP1.commit
  let ptP2 := ptP1_committed.insert 2 "P2" 2 -- Simulate Paste 2 (contiguous)
  assert "Text is P1P2" (ptP2.toString == "P1P2")
  -- Expectation: 2 undo items (one for P1, one for P2).
  -- Bug: they merge into 1 item because offset 2 == lastInsert end.
  if ptP2.undoStack.length == 1 then
     IO.println "[FAIL] Paste operations merged (expected 2 undo items)"
     assert "Paste should not merge" false
  else
     IO.println "[PASS] Paste operations distinct (2 undo items)"
  IO.println "TestUndo passed!"
end ViETest.Undo

File addition: TreeStatsMain.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViETest.TreeStats
def main (args : List String) : IO Unit :=
  ViETest.TreeStats.main args

File addition: TreeStats.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Data.PieceTable
import ViETest.Utils
namespace ViETest.TreeStats
open ViE
open ViETest.Utils
def buildWorkload (iterations : Nat) : PieceTable := Id.run do
  let mut pt := PieceTable.fromString "Initial content\n"
  for i in [0:iterations] do
    pt := pt.insert pt.tree.length s!"line {i}\n" pt.tree.length
  return pt
mutual
  def countNodes (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf _ _ _ => 1
    | .internal cs _ _ _ => 1 + countNodesList cs.toList
  def countNodesList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => countNodes t + countNodesList rest
end
mutual
  def countLeaves (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf _ _ _ => 1
    | .internal cs _ _ _ => countLeavesList cs.toList
  def countLeavesList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => countLeaves t + countLeavesList rest
end
mutual
  def maxLeafPieces (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf ps _ _ => ps.size
    | .internal cs _ _ _ => maxLeafPiecesList cs.toList
  def maxLeafPiecesList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => max (maxLeafPieces t) (maxLeafPiecesList rest)
end
mutual
  def maxInternalChildren (t : PieceTree) : Nat :=
    match t with
    | .empty => 0
    | .leaf _ _ _ => 0
    | .internal cs _ _ _ =>
        max cs.size (maxInternalChildrenList cs.toList)
  def maxInternalChildrenList (ts : List PieceTree) : Nat :=
    match ts with
    | [] => 0
    | t :: rest => max (maxInternalChildren t) (maxInternalChildrenList rest)
end
def parseIterations (args : List String) : Nat :=
  let args :=
    match args with
    | "--" :: rest => rest
    | _ => args
  match args with
  | a :: _ =>
      match a.toNat? with
      | some n => n
      | none => 5000
  | [] => 5000
def report (pt : PieceTable) (iterations : Nat) : IO Unit := do
  let tree := pt.tree
  let h := PieceTree.height tree
  let nodes := countNodes tree
  let leaves := countLeaves tree
  let maxLeaf := maxLeafPieces tree
  let maxChildren := maxInternalChildren tree
  IO.println s!"iterations={iterations}"
  IO.println s!"bytes={PieceTree.length tree} lines={PieceTree.lineBreaks tree} height={h}"
  IO.println s!"nodes={nodes} leaves={leaves} maxLeafPieces={maxLeaf} maxChildren={maxChildren}"
  match tree with
  | .empty => IO.println "root=empty"
  | .leaf ps _ _ => IO.println s!"root=leaf pieces={ps.size}"
  | .internal cs _ _ _ => IO.println s!"root=internal children={cs.size}"
  if iterations > 0 then
    let start := ← IO.monoMsNow
    let _ := pt.getLineRange (iterations - 1)
    let stop := ← IO.monoMsNow
    IO.println s!"getLineRange(last)={stop - start}ms"
def test : IO Unit := do
  IO.println "Starting TreeStats ViETest..."
  let iterations := 3000
  let pt := buildWorkload iterations
  let t := pt.tree
  let bytes := PieceTree.length t
  let textBytes := pt.toString.toUTF8.size
  let isNonEmpty :=
    match t with
    | .empty => false
    | _ => true
  assertEqual "tree length equals rendered bytes" textBytes bytes
  assert "tree is non-empty" isNonEmpty
  assert "tree height is positive for non-empty tree" (PieceTree.height t >= 1)
  assert "leaf piece count stays within node capacity" (maxLeafPieces t <= NodeCapacity)
  assert "internal children stay within node capacity" (maxInternalChildren t <= NodeCapacity)
  assert "line range for last inserted line exists" ((pt.getLineRange (iterations - 1)).isSome)
  IO.println "TreeStats Test passed!"
def main (args : List String) : IO Unit := do
  let iterations := parseIterations args
  let pt := buildWorkload iterations
  report pt iterations
end ViETest.TreeStats

File addition: SyntaxHighlight.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.UI.Search
import ViETest.Utils
import Bliku.Tui.Syntax
open ViETest.Utils
namespace ViETest.SyntaxHighlight
private def firstRangeOf (line : String) (pat : String) : Option (Nat × Nat) :=
  (ViE.UI.findAllMatchesBytes line.toUTF8 pat.toUTF8)[0]?
def testLean : IO Unit := do
  let line := "def x := 42 -- comment"
  let spans := Bliku.Tui.Syntax.highlightLine (some "Main.lean") line
  let (defS, defE) := (firstRangeOf line "def").getD (0, 0)
  let (numS, numE) := (firstRangeOf line "42").getD (0, 0)
  let (comS, comE) := (firstRangeOf line "-- comment").getD (0, 0)
  assertEqual "Lean keyword style" (Bliku.Tui.Syntax.defaultPalette.faceFor .keyword)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans defS defE)
  assertEqual "Lean number style" (Bliku.Tui.Syntax.defaultPalette.faceFor .numberLiteral)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans numS numE)
  assertEqual "Lean comment style" (Bliku.Tui.Syntax.defaultPalette.faceFor .comment)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans comS comE)
def testMarkdown : IO Unit := do
  let line := "Use `code` and [link](url)"
  let spans := Bliku.Tui.Syntax.highlightLine (some "README.md") line
  let (codeS, codeE) := (firstRangeOf line "`code`").getD (0, 0)
  let (linkS, linkE) := (firstRangeOf line "[link](url)").getD (0, 0)
  assertEqual "Markdown code style" (Bliku.Tui.Syntax.defaultPalette.faceFor .code)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans codeS codeE)
  assertEqual "Markdown link style" (Bliku.Tui.Syntax.defaultPalette.faceFor .link)
    (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette spans linkS linkE)
def test : IO Unit := do
  IO.println "Starting SyntaxHighlight ViETest..."
  testLean
  testMarkdown
  IO.println "SyntaxHighlight Test passed!"
end ViETest.SyntaxHighlight

File addition: SearchHighlight.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.UI
import ViE.Config
import ViETest.Utils
namespace ViETest.SearchHighlight
open ViETest.Utils
open ViE
def test : IO Unit := do
  IO.println "Starting Search Highlight ViETest..."
  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
  let s0 := ViE.startOrUpdateSearch ViE.initialState "abc" .forward false
  let (m1, s1) := ViE.UI.getLineSearchMatches s0 s0.getActiveBuffer.id 0 "abc abc"
  assertEqual "Line search cache computes matches" true (m1.size > 0)
  let cachedBeforeSwitch :=
    match s1.searchState with
    | some ss => ss.lineMatches.contains 0
    | none => false
  assertEqual "Line search cache populated" true cachedBeforeSwitch
  let s2 := ViE.UI.ensureSearchLineCacheForBuffer s1 9999
  let cacheClearedOnSwitch :=
    match s2.searchState with
    | some ss => ss.lineMatches.isEmpty && ss.lineCacheBufferId == some 9999
    | none => false
  assertEqual "Line search cache resets on buffer switch" true cacheClearedOnSwitch
  let sInc0 := ViE.startOrUpdateSearch ViE.initialState "abc" .forward false
  let sInc1 := {
    sInc0 with
      mode := .searchForward
      inputState := { sInc0.inputState with commandBuffer := "" }
  }
  let sInc2 := ViE.runIncrementalSearch sInc1
  let incCleared :=
    match sInc2.searchState with
    | none => true
    | some _ => false
  assertEqual "Incremental search with empty pattern clears highlight state" true incCleared
  let t0 := 1000
  let (p0, k0) := ViE.parseKey ViE.initialState '\x1b' t0
  let (p1, k1) := ViE.parseKey p0 '[' (t0 + 1)
  let (p2, k2) := ViE.parseKey p1 '1' (t0 + 2)
  let (p3, k3) := ViE.parseKey p2 ';' (t0 + 3)
  let (p4, k4) := ViE.parseKey p3 '2' (t0 + 4)
  let (p5, k5) := ViE.parseKey p4 'X' (t0 + 5)
  assertEqual "Unknown CSI emits no keys while pending" ([] : List Key) (k0 ++ k1 ++ k2 ++ k3 ++ k4)
  assertEqual "Unknown CSI final emits Key.unknown" [Key.unknown 'X'] k5
  assertEqual "Unknown CSI clears pending state" "" p5.inputState.pendingKeys
  let chars : List Char := ['\x1b', '[', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3']
  let (pLong, emitted) := chars.foldl
    (fun (acc : EditorState × List Key) ch =>
      let (st, out) := acc
      let (st', keys) := ViE.parseKey st ch (t0 + 20)
      (st', out ++ keys))
    (ViE.initialState, [])
  assertEqual "Overlong unknown CSI flushes emitted keys" true (!emitted.isEmpty)
  assertEqual "Overlong unknown CSI clears pending state" "" pLong.inputState.pendingKeys
  let (_, tabKeys) := ViE.parseKey ViE.initialState '\x09' (t0 + 30)
  assertEqual "Tab parses as char tab" [Key.char '\t'] tabKeys
end ViETest.SearchHighlight

File addition: Scroll.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Window.Actions
import ViE.State
import ViE.Types
import ViE.Config
namespace ViETest.Scroll
open ViE
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  let state := ViE.initialState
  -- Set window size (e.g., 10 lines)
  let state := { state with windowHeight := 10, windowWidth := 80 }
  -- Move cursor to line 100
  let state := state.setCursor { row := ⟨100⟩, col := ⟨0⟩ }
  -- Enforce scroll
  let state := ViE.Window.enforceScroll state
  let (sRow, _) := state.getScroll
  IO.println s!"Cursor Row: 100, Scroll Row: {sRow.val}, Window Height: 10"
  -- View range is [sRow, sRow + 9] (10 lines)
  -- We expect 100 to be in [sRow, sRow + 9]
  -- So sRow <= 100 AND 100 < sRow + 10  => sRow > 90
  let visible := sRow.val <= 100 && 100 < sRow.val + 10
  assert "Cursor is visible" visible
  -- Upper boundary: cursor above scroll should pull scroll up
  let state2 := { state with
    mode := .normal
  }
  let state2 := state2.setScroll ⟨10⟩ ⟨0⟩
  let state2 := state2.setCursor { row := ⟨2⟩, col := ⟨0⟩ }
  let state2 := ViE.Window.enforceScroll state2
  let (sRow2, _) := state2.getScroll
  assert "Scroll moves up to include cursor" (sRow2.val == 2)
  -- Horizontal right boundary: cursor beyond view should scroll right
  let state3 := { state with windowHeight := 5, windowWidth := 20 }
  let state3 := state3.setScroll ⟨0⟩ ⟨0⟩
  let state3 := state3.setCursor { row := ⟨0⟩, col := ⟨30⟩ }
  let state3 := ViE.Window.enforceScroll state3
  let (_, sCol3) := state3.getScroll
  let colsInView := 20 -- showLineNumbers is false by default
  let visible3 := sCol3.val <= 30 && 30 < sCol3.val + colsInView
  assert "Horizontal scroll keeps cursor visible" visible3
  -- Horizontal left boundary: cursor before scroll should pull scroll left
  let state4 := { state with windowHeight := 5, windowWidth := 20 }
  let state4 := state4.setScroll ⟨0⟩ ⟨10⟩
  let state4 := state4.setCursor { row := ⟨0⟩, col := ⟨2⟩ }
  let state4 := ViE.Window.enforceScroll state4
  let (_, sCol4) := state4.getScroll
  assert "Horizontal scroll moves left to include cursor" (sCol4.val == 2)

File addition: PreviewData.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Buffer.LowIO
import ViE.State.Config
import ViE.State.Layout
import ViETest.Utils
namespace ViETest.PreviewData
open ViETest.Utils
def basePath : String := "ViETest/test_paths"
def testFiles : List String := [
  s!"{basePath}/file0.txt",
  s!"{basePath}/dir0/file0.txt",
  s!"{basePath}/dir0/file1.txt",
  s!"{basePath}/dir0/file2.txt",
  s!"{basePath}/dir0/file3.txt",
  s!"{basePath}/dir0/dir0/file0.txt",
  s!"{basePath}/dir0/dir1/file1.txt",
  s!"{basePath}/dir0/dir1/file2.txt",
  s!"{basePath}/dir0/dir1/file3.txt",
  s!"{basePath}/dir0/dir1/file4.txt",
  s!"{basePath}/dir0/dir1/file5.txt"
]
def test : IO Unit := do
  IO.println "Starting Preview Data ViETest..."
  for path in testFiles do
    let buf ← ViE.loadBufferByteArray path
    let content := buf.table.toString
    let byteLen := content.toUTF8.size
    assertEqual s!"{path} has content" true (content.length > 0)
    assertEqual s!"{path} has bytes" true (byteLen > 0)
    assertEqual s!"{path} has lines" true (buf.lineCount > 0)
    let firstLine := ViE.getLineFromBuffer buf 0 |>.getD ""
    assertEqual s!"{path} has first line" true (firstLine.length > 0)
  IO.println "PreviewDataTest passed!"
end ViETest.PreviewData

File addition: PieceTable (d--x------)
[0.87]

File addition: UndoRedo.lean (----------)

[0.70437]

import ViE.Data.PieceTable
import ViETest.Utils
open ViE
namespace ViETest.PieceTable.UndoRedo
open ViETest.Utils
def testUndoRedo : IO Unit := do
  IO.println "testUndoRedo..."
  let pt := PieceTable.fromString ""
  -- Insert "A" at 0
  let pt1 := pt.insert 0 "A" 0
  -- Insert "B" at 0 (Prepend) -> "BA"
  let pt2 := pt1.insert 0 "B" 0
  assertEqual "Initial state" "BA" pt2.toString
  -- Undo B (restores to "A")
  let (pt3, _) := pt2.undo 0
  assertEqual "After Undo 1" "A" pt3.toString
  -- Undo A
  let (pt4, _) := pt3.undo 0
  assertEqual "After Undo 2" "" pt4.toString
  -- Redo A
  let (pt5, _) := pt4.redo 0
  assertEqual "After Redo 1" "A" pt5.toString
  -- Redo B
  let (pt6, _) := pt5.redo 0
  assertEqual "After Redo 2" "BA" pt6.toString
def testComplexUndo : IO Unit := do
  IO.println "testComplexUndo..."
  let pt := PieceTable.fromString "Base"
  let pt1 := pt.insert 4 "1" 4 -- Base1
  let pt1 := pt1.commit -- Prevent merge
  let pt2 := pt1.insert 5 "2" 5 -- Base12
  let pt3 := pt2.delete 5 1 5 -- Base1
  let pt4 := pt3.insert 5 "3" 5 -- Base13
  assertEqual "State before undo" "Base13" pt4.toString
  -- Undo insert "3" -> Base1
  let (u1, _) := pt4.undo 0
  assertEqual "Undo 3" "Base1" u1.toString
  -- Undo delete "2" -> Base12
  let (u2, _) := u1.undo 0
  assertEqual "Undo delete 2" "Base12" u2.toString
  -- Undo insert "2" -> Base1
  let (u3, _) := u2.undo 0
  assertEqual "Undo insert 2" "Base1" u3.toString
  -- Undo insert "1" -> Base
  let (u4, _) := u3.undo 0
  assertEqual "Undo insert 1" "Base" u4.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Undo/Redo ViETest..."
  testUndoRedo
  testComplexUndo
  IO.println "PieceTable Undo/Redo Test passed!"
end ViETest.PieceTable.UndoRedo

File addition: Stress.lean (----------)

[0.70437]

import ViE.Data.PieceTable
import ViETest.Utils
open ViE
namespace ViETest.PieceTable.Stress
open ViETest.Utils
/-- Naive string manipulation for verification -/
def naiveInsert (s : String) (idx : Nat) (content : String) : String :=
  let lst := s.toList
  let pre := lst.take idx
  let post := lst.drop idx
  String.ofList (pre ++ content.toList ++ post)
def naiveDelete (s : String) (idx : Nat) (len : Nat) : String :=
  let lst := s.toList
  let pre := lst.take idx
  let post := lst.drop (idx + len)
  String.ofList (pre ++ post)
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 testConsistency : IO Unit := do
  IO.println "testConsistency (Small Stress)..."
  let mut pt := PieceTable.fromString ""
  let mut mirror := ""
  -- 1. Insert Hello
  pt := pt.insert 0 "Hello" 0
  mirror := naiveInsert mirror 0 "Hello"
  assertEqual "Step 1" mirror pt.toString
  -- 2. Insert World
  pt := pt.insert 5 " World" 5
  mirror := naiveInsert mirror 5 " World"
  assertEqual "Step 2" mirror pt.toString
  -- 3. Delete space at 5
  -- "Hello World" -> "HelloWorld"
  pt := pt.delete 5 1 5
  mirror := naiveDelete mirror 5 1
  assertEqual "Step 3" mirror pt.toString
  -- 4. Insert comma at 5
  -- "HelloWorld" -> "Hello,World"
  pt := pt.insert 5 "," 5
  mirror := naiveInsert mirror 5 ","
  assertEqual "Step 4" mirror pt.toString
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"
def testYankPasteClearing : IO Unit := do
  IO.println "testYankPasteClearing (yy+p reproduction)..."
  -- Simulate: insert 25 'i' chars + newline, then yy+p 4000 times
  let initLine := String.ofList (List.replicate 25 'i') ++ "\n"
  let lineBytes := initLine.toUTF8.size  -- 26 bytes
  let mut pt := PieceTable.fromString initLine
  let mut cursorLine : Nat := 0
  for step in [0:4000] do
    -- 1. yy: read current line content via getLineRange + getBytes (like real editor)
    let range := PieceTree.getLineRange pt.tree cursorLine pt
    match range with
    | none =>
        throw <| IO.userError s!"[YankPaste] getLineRange returned none at step {step}, line {cursorLine}"
    | some (off, len) =>
        let yankedBytes := PieceTree.getBytes pt.tree off len pt
        if yankedBytes.size == 0 then
          throw <| IO.userError s!"[YankPaste] Empty yank at step {step}, line {cursorLine}, off={off} len={len}"
        -- 2. p: paste below current line.
        -- Insert after end of current line (off + len + 1 for newline)
        let insertOffset := off + len + 1
        let insertOffset := min insertOffset pt.length
        let yankStr := (String.fromUTF8! yankedBytes) ++ "\n"
        pt := pt.insert insertOffset yankStr insertOffset
        -- 3. Move cursor to pasted line
        cursorLine := cursorLine + 1
    -- 4. Verify tree length
    let expectedLen := lineBytes * (step + 2)
    let actualLen := pt.length
    if actualLen != expectedLen then
      throw <| IO.userError s!"[YankPaste] Length mismatch at step {step}: expected={expectedLen} actual={actualLen}"
    -- 5. Full consistency check every 500 steps
    if step % 500 == 0 then
      let rendered := pt.toString.toUTF8.size
      if rendered != expectedLen then
        throw <| IO.userError s!"[YankPaste] Rendered mismatch at step {step}: expected={expectedLen} rendered={rendered}"
      IO.println s!"  step {step}: length={actualLen} lines={PieceTree.lineBreaks pt.tree} height={PieceTree.height pt.tree} OK"
  IO.println "[PASS] yank+paste 4000 iterations with getLineRange consistent"
def test : IO Unit := do
  IO.println "Starting PieceTable Stress ViETest..."
  testConsistency
  testLengthAndLineCountConsistency
  testYankPasteClearing
  IO.println "PieceTable Stress Test passed!"
end ViETest.PieceTable.Stress

File addition: Search.lean (----------)

[0.70437]

import ViE.Data.PieceTable
import ViETest.Utils
import Proof.PieceTable.Search.TwoWay
open ViE
namespace ViETest.PieceTable.Search
open ViETest.Utils
def makeBoundaryTable : PieceTable :=
  let n := ViE.NodeCapacity + 1
  let startIdx := n / 2 - 1
  let chars := Id.run do
    let mut cs := Array.replicate n 'x'
    cs := cs.set! startIdx 'a'
    cs := cs.set! (startIdx + 1) 'b'
    cs := cs.set! (startIdx + 2) 'c'
    return cs
  let s := String.ofList chars.toList
  let bytes := s.toUTF8
  let pieces := (Array.range n).map fun i =>
    { source := BufferSource.original
      start := i.toUInt64
      length := (1 : UInt64)
      lineBreaks := (0 : UInt64)
      charCount := (1 : UInt64) }
  let tmp : PieceTable := {
    original := bytes
    addBuffers := #[]
    tree := PieceTree.empty
    undoStack := []
    redoStack := []
    undoStackCount := 0
    redoStackCount := 0
    undoLimit := 100
    lastInsert := none
  }
  let tree := PieceTree.fromPieces pieces tmp
  { tmp with tree := tree }
def testCrossLeafSearch : IO Unit := do
  IO.println "testCrossLeafSearch..."
  let pt := makeBoundaryTable
  let n := ViE.NodeCapacity + 1
  let startIdx := n / 2 - 1
  let pattern := "abc".toUTF8
  let (r1, _, _) := PieceTree.searchNext pt.tree pt pattern 0 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchNext bloom across leaf" (some startIdx) r1
  let total := pt.tree.length
  let (r2, _, _) := PieceTree.searchPrev pt.tree pt pattern total 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchPrev bloom across leaf" (some startIdx) r2
def testCrossLeafSearchNearBoundary : IO Unit := do
  IO.println "testCrossLeafSearchNearBoundary..."
  let pt := makeBoundaryTable
  let n := ViE.NodeCapacity + 1
  let startIdx := n / 2 - 1
  let pattern := "abc".toUTF8
  let startOffset := startIdx - 1
  let (r1, _, _) := PieceTree.searchNext pt.tree pt pattern startOffset 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchNext from near boundary" (some startIdx) r1
  let startExclusive := startIdx + pattern.size
  let (r2, _, _) := PieceTree.searchPrev pt.tree pt pattern startExclusive 64 true (Lean.RBMap.empty) #[] 16
  assertEqual "searchPrev to near boundary" (some startIdx) r2
def test : IO Unit := do
  IO.println "Starting PieceTable Search ViETest..."
  testCrossLeafSearch
  testCrossLeafSearchNearBoundary
  IO.println "PieceTable Search Test passed!"
end ViETest.PieceTable.Search

File addition: Basic.lean (----------)

[0.70437]

import ViE.Data.PieceTable
import ViETest.Utils
open ViE
namespace ViETest.PieceTable.Basic
open ViETest.Utils
def testInsert : IO Unit := do
  IO.println "testInsert..."
  let pt := PieceTable.fromString "Hello"
  -- Insert at end
  let pt1 := pt.insert 5 " World" 5
  assertEqual "Insert at end" "Hello World" pt1.toString
  -- Insert at middle
  let pt2 := pt1.insert 5 "," 5
  assertEqual "Insert at middle" "Hello, World" pt2.toString
  -- Insert at start
  let pt3 := pt2.insert 0 "Say: " 0
  assertEqual "Insert at start" "Say: Hello, World" pt3.toString
def testDelete : IO Unit := do
  IO.println "testDelete..."
  let pt := PieceTable.fromString "Hello, World!"
  -- Delete "World" (offset 7, len 5)
  let pt1 := pt.delete 7 5 7
  assertEqual "Delete middle" "Hello, !" pt1.toString
  -- Delete start
  let pt2 := pt1.delete 0 7 0
  assertEqual "Delete start" "!" pt2.toString
  -- Delete end
  let pt3 := pt2.delete 0 1 0
  assertEqual "Delete end" "" pt3.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Basic ViETest..."
  testInsert
  testDelete
  IO.println "PieceTable Basic Test passed!"
end ViETest.PieceTable.Basic

File addition: Appended.lean (----------)

[0.70437]

import ViE.Data.PieceTable
import ViETest.Utils
open ViE
namespace ViETest.PieceTable.Appended
open ViETest.Utils
def testAppends : IO Unit := do
  IO.println "testAppends..."
  let pt := PieceTable.fromString "Line1\n"
  -- Append Line 2
  let pt1 := pt.insert pt.length "Line2\n" pt.length
  assertEqual "Append 1" "Line1\nLine2\n" pt1.toString
  -- Append Line 3
  let pt2 := pt1.insert pt1.length "Line3" pt1.length
  assertEqual "Append 2" "Line1\nLine2\nLine3" pt2.toString
def test : IO Unit := do
  IO.println "Starting PieceTable Appended ViETest..."
  testAppends
  IO.println "PieceTable Appended Test passed!"
end ViETest.PieceTable.Appended

File addition: PasteReproduction.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Data.PieceTable
namespace ViETest.PasteReproduction
def test : IO Unit := do
  IO.println "--- Test 1: Paste below last line (no trailing newline) ---"
  let pt := ViE.PieceTable.fromString "line 1"
  IO.println s!"Initial: [{pt.toString}]"
  -- Yank line 1 (manually simulating EditorState.yankCurrentLine)
  let line1 := pt.getLine 0 |>.getD ""
  let yanked := if line1.endsWith "\n" then line1 else line1 ++ "\n"
  IO.println s!"Yanked: [{yanked}]"
  -- Paste below line 0 (simulating EditorState.pasteBelow)
  let (off, text) := match pt.getOffsetFromPoint 1 0 with
    | some o => (o, yanked)
    | none =>
        let len := pt.length
        if len > 0 then
           if !pt.endsWithNewline then (len, "\n" ++ yanked) else (len, yanked)
        else (0, yanked)
  let pt2 := pt.insert off text off
  IO.println s!"After paste:\n[{pt2.toString}]"
  IO.println s!"Line count: {pt2.lineCount}"
  for i in [:pt2.lineCount] do
    IO.println s!"Line {i}: [{pt2.getLine i |>.getD "NONE"}]"
  IO.println "\n--- Test 2: Paste below last line (with trailing newline) ---"
  let ptB := ViE.PieceTable.fromString "line 1\n"
  IO.println s!"Initial: [{ptB.toString}]"
  let line1B := ptB.getLine 0 |>.getD ""
  let yankedB := if line1B.endsWith "\n" then line1B else line1B ++ "\n"
  let (offB, textB) := match ptB.getOffsetFromPoint 1 0 with
    | some o => (o, yankedB)
    | none =>
        let len := ptB.length
        if len > 0 then
           if !ptB.endsWithNewline then (len, "\n" ++ yankedB) else (len, yankedB)
        else (0, yankedB)
  let ptB2 := ptB.insert offB textB offB
  IO.println s!"After paste:\n[{ptB2.toString}]"
  IO.println s!"Line count: {ptB2.lineCount}"
  for i in [:ptB2.lineCount] do
    IO.println s!"Line {i}: [{ptB2.getLine i |>.getD "NONE"}]"

File addition: Mode.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.Config
import ViE.Command.Impl
import ViE.Key.Map
import ViE.State.Edit
import ViE.State.Movement
import Proof.Visual
namespace ViETest.Mode
open ViE
private theorem visualLineProofWitness :
    (ViE.initialState.startVisualLineMode).mode = .visualLine := by
  simpa using Proof.startVisualLineMode_setsMode ViE.initialState
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
-- Helper to construct a full Config
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
-- Run a sequence of keys
def runKeys (startState : EditorState) (keys : List Key) : IO EditorState := do
  let config := makeTestConfig
  let mut s := startState
  for k in keys do
    s ← ViE.update config s k
  return s
def test : IO Unit := do
  IO.println "Starting Mode ViETest..."
  let s := ViE.initialState
  -- Scenario: Insert 'abc' then Esc.
  -- Initial: (0,0)
  -- 'i' -> Insert Mode
  -- 'a' -> "a", (0,1)
  -- 'b' -> "ab", (0,2)
  -- 'c' -> "abc", (0,3)
  -- Esc -> Normal Mode.
  -- Expected Vim behavior: Cursor should move left to (0,2) 'c'.
  -- If empty line "insert a then esc", "a" (0,1) -> (0,0).
  let keys := [Key.char 'i', Key.char 'a', Key.char 'b', Key.char 'c', Key.esc]
  let sEnd ← runKeys s keys
  -- Check Mode
  if sEnd.mode != Mode.normal then
    IO.println s!"[FAIL] Mode mismatch. Expected Normal, got {sEnd.mode}"
    assert "Mode is Normal" false
  else
    IO.println "[PASS] Mode is Normal"
  -- Check Text
  let text := getLineFromBuffer sEnd.getActiveBuffer 0 |>.getD ""
  if text != "abc" then
    IO.println s!"[FAIL] Text mismatch. Expected 'abc', got '{text}'"
    assert "Text is 'abc'" false
  else
     IO.println "[PASS] Text is 'abc'"
  -- Check Cursor
  -- Expect (0, 2)
  let cursor := sEnd.getCursor
  if cursor.col.val != 2 then
    IO.println s!"[FAIL] Cursor mismatch. Expected (0, 2), got ({cursor.row.val}, {cursor.col.val})"
    assert "Cursor moved left on Esc" false
  else
    IO.println "[PASS] Cursor moved left on Esc"
  IO.println "ModeTest passed!"
end ViETest.Mode

File addition: MissingEol.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.State.Layout
import ViE.Data.PieceTable
import ViETest.Utils
open ViE
namespace ViETest.MissingEol
open ViETest.Utils
def testMissingEol : IO Unit := do
  IO.println "testMissingEol..."
  let s := ViE.initialState
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := PieceTable.fromString "abc\n", dirty := true }
  let buf := s.getActiveBuffer
  assert "missingEol false with trailing newline" (!buf.missingEol)
  let len := buf.table.length
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := buffer.table.delete (len - 1) 1 (len - 1), dirty := true }
  let buf2 := s.getActiveBuffer
  assert "missingEol true after deleting newline" buf2.missingEol
  let s := ViE.initialState
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := PieceTable.fromString "abc", dirty := true }
  let buf3 := s.getActiveBuffer
  assert "missingEol true without newline" buf3.missingEol
  let len2 := buf3.table.length
  let s := s.updateActiveBuffer fun buffer =>
    { buffer with table := buffer.table.insert len2 "\n" len2, dirty := true }
  let buf4 := s.getActiveBuffer
  assert "missingEol false after adding newline" (!buf4.missingEol)
def test : IO Unit := do
  IO.println "Starting MissingEol ViETest..."
  testMissingEol
  IO.println "MissingEol Test passed!"
end ViETest.MissingEol

File addition: Lsp.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE
import ViETest.Utils
namespace ViETest.Lsp
open ViETest.Utils
def test : IO Unit := do
  IO.println "Starting LSP ViETest..."
  let leanBuf := { ViE.initialBuffer with filename := some "Main.lean" }
  let txtBuf := { ViE.initialBuffer with filename := some "notes.txt" }
  assertEqual "isLeanBuffer true for .lean" true (ViE.Lsp.Lean.isLeanBuffer leanBuf)
  assertEqual "isLeanBuffer false for non-.lean" false (ViE.Lsp.Lean.isLeanBuffer txtBuf)
  let uriAbs := ViE.Lsp.Lean.fileUri "/tmp/a b#c%.lean"
  assertEqual "fileUri percent-encodes reserved bytes" "file:///tmp/a%20b%23c%25.lean" uriAbs
  let uriRel := ViE.Lsp.Lean.fileUri "tmp/test.lean"
  assertEqual "fileUri normalizes relative path with leading slash" "file:///tmp/test.lean" uriRel
  let uriWs ← ViE.Lsp.Lean.fileUriWithWorkspace (some "/tmp/ws") "dir/a b.lean"
  assertEqual "fileUriWithWorkspace resolves relative path from workspace root" "file:///tmp/ws/dir/a%20b.lean" uriWs
  let uriWsAbs ← ViE.Lsp.Lean.fileUriWithWorkspace (some "/tmp/ws") "/tmp/alt/x.lean"
  assertEqual "fileUriWithWorkspace keeps absolute path priority" "file:///tmp/alt/x.lean" uriWsAbs
  let okResp : Lean.Json := Lean.Json.mkObj [("id", (12 : Lean.Json)), ("result", Lean.Json.null)]
  let errResp : Lean.Json := Lean.Json.mkObj [("id", (13 : Lean.Json)), ("error", Lean.Json.mkObj [("code", (1 : Lean.Json))])]
  let notif : Lean.Json := Lean.Json.mkObj [("method", .str "textDocument/publishDiagnostics"), ("params", Lean.Json.mkObj [])]
  assertEqual "responseId? parses result response id" (some 12) (ViE.Lsp.Lean.responseId? okResp)
  assertEqual "responseId? parses error response id" (some 13) (ViE.Lsp.Lean.responseId? errResp)
  assertEqual "responseId? is none for notifications" (none : Option Nat) (ViE.Lsp.Lean.responseId? notif)
  assertEqual "isResponseForRequest true for same id" true (ViE.Lsp.Lean.isResponseForRequest okResp 12)
  assertEqual "isResponseForRequest false for different id" false (ViE.Lsp.Lean.isResponseForRequest okResp 99)
  let s0 := ViE.initialState
  let sStatus ← ViE.Lsp.Lean.cmdLsp ["status"] s0
  assertEqual "lsp status reports stopped when no session" "LSP: stopped" sStatus.message
  let sStop ← ViE.Lsp.Lean.cmdLsp ["stop"] s0
  assertEqual "lsp stop reports not running when no session" "LSP is not running" sStop.message
  IO.println "LSP Test passed!"
end ViETest.Lsp

File addition: Layout.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Types
open ViE
namespace ViETest.Layout
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  IO.println "Starting Layout ViETest..."
  -- 1. Construct Layouts
  let view1 : ViewState := { bufferId := 1, cursor := {row:=0, col:=0}, scrollRow:=0, scrollCol:=0 }
  let win1 := Layout.window 1 view1
  let view2 : ViewState := { bufferId := 2, cursor := {row:=0, col:=0}, scrollRow:=0, scrollCol:=0 }
  let win2 := Layout.window 2 view2
  -- 2. Test Split Construction
  let hsplit := Layout.hsplit win1 win2 0.5
  match hsplit with
  | .hsplit _ _ ratio =>
      assert "HSplit match" true
      assert "HSplit ratio" (ratio == 0.5)
  | _ => assert "HSplit construction failed" false
  let vsplit := Layout.vsplit hsplit win1 0.3
  match vsplit with
  | .vsplit t _ ratio =>
      assert "VSplit match" true
      assert "VSplit ratio" (ratio == 0.3)
      match t with
      | .hsplit _ _ _ => assert "VSplit top is HSplit" true
      | _ => assert "VSplit top incorrect" false
  | _ => assert "VSplit construction failed" false
  IO.println "LayoutTest passed!"
end ViETest.Layout

File addition: Keybinds.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Movement
import ViE.State.Edit
import ViE.Key.Map
import ViE.Types
import ViE.Buffer.Content
import ViE.Config
import ViE.Command.Impl
import ViETest.Utils
namespace ViETest.Keybinds
open ViE
open ViETest.Utils
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
def keys (s : String) : List Key :=
  s.toList.map fun c =>
    if c == '\n' then Key.enter else Key.char c
def runKeys (s : EditorState) (ks : List Key) : IO EditorState := do
  let config := makeTestConfig
  ks.foldlM (fun s k => ViE.update config s k) s
def findEntryIndex (entries : List FileEntry) (name : String) : Option Nat :=
  let rec loop (rest : List FileEntry) (idx : Nat) : Option Nat :=
    match rest with
    | [] => none
    | e :: tail =>
        if e.name == name then
          some idx
        else
          loop tail (idx + 1)
  loop entries 0
def findEntryIndexByPath (entries : List FileEntry) (path : String) : Option Nat :=
  let rec loop (rest : List FileEntry) (idx : Nat) : Option Nat :=
    match rest with
    | [] => none
    | e :: tail =>
        if e.path == path then
          some idx
        else
          loop tail (idx + 1)
  loop entries 0
def testMotions : IO Unit := do
  IO.println "  Testing Motions..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "line1\nline2\nline3" ++ [Key.esc] ++ keys "gg0")
  -- "line1\nline2\nline3" cursor at (0,0)
  -- l, h
  let s_l ← runKeys s1 [Key.char 'l']
  assertCursor "l moves right" s_l 0 1
  let s_lh ← runKeys s_l [Key.char 'h']
  assertCursor "h moves left" s_lh 0 0
  -- j, k
  let s_j ← runKeys s1 [Key.char 'j']
  assertCursor "j moves down" s_j 1 0
  let s_jk ← runKeys s_j [Key.char 'k']
  assertCursor "k moves up" s_jk 0 0
  -- 0, $
  let s_end ← runKeys s1 [Key.char '$']
  assertCursor "$ moves to end" s_end 0 4 -- '1' is at col 4
  let s_start ← runKeys s_end [Key.char '0']
  assertCursor "0 moves to start" s_start 0 0
  -- w, b, e
  let s_text ← runKeys s0 ([Key.char 'i'] ++ keys "word1 word2" ++ [Key.esc] ++ [Key.char '0'])
  let s_w ← runKeys s_text [Key.char 'w']
  assertCursor "w moves to next word" s_w 0 6
  let s_e ← runKeys s_text [Key.char 'e']
  assertCursor "e moves to end of word" s_e 0 4
  let s_we ← runKeys s_w [Key.char 'e']
  assertCursor "we moves to end of next word" s_we 0 10
  let s_web ← runKeys s_we [Key.char 'b']
  assertCursor "b moves to start of word" s_web 0 6
  -- gg, G
  let s_G ← runKeys s1 [Key.char 'G']
  assertCursor "G moves to last line" s_G 2 0
  let s_gg ← runKeys s_G [Key.char 'g', Key.char 'g']
  assertCursor "gg moves to first line" s_gg 0 0
  -- | (jump to column)
  let s_pipe ← runKeys s1 [Key.char '3', Key.char '|']
  assertCursor "| jumps to column" s_pipe 0 2 -- 1-indexed count 3 -> col 2
def testEditing : IO Unit := do
  IO.println "  Testing Editing..."
  let s0 := ViE.initialState
  -- i, a, A
  let s_i ← runKeys s0 [Key.char 'i', Key.char 'x', Key.esc]
  assertBuffer "i inserts" s_i "x"
  let s_a ← runKeys s_i [Key.char 'a', Key.char 'y', Key.esc]
  assertBuffer "a appends" s_a "xy"
  let s_A ← runKeys s_a [Key.char '0', Key.char 'A', Key.char 'z', Key.esc]
  assertBuffer "A appends at end" s_A "xyz"
  let s_q ← runKeys s0 [Key.char 'q']
  assertEqual "q does not enter command mode" Mode.normal s_q.mode
  let s_V ← runKeys s0 [Key.char 'V']
  assertEqual "V enters visual line mode" Mode.visualLine s_V.mode
  let s_ctrlV ← runKeys s0 [Key.ctrl 'v']
  assertEqual "Ctrl-v enters visual block mode" Mode.visualBlock s_ctrlV.mode
  let s_tab_insert ← runKeys s0 [Key.char 'i', Key.char '\t']
  assertCursor "Tab advances cursor to next tab stop in insert mode" s_tab_insert 0 4
  let s_tab_backspace ← runKeys s0 [Key.char 'i', Key.char '\t', Key.backspace]
  assertBuffer "Tab backspace deletes tab in insert mode" s_tab_backspace ""
  assertCursor "Tab backspace restores cursor column" s_tab_backspace 0 0
  let s_tab ← runKeys s0 [Key.char 'i', Key.char '\t', Key.esc]
  assertBuffer "Tab inserts in insert mode" s_tab "\t"
  assertCursor "Esc after tab returns to tab char in normal mode" s_tab 0 0
  let s0_tab8 := { s0 with config := { s0.config with tabStop := 8 } }
  let s_tab8 ← runKeys s0_tab8 [Key.char 'i', Key.char '\t']
  assertCursor "Tab follows custom tabStop in insert mode" s_tab8 0 8
  -- o, O
  let s_o ← runKeys s_i [Key.char 'o', Key.char 'y', Key.esc]
  assertBuffer "o inserts line below" s_o "x\ny"
  let s_O ← runKeys s_o [Key.char 'k', Key.char 'O', Key.char 'z', Key.esc]
  assertBuffer "O inserts line above" s_O "z\nx\ny"
  -- x
  let s_x ← runKeys s_i [Key.char 'x']
  assertBuffer "x deletes char" s_x ""
  match s_x.clipboard with
  | some reg =>
      assertEqual "x register kind" RegisterKind.charwise reg.kind
      assertEqual "x register text" "x" reg.text
  | none => assertEqual "x register set" true false
def testOperators : IO Unit := do
  IO.println "  Testing Operators..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "hello world" ++ [Key.esc] ++ [Key.char '0'])
  -- dw
  let s_dw ← runKeys s1 [Key.char 'd', Key.char 'w']
  assertBuffer "dw deletes word" s_dw "world"
  match s_dw.clipboard with
  | some reg =>
      assertEqual "dw register kind" RegisterKind.charwise reg.kind
      assertEqual "dw register text" "hello " reg.text
  | none => assertEqual "dw register set" true false
  -- cw
  let s_cw ← runKeys s1 [Key.char 'c', Key.char 'w', Key.char 'h', Key.char 'i', Key.esc]
  assertBuffer "cw changes word" s_cw "hi world"
  -- dd
  let s_lines ← runKeys s0 ([Key.char 'i'] ++ keys "line1\nline2\nline3" ++ [Key.esc] ++ keys "ggj")
  let s_dd ← runKeys s_lines [Key.char 'd', Key.char 'd']
  assertBuffer "dd deletes current line" s_dd "line1\nline3"
  match s_dd.clipboard with
  | some reg =>
      assertEqual "dd register kind" RegisterKind.linewise reg.kind
      assertEqual "dd register text" "line2\n" reg.text
  | none => assertEqual "dd register set" true false
  -- yy, p, P
  let s_yy ← runKeys s_lines [Key.char 'g', Key.char 'g', Key.char 'y', Key.char 'y']
  let s_p ← runKeys s_yy [Key.char 'G', Key.char 'p']
  assertBuffer "p pastes below" s_p "line1\nline2\nline3\nline1\n"
  let s_P ← runKeys s_yy [Key.char 'g', Key.char 'g', Key.char 'P']
  assertBuffer "P pastes above" s_P "line1\nline1\nline2\nline3"
  let s_indent ← runKeys s0 ([Key.char 'i'] ++ keys "  indented\nx" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char 'y', Key.char 'y', Key.char 'j', Key.char 'p'])
  assertCursor "linewise paste moves to first non-blank" s_indent 2 2
  -- paste should not overwrite register
  let s_reg0 ← runKeys s0 ([Key.char 'i'] ++ keys "one\ntwo" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char 'y', Key.char 'y'])
  let regBefore := s_reg0.clipboard
  let s_regP ← runKeys s_reg0 [Key.char 'j', Key.char 'p']
  match (regBefore, s_regP.clipboard) with
  | (some before, some after) =>
      assertEqual "paste keeps register kind" before.kind after.kind
      assertEqual "paste keeps register text" before.text after.text
  | _ => assertEqual "paste keeps register" true false
  -- charwise y/p from normal mode
  let s_char0 ← runKeys s0 ([Key.char 'i'] ++ keys "hello" ++ [Key.esc] ++ [Key.char '0'])
  let s_charY ← runKeys s_char0 [Key.char 'v', Key.char 'l', Key.char 'y']
  let s_charP ← runKeys s_charY [Key.char '$', Key.char 'p']
  assertBuffer "charwise paste in normal mode" s_charP "hellohe"
  assertCursor "charwise paste cursor at end" s_charP 0 6
  let s_charP2 ← runKeys s_charY [Key.char '0', Key.char 'P']
  assertBuffer "charwise P pastes before cursor" s_charP2 "hehello"
  assertCursor "charwise P cursor at end" s_charP2 0 1
def testVisual : IO Unit := do
  IO.println "  Testing Visual Mode..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "highlight me" ++ [Key.esc] ++ [Key.char '0'])
  -- v, d
  let s_v ← runKeys s1 [Key.char 'v', Key.char 'l', Key.char 'd']
  assertBuffer "visual d deletes selection" s_v "ghlight me"
  match s_v.clipboard with
  | some reg =>
      assertEqual "visual d register kind" RegisterKind.charwise reg.kind
      assertEqual "visual d register text" "hi" reg.text
  | none => assertEqual "visual d register set" true false
  -- v, y, p
  let s_vy ← runKeys s1 [Key.char 'v', Key.char 'e', Key.char 'y']
  let s_vyp ← runKeys s_vy [Key.char '$', Key.char 'p']
  assertBuffer "visual y yanks selection" s_vyp "highlight mehighlight"
  let s_linewise0 ← runKeys s0 ([Key.char 'i'] ++ keys "aa\nbb\ncc" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g'])
  let s_linewiseD ← runKeys s_linewise0 [Key.char 'V', Key.char 'j', Key.char 'd']
  assertBuffer "visual line d deletes full lines" s_linewiseD "cc"
  match s_linewiseD.clipboard with
  | some reg =>
      assertEqual "visual line d register kind" RegisterKind.linewise reg.kind
      assertEqual "visual line d register text" "aa\nbb\n" reg.text
  | none => assertEqual "visual line d register set" true false
  let s_linewiseY ← runKeys s_linewise0 [Key.char 'V', Key.char 'j', Key.char 'y']
  let s_linewiseP ← runKeys s_linewiseY [Key.char 'G', Key.char 'p']
  assertBuffer "visual line y/p pastes linewise" s_linewiseP "aa\nbb\ncc\naa\nbb\n"
  let s_char0 ← runKeys s0 ([Key.char 'i'] ++ keys "abc" ++ [Key.esc] ++ [Key.char '0'])
  let s_charY ← runKeys s_char0 [Key.char 'l', Key.char 'v', Key.char 'y']
  let s_charP ← runKeys s_charY [Key.char '$', Key.char 'p']
  assertBuffer "charwise paste appends" s_charP "abcb"
  assertCursor "charwise paste cursor at end" s_charP 0 3
  let s_charP2 ← runKeys s_charY [Key.char '0', Key.char 'P']
  assertBuffer "charwise P inserts before" s_charP2 "babc"
  assertCursor "charwise P cursor at end" s_charP2 0 0
  -- visual block yank/paste cursor position
  let s_blk0 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\nefgh" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char '0'])
  let s_blkY ← runKeys s_blk0 [Key.char 'l', Key.ctrl 'v', Key.char 'l', Key.char 'j', Key.char 'y']
  let s_blkP ← runKeys s_blkY [Key.char 'g', Key.char 'g', Key.char '0', Key.char 'p']
  assertBuffer "visual block y/p inserts block" s_blkP "abcbcd\nefgfgh"
  assertCursor "visual block paste cursor at block start" s_blkP 0 1
  let s_blkP2 ← runKeys s_blkY [Key.char 'g', Key.char 'g', Key.char '0', Key.char 'P']
  assertBuffer "visual block P inserts block" s_blkP2 "bcabcd\nfgefgh"
  assertCursor "visual block P cursor at block start" s_blkP2 0 0
  let s_blkD0 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\nefgh" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g', Key.char '0'])
  let s_blkD ← runKeys s_blkD0 [Key.char 'l', Key.ctrl 'v', Key.char 'l', Key.char 'j', Key.char 'd']
  assertBuffer "visual block d deletes block" s_blkD "ad\neh"
  match s_blkD.clipboard with
  | some reg =>
      assertEqual "visual block d register kind" RegisterKind.blockwise reg.kind
      assertEqual "visual block d register text" "bc\nfg" reg.text
  | none => assertEqual "visual block d register set" true false
  -- linewise yank/paste (via yy + P)
  let s_line0 ← runKeys s0 ([Key.char 'i'] ++ keys "aa\nbb\ncc" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g'])
  let s_lineY ← runKeys s_line0 [Key.char 'y', Key.char 'y']
  let s_lineP ← runKeys s_lineY [Key.char 'j', Key.char 'P']
  assertBuffer "linewise paste above keeps lines" s_lineP "aa\naa\nbb\ncc"
  let s_lineP2 ← runKeys s_lineY [Key.char 'j', Key.char 'p']
  assertBuffer "linewise paste below keeps lines" s_lineP2 "aa\nbb\naa\ncc"
def testCounted : IO Unit := do
  IO.println "  Testing Counted Actions..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "a b c d e" ++ [Key.esc] ++ [Key.char '0'])
  -- 3w
  let s_3w ← runKeys s1 [Key.char '3', Key.char 'w']
  assertCursor "3w moves 3 words" s_3w 0 6
  -- 2j
  let s_lines ← runKeys s0 ([Key.char 'i'] ++ keys "1\n2\n3\n4" ++ [Key.esc] ++ [Key.char 'g', Key.char 'g'])
  let s_2j ← runKeys s_lines [Key.char '2', Key.char 'j']
  assertCursor "2j moves 2 lines down" s_2j 2 0
def testVimCompatMotions : IO Unit := do
  IO.println "  Testing Vim Compatibility Motions..."
  let s0 := { ViE.initialState with windowHeight := 12, windowWidth := 80 }
  let lines := String.intercalate "\n" ((List.range 30).map (fun i => s!"  line{i}")) ++ "\n"
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys lines ++ [Key.esc] ++ keys "gg0")
  let sCd ← runKeys s1 [Key.ctrl 'd']
  assertCursor "Ctrl-d scrolls half page down" sCd 5 0
  let sCu ← runKeys sCd [Key.ctrl 'u']
  assertCursor "Ctrl-u scrolls half page up" sCu 0 0
  let sCf ← runKeys s1 [Key.ctrl 'f']
  assertCursor "Ctrl-f scrolls one page down" sCf 10 0
  let sCb ← runKeys sCf [Key.ctrl 'b']
  assertCursor "Ctrl-b scrolls one page up" sCb 0 0
  let sCe ← runKeys s1 [Key.ctrl 'e']
  let (ceRow, _) := sCe.getScroll
  assertEqual "Ctrl-e scrolls window down by one line" 1 ceRow.val
  let sCy ← runKeys sCe [Key.ctrl 'y']
  let (cyRow, _) := sCy.getScroll
  assertEqual "Ctrl-y scrolls window up by one line" 0 cyRow.val
  let sH ← runKeys sCf [Key.char 'H']
  assertCursor "H moves to top line of screen" sH 10 2
  let sM ← runKeys sCf [Key.char 'M']
  assertCursor "M moves to middle line of screen" sM 15 2
  let sL ← runKeys sCf [Key.char 'L']
  assertCursor "L moves to bottom line of screen" sL 19 2
  let sF0 ← runKeys s0 ([Key.char 'i'] ++ keys "abcaXcaYca" ++ [Key.esc] ++ [Key.char '0'])
  let sF1 ← runKeys sF0 [Key.char 'f', Key.char 'a']
  assertCursor "fa finds next character" sF1 0 3
  let sF2 ← runKeys sF1 [Key.char ';']
  assertCursor "; repeats last f motion" sF2 0 6
  let sF3 ← runKeys sF2 [Key.char ',']
  assertCursor ", reverses last f motion" sF3 0 3
  let sT1 ← runKeys sF3 [Key.char 't', Key.char 'a']
  assertCursor "ta moves before target" sT1 0 5
  let sT2 ← runKeys sT1 [Key.char ';']
  assertCursor "; repeats last t motion" sT2 0 8
  let sPct0 ← runKeys s0 ([Key.char 'i'] ++ keys "(a[b]c)" ++ [Key.esc] ++ [Key.char '0'])
  let sPct1 ← runKeys sPct0 [Key.char '%']
  assertCursor "% jumps to matching bracket" sPct1 0 6
  let sPct2 ← runKeys sPct1 [Key.ctrl 'o']
  assertCursor "Ctrl-o jumps back in jump list" sPct2 0 0
  let sPct3 ← runKeys sPct2 [Key.char '\t']
  assertCursor "Ctrl-i (Tab) jumps forward in jump list" sPct3 0 6
  let sStar0 := ViE.initialState
  let sStar1 ← runKeys sStar0 ([Key.char 'i'] ++ keys "foo bar\nfoo baz\nbar foo\n" ++ [Key.esc] ++ keys "gg0")
  let sStar2 ← runKeys sStar1 [Key.char '*']
  assertCursor "* searches next word under cursor" sStar2 1 0
  let sStar3 ← runKeys sStar2 [Key.char '#']
  assertCursor "# searches previous word under cursor" sStar3 0 0
def testWorkgroupSwitch : IO Unit := do
  IO.println "  Testing Workgroup Switching..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 [Key.alt '3']
  assertEqual "Alt-3 switches workgroup" 3 s1.currentGroup
  let s2 ← runKeys s1 [Key.alt '0']
  assertEqual "Alt-0 switches workgroup" 0 s2.currentGroup
def testSearch : IO Unit := do
  IO.println "  Testing Search..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "hello world\nhello again\n" ++ [Key.esc])
  let s2 ← runKeys s1 ([Key.char '/'] ++ keys "hello" ++ [Key.enter])
  assertCursor "/hello finds first match" s2 0 0
  let s2Prompt ← runKeys s2 [Key.char '/']
  let promptCleared :=
    match s2Prompt.searchState with
    | none => true
    | some _ => false
  assertEqual "Starting new search prompt clears old search highlight state" true promptCleared
  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"
  let s3 ← runKeys s2 [Key.char 'n']
  assertCursor "n finds next match" s3 1 0
  let s4 ← runKeys s3 [Key.char 'N']
  assertCursor "N finds previous match" s4 0 0
  let s5 ← runKeys s4 ([Key.char '?'] ++ keys "world" ++ [Key.enter])
  assertCursor "?world searches backward" s5 0 6
def testCommandSubstitute : IO Unit := do
  IO.println "  Testing Command Substitute..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "foo bar\nfoo baz\nbar foo\n" ++ [Key.esc] ++ keys "gg0")
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "s/foo/xxx/" ++ [Key.enter])
  assertBuffer ":s replaces first match on current line" s2 "xxx bar\nfoo baz\nbar foo\n"
  let s3 := ViE.initialState
  let s4 ← runKeys s3 ([Key.char 'i'] ++ keys "foo foo\nfoo foo\n" ++ [Key.esc] ++ keys "gg0")
  let s5 ← runKeys s4 ([Key.char ':'] ++ keys "%s/foo/yyy/" ++ [Key.enter])
  assertBuffer ":%s replaces first match per line" s5 "yyy foo\nyyy foo\n"
  let s6 := ViE.initialState
  let s7 ← runKeys s6 ([Key.char 'i'] ++ keys "foo bar\nfoo baz\nbar foo\n" ++ [Key.esc] ++ keys "gg0")
  let s8 ← runKeys s7 ([Key.char ':'] ++ keys "%s/foo/yyy/g" ++ [Key.enter])
  assertBuffer ":%s with g replaces all matches" s8 "yyy bar\nyyy baz\nbar yyy\n"
def testCommandGlobal : IO Unit := do
  IO.println "  Testing Command Global..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "a\nfoo1\nb\nfoo2\n" ++ [Key.esc] ++ keys "gg0")
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "g/foo/ d" ++ [Key.enter])
  assertBuffer ":g/pat/ d deletes matching lines" s2 "a\nb\n"
  let s3 := ViE.initialState
  let s4 ← runKeys s3 ([Key.char 'i'] ++ keys "foo foo\nbar foo\nfoo bar\n" ++ [Key.esc] ++ keys "gg0")
  let s5 ← runKeys s4 ([Key.char ':'] ++ keys "g/foo/ s/foo/xxx/" ++ [Key.enter])
  assertBuffer ":g/pat/ s replaces first match per line" s5 "xxx foo\nbar xxx\nxxx bar\n"
  let s6 := ViE.initialState
  let s7 ← runKeys s6 ([Key.char 'i'] ++ keys "keep1\nfoo\nkeep2\n" ++ [Key.esc] ++ keys "gg0")
  let s8 ← runKeys s7 ([Key.char ':'] ++ keys "v/foo/ d" ++ [Key.enter])
  assertBuffer ":v/pat/ d deletes non-matching lines" s8 "foo\n"
  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 testCommandBloom : IO Unit := do
  IO.println "  Testing Command Bloom..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char 'i'] ++ keys "hello bloom\nbloom hello\n" ++ [Key.esc] ++ keys "gg0")
  let s2 ← runKeys s1 ([Key.char ':'] ++ keys "bloom /bloom" ++ [Key.enter])
  assertCursor ":bloom moves to first match" s2 0 6
  let s3 ← runKeys s2 ([Key.char ':'] ++ keys "bloom /nomatch" ++ [Key.enter])
  assertEqual ":bloom not found message" "Pattern not found: nomatch" s3.message
def testUiCommands : IO Unit := do
  IO.println "  Testing UI Commands..."
  let s0 := ViE.initialState
  let s1 ← runKeys s0 ([Key.char ':'] ++ keys "float hello" ++ [Key.enter])
  assertEqual ":float shows overlay" true s1.floatingOverlay.isSome
  let s2 ← runKeys s1 [Key.esc]
  assertEqual "Esc closes overlay" false s2.floatingOverlay.isSome
  let s3 ← runKeys s0 ([Key.char ':'] ++ keys "float alpha\\nbeta" ++ [Key.enter])
  match s3.floatingOverlay with
  | some overlay =>
      assertEqual ":float parses newline escape (line count)" 2 overlay.lines.size
      assertEqual ":float parses newline escape (line 1)" "alpha" overlay.lines[0]!
      assertEqual ":float parses newline escape (line 2)" "beta" overlay.lines[1]!
  | none =>
      assertEqual ":float newline overlay exists" true false
  let s4 ← runKeys s3 ([Key.char ':'] ++ keys "nofloat" ++ [Key.enter])
  assertEqual ":nofloat clears overlay" false s4.floatingOverlay.isSome
  let s5 ← runKeys s0 ([Key.char ':'] ++ keys "redraw" ++ [Key.enter])
  assertEqual ":redraw sets message" "redraw" s5.message
  assertEqual ":redraw marks dirty" true s5.dirty
  let s6 ← runKeys s0 ([Key.char ':'] ++ keys "redraw!" ++ [Key.enter])
  assertEqual ":redraw! alias works" "redraw" s6.message
  let s7 ← runKeys s0 [Key.ctrl 'l']
  assertEqual "Ctrl-l redraw marks dirty" true s7.dirty
  let s8 ← runKeys s0 ([Key.char ':'] ++ keys "float --title Note --width 32 hello world" ++ [Key.enter])
  match s8.floatingOverlay with
  | some overlay =>
      assertEqual ":float --title sets title" "Note" overlay.title
      assertEqual ":float --width sets width" 32 overlay.maxWidth
      assertEqual ":float with options keeps text" "hello world" overlay.lines[0]!
  | none =>
      assertEqual ":float with options shows overlay" true false
  let s9 ← runKeys s0 ([Key.char ':'] ++ keys "float --title=Panel --width=28 hi" ++ [Key.enter])
  match s9.floatingOverlay with
  | some overlay =>
      assertEqual ":float --title= sets title" "Panel" overlay.title
      assertEqual ":float --width= sets width" 28 overlay.maxWidth
  | none =>
      assertEqual ":float with inline options shows overlay" true false
  let s10 ← runKeys s0 ([Key.char ':'] ++ keys "float --width nope hi" ++ [Key.enter])
  assertEqual ":float invalid width message" "Invalid float width: nope" s10.message
  let s11 ← runKeys s0 ([Key.char 'i'] ++ keys "abc" ++ [Key.esc] ++ [Key.char ':'] ++ keys "float guard" ++ [Key.enter])
  let s12 ← runKeys s11 [Key.char 'i']
  assertEqual "floating overlay enters insert mode" Mode.insert s12.mode
  let s13 ← runKeys s12 (keys "X" ++ [Key.enter] ++ keys "Y")
  match s13.floatingOverlay with
  | some overlay =>
      assertEqual "floating overlay writes text" "guardX" overlay.lines[0]!
      assertEqual "floating overlay writes next line" "Y" overlay.lines[1]!
  | none =>
      assertEqual "floating overlay remains open while editing" true false
  let s14 ← runKeys s13 [Key.esc]
  assertEqual "Esc exits floating overlay insert mode" Mode.normal s14.mode
  let s15 ← runKeys s14 [Key.enter]
  assertEqual "Enter closes floating overlay" false s15.floatingOverlay.isSome
  let sMsg0 := { s0 with message := "Error: sample message", dirty := true }
  let sMsg1 ← runKeys sMsg0 [Key.enter]
  assertEqual "Enter closes message float" "" sMsg1.message
  let sMsg2 := { s0 with message := "Cannot write preview buffer", dirty := true }
  let sMsg3 ← runKeys sMsg2 [Key.esc]
  assertEqual "Esc closes message float" "" sMsg3.message
  let sPrompt0 ← runKeys s0 ([Key.char ':'] ++ keys "ws list" ++ [Key.enter])
  let sPrompt1 := sPrompt0.updateActiveView fun v => { v with cursor := { row := ⟨2⟩, col := 0 } }
  let sPrompt2 ← runKeys sPrompt1 [Key.enter]
  assertEqual "Workspace explorer New opens floating input" true sPrompt2.floatingOverlay.isSome
  assertEqual "Workspace explorer New sets floating command prefix" (some "ws new ") sPrompt2.floatingInputCommand
  let sPrompt3 ← runKeys sPrompt2 (keys "TmpWS" ++ [Key.enter])
  assertEqual "Workspace explorer floating input submits with Enter" "TmpWS" sPrompt3.getCurrentWorkspace.name
  assertEqual "Workspace explorer floating input closes after submit" false sPrompt3.floatingOverlay.isSome
  let sWsCmd0 ← runKeys s0 ([Key.char ':'] ++ keys "ws new" ++ [Key.enter])
  assertEqual ":ws new opens floating input" true sWsCmd0.floatingOverlay.isSome
  assertEqual ":ws new floating command prefix" (some "ws new ") sWsCmd0.floatingInputCommand
  let sWsCmd1 ← runKeys sWsCmd0 (keys "CmdWorkspace" ++ [Key.enter])
  assertEqual ":ws new floating input submits name" "CmdWorkspace" sWsCmd1.getCurrentWorkspace.name
  let sWgCmd0 ← runKeys s0 ([Key.char ':'] ++ keys "wg new" ++ [Key.enter])
  assertEqual ":wg new opens floating input" true sWgCmd0.floatingOverlay.isSome
  assertEqual ":wg new floating command prefix" (some "wg new ") sWgCmd0.floatingInputCommand
  let sWgCmd1 ← runKeys sWgCmd0 (keys "CmdGroup" ++ [Key.enter])
  assertEqual ":wg new floating input submits name" "CmdGroup" sWgCmd1.getCurrentWorkgroup.name
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-explorer-create-{stamp}"
  IO.FS.createDirAll tmpRoot
  let sExp0 := { s0 with windowHeight := 30, windowWidth := 100 }
  let sExp1 ← runKeys sExp0 ([Key.char ':'] ++ keys s!"ex list {tmpRoot}" ++ [Key.enter])
  let explorerOpt := sExp1.explorers.find? (fun (id, _) => id == sExp1.getActiveBuffer.id)
  match explorerOpt with
  | none =>
      assertEqual "Explorer create test has active explorer" true false
  | some (_, explorer) =>
      let newFileIdx := (findEntryIndex explorer.entries "[New File]").getD 0
      let sExp2 := sExp1.updateActiveView fun v => { v with cursor := { row := ⟨2 + newFileIdx⟩, col := 0 } }
      let sExp3 ← runKeys sExp2 [Key.enter]
      assertEqual "Explorer [New File] opens floating input" true sExp3.floatingOverlay.isSome
      assertEqual "Explorer [New File] sets command prefix" (some s!"mkfile {tmpRoot}/") sExp3.floatingInputCommand
      let sExp4 ← runKeys sExp3 (keys "alpha.txt" ++ [Key.enter])
      let fileCreated ← (System.FilePath.mk s!"{tmpRoot}/alpha.txt").pathExists
      assertEqual "Explorer [New File] creates file" true fileCreated
      let explorerOpt2 := sExp4.explorers.find? (fun (id, _) => id == sExp4.getActiveBuffer.id)
      match explorerOpt2 with
      | none =>
          assertEqual "Explorer refreshed after file create" true false
      | some (_, explorer2) =>
          assertEqual "Explorer list includes created file" true (findEntryIndex explorer2.entries "alpha.txt").isSome
      let newDirIdx := (findEntryIndex explorer.entries "[New Directory]").getD 1
      let sExp5 := sExp4.updateActiveView fun v => { v with cursor := { row := ⟨2 + newDirIdx⟩, col := 0 } }
      let sExp6 ← runKeys sExp5 [Key.enter]
      assertEqual "Explorer [New Directory] opens floating input" true sExp6.floatingOverlay.isSome
      assertEqual "Explorer [New Directory] sets command prefix" (some s!"mkdir {tmpRoot}/") sExp6.floatingInputCommand
      let sExp7 ← runKeys sExp6 (keys "subdir" ++ [Key.enter])
      let createdDirPath := System.FilePath.mk s!"{tmpRoot}/subdir"
      let dirExists ← createdDirPath.pathExists
      let dirIsDir ← if dirExists then createdDirPath.isDir else pure false
      assertEqual "Explorer [New Directory] creates directory" true dirIsDir
      let explorerOpt3 := sExp7.explorers.find? (fun (id, _) => id == sExp7.getActiveBuffer.id)
      match explorerOpt3 with
      | none =>
          assertEqual "Explorer refreshed after directory create" true false
      | some (_, explorer3) =>
          assertEqual "Explorer list includes created directory" true (findEntryIndex explorer3.entries "subdir").isSome
  let s16 ← runKeys s0 ([Key.char ':'] ++ keys "vs" ++ [Key.enter])
  let ws16 := s16.getCurrentWorkspace
  assertEqual "split creates second window" true (ws16.nextWindowId >= 2)
  let s17 ← runKeys s16 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let ws17 := s17.getCurrentWorkspace
  assertEqual ":floatwin on marks active window floating" true (ws17.isFloatingWindow ws17.activeWindowId)
  let s18 ← runKeys s17 ([Key.char ':'] ++ keys "floatwin off" ++ [Key.enter])
  let ws18 := s18.getCurrentWorkspace
  assertEqual ":floatwin off clears floating flag" false (ws18.isFloatingWindow ws18.activeWindowId)
  let s19 ← runKeys s18 ([Key.char ':'] ++ keys "floatwin" ++ [Key.enter])
  let ws19 := s19.getCurrentWorkspace
  assertEqual ":floatwin toggles floating flag" true (ws19.isFloatingWindow ws19.activeWindowId)
  let sFloatMove0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatMove1 ← runKeys sFloatMove0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let floatMoveId := sFloatMove1.getCurrentWorkspace.activeWindowId
  let beforeFloatMove := sFloatMove1.getFloatingWindowBounds floatMoveId
  let sFloatMove2 ← runKeys sFloatMove1 [Key.alt 'L']
  let afterFloatMove := sFloatMove2.getFloatingWindowBounds floatMoveId
  match beforeFloatMove, afterFloatMove with
  | some (_, left0, _, _), some (_, left1, _, _) =>
      assertEqual "Alt-Shift-l moves floating window right" (left0 + 1) left1
  | _, _ =>
      assertEqual "Alt-Shift-l moves floating window right" true false
  let sFloatMoveGrp0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatMoveGrp1 ← runKeys sFloatMoveGrp0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatMoveGrp2 ← runKeys sFloatMoveGrp1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let moveGrpIds := sFloatMoveGrp2.getCurrentWorkspace.getFloatingWindowIds.toList
  let beforeGrp := moveGrpIds.filterMap (fun wid => (sFloatMoveGrp2.getFloatingWindowBounds wid).map (fun b => (wid, b)))
  let sFloatMoveGrp3 ← runKeys sFloatMoveGrp2 [Key.alt 'J']
  let afterGrp := moveGrpIds.filterMap (fun wid => (sFloatMoveGrp3.getFloatingWindowBounds wid).map (fun b => (wid, b)))
  let movedAllDown :=
    moveGrpIds.all (fun wid =>
      match beforeGrp.find? (fun (id, _) => id == wid), afterGrp.find? (fun (id, _) => id == wid) with
      | some (_, (top0, _, _, _)), some (_, (top1, _, _, _)) => top1 == top0 + 1
      | _, _ => false)
  assertEqual "Alt-Shift-j moves all panes in active floating subtree down" true movedAllDown
  let sFloatVs0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatVs1 ← runKeys sFloatVs0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatVs2 ← runKeys sFloatVs1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let wsFloatVs2 := sFloatVs2.getCurrentWorkspace
  let floatingIdsVs := wsFloatVs2.getFloatingWindowIds.toList
  assertEqual "vsplit in floating window keeps new pane floating" true (floatingIdsVs.length >= 2)
  match floatingIdsVs with
  | a :: b :: _ =>
      let sideBySide :=
        match sFloatVs2.getFloatingWindowBounds a, sFloatVs2.getFloatingWindowBounds b with
        | some (t1, l1, h1, w1), some (t2, l2, h2, w2) =>
            t1 == t2 && h1 == h2 && ((l1 + w1 == l2) || (l2 + w2 == l1))
        | _, _ => false
      assertEqual "vsplit in floating window keeps pair side-by-side" true sideBySide
  | _ =>
      assertEqual "vsplit in floating window keeps pair side-by-side" true false
  let sFloatSp0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatSp1 ← runKeys sFloatSp0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatSp2 ← runKeys sFloatSp1 ([Key.char ':'] ++ keys "split" ++ [Key.enter])
  let wsFloatSp2 := sFloatSp2.getCurrentWorkspace
  let floatingIdsSp := wsFloatSp2.getFloatingWindowIds.toList
  assertEqual "split in floating window keeps new pane floating" true (floatingIdsSp.length >= 2)
  match floatingIdsSp with
  | a :: b :: _ =>
      let stacked :=
        match sFloatSp2.getFloatingWindowBounds a, sFloatSp2.getFloatingWindowBounds b with
        | some (t1, l1, h1, w1), some (t2, l2, h2, w2) =>
            l1 == l2 && w1 == w2 && ((t1 + h1 == t2) || (t2 + h2 == t1))
        | _, _ => false
      assertEqual "split in floating window keeps pair stacked" true stacked
  | _ =>
      assertEqual "split in floating window keeps pair stacked" true false
  let sFloatMix0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatMix1 ← runKeys sFloatMix0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatMix2 ← runKeys sFloatMix1 ([Key.char ':'] ++ keys "vsplit" ++ [Key.enter])
  let sFloatMix3 ← runKeys sFloatMix2 ([Key.char ':'] ++ keys "split" ++ [Key.enter])
  let wsFloatMix3 := sFloatMix3.getCurrentWorkspace
  let floatingIdsMix := wsFloatMix3.getFloatingWindowIds.toList
  assertEqual "vsplit then split in floating window keeps three panes floating" 3 floatingIdsMix.length
  let boundsMix := floatingIdsMix.filterMap (fun wid => sFloatMix3.getFloatingWindowBounds wid)
  assertEqual "vsplit then split in floating window resolves bounds for all panes" 3 boundsMix.length
  let overlaps (a b : Nat × Nat × Nat × Nat) : Bool :=
    let (ta, la, ha, wa) := a
    let (tb, lb, hb, wb) := b
    la < lb + wb && lb < la + wa && ta < tb + hb && tb < ta + ha
  let rec hasOverlap (xs : List (Nat × Nat × Nat × Nat)) : Bool :=
    match xs with
    | [] => false
    | x :: rest => rest.any (fun y => overlaps x y) || hasOverlap rest
  assertEqual "vsplit then split in floating window panes do not overlap" false (hasOverlap boundsMix)
  let sFloatDeep0 := { s0 with windowHeight := 24, windowWidth := 80 }
  let sFloatDeep1 ← runKeys sFloatDeep0 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let sFloatDeep2 ← runKeys sFloatDeep1 ([Key.char ':'] ++ keys "vs" ++ [Key.enter])
  let sFloatDeep3 ← runKeys sFloatDeep2 ([Key.char ':'] ++ keys "hs" ++ [Key.enter])
  let sFloatDeep4 ← runKeys sFloatDeep3 ([Key.char ':'] ++ keys "vs" ++ [Key.enter])
  let wsFloatDeep4 := sFloatDeep4.getCurrentWorkspace
  let floatingIdsDeep := wsFloatDeep4.getFloatingWindowIds.toList
  assertEqual "vs -> hs -> vs in floating window creates four panes" 4 floatingIdsDeep.length
  let boundsDeep := floatingIdsDeep.filterMap (fun wid => sFloatDeep4.getFloatingWindowBounds wid)
  assertEqual "vs -> hs -> vs in floating window resolves bounds for all panes" 4 boundsDeep.length
  assertEqual "vs -> hs -> vs in floating window panes do not overlap" false (hasOverlap boundsDeep)
  let sideBySideTouch (a b : Nat × Nat × Nat × Nat) : Bool :=
    let (t1, l1, h1, w1) := a
    let (t2, l2, h2, w2) := b
    ((l1 + w1 == l2) || (l2 + w2 == l1)) && (t1 < t2 + h2 && t2 < t1 + h1)
  let stackedTouch (a b : Nat × Nat × Nat × Nat) : Bool :=
    let (t1, l1, h1, w1) := a
    let (t2, l2, h2, w2) := b
    ((t1 + h1 == t2) || (t2 + h2 == t1)) && (l1 < l2 + w2 && l2 < l1 + w1)
  let rec hasPairWith
      (pred : (Nat × Nat × Nat × Nat) → (Nat × Nat × Nat × Nat) → Bool)
      (xs : List (Nat × Nat × Nat × Nat)) : Bool :=
    match xs with
    | [] => false
    | x :: rest => rest.any (fun y => pred x y) || hasPairWith pred rest
  assertEqual "vs -> hs -> vs in floating window keeps horizontal adjacency" true (hasPairWith sideBySideTouch boundsDeep)
  assertEqual "vs -> hs -> vs in floating window keeps vertical adjacency" true (hasPairWith stackedTouch boundsDeep)
  let longLine := "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  let longText := String.intercalate "\n" [longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine, longLine] ++ "\n"
  let s20 := { s0 with windowHeight := 14, windowWidth := 40 }
  let s21 ← runKeys s20 ([Key.char 'i'] ++ keys longText ++ [Key.esc] ++ keys "gg0")
  let s22 ← runKeys s21 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let s23 ← runKeys s22 [Key.char '1', Key.char '0', Key.char 'j']
  let (sRow23, _) := s23.getScroll
  assertEqual "floating window vertical scroll follows cursor" true (sRow23.val > 0)
  let s24 ← runKeys s23 [Key.char '3', Key.char '5', Key.char 'l']
  let (_, sCol24) := s24.getScroll
  assertEqual "floating window horizontal scroll follows cursor" true (sCol24.val > 0)
  let s25 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\n" ++ [Key.esc] ++ keys "gg0")
  let s26 ← runKeys s25 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let s27 ← runKeys s26 [Key.char 'v', Key.char 'l', Key.char 'd']
  assertBuffer "visual mode edits active floating window buffer" s27 "cd\n"
  let s28 ← runKeys s0 ([Key.char 'i'] ++ keys "abcd\nefgh\n" ++ [Key.esc] ++ keys "gg0")
  let s29 ← runKeys s28 ([Key.char ':'] ++ keys "floatwin on" ++ [Key.enter])
  let s30 ← runKeys s29 [Key.char 'l', Key.ctrl 'v', Key.char 'l', Key.char 'j', Key.char 'd']
  assertBuffer "visual block edits active floating window buffer" s30 "ad\neh\n"
def testBufferExplorerCommand : IO Unit := do
  IO.println "  Testing Buffer Explorer..."
  let s0 := ViE.initialState
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-buffer-explorer-{stamp}"
  IO.FS.createDirAll tmpRoot
  let bufAPath := s!"{tmpRoot}/bufA.txt"
  let bufBPath := s!"{tmpRoot}/bufB.txt"
  IO.FS.writeFile bufAPath "alpha\n"
  IO.FS.writeFile bufBPath "beta\n"
  let sBuf0 := { s0 with windowHeight := 30, windowWidth := 100 }
  let sBuf1 ← runKeys sBuf0 ([Key.char ':'] ++ keys s!"e {bufAPath}" ++ [Key.enter])
  let sBuf2 ← runKeys sBuf1 ([Key.char ':'] ++ keys s!"e {bufBPath}" ++ [Key.enter])
  let targetBufIdOpt := sBuf2.getCurrentWorkspace.buffers.find? (fun b => b.filename == some bufAPath) |>.map (fun b => b.id)
  assertEqual "Buffer explorer target buffer exists" true targetBufIdOpt.isSome
  let targetBufId := targetBufIdOpt.getD 0
  let sBuf3 ← runKeys sBuf2 ([Key.char ':'] ++ keys "buf list" ++ [Key.enter])
  assertEqual ":buf list opens buffer explorer" true ((sBuf3.getActiveBuffer.filename.getD "").startsWith "explorer://buffers")
  let explorerBufId := sBuf3.getActiveBuffer.id
  let explorerBufOpt := sBuf3.explorers.find? (fun (id, _) => id == explorerBufId)
  match explorerBufOpt with
  | none =>
      assertEqual "Buffer explorer registered" true false
  | some (_, explorerBuf) =>
      let targetPath := s!"buffer://{targetBufId}"
      let targetIdxOpt := findEntryIndexByPath explorerBuf.entries targetPath
      assertEqual "Buffer explorer contains target buffer entry" true targetIdxOpt.isSome
      let targetIdx := targetIdxOpt.getD 0
      let sBuf4 := sBuf3.updateActiveView fun v => { v with cursor := { row := ⟨2 + targetIdx⟩, col := 0 } }
      let sBuf5 ← runKeys sBuf4 [Key.enter]
      assertEqual "Buffer explorer Enter switches active buffer" (some bufAPath) sBuf5.getActiveBuffer.filename
      assertEqual "Buffer explorer closes after selection" false (sBuf5.explorers.any (fun (id, _) => id == explorerBufId))
  let sBufCompat ← runKeys sBuf2 ([Key.char ':'] ++ keys "buffers" ++ [Key.enter])
  assertEqual ":buffers alias opens buffer explorer" true ((sBufCompat.getActiveBuffer.filename.getD "").startsWith "explorer://buffers")
  let sBufAlias ← runKeys sBuf2 ([Key.char ':'] ++ keys "ls" ++ [Key.enter])
  assertEqual ":ls alias opens buffer explorer" true ((sBufAlias.getActiveBuffer.filename.getD "").startsWith "explorer://buffers")
def testExplorerCommandAliases : IO Unit := do
  IO.println "  Testing Explorer Command Names..."
  let s0 := ViE.initialState
  let stamp ← IO.monoMsNow
  let tmpRoot := s!"/tmp/vie-ex-alias-{stamp}"
  IO.FS.createDirAll tmpRoot
  IO.FS.writeFile s!"{tmpRoot}/x.txt" "x\n"
  let s1 ← runKeys s0 ([Key.char ':'] ++ keys s!"ex list {tmpRoot}" ++ [Key.enter])
  assertEqual ":ex list opens file explorer" true ((s1.getActiveBuffer.filename.getD "").startsWith "explorer://")
  let s2 ← runKeys s0 ([Key.char ':'] ++ keys s!"ee {tmpRoot}" ++ [Key.enter])
  assertEqual ":ee alias opens file explorer" true ((s2.getActiveBuffer.filename.getD "").startsWith "explorer://")
  let s3 ← runKeys s0 ([Key.char ':'] ++ keys "wgex" ++ [Key.enter])
  assertEqual ":wgex alias opens workgroup explorer" (some "explorer://workgroups") s3.getActiveBuffer.filename
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
def testLeanCompletionPopupBehavior : IO Unit := do
  IO.println "  Testing Lean Completion Popup..."
  let popup : CompletionPopup := {
    items := #[
      { label := "foo", insertText := "foo" },
      { label := "foobar", insertText := "foobar" }
    ]
    selected := 0
    anchorRow := 0
    anchorCol := 2
  }
  let s0 : EditorState :=
    ({ ViE.initialState with mode := .insert, completionPopup := some popup }).updateActiveBuffer fun b =>
      { b with filename := some "Main.lean", table := ViE.PieceTable.fromString "ab" }
  let s0 := s0.setCursor { row := ⟨0⟩, col := ⟨2⟩ }
  let s1 ← runKeys s0 [Key.char 'c']
  assertBuffer "completion popup keeps showing on char insert" s1 "abc"
  assertEqual "completion popup remains visible after char insert" true s1.completionPopup.isSome
  let s2 ← runKeys s1 [Key.enter]
  assertBuffer "Enter inserts newline instead of accepting completion" s2 "abc\n"
  assertCursor "Enter moves cursor to next line head with completion popup" s2 1 0
  assertEqual "Enter closes completion popup" true s2.completionPopup.isNone
def test : IO Unit := do
  IO.println "Starting Expanded Keybind Tests..."
  testMotions
  testEditing
  testOperators
  testVisual
  testCounted
  testVimCompatMotions
  testWorkgroupSwitch
  testSearch
  testCommandSubstitute
  testCommandGlobal
  testCursorDriftCustomTabStop
  testCommandBloom
  testUiCommands
  testBufferExplorerCommand
  testExplorerCommandAliases
  testExplorerOpenUsesFocusedWindow
  testLeanCompletionPopupBehavior
  IO.println "All Expanded Keybind Tests passed!"
end ViETest.Keybinds

File addition: Integration.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Types
import ViE.State.Config
import ViE.Config
import ViE.Key.Map
import ViE.Command.Impl
import ViETest.Utils
open ViE
open ViETest.Utils
namespace ViETest.Integration
-- Helper to construct a full Config
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
-- Run a sequence of keys
def runKeys (startState : EditorState) (keys : List Key) : IO EditorState := do
  let config := makeTestConfig
  let mut s := startState
  for k in keys do
    s ← ViE.update config s k
  return s
-- Helper: Convert string to list of char keys
def keys (s : String) : List Key :=
  s.toList.map Key.char
def test : IO Unit := do
  IO.println "Starting Integration ViETest..."
  -- Test 1: Typing "abc" -> Undo -> Insert "d"
  -- Expected: "abc" -> "" -> "d"
  -- Bug Report: After Undo, Insert mode might fail or buffer might be corrupted
  let s0 := ViE.initialState
  -- 1. Insert "abc"
  -- i a b c Esc
  let input1 := [Key.char 'i'] ++ keys "abc" ++ [Key.esc]
  let s1 ← runKeys s0 input1
  assertBuffer "Text after insert abc" s1 "abc"
  -- 2. Undo
  -- u
  let s2 ← runKeys s1 [Key.char 'u']
  assertBuffer "Text after undo" s2 ""
  assertCursor "Cursor after undo should be (0,0)" s2 0 0
  -- 3. Insert "d"
  -- i d Esc
  let s3 ← runKeys s2 [Key.char 'i', Key.char 'd', Key.esc]
  assertBuffer "Text after re-insert d" s3 "d"
  assertCursor "Cursor after insert 'd' and Esc should be (0,0)" s3 0 0
  IO.println "IntegrationTest passed!"
end ViETest.Integration

File addition: InfoView.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE
import ViETest.Utils
namespace ViETest.InfoView
open ViETest.Utils
def makeTestConfig : ViE.Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
def test : IO Unit := do
  IO.println "Starting InfoView ViETest..."
  let s0 : ViE.EditorState :=
    ({ ViE.initialState with message := "", floatingOverlay := none, mode := .normal, infoViewRequested := false }).updateActiveBuffer fun b =>
      { b with filename := some "Main.lean" }
  let s0' ← ViE.Lsp.Lean.syncInfoViewWindow s0
  let ws0 := s0'.getCurrentWorkspace
  assertEqual "InfoView hidden when not requested" 1 (ViE.Window.getWindowIds ws0.layout |>.length)
  let sNonLean := ({ s0 with infoViewRequested := true }).updateActiveBuffer fun b =>
    { b with filename := some "note.md" }
  let sNonLean' ← ViE.Lsp.Lean.syncInfoViewWindow sNonLean
  let wsNonLean := sNonLean'.getCurrentWorkspace
  assertEqual "InfoView hidden for non-Lean buffer" 1 (ViE.Window.getWindowIds wsNonLean.layout |>.length)
  let sLean := ({ s0 with infoViewRequested := true }).updateActiveBuffer fun b =>
    { b with table := ViE.PieceTable.fromString "abc\n" }
  let sLean' ← ViE.Lsp.Lean.syncInfoViewWindow sLean
  let wsLean := sLean'.getCurrentWorkspace
  assertEqual "InfoView split creates second window" 2 (ViE.Window.getWindowIds wsLean.layout |>.length)
  let infoBufOpt := wsLean.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)
  assertEqual "InfoView buffer exists" true infoBufOpt.isSome
  match infoBufOpt with
  | none =>
      assertEqual "InfoView content check skipped unexpectedly" true false
  | some infoBuf =>
      let line0 := ViE.getLineFromBuffer infoBuf 0 |>.getD ""
      let line1 := ViE.getLineFromBuffer infoBuf 1 |>.getD ""
      assert "InfoView includes file line" (line0.startsWith "File: Main.lean")
      assertEqual "InfoView position line" "Position: 1:1  Byte: 0" line1
  let cfg := makeTestConfig
  let sMoved ← ViE.update cfg sLean' (ViE.Key.char 'l')
  let wsMoved := sMoved.getCurrentWorkspace
  let movedInfoBufOpt := wsMoved.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)
  assertEqual "InfoView buffer exists after cursor move" true movedInfoBufOpt.isSome
  match movedInfoBufOpt with
  | none =>
      assertEqual "InfoView cursor move check skipped unexpectedly" true false
  | some infoBuf =>
      let line1 := ViE.getLineFromBuffer infoBuf 1 |>.getD ""
      assertEqual "InfoView position updates on cursor move" "Position: 1:2  Byte: 1" line1
  let sOff := { sLean' with infoViewRequested := false }
  let sOff' ← ViE.Lsp.Lean.syncInfoViewWindow sOff
  let wsOff := sOff'.getCurrentWorkspace
  assertEqual "InfoView off closes split window" 1 (ViE.Window.getWindowIds wsOff.layout |>.length)
  assertEqual "InfoView off removes buffer" true ((wsOff.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)).isNone)
  let sInfoOnly := ViE.Window.closeActiveWindow sLean'
  let sInfoOnly' ← ViE.Lsp.Lean.syncInfoViewWindow sInfoOnly
  let wsInfoOnly := sInfoOnly'.getCurrentWorkspace
  assertEqual "InfoView-only fallback requests quit" true sInfoOnly'.shouldQuit
  assertEqual "InfoView-only fallback removes InfoView buffer" true ((wsInfoOnly.buffers.find? (fun b => b.filename == some ViE.Lsp.Lean.infoViewVirtualPath)).isNone)
  IO.println "InfoView Test passed!"
end ViETest.InfoView

File addition: ExplorerPreview.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.Command.Explorer
import ViE.Window.Analysis
import ViE.Window.Actions
import ViE.BlikuAdapter
import ViETest.Utils
namespace ViETest.ExplorerPreview
open ViETest.Utils
open ViE
def findEntryIndex (entries : List FileEntry) (name : String) : Option Nat :=
  let rec loop (list : List FileEntry) (idx : Nat) : Option Nat :=
    match list with
    | [] => none
    | e :: rest =>
      if e.name == name then
        some idx
      else
        loop rest (idx + 1)
  loop entries 0
def test : IO Unit := do
  IO.println "Starting Explorer Preview ViETest..."
  let s0 := { ViE.initialState with windowHeight := 40, windowWidth := 120 }
  let path := "ViETest/test_paths/dir0/dir1"
  let s1 ← ViE.Feature.openExplorer s0 path
  let buf := s1.getActiveBuffer
  let ws1 := s1.getCurrentWorkspace
  assert "File explorer opens in regular window" (!ws1.isFloatingWindow ws1.activeWindowId)
  let model1 := ViE.BlikuAdapter.toModel s1
  let explorerClustered :=
    match model1.workspace.floatingClusters[0]? with
    | some cluster =>
        match cluster.root, cluster.sizePolicy with
        | .group gid, .multiPane => gid == buf.id
        | _, _ => false
    | none => false
  assert "Bliku adapter lifts explorer/preview into floating multi-pane cluster" explorerClustered
  let baseBufId := s0.getActiveBuffer.id
  let baseWinId :=
    (ViE.Window.getWindowIds ws1.layout).find? (fun wid =>
      if wid == ws1.activeWindowId then
        false
      else
        match ws1.layout.findView wid with
        | some v => v.bufferId == baseBufId
        | none => false)
  let baseWindowStillExists :=
    (ViE.Window.getWindowIds ws1.layout).any (fun wid =>
      if wid == ws1.activeWindowId then
        false
      else
        match ws1.layout.findView wid with
        | some v => v.bufferId == baseBufId
        | none => false)
  assert "Opening explorer keeps original buffer window intact" baseWindowStillExists
  let explorerOpt := s1.explorers.find? (fun (id, _) => id == buf.id)
  match explorerOpt with
  | none =>
    throw (IO.userError "Explorer buffer not registered")
  | some (_, explorer) =>
    let idx1 := findEntryIndex explorer.entries "file1.txt"
    let idx2 := findEntryIndex explorer.entries "file2.txt"
    assert "file1.txt exists in explorer entries" idx1.isSome
    assert "file2.txt exists in explorer entries" idx2.isSome
    let row1 : Row := ⟨2 + idx1.get!⟩
    let row2 : Row := ⟨2 + idx2.get!⟩
    let exAfterOpen := s1.explorers.find? (fun (id, _) => id == buf.id) |>.map (fun (_, ex) => ex)
    match exAfterOpen with
    | none => throw (IO.userError "Explorer buffer not registered after open")
    | some exOpen =>
      assert "Preview window created on open" exOpen.previewWindowId.isSome
      let previewRegular :=
        match exOpen.previewWindowId with
        | some wid => !s1.getCurrentWorkspace.isFloatingWindow wid
        | none => false
      assert "Preview window opens in regular window" previewRegular
      let pairSideBySide :=
        match exOpen.previewWindowId with
        | some wid =>
          let bounds := ViE.Window.getAllWindowBounds s1.getCurrentWorkspace.layout
            (if s1.windowHeight > 0 then s1.windowHeight - 1 else 0) s1.windowWidth
          match bounds.find? (fun (id, _, _, _, _) => id == s1.getCurrentWorkspace.activeWindowId),
                bounds.find? (fun (id, _, _, _, _) => id == wid) with
          | some (_, et, el, eh, ew), some (_, pt, pl, ph, pw) =>
            et == pt && eh == ph && ((el + ew <= pl) || (pl + pw <= el))
          | _, _ => false
        | none => false
      assert "Explorer/preview pair is side-by-side" pairSideBySide
    let s2 := s1.updateActiveView fun v => { v with cursor := { row := row1, col := 0 } }
    let s3 ← ViE.Feature.refreshExplorerPreview s2
    let exAfterOpt := s3.explorers.find? (fun (id, _) => id == buf.id)
    match exAfterOpt with
    | none =>
      throw (IO.userError "Explorer buffer not registered after preview")
    | some (_, exAfter) =>
      assert "Preview window created" exAfter.previewWindowId.isSome
      assert "Preview buffer created" exAfter.previewBufferId.isSome
      let ws := s3.getCurrentWorkspace
      let previewWinId := exAfter.previewWindowId.get!
      let previewView := ws.layout.findView previewWinId |>.getD initialView
      let previewBuf := ws.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
      assert "Preview filename has prefix" ((previewBuf.filename.getD "").startsWith "preview://")
      assert "Preview filename contains file1.txt" ((previewBuf.filename.getD "").contains "file1.txt")
      let dirIdx := findEntryIndex exAfter.entries "dir0"
      assert "dir0 exists in explorer entries" dirIdx.isSome
      let dirRow : Row := ⟨2 + dirIdx.get!⟩
      let s3a := s3.updateActiveView fun v => { v with cursor := { row := dirRow, col := 0 } }
      let s3b ← ViE.Feature.handleExplorerEnter s3a
      let idsAfterDir := ViE.Window.getWindowIds s3b.getCurrentWorkspace.layout
      assert "Preview window kept on directory navigation" (idsAfterDir.contains previewWinId)
      let newExplorerOpt := s3b.explorers.find? (fun (id, _) => id == s3b.getActiveBuffer.id)
      match newExplorerOpt with
      | none => throw (IO.userError "Explorer buffer not registered after directory nav")
      | some (_, exAfterDir) =>
        assert "Preview window id preserved on directory nav" (exAfterDir.previewWindowId == exAfter.previewWindowId)
      let s4 := s3.updateActiveView fun v => { v with cursor := { row := row2, col := 0 } }
      let s5 ← ViE.Feature.refreshExplorerPreview s4
      let ws5 := s5.getCurrentWorkspace
      let previewView2 := ws5.layout.findView previewWinId |>.getD initialView
      let previewBuf2 := ws5.buffers.find? (fun b => b.id == previewView2.bufferId) |>.getD initialBuffer
      assert "Preview filename updates to file2.txt" ((previewBuf2.filename.getD "").contains "file2.txt")
      let s5a := s5.updateActiveView fun v => { v with cursor := { row := row2, col := 0 } }
      let explorerWinId := s5a.getCurrentWorkspace.activeWindowId
      let s5b ← ViE.Feature.handleExplorerEnter s5a
      let ws5b := s5b.getCurrentWorkspace
      assert "Opening file from explorer leaves regular window" (!ws5b.isFloatingWindow ws5b.activeWindowId)
      match baseWinId with
      | some wid =>
          assert "Opening file from explorer uses original buffer window" (ws5b.activeWindowId == wid)
      | none =>
          throw (IO.userError "Base window id not found after explorer open")
      let idsAfterOpen := ViE.Window.getWindowIds s5b.getCurrentWorkspace.layout
      assert "Explorer window removed on file open" (!idsAfterOpen.contains explorerWinId)
      assert "Preview window removed on file open" (!idsAfterOpen.contains previewWinId)
      let bufIdsAfterOpen := s5b.getCurrentWorkspace.buffers.map (fun b => b.id)
      let previewBufId := exAfter.previewBufferId.getD 0
      assert "Preview buffer removed on file open" (!bufIdsAfterOpen.contains previewBufId)
      let sClose := ViE.Window.closeActiveWindow s5
      let idsAfter := ViE.Window.getWindowIds sClose.getCurrentWorkspace.layout
      assert "Preview window removed on explorer close" (!idsAfter.contains previewWinId)
      let bufIdsAfterClose := sClose.getCurrentWorkspace.buffers.map (fun b => b.id)
      assert "Preview buffer removed on explorer close" (!bufIdsAfterClose.contains previewBufId)
      let s6 ← ViE.Feature.toggleExplorerPreview s5
      let exAfterClose := s6.explorers.find? (fun (id, _) => id == buf.id) |>.map (fun (_, ex) => ex)
      match exAfterClose with
      | none => throw (IO.userError "Explorer buffer missing after close")
      | some exClose =>
        assert "Preview window cleared" exClose.previewWindowId.isNone
  IO.println "Explorer Preview Test passed!"
end ViETest.ExplorerPreview

File addition: CursorReproduction.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.Config
import ViE.Command.Impl
import ViE.Key.Map
import ViE.State.Edit
namespace ViETest.CursorReproduction
open ViE
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
-- Helper to construct a full Config
def makeTestConfig : Config := {
  settings := ViE.defaultConfig
  commands := ViE.Command.defaultCommandMap
  bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
}
-- Run a sequence of keys
def runKeys (startState : EditorState) (keys : List Key) : IO EditorState := do
  let config := makeTestConfig
  let mut s := startState
  for k in keys do
    s ← ViE.update config s k
  return s
def test : IO Unit := do
  IO.println "Starting Cursor Reproduction ViETest..."
  let s := ViE.initialState
  -- Scenario: Insert, Undo, Insert
  let s1 := s.insertChar 'a'
  let s1 := s1.commitEdit -- Force separate undo group
  let s2 := s1.insertChar 'b'
  -- Text: 'ab', Cursor: (0, 2)
  let s3 := s2.undo
  -- Text: 'a', Cursor should be (0, 1)
  let cursor := s3.getCursor
  if cursor.col.val != 1 then
     IO.println s!"[FAIL] Undo cursor mismatch. Expected 1, got {cursor.col.val}"
     assert "Undo cursor" false
  else
     IO.println "[PASS] Undo cursor correct"
  -- Scenario: Wide character insert moves cursor by display width
  let s := ViE.initialState
  let wide := Char.ofNat 0x3042 -- Hiragana A (wide)
  let s := s.insertChar wide
  let cursor := s.getCursor
  if cursor.col.val != 2 then
     IO.println s!"[FAIL] Wide char cursor mismatch. Expected 2, got {cursor.col.val}"
     assert "Wide char cursor" false
  else
     IO.println "[PASS] Wide char cursor correct"
  let s4 := s3.insertChar 'c'
  -- Text: 'ac'
  let text := getLineFromBuffer s4.getActiveBuffer 0 |>.getD ""
  if text != "ac" then
      IO.println s!"[FAIL] Insert after undo failed. Expected 'ac', got '{text}'"
      assert "Insert after undo" false
  else
      IO.println "[PASS] Insert after undo works"
  -- Scenario: Paste, Undo, Paste (checking grouping too, but focusing on cursor)
  -- Reset
  let s := ViE.initialState
  let s := s.insertChar 'x'
  let s := s.yankCurrentLine -- Yank 'x\n'
  let _s := s.pasteBelow -- Paste 'x\n' -> 'x\nx\n' ??
  -- PasteBelow pastes line.
  -- Scenario: x command
  let s := ViE.initialState
  let s := s.insertChar 'h'
  let s := s.insertChar 'e'
  let s := s.insertChar 'y'
  -- "hey"
  let s := (s.moveCursorLeft).moveCursorLeft -- At 'h' (0,0)? No: 3 -> 2 -> 1. 'e'
  -- "hey" cursor at 2 ('y'). Left -> 1 ('e'). Left -> 0 ('h').
  -- Actually moveCursorLeft from (0,3) -> (0,2) 'y'.
  -- Let's use setCursor
  let s := s.setCursor (Point.make 0 1) -- 'e'
  let s := s.deleteCharAfterCursor -- Should delete 'e' -> "hy"
  let text := getLineFromBuffer s.getActiveBuffer 0 |>.getD ""
  if text != "hy" then
     IO.println s!"[FAIL] 'x' command (deleteCharAfterCursor) failed. Expected 'hy', got '{text}'"
     assert "x command" false
  else
     IO.println "[PASS] 'x' command works"
  -- 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)
  IO.println "Cursor Reproduction Test Finished"
end ViETest.CursorReproduction

File addition: Checkpoint.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.App
import ViE.Buffer.Manager
import ViE.Checkpoint
import ViE.State.Config
import ViETest.Utils
namespace ViETest.Checkpoint
open ViETest.Utils
open ViE
def testLoadSessionInvalid : IO Unit := do
  IO.println "Starting Checkpoint Parse Invalid ViETest..."
  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 ViETest..."
  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 ViETest..."
  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
      assertEqual "Restored inactive buffer is lazy" false b1.loaded
      assertEqual "Restored active buffer is loaded" true b2.loaded
  | _ =>
      throw (IO.userError "Expected two restored buffers")
  let s0 := ({ ViE.initialState with config := ViE.defaultConfig }).updateCurrentWorkspace (fun _ => ws)
  let s1 := s0.updateCurrentWorkspace fun ws =>
    { ws with layout := ws.layout.updateView ws.activeWindowId (fun v => { v with bufferId := 0 }) }
  let s2 ← ViE.Buffer.ensureActiveBufferLoaded s1
  let activeLoaded := s2.getActiveBuffer
  assertEqual "Lazy buffer loads on activation" true activeLoaded.loaded
  assertEqual "Lazy loaded buffer keeps file path" (some f1) activeLoaded.filename
def testBuildRestoredWorkspaceCustomTabStop : IO Unit := do
  IO.println "Starting Restored Workspace Custom TabStop ViETest..."
  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
def test : IO Unit := do
  testLoadSessionInvalid
  testLoadSessionValid
  testBuildRestoredWorkspace
  testBuildRestoredWorkspaceCustomTabStop
end ViETest.Checkpoint

File addition: Buffer.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.Buffer.Content
import ViE.Types
import ViE.Data.PieceTable
open ViE
namespace ViETest.Buffer
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  IO.println "Starting Buffer ViETest..."
  -- 1. Test fromString and getLine
  let text := "Hello\nWorld"
  let pt := PieceTable.fromString text
  let buf : FileBuffer := { initialFileBuffer with table := pt }
  -- Check lines
  match getLineFromBuffer buf 0 with
  | some l => assert "Line 0 is Hello" (l == "Hello")
  | none => assert "Line 0 missing" false
  match getLineFromBuffer buf 1 with
  | some l => assert "Line 1 is World" (l == "World")
  | none => assert "Line 1 missing" false
  match getLineFromBuffer buf 2 with
  | some _ => assert "Line 2 should be missing" false
  | none => assert "Line 2 correctly missing" true
  -- 2. Test FileBuffer <-> TextBuffer conversion
  let tb : TextBuffer := #[ #['A', 'B'], #['C'] ] -- "AB\nC"
  let buf2 := ViE.Buffer.fileBufferFromTextBuffer 1 (some "test.txt") tb
  assert "Buffer created from TextBuffer id" (buf2.id == 1)
  assert "Buffer created from TextBuffer filename" (buf2.filename == some "test.txt")
  let tb2 := ViE.Buffer.fileBufferToTextBuffer buf2
  assert "Roundtrip TextBuffer size" (tb2.size == 2)
  if tb2.size == 2 then
    let l0 := tb2[0]!
    let l1 := tb2[1]!
    assert "Roundtrip Line 0" (String.ofList l0.toList == "AB")
    assert "Roundtrip Line 1" (String.ofList l1.toList == "C")
  IO.println "BufferTest passed!"
end ViETest.Buffer

File addition: Benchmark.lean (----------)

[0.87]

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.State.Config
import ViE.Config
import ViE.Command.Impl
import ViE.Key.Map
import ViE.State.Edit
import ViE.State.Search
import ViE.Data.PieceTable.Tree
import ViE.UI
namespace ViE.Benchmark
open ViE
/-- Mock Config for Benchmarking -/
def makeBenchConfig (buildLeafBits : Option Bool := none) : Config :=
  let base := ViE.defaultConfig
  let settings :=
    match buildLeafBits with
    | some v => { base with searchBloomBuildLeafBits := v }
    | none => base
  {
    settings := settings
    commands := ViE.Command.defaultCommandMap
    bindings := ViE.Key.makeKeyMap ViE.Command.defaultCommandMap
  }
structure BenchOptions where
  iterations : Nat := 1000
  render : Bool := true
  cases : List String := []
  textLines : Nat := 200
  lineLen : Nat := 80
  warmup : Nat := 0
  buildLeafBits : Option Bool := none
  listOnly : Bool := false
def parseArgs (args : List String) : BenchOptions :=
  let rec loop (opts : BenchOptions) (args : List String) : BenchOptions :=
    match args with
    | [] => opts
    | "--no-render" :: rest => loop { opts with render := false } rest
    | "--case" :: name :: rest => loop { opts with cases := opts.cases ++ [name] } rest
    | "--lines" :: n :: rest =>
        match n.toNat? with
        | some v => loop { opts with textLines := v } rest
        | none => loop opts rest
    | "--line-len" :: n :: rest =>
        match n.toNat? with
        | some v => loop { opts with lineLen := v } rest
        | none => loop opts rest
    | "--warmup" :: n :: rest =>
        match n.toNat? with
        | some v => loop { opts with warmup := v } rest
        | none => loop opts rest
    | "--bloom-leaf-bits" :: rest => loop { opts with buildLeafBits := some true } rest
    | "--no-bloom-leaf-bits" :: rest => loop { opts with buildLeafBits := some false } rest
    | "--list" :: rest => loop { opts with listOnly := true } rest
    | arg :: rest =>
        match arg.toNat? with
        | some v => loop { opts with iterations := v } rest
        | none => loop opts rest
  loop {} args
def timeCase (label : String) (iterations : Nat) (f : IO Unit) : IO Unit := do
  let t0 ← IO.monoMsNow
  f
  let t1 ← IO.monoMsNow
  let ms := t1 - t0
  let opsPerSec := if ms == 0 then 0 else (iterations * 1000) / ms
  IO.println s!"[bench] {label}: {ms} ms ({opsPerSec} ops/s)"
/-- Build a simple multi-line ASCII buffer for search benchmarks. -/
def buildText (lines : Nat) (lineLen : Nat) : String :=
  let line := String.ofList (List.replicate lineLen 'a')
  String.intercalate "\n" (List.replicate lines line)
/-- Insert a needle in the middle of text for search benchmarks. -/
def buildSearchText (lines : Nat) (lineLen : Nat) (needle : String) : String :=
  let baseLine := String.ofList (List.replicate lineLen 'a')
  let mid := lines / 2
  let leftLen := lineLen / 2
  let rightLen := if lineLen > leftLen + needle.length then lineLen - leftLen - needle.length else 0
  let needleLine :=
    (String.ofList (List.replicate leftLen 'a')) ++
    needle ++
    (String.ofList (List.replicate rightLen 'a'))
  let linesArr := Id.run do
    let mut arr := Array.replicate lines baseLine
    if mid < arr.size then
      arr := arr.set! mid needleLine
    return arr
  String.intercalate "\n" linesArr.toList
/-- Case: Large insert workload (EditorState). -/
def benchInsert (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for i in [0:iterations] do
    s := s.insertChar 'a'
    if i % 100 == 0 then
      s := s.commitEdit
/-- Case: Mixed small edits/movements. -/
def benchEditMix (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for _ in [0:iterations] do
    s := s.insertChar 'a'
    s := s.moveCursorLeft
    s := s.insertChar 'b'
    s := s.moveCursorRight
/-- Case: Clipboard (yank/paste). -/
def benchClipboard (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  s := s.insertChar 'x'
  for _ in [0:iterations/50] do
    s := s.yankCurrentLine
    s := s.pasteBelow
/-- Case: Workgroup churn. -/
def benchWorkgroups (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for i in [0:iterations/200] do
    s := ← ViE.Command.cmdWg ["new", s!"BenchGroup {i}"] s
    s := s.insertChar 'w'
  for _ in [0:iterations/200] do
    s := ← ViE.Command.cmdWg ["close"] s
/-- Case: Window splits/cycles. -/
def benchWindows (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for _ in [0:iterations/500] do
    s := ViE.Window.splitWindow s true
    s := ViE.Window.splitWindow s false
    s := s.insertChar 'v'
    s := ViE.Window.cycleWindow s
  for _ in [0:iterations/200] do
    s := ViE.Window.closeActiveWindow s
/-- Case: Undo/Redo stress. -/
def benchUndoRedo (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for i in [0:iterations] do
    s := s.insertChar 'a'
    if i % 50 == 0 then
      s := s.commitEdit
  for _ in [0:iterations/10] do
    s := s.undo
  for _ in [0:iterations/10] do
    s := s.redo
/-- Case: Search workload (PieceTable). -/
def benchSearch (iterations : Nat) (useBloom : Bool) (lines lineLen : Nat) (buildLeafBits : Bool) (cacheMax : Nat) : IO Unit := do
  let needle := "needle"
  let text := buildSearchText lines lineLen needle
  let pt := PieceTable.fromString text buildLeafBits
  let pattern := needle.toUTF8
  let mut offset := 0
  let mut cache : Lean.RBMap Nat ByteArray compare := Lean.RBMap.empty
  let mut order : Array Nat := #[]
  for _ in [0:iterations] do
    let (res, cache', order') := PieceTree.searchNext pt.tree pt pattern offset searchChunkSize useBloom cache order cacheMax
    cache := cache'
    order := order'
    offset := match res with
      | some r => r + 1
      | none => 0
/-- Case: Render workload. -/
def benchRender (iterations : Nat) : IO Unit := do
  let mut s := ViE.initialState
  for _ in [0:iterations/20] do
    s := s.insertChar 'a'
  let _ ← ViE.UI.render s
/-- Generate large text content of specified size (in bytes). -/
def buildLargeText (sizeBytes : Nat) : String :=
  let lineLen := 80
  let line := String.ofList (List.replicate lineLen 'a') ++ "\n"
  let lineBytes := line.utf8ByteSize
  let numLines := sizeBytes / lineBytes
  String.intercalate "" (List.replicate numLines line)
/-- Case: Load large file (1MB). -/
def benchLoadLarge1MB (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)  -- 1MB
  let _ := PieceTable.fromString text buildLeafBits
  pure ()
/-- Case: Load large file (10MB). -/
def benchLoadLarge10MB (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)  -- 10MB
  let _ := PieceTable.fromString text buildLeafBits
  pure ()
/-- Case: Load large file (100MB). -/
def benchLoadLarge100MB (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (100 * 1024 * 1024)  -- 100MB
  let _ := PieceTable.fromString text buildLeafBits
  pure ()
/-- Case: Insert at middle of large file (1MB). -/
def benchInsertMidLarge1MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  -- Consume split results so optimizer cannot erase this loop.
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Insert at middle of large file (10MB). -/
def benchInsertMidLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  -- Consume split results so optimizer cannot erase this loop.
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Split operation on large file (1MB). -/
def benchSplitLarge1MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: Split operation on large file (10MB). -/
def benchSplitLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let midOffset := pt.tree.stats.bytes.toNat / 2
  let mut checksum := 0
  for _ in [0:iterations] do
    let (l, r) := PieceTree.split pt.tree midOffset pt
    checksum := checksum + l.stats.bytes.toNat + r.stats.bytes.toNat
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: GetBytes operation on large file (1MB). -/
def benchGetBytesLarge1MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let chunkSize := 1024  -- 1KB chunks
  let mut checksum := 0
  for i in [0:iterations] do
    let offset := (i * chunkSize) % pt.tree.stats.bytes.toNat
    let bytes := PieceTree.getBytes pt.tree offset chunkSize pt
    checksum := checksum + bytes.size
  if checksum == 0 then
    IO.println "Zero bytes?"
/-- Case: GetBytes operation on large file (10MB). -/
def benchGetBytesLarge10MB (iterations : Nat) (buildLeafBits : Bool) : IO Unit := do
  let text := buildLargeText (10 * 1024 * 1024)
  let pt := PieceTable.fromString text buildLeafBits
  let chunkSize := 1024  -- 1KB chunks
  let mut checksum := 0
  for i in [0:iterations] do
    let offset := (i * chunkSize) % pt.tree.stats.bytes.toNat
    let bytes := PieceTree.getBytes pt.tree offset chunkSize pt
    checksum := checksum + bytes.size
  if checksum == 0 then
    IO.println "Zero bytes?"
def availableCases : List String :=
  [ "insert", "edit", "clipboard", "workgroups", "windows", "undo", "search-bloom", "search-linear", "render",
    "load-1mb", "load-10mb", "load-100mb",
    "insert-mid-1mb", "insert-mid-10mb",
    "split-1mb", "split-10mb",
    "getbytes-1mb", "getbytes-10mb" ]
/-- Run benchmark cases. -/
def runBenchmark (opts : BenchOptions) : IO Unit := do
  let buildLeafBits := opts.buildLeafBits.getD ViE.defaultConfig.searchBloomBuildLeafBits
  let config := makeBenchConfig (some buildLeafBits)
  let cacheMax := config.settings.searchBloomCacheMax
  let cases := if opts.cases.isEmpty then availableCases else opts.cases
  IO.println s!"Starting benchmark: iter={opts.iterations}, render={opts.render}"
  if opts.warmup > 0 then
    IO.println s!"Warmup: {opts.warmup} iterations"
    for _ in [0:opts.warmup] do
      let mut s := ViE.initialState
      s := s.insertChar 'a'
      let _ ← pure s
  for c in cases do
    match c with
    | "insert" => timeCase "insert" opts.iterations (benchInsert opts.iterations)
    | "edit" => timeCase "edit" opts.iterations (benchEditMix opts.iterations)
    | "clipboard" => timeCase "clipboard" opts.iterations (benchClipboard opts.iterations)
    | "workgroups" => timeCase "workgroups" opts.iterations (benchWorkgroups opts.iterations)
    | "windows" => timeCase "windows" opts.iterations (benchWindows opts.iterations)
    | "undo" => timeCase "undo/redo" opts.iterations (benchUndoRedo opts.iterations)
    | "search-bloom" =>
        timeCase "search-bloom" opts.iterations (benchSearch opts.iterations true opts.textLines opts.lineLen buildLeafBits cacheMax)
    | "search-linear" =>
        timeCase "search-linear" opts.iterations (benchSearch opts.iterations false opts.textLines opts.lineLen buildLeafBits cacheMax)
    | "render" =>
        if opts.render then
          timeCase "render" opts.iterations (benchRender opts.iterations)
        else
          IO.println "[bench] render skipped (--no-render)"
    | "load-1mb" =>
        let text := buildLargeText (1024 * 1024)
        timeCase "load-1mb" opts.iterations (for _ in [0:opts.iterations] do
          let pt := PieceTable.fromString text buildLeafBits
          if pt.tree.stats.bytes == 0 then IO.println "Zero bytes?" -- force usage
        )
    | "load-10mb" =>
        let text := buildLargeText (10 * 1024 * 1024)
        timeCase "load-10mb" opts.iterations (for _ in [0:opts.iterations] do
          let pt := PieceTable.fromString text buildLeafBits
          if pt.tree.stats.bytes == 0 then IO.println "Zero bytes?"
        )
    | "load-100mb" =>
        let text := buildLargeText (100 * 1024 * 1024)
        timeCase "load-100mb" opts.iterations (for _ in [0:opts.iterations] do
          let pt := PieceTable.fromString text buildLeafBits
          if pt.tree.stats.bytes == 0 then IO.println "Zero bytes?"
        )
    | "insert-mid-1mb" => timeCase "insert-mid-1mb" opts.iterations (benchInsertMidLarge1MB opts.iterations buildLeafBits)
    | "insert-mid-10mb" => timeCase "insert-mid-10mb" opts.iterations (benchInsertMidLarge10MB opts.iterations buildLeafBits)
    | "split-1mb" => timeCase "split-1mb" opts.iterations (benchSplitLarge1MB opts.iterations buildLeafBits)
    | "split-10mb" => timeCase "split-10mb" opts.iterations (benchSplitLarge10MB opts.iterations buildLeafBits)
    | "getbytes-1mb" => timeCase "getbytes-1mb" opts.iterations (benchGetBytesLarge1MB opts.iterations buildLeafBits)
    | "getbytes-10mb" => timeCase "getbytes-10mb" opts.iterations (benchGetBytesLarge10MB opts.iterations buildLeafBits)
    | other =>
        IO.println s!"[bench] Unknown case: {other}"
  IO.println "Benchmark completed."
end ViE.Benchmark
/-- CLI entrypoint. -/
def main (args : List String) : IO Unit := do
  let opts := ViE.Benchmark.parseArgs args
  if opts.listOnly then
    IO.println "Available cases:"
    IO.println (String.intercalate ", " ViE.Benchmark.availableCases)
  else
    ViE.Benchmark.runBenchmark opts

test: rename Test modules to ViETest and remove dead code

Dependencies

In channels

Change contents

File deletion: Test.lean

File deletion: Test

File deletion: TreeStatsMain.lean

File deletion: ExplorerPreview.lean

File deletion: PreviewData.lean

File deletion: WorkgroupExplorer.lean

File deletion: Workspace.lean

File deletion: test_paths

File deletion: dir0

File deletion: dir0

File deletion: dir0

File deletion: file0.txt

File deletion: file0.txt

File deletion: file1.txt

File deletion: dir1

File deletion: dir0

File deletion: file0.txt

File deletion: dir1

File deletion: file0.txt

File deletion: dir2

File deletion: file0.txt

File deletion: dir3

File deletion: file0.txt

File deletion: file1.txt

File deletion: file2.txt

File deletion: file3.txt

File deletion: file4.txt

File deletion: file5.txt

File deletion: dir2

File deletion: file0.txt

File deletion: file1.txt

File deletion: file2.txt

File deletion: file3.txt

File deletion: file0.txt

File deletion: InfoView.lean

File deletion: Keybinds.lean

File deletion: Mode.lean

File deletion: Benchmark.lean

File deletion: CursorReproduction.lean

File deletion: MissingEol.lean

File deletion: PasteReproduction.lean

File deletion: SyntaxHighlight.lean

File deletion: TreeStats.lean

File deletion: Buffer.lean

File deletion: Integration.lean

File deletion: Layout.lean

File deletion: Undo.lean

File deletion: Scroll.lean

File deletion: Checkpoint.lean

File deletion: PieceTable

File deletion: Search.lean

File deletion: Appended.lean

File deletion: Basic.lean

File deletion: Stress.lean

File deletion: UndoRedo.lean

File deletion: SearchHighlight.lean

File deletion: Utils.lean

File deletion: Lsp.lean

Replacement in lakefile.lean at line 14 [30.38]

Replacement in lakefile.lean at line 23 [30.38]

Replacement in lakefile.lean at line 26 [30.38]

File addition: ViETest (d--x------)

File addition: test_paths (d--x------)

File addition: file0.txt (----------)

File addition: dir0 (d--x------)

File addition: file3.txt (----------)

File addition: file2.txt (----------)

File addition: file1.txt (----------)

File addition: file0.txt (----------)

File addition: dir2 (d--x------)

File addition: dir1 (d--x------)

File addition: file5.txt (----------)

File addition: file4.txt (----------)

File addition: file3.txt (----------)

File addition: file2.txt (----------)

File addition: file1.txt (----------)