def Workspace.resolvePath (ws : Workspace) (path : String) : String :=

def WorkspaceState.resolvePath (ws : WorkspaceState) (path : String) : String :=

  let wg := state.getCurrentWorkgroup
  let bounds := ViE.Window.getAllWindowBounds wg.layout (if state.windowHeight > 0 then state.windowHeight - 1 else 0) state.windowWidth
  let current := bounds.find? (fun (id, _, _, _, _) => id == wg.activeWindowId)

  let ws := state.getCurrentWorkspace
  let bounds := ViE.Window.getAllWindowBounds ws.layout (if state.windowHeight > 0 then state.windowHeight - 1 else 0) state.windowWidth
  let current := bounds.find? (fun (id, _, _, _, _) => id == ws.activeWindowId)

      id != wg.activeWindowId &&

      id != ws.activeWindowId &&

    | some (id, _, _, _, _) => state.updateCurrentWorkgroup fun wg => { wg with activeWindowId := id }

    | some (id, _, _, _, _) => state.updateCurrentWorkspace fun ws => { ws with activeWindowId := id }

  let wg := state.getCurrentWorkgroup
  match wg.layout.remove wg.activeWindowId with
  | none => { state with shouldQuit := true }
  | some newLayout =>
    state.updateCurrentWorkgroup fun wg =>
      let newIds := ViE.Window.getWindowIds newLayout
      let newActiveId := match newIds with
        | [] => 0 -- Should not happen if layout valid
        | h :: _ => h
      { wg with layout := newLayout, activeWindowId := newActiveId }

  let doClose (st : EditorState) : EditorState :=
    let ws := st.getCurrentWorkspace
    match ws.layout.remove ws.activeWindowId with
    | none => { st with shouldQuit := true }
    | some newLayout =>
      st.updateCurrentWorkspace fun ws =>
        let newIds := ViE.Window.getWindowIds newLayout
        let newActiveId := match newIds with
          | [] => 0 -- Should not happen if layout valid
          | h :: _ => h
        { ws with layout := newLayout, activeWindowId := newActiveId }
  let activeBuf := state.getActiveBuffer
  let explorerOpt := state.explorers.find? (fun (id, _) => id == activeBuf.id)
  match explorerOpt with
  | none => doClose state
  | some (bufId, explorer) =>
      let s1 := { state with explorers := state.explorers.filter (fun (id, _) => id != bufId) }
      let s2 :=
        match explorer.previewWindowId with
        | none => s1
        | some previewId =>
          s1.updateCurrentWorkspace fun ws =>
            match ws.layout.remove previewId with
            | some newLayout => { ws with layout := newLayout }
            | none => ws
      let s3 :=
        match explorer.previewBufferId with
        | some previewBufId => ViE.Buffer.removeBuffer s2 previewBufId
        | none => s2
      doClose s3

  let s' := state.updateCurrentWorkgroup fun wg =>
    let activeId := wg.activeWindowId
    let nextId := wg.nextWindowId
    let currentView := wg.layout.findView activeId |>.getD initialView

  let s' := state.updateCurrentWorkspace fun ws =>
    let activeId := ws.activeWindowId
    let nextId := ws.nextWindowId
    let currentView := ws.layout.findView activeId |>.getD initialView

    { wg with layout := updateLayout wg.layout, nextWindowId := nextId + 1 }

    { ws with layout := updateLayout ws.layout, nextWindowId := nextId + 1 }

  state.updateCurrentWorkgroup fun wg =>
    let activeId := wg.activeWindowId

  state.updateCurrentWorkspace fun ws =>
    let activeId := ws.activeWindowId

    match traverse wg.layout with
    | some (newLayout, _) => { wg with layout := newLayout }
    | none => wg

    match traverse ws.layout with
    | some (newLayout, _) => { ws with layout := newLayout }
    | none => ws

  state.updateCurrentWorkgroup fun wg =>
    let ids := ViE.Window.getWindowIds wg.layout
    if ids.isEmpty then wg

  state.updateCurrentWorkspace fun ws =>
    let ids := ViE.Window.getWindowIds ws.layout
    if ids.isEmpty then ws

      let current := wg.activeWindowId

      let current := ws.activeWindowId

      | some nextId => { wg with activeWindowId := nextId }
      | none => { wg with activeWindowId := match ids with | [] => wg.activeWindowId | h :: _ => h }

      | some nextId => { ws with activeWindowId := nextId }
      | none => { ws with activeWindowId := match ids with | [] => ws.activeWindowId | h :: _ => h }

  let wg := state.getCurrentWorkgroup

  let ws := state.getCurrentWorkspace

    let wg := st.getCurrentWorkgroup
    wg.buffers.find? (fun b => b.id == id) |>.getD initialFileBuffer

    let ws := st.getCurrentWorkspace
    ws.buffers.find? (fun b => b.id == id) |>.getD initialFileBuffer

                   let s' := currentSt.updateCurrentWorkgroup fun wg =>
                     { wg with buffers := wg.buffers.map (fun (b : FileBuffer) => if b.id == buf.id then updatedBuf else b) }

                   let s' := currentSt.updateCurrentWorkspace fun ws =>
                     { ws with buffers := ws.buffers.map (fun (b : FileBuffer) => if b.id == buf.id then updatedBuf else b) }

                 let s' := currentSt.updateCurrentWorkgroup fun wg =>
                   { wg with buffers := wg.buffers.map (fun (b : FileBuffer) => if b.id == buf.id then updatedBuf else b) }

                 let s' := currentSt.updateCurrentWorkspace fun ws =>
                   { ws with buffers := ws.buffers.map (fun (b : FileBuffer) => if b.id == buf.id then updatedBuf else b) }

      let modeStr := if id == currentSt.getCurrentWorkgroup.activeWindowId then s!"-- {st.mode} --" else "--"

      let modeStr := if id == currentSt.getCurrentWorkspace.activeWindowId then s!"-- {st.mode} --" else "--"

      let statusStr := s!"{modeStr} {fileName}{eolMark} [W:{id} B:{view.bufferId}] [{wg.name}] {st.workspace.name}"

      let statusStr := s!"{modeStr} {fileName}{eolMark} [W:{id} B:{view.bufferId}] [{st.getCurrentWorkgroup.name}] {st.getCurrentWorkspace.name}"

  let (layoutStr, state) := renderLayout wg.layout state 0 0 layoutH cols

  let (layoutStr, state) := renderLayout ws.layout state 0 0 layoutH cols

      if id == wg.activeWindowId then

      if id == ws.activeWindowId then

    match getCursorPos wg.layout 0 0 layoutH cols with

    match getCursorPos ws.layout 0 0 layoutH cols with

/-- Workspace configuration -/
structure Workspace where
  rootPath : Option String := none
  name : String := "Untitled"
deriving Repr, Inhabited

inductive ExplorerMode where
  | files
  | workgroups
  | workspaces
  deriving Repr, Inhabited, BEq

  mode : ExplorerMode
  previewWindowId : Option Nat
  previewBufferId : Option Nat

/-- State for a single workgroup (independent buffer set and layout) -/
structure WorkgroupState where

/-- State for a single workspace (project unit). -/
structure WorkspaceState where

  rootPath : Option String

  deriving Repr, Inhabited
/-- State for a single workgroup (collection of workspaces). -/
structure WorkgroupState where
  name : String
  workspaces : Array WorkspaceState
  currentWorkspace : Nat

  workspace : Workspace

  let wg := s.getCurrentWorkgroup
  match wg.layout.findView wg.activeWindowId with

  let ws := s.getCurrentWorkspace
  match ws.layout.findView ws.activeWindowId with

/-- Get current workspace within the active workgroup -/
def EditorState.getCurrentWorkspace (s : EditorState) : WorkspaceState :=
  let wg := s.getCurrentWorkgroup
  wg.workspaces[wg.currentWorkspace]!

/-- Update current workspace within the active workgroup -/
def EditorState.updateCurrentWorkspace (s : EditorState) (f : WorkspaceState → WorkspaceState) : EditorState :=
  s.updateCurrentWorkgroup fun wg =>
    if h : wg.currentWorkspace < wg.workspaces.size then
      let ws := wg.workspaces[wg.currentWorkspace]!
      let updated := f ws
      { wg with workspaces := wg.workspaces.set! wg.currentWorkspace updated }
    else
      wg

  let wg := s.getCurrentWorkgroup
  match wg.layout.findView wg.activeWindowId with
  | some v => wg.buffers.find? (fun b => b.id == v.bufferId) |>.getD initialBuffer

  let ws := s.getCurrentWorkspace
  match ws.layout.findView ws.activeWindowId with
  | some v => ws.buffers.find? (fun b => b.id == v.bufferId) |>.getD initialBuffer

  s.updateCurrentWorkgroup fun wg =>
    let view := wg.layout.findView wg.activeWindowId

  s.updateCurrentWorkspace fun ws =>
    let view := ws.layout.findView ws.activeWindowId

      let newBuffers := wg.buffers.map fun b => if b.id == v.bufferId then FileBuffer.clearCache (f b) else b
      { wg with buffers := newBuffers }
    | none => wg

      let newBuffers := ws.buffers.map fun b => if b.id == v.bufferId then FileBuffer.clearCache (f b) else b
      { ws with buffers := newBuffers }
    | none => ws

  let wg := s.getCurrentWorkgroup
  match wg.layout.findView wg.activeWindowId with

  let ws := s.getCurrentWorkspace
  match ws.layout.findView ws.activeWindowId with

  s.updateCurrentWorkgroup fun wg =>
    { wg with layout := wg.layout.updateView wg.activeWindowId f }

  s.updateCurrentWorkspace fun ws =>
    { ws with layout := ws.layout.updateView ws.activeWindowId f }

  let wg := s.getCurrentWorkgroup

  let ws := s.getCurrentWorkspace

    | .window id _ => if id == wg.activeWindowId then some (h, w) else none

    | .window id _ => if id == ws.activeWindowId then some (h, w) else none

  (findBounds wg.layout layoutH s.windowWidth).getD (layoutH, s.windowWidth)

  (findBounds ws.layout layoutH s.windowWidth).getD (layoutH, s.windowWidth)

import ViE.Workspace

def defaultWorkspace : Workspace := {
  rootPath := none
  name := "ViE"
}

def defaultWorkspaceName : String := "ViE"

def initialWorkgroupState : WorkgroupState := {
  name := "1"
  buffers := [initialBuffer]
  nextBufferId := 1
  layout := .window 0 initialView

def makeWorkspaceState (name : String) (rootPath : Option String) (nextBufId : Nat) : WorkspaceState := {
  name := name
  rootPath := rootPath
  buffers := [{ initialBuffer with id := nextBufId }]
  nextBufferId := nextBufId + 1
  layout := .window 0 { initialView with bufferId := nextBufId }

}
def initialWorkgroupState : WorkgroupState := {
  name := "1"
  workspaces := #[makeWorkspaceState defaultWorkspaceName none 0]
  currentWorkspace := 0

  buffers := [{ initialBuffer with id := nextBufId }]
  nextBufferId := nextBufId + 1
  layout := .window 0 initialView
  activeWindowId := 0
  nextWindowId := 1

  workspaces := #[makeWorkspaceState defaultWorkspaceName none nextBufId]
  currentWorkspace := 0

def makeInitialWorkgroups : Array WorkgroupState :=
  #[initialWorkgroupState]

def makeInitialWorkgroups : Array WorkgroupState := Id.run do
  let mut groups : Array WorkgroupState := #[]
  let mut nextBufId := 0
  for i in [0:10] do
    let name := s!"{i}"
    let wg := createEmptyWorkgroup name nextBufId
    groups := groups.push wg
    nextBufId := nextBufId + 1
  groups

  workspace := defaultWorkspace

  | Key.char 'j' => handleMotion s EditorState.moveCursorDown
  | Key.char 'k' => handleMotion s EditorState.moveCursorUp

  | Key.char 'j' => do
      let s' ← handleMotion s EditorState.moveCursorDown
      ViE.Feature.refreshExplorerPreview s'
  | Key.char 'k' => do
      let s' ← handleMotion s EditorState.moveCursorUp
      ViE.Feature.refreshExplorerPreview s'

  | Key.char 'p' => pure $ clearInput (EditorState.pasteBelow s)

  | Key.char 'p' =>
      let buf := s.getActiveBuffer
      let isExplorer := s.explorers.any (fun (id, _) => id == buf.id)
      if isExplorer then
        ViE.Feature.toggleExplorerPreview s
      else
        pure $ clearInput (EditorState.pasteBelow s)

            let next := (s.currentGroup + 1) % 10
            let s'' := s.switchToWorkgroup next
            pure { s'' with message := s!"Switched to workgroup {next}" }

            let size := s.workgroups.size
            if size == 0 then
              pure s'
            else
              let next := (s.currentGroup + 1) % size
              let s'' := s.switchToWorkgroup next
              pure { s'' with message := s!"Switched to workgroup {next}" }

            let prev := if s.currentGroup == 0 then 9 else s.currentGroup - 1
            let s'' := s.switchToWorkgroup prev
            pure { s'' with message := s!"Switched to workgroup {prev}" }

            let size := s.workgroups.size
            if size == 0 then
              pure s'
            else
              let prev := if s.currentGroup == 0 then size - 1 else s.currentGroup - 1
              let s'' := s.switchToWorkgroup prev
              pure { s'' with message := s!"Switched to workgroup {prev}" }

      | _ => pure s'

      | _ =>
        if c.isDigit then
          match c.toString.toNat? with
          | some idx =>
            if idx < s.workgroups.size then
              let s'' := s.switchToWorkgroup idx
              pure { s'' with message := s!"Switched to workgroup {idx}" }
            else
              pure s'
          | none => pure s'
        else
          pure s'

import ViE.Workspace

    let resolvedPath := state.workspace.resolvePath fname

    let resolvedPath := state.getCurrentWorkspace.resolvePath fname

    let ws := state.getCurrentWorkspace

                   else match state.workspace.rootPath with

                   else match ws.rootPath with

    return { state with
      workspace := { state.workspace with rootPath := some absPath },
      message := s!"Workspace path: {absPath}"
    }

    let s' := state.updateCurrentWorkspace fun ws =>
      { ws with rootPath := some absPath, name := ws.name }
    return { s' with message := s!"Workspace path: {absPath}" }

    return { state with
      workspace := defaultWorkspace,
      message := "Workspace cleared"
    }

    let s' := state.updateCurrentWorkspace fun ws =>
      { ws with rootPath := none, name := ws.name }
    return { s' with message := "Workspace cleared" }

    return { state with
      workspace := { state.workspace with name := name },
      message := s!"Workspace renamed to: {name}"
    }

    let trimmed := name.trimAscii.toString
    if trimmed.isEmpty then
      return { state with message := "Workspace name cannot be empty" }
    else
      let wg := state.getCurrentWorkgroup
      let currentName := state.getCurrentWorkspace.name
      let duplicate := wg.workspaces.any (fun ws => ws.name == trimmed && ws.name != currentName)
      if duplicate then
        return { state with message := s!"Workspace name already exists: {trimmed}" }
      else
        let s' := state.updateCurrentWorkspace fun ws =>
          { ws with name := trimmed }
        return { s' with message := s!"Workspace renamed to: {trimmed}" }

  match state.workspace.rootPath with

  match state.getCurrentWorkspace.rootPath with

  | ["list"] =>
    ViE.Feature.openWorkgroupExplorer state

    let nextBufId := state.workgroups.foldl (fun m g => max m g.nextBufferId) 0

    let nextBufId := state.workgroups.foldl (fun m g =>
      g.workspaces.foldl (fun m2 ws => max m2 ws.nextBufferId) m) 0

    let nextBufId := state.workgroups.foldl (fun m g => max m g.nextBufferId) 0

    let nextBufId := state.workgroups.foldl (fun m g =>
      g.workspaces.foldl (fun m2 ws => max m2 ws.nextBufferId) m) 0

    let current := state.workgroups[state.currentGroup]!
    let updated := { current with name := name }
    return { state with
      workgroups := state.workgroups.set! state.currentGroup updated,
      message := s!"Workgroup renamed to: {name}"
    }

    let trimmed := name.trimAscii.toString
    if trimmed.isEmpty then
      return { state with message := "Workgroup name cannot be empty" }
    else
      let currentName := state.getCurrentWorkgroup.name
      let duplicate := state.workgroups.any (fun wg => wg.name == trimmed && wg.name != currentName)
      if duplicate then
        return { state with message := s!"Workgroup name already exists: {trimmed}" }
      else
        let current := state.workgroups[state.currentGroup]!
        let updated := { current with name := trimmed }
        return { state with
          workgroups := state.workgroups.set! state.currentGroup updated,
          message := s!"Workgroup renamed to: {trimmed}"
        }

  | _ => return { state with message := "Usage: :wg <new|close|rename|next|prev|index> [args]" }

  | _ => return { state with message := "Usage: :wg <new|list|close|rename|next|prev|index> [args]" }
def cmdWs (args : List String) (state : EditorState) : IO EditorState :=
  let wg := state.getCurrentWorkgroup
  let maxBufId := wg.workspaces.foldl (fun m ws => max m ws.nextBufferId) 0
  let resolvePath (p : String) : String :=
    if p.startsWith "/" then p
    else
      match state.getCurrentWorkspace.rootPath with
      | some root => root ++ "/" ++ p
      | none => p
  let parseOpenArgs (rest : List String) : Option (Option String × String) :=
    match rest with
    | ["--name", name, path] => some (some name, path)
    | [path, "--name", name] => some (some name, path)
    | [path] => some (none, path)
    | [name, path] => some (some name, path)
    | _ => none
  match args with
  | ["list"] =>
    ViE.Feature.openWorkspaceExplorer state
  | "open" :: rest =>
    match parseOpenArgs rest with
    | some (maybeName, path) =>
      let absPath := resolvePath path
      let name := maybeName.getD ((System.FilePath.fileName absPath).getD "Workspace")
      let newWs := makeWorkspaceState name (some absPath) maxBufId
      let newState := state.updateCurrentWorkgroup fun wg =>
        { wg with
          workspaces := wg.workspaces.push newWs,
          currentWorkspace := wg.workspaces.size
        }
      return { newState with message := s!"Opened workspace: {name} ({absPath})" }
    | none =>
      return { state with message := "Usage: :ws open [--name <name>] <path>" }
  | ["new"] =>
    let name := s!"Workspace {wg.workspaces.size}"
    let newWs := makeWorkspaceState name none maxBufId
    let newState := state.updateCurrentWorkgroup fun wg =>
      { wg with
        workspaces := wg.workspaces.push newWs,
        currentWorkspace := wg.workspaces.size
      }
    return { newState with message := s!"Created workspace: {name}" }
  | ["new", name] =>
    let newWs := makeWorkspaceState name none maxBufId
    let newState := state.updateCurrentWorkgroup fun wg =>
      { wg with
        workspaces := wg.workspaces.push newWs,
        currentWorkspace := wg.workspaces.size
      }
    return { newState with message := s!"Created workspace: {name}" }
  | ["new", name, path] =>
    let absPath := resolvePath path
    let newWs := makeWorkspaceState name (some absPath) maxBufId
    let newState := state.updateCurrentWorkgroup fun wg =>
      { wg with
        workspaces := wg.workspaces.push newWs,
        currentWorkspace := wg.workspaces.size
      }
    return { newState with message := s!"Created workspace: {name} ({absPath})" }
  | ["close"] =>
    if wg.workspaces.size <= 1 then
      return { state with message := "Cannot close the last workspace" }
    else
      if h_idx : wg.currentWorkspace < wg.workspaces.size then
        let prevIdx := if wg.currentWorkspace == 0 then wg.workspaces.size - 1 else wg.currentWorkspace - 1
        let newSpaces := wg.workspaces.eraseIdx wg.currentWorkspace h_idx
        let newIdx := if prevIdx < newSpaces.size then prevIdx else newSpaces.size - 1
        let newState := state.updateCurrentWorkgroup fun wg =>
          { wg with workspaces := newSpaces, currentWorkspace := newIdx }
        let newWs := newSpaces[newIdx]!
        return { newState with message := s!"Workspace closed. Switched to: {newWs.name}" }
      else
        return { state with message := "Error: invalid workspace index" }
  | ["rename", name] =>
    let trimmed := name.trimAscii.toString
    if trimmed.isEmpty then
      return { state with message := "Workspace name cannot be empty" }
    else
      let wg := state.getCurrentWorkgroup
      let duplicate := wg.workspaces.any (fun ws => ws.name == trimmed)
      if duplicate then
        return { state with message := s!"Workspace name already exists: {trimmed}" }
      else
        let s' := state.updateCurrentWorkspace fun ws =>
          { ws with name := trimmed }
        return { s' with message := s!"Workspace renamed to: {trimmed}" }
  | ["next"] =>
    let nextIdx := (wg.currentWorkspace + 1) % wg.workspaces.size
    let ws := wg.workspaces[nextIdx]!
    let newState := state.updateCurrentWorkgroup fun wg =>
      { wg with currentWorkspace := nextIdx }
    return { newState with message := s!"Switched to: {ws.name}" }
  | ["prev"] =>
    let prevIdx := if wg.currentWorkspace == 0 then wg.workspaces.size - 1 else wg.currentWorkspace - 1
    let ws := wg.workspaces[prevIdx]!
    let newState := state.updateCurrentWorkgroup fun wg =>
      { wg with currentWorkspace := prevIdx }
    return { newState with message := s!"Switched to: {ws.name}" }
  | [n] =>
    match n.toNat? with
    | some num =>
      if num < wg.workspaces.size then
        let ws := wg.workspaces[num]!
        let newState := state.updateCurrentWorkgroup fun wg =>
          { wg with currentWorkspace := num }
        return { newState with message := s!"Switched to: {ws.name}" }
      else
        return { state with message := s!"Workspace index out of range (0-{wg.workspaces.size - 1})" }
    | none => return { state with message := "Invalid workspace number" }
  | [] =>
    let ws := wg.workspaces[wg.currentWorkspace]!
    return { state with message := s!"Current workspace: {ws.name} (index {wg.currentWorkspace})" }
  | _ => return { state with message := "Usage: :ws <new|open|list|close|rename|next|prev|index> [args]" }

     | [] => state.workspace.rootPath.getD "."

     | [] => state.getCurrentWorkspace.rootPath.getD "."

def cmdWgExplorer (_ : List String) (state : EditorState) : IO EditorState :=
  ViE.Feature.openWorkgroupExplorer state

  ("ws", cmdWs),

  ("wgex", cmdWgExplorer),

import ViE.Buffer.Content

import ViE.State.Config
import ViE.Buffer.LowIO
import ViE.Window.Actions

def previewMaxBytes : Nat := 65536
def updateExplorerState (state : EditorState) (bufId : Nat) (f : ExplorerState → ExplorerState) : EditorState :=
  { state with explorers := state.explorers.map (fun (id, ex) => if id == bufId then (id, f ex) else (id, ex)) }
def getSelectedEntry (state : EditorState) (explorer : ExplorerState) : Option FileEntry :=
  let cursor := state.getCursor
  if cursor.row < 2 then
    none
  else
    let idx := cursor.row - 2
    if idx.val < explorer.entries.length then
      some (explorer.entries[idx.val]!)
    else
      none
def ensurePreviewBuffer (state : EditorState) (explorer : ExplorerState) (entry : FileEntry) : IO (EditorState × Nat) := do
  let resolved := entry.path
  let loaded ← ViE.loadPreviewBufferByteArray resolved previewMaxBytes
  let previewName := some s!"preview://{resolved}"
  let previewBuf := { loaded with filename := previewName, dirty := false }
  match explorer.previewBufferId with
  | some pid =>
    let ws := state.getCurrentWorkspace
    if ws.buffers.any (fun b => b.id == pid) then
      let updated := { previewBuf with id := pid }
      let s' := state.updateCurrentWorkspace fun ws =>
        { ws with buffers := ws.buffers.map (fun b => if b.id == pid then updated else b) }
      return (s', pid)
    else
      let (pid, s') := ViE.Buffer.addBuffer state previewBuf
      return (s', pid)
  | none =>
    let (pid, s') := ViE.Buffer.addBuffer state previewBuf
    return (s', pid)
def refreshExplorerPreview (state : EditorState) : IO EditorState := do
  let buf := state.getActiveBuffer
  let explorerOpt := state.explorers.find? (fun (id, _) => id == buf.id)
  match explorerOpt with
  | none => return state
  | some (bufId, explorer) =>
    if explorer.mode != .files then
      return state
    match explorer.previewWindowId with
    | none => return state
    | some previewWinId =>
      match getSelectedEntry state explorer with
      | none => return state
      | some entry =>
        if entry.isDirectory then
          return state
        else
          let (s1, previewBufId) ← ensurePreviewBuffer state explorer entry
          let s2 := s1.updateCurrentWorkspace fun ws =>
            { ws with layout := ws.layout.updateView previewWinId (fun v =>
              { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
          let s3 := updateExplorerState s2 bufId (fun ex => { ex with previewBufferId := some previewBufId })
          return s3
def openExplorerDefaultPreview (state : EditorState) (bufId : Nat) (explorer : ExplorerState) : IO EditorState := do
  if explorer.mode != .files then
    return state
  match explorer.previewWindowId with
  | some _ => return state
  | none =>
    let ws := state.getCurrentWorkspace
    let previewWinId := ws.nextWindowId
    let s1 := ViE.Window.splitWindow state false
    let entryOpt := getSelectedEntry s1 explorer
    let (s2, previewBufId) ←
      match entryOpt with
      | some entry =>
        if entry.isDirectory then
          let content : TextBuffer := #[#[]]
          let buf := { ViE.Buffer.fileBufferFromTextBuffer 0 (some "preview://") content with dirty := false }
          let (pid, s2) := ViE.Buffer.addBuffer s1 buf
          pure (s2, pid)
        else
          ensurePreviewBuffer s1 explorer entry
      | none =>
        let content : TextBuffer := #[#[]]
        let buf := { ViE.Buffer.fileBufferFromTextBuffer 0 (some "preview://") content with dirty := false }
        let (pid, s2) := ViE.Buffer.addBuffer s1 buf
        pure (s2, pid)
    let s3 := s2.updateCurrentWorkspace fun ws =>
      { ws with layout := ws.layout.updateView previewWinId (fun v =>
        { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
    let s4 := updateExplorerState s3 bufId (fun ex =>
      { ex with previewWindowId := some previewWinId, previewBufferId := some previewBufId })
    return s4
def toggleExplorerPreview (state : EditorState) : IO EditorState := do
  let buf := state.getActiveBuffer
  let explorerOpt := state.explorers.find? (fun (id, _) => id == buf.id)
  match explorerOpt with
  | none => return state
  | some (bufId, explorer) =>
    if explorer.mode != .files then
      return { state with message := "Preview is only available in file explorer" }
    match explorer.previewWindowId with
    | some previewWinId =>
      let s1 := state.updateCurrentWorkspace fun ws =>
        match ws.layout.remove previewWinId with
        | some newLayout => { ws with layout := newLayout }
        | none => ws
      let s2 := updateExplorerState s1 bufId (fun ex => { ex with previewWindowId := none, previewBufferId := none })
      return { s2 with message := "Preview closed" }
    | none =>
      match getSelectedEntry state explorer with
      | none => return { state with message := "Preview: no selection" }
      | some entry =>
        if entry.isDirectory then
          return { state with message := "Preview: directory" }
        else
          let ws := state.getCurrentWorkspace
          let previewWinId := ws.nextWindowId
          let s1 := ViE.Window.splitWindow state false
          let (s2, previewBufId) ← ensurePreviewBuffer s1 explorer entry
          let s3 := s2.updateCurrentWorkspace fun ws =>
            { ws with layout := ws.layout.updateView previewWinId (fun v =>
              { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
          let s4 := updateExplorerState s3 bufId (fun ex => { ex with previewWindowId := some previewWinId, previewBufferId := some previewBufId })
          return { s4 with message := s!"Preview: {entry.name}" }

  let path := if pathArg == "." || pathArg == "" then state.workspace.rootPath.getD "."
              else if pathArg.startsWith "/" then pathArg
              else match state.workspace.rootPath with
                   | some root => root ++ "/" ++ pathArg
                   | none => pathArg

  let ws := state.getCurrentWorkspace
  let path := if pathArg == "." || pathArg == "" then
                ws.rootPath.getD "."
              else if pathArg.startsWith "/" then
                pathArg
              else
                match ws.rootPath with
                | some root =>
                  if pathArg == root then root else root ++ "/" ++ pathArg
                | none => pathArg

      mode := .files
      previewWindowId := none
      previewBufferId := none

    return { s''' with message := s!"Explorer: {path}" }

    let s'''' := { s''' with message := s!"Explorer: {path}" }
    -- Auto-open preview by default for file explorer
    return (← openExplorerDefaultPreview s'''' bufferId explorerState)
  catch e =>
    return { state with message := s!"Error reading directory: {e}" }
def openExplorerWithPreview (state : EditorState) (pathArg : String) (previewWindowId : Option Nat) (previewBufferId : Option Nat) : IO EditorState := do
  let ws := state.getCurrentWorkspace
  let path := if pathArg == "." || pathArg == "" then
                ws.rootPath.getD "."
              else if pathArg.startsWith "/" then
                pathArg
              else
                match ws.rootPath with
                | some root =>
                  if pathArg == root then root else root ++ "/" ++ pathArg
                | none => pathArg
  try
    let dirPath := System.FilePath.mk path
    let entries := (← System.FilePath.readDir dirPath).toList
    let mut fileEntries : List FileEntry := []
    if path != "/" then
      let parentPath := match dirPath.parent with
        | some p => p.toString
        | none => "/"
      fileEntries := fileEntries ++ [{
        name := ".."
        path := parentPath
        isDirectory := true
      }]
    for entry in entries do
      let entryPath := entry.path.toString
      let isDir ← entry.path.isDir
      fileEntries := fileEntries ++ [{
        name := entry.fileName
        path := entryPath
        isDirectory := isDir
      }]
    let sortedEntries := fileEntries.toArray.qsort fun a b =>
      if a.isDirectory != b.isDirectory then
        a.isDirectory
      else
        a.name < b.name
    let explorerState : ExplorerState := {
      currentPath := path
      entries := sortedEntries.toList
      selectedIndex := 0
      mode := .files
      previewWindowId := previewWindowId
      previewBufferId := previewBufferId
    }

    let header := [s!"Explorer: {path}", ""]
    let mut content := header
    let mut idx := 0
    for entry in explorerState.entries do
      let pref := if idx == 0 then "> " else "  "
      let icon := if entry.isDirectory then state.config.dirIcon else state.config.fileIcon
      let suffix := if entry.isDirectory then "/" else ""
      content := content ++ [s!"{pref}{icon}{entry.name}{suffix}"]
      idx := idx + 1
    let contentBuffer := content.toArray.map stringToLine
    let (bufferId, s') := ViE.Buffer.createNewBuffer state contentBuffer (some s!"explorer://{path}")
    let s'' := { s' with explorers := (bufferId, explorerState) :: s'.explorers }
    let s''' := s''.updateActiveView fun v => { v with bufferId := bufferId, cursor := {row := 2, col := 0}, scrollRow := 0, scrollCol := 0 }
    let s'''' := { s''' with message := s!"Explorer: {path}" }
    match previewWindowId with
    | some _ => refreshExplorerPreview s''''
    | none => openExplorerDefaultPreview s'''' bufferId explorerState

/-- Open the workspace explorer to list workspaces. -/
def openWorkspaceExplorer (state : EditorState) : IO EditorState := do
  let wg := state.getCurrentWorkgroup
  let mut entries : List FileEntry := []
  entries := entries ++ [{
    name := "[New Workspace]"
    path := ""
    isDirectory := false
  }]
  entries := entries ++ [{
    name := "[Rename Workspace]"
    path := ""
    isDirectory := false
  }]
  for ws in wg.workspaces.toList do
    let label :=
      match ws.rootPath with
      | some root => s!"{ws.name} — {root}"
      | none => ws.name
    entries := entries ++ [{
      name := label
      path := ws.rootPath.getD ""
      isDirectory := true
    }]
  let explorerState : ExplorerState := {
    currentPath := s!"workgroup:{wg.name}"
    entries := entries
    selectedIndex := 0
    mode := .workspaces
    previewWindowId := none
    previewBufferId := none
  }
  let header := [s!"Workspace Explorer: {wg.name}", ""]
  let mut content := header
  let mut idx := 0
  for entry in explorerState.entries do
    let pref := if idx == 0 then "> " else "  "
    let mark := if idx == (wg.currentWorkspace + 1) then "* " else "  "
    let icon := if entry.isDirectory then state.config.dirIcon else state.config.fileIcon
    content := content ++ [s!"{pref}{mark}{icon}{entry.name}"]
    idx := idx + 1
  let contentBuffer := content.toArray.map stringToLine
  let (bufferId, s') := ViE.Buffer.createNewBuffer state contentBuffer (some "explorer://workgroup")
  let s'' := { s' with explorers := (bufferId, explorerState) :: s'.explorers }
  let s''' := s''.updateActiveView fun v => { v with bufferId := bufferId, cursor := {row := 2, col := 0}, scrollRow := 0, scrollCol := 0 }
  return { s''' with message := s!"Workspace Explorer: {wg.name}" }
/-- Open the workgroup explorer to list workgroups. -/
def openWorkgroupExplorer (state : EditorState) : IO EditorState := do
  let mut entries : List FileEntry := []
  entries := entries ++ [{
    name := "[New Workgroup]"
    path := ""
    isDirectory := false
  }]
  entries := entries ++ [{
    name := "[Rename Workgroup]"
    path := ""
    isDirectory := false
  }]
  for wg in state.workgroups.toList do
    entries := entries ++ [{
      name := wg.name
      path := ""
      isDirectory := true
    }]
  let explorerState : ExplorerState := {
    currentPath := "workgroups"
    entries := entries
    selectedIndex := 0
    mode := .workgroups
    previewWindowId := none
    previewBufferId := none
  }

  let header := ["Workgroup Explorer", ""]
  let mut content := header
  let mut idx := 0
  for entry in explorerState.entries do
    let pref := if idx == explorerState.selectedIndex then "> " else "  "
    let mark := if idx == (state.currentGroup + 1) then "* " else "  "
    let icon := if entry.isDirectory then state.config.dirIcon else state.config.fileIcon
    content := content ++ [s!"{pref}{mark}{icon}{entry.name}"]
    idx := idx + 1
  let contentBuffer := content.toArray.map stringToLine
  let (bufferId, s') := ViE.Buffer.createNewBuffer state contentBuffer (some "explorer://workgroups")
  let s'' := { s' with explorers := (bufferId, explorerState) :: s'.explorers }
  let s''' := s''.updateActiveView fun v =>
    { v with bufferId := bufferId, cursor := {row := ⟨2 + explorerState.selectedIndex⟩, col := 0}, scrollRow := 0, scrollCol := 0 }
  return { s''' with message := "Workgroup Explorer" }

    -- Get selected entry
    let entry := explorer.entries[selectedIdx.val]!

    match explorer.mode with
    | .files =>
      -- Get selected entry
      let entry := explorer.entries[selectedIdx.val]!

    if entry.isDirectory then
      -- Navigate to directory
      openExplorer state entry.path
    else
      -- Open file
      ViE.Buffer.openBuffer state entry.path

      if entry.isDirectory then
        -- Navigate to directory
        openExplorerWithPreview state entry.path explorer.previewWindowId explorer.previewBufferId
      else
        -- Close preview window if it exists
        let s1 :=
          match explorer.previewWindowId with
          | none => state
          | some previewId =>
            let s1 := state.updateCurrentWorkspace fun ws =>
              match ws.layout.remove previewId with
              | some newLayout => { ws with layout := newLayout }
              | none => ws
            let s2 := updateExplorerState s1 buf.id (fun ex => { ex with previewWindowId := none, previewBufferId := none })
            match explorer.previewBufferId with
            | some previewBufId => ViE.Buffer.removeBuffer s2 previewBufId
            | none => s2
        -- Open file
        ViE.Buffer.openBuffer s1 entry.path
    | .workgroups =>
      let idx := selectedIdx.val
      if idx == 0 then
        let s' := { state with
          mode := .command
          inputState := { state.inputState with commandBuffer := "wg new ", countBuffer := "", previousKey := none, pendingKeys := "" }
        }
        return { s' with message := "Workgroup name:" }
      else if idx == 1 then
        let current := state.getCurrentWorkgroup.name
        let s' := { state with
          mode := .command
          inputState := { state.inputState with commandBuffer := s!"wg rename {current}", countBuffer := "", previousKey := none, pendingKeys := "" }
        }
        return { s' with message := "Workgroup rename:" }
      else
        let realIdx := idx - 2
        if realIdx < state.workgroups.size then
          let s' := { state with currentGroup := realIdx }
          let wg := s'.getCurrentWorkgroup
          return { s' with message := s!"Switched workgroup: {wg.name}" }
        else
          return state
    | .workspaces =>
      let idx := selectedIdx.val
      if idx == 0 then
        let s' := { state with
          mode := .command
          inputState := { state.inputState with commandBuffer := "ws new ", countBuffer := "", previousKey := none, pendingKeys := "" }
        }
        return { s' with message := "Workspace name:" }
      else if idx == 1 then
        let current := state.getCurrentWorkspace.name
        let s' := { state with
          mode := .command
          inputState := { state.inputState with commandBuffer := s!"ws rename {current}", countBuffer := "", previousKey := none, pendingKeys := "" }
        }
        return { s' with message := "Workspace rename:" }
      else
        let realIdx := idx - 2
        let s' := state.updateCurrentWorkgroup fun wg =>
          if realIdx < wg.workspaces.size then
            { wg with currentWorkspace := realIdx }
          else
            wg
        let ws := s'.getCurrentWorkspace
        return { s' with message := s!"Switched workspace: {ws.name}" }

  let wg := state.getCurrentWorkgroup
  let buffers := wg.buffers.filter (fun b => b.filename.isSome)

  let ws := state.getCurrentWorkspace
  let buffers := ws.buffers.filter (fun b => b.filename.isSome)

import ViE.Workspace

  let s' := state.updateCurrentWorkgroup fun wg =>
    let id := wg.nextBufferId

  let s' := state.updateCurrentWorkspace fun ws =>
    let id := ws.nextBufferId

    { wg with buffers := buf :: wg.buffers, nextBufferId := id + 1 }
  let wg := s'.getCurrentWorkgroup
  (wg.nextBufferId - 1, s')

    { ws with buffers := buf :: ws.buffers, nextBufferId := id + 1 }
  let ws := s'.getCurrentWorkspace
  (ws.nextBufferId - 1, s')
def addBuffer (state : EditorState) (buf : FileBuffer) : (Nat × EditorState) :=
  let s' := state.updateCurrentWorkspace fun ws =>
    let id := ws.nextBufferId
    let newBuf := { buf with id := id }
    { ws with buffers := newBuf :: ws.buffers, nextBufferId := id + 1 }
  let ws := s'.getCurrentWorkspace
  (ws.nextBufferId - 1, s')
def removeBuffer (state : EditorState) (bufId : Nat) : EditorState :=
  state.updateCurrentWorkspace fun ws =>
    { ws with buffers := ws.buffers.filter (fun b => b.id != bufId) }

  let wg := state.getCurrentWorkgroup
  wg.buffers.find? (fun b => b.filename == some fname) |>.map (fun b => b.id)

  let ws := state.getCurrentWorkspace
  ws.buffers.find? (fun b => b.filename == some fname) |>.map (fun b => b.id)

  let resolvedPath := state.workspace.resolvePath filename

  let resolvedPath := state.getCurrentWorkspace.resolvePath filename

      let s' := state.updateCurrentWorkgroup fun wg =>
        let id := wg.nextBufferId

      let s' := state.updateCurrentWorkspace fun ws =>
        let id := ws.nextBufferId

        { wg with buffers := buf :: wg.buffers, nextBufferId := id + 1 }

        { ws with buffers := buf :: ws.buffers, nextBufferId := id + 1 }

      let wg := s'.getCurrentWorkgroup
      let bid := wg.nextBufferId - 1

      let ws := s'.getCurrentWorkspace
      let bid := ws.nextBufferId - 1

def loadPreviewBufferByteArray (filename : String) (maxBytes : Nat) : IO FileBuffer := do
  try
    let path := System.FilePath.mk filename
    if ← path.pathExists then
      if ← path.isDir then
        return {
          id := 0
          filename := some filename
          dirty := false
          table := PieceTable.fromString ""
          missingEol := false
          cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
        }
      else
        let data ← IO.FS.withFile filename IO.FS.Mode.read fun handle =>
          handle.read (USize.ofNat maxBytes)
        let missingEol := data.size > 0 && data[data.size - 1]! != 10
        let table := PieceTable.fromByteArray data
        return {
          id := 0
          filename := some filename
          dirty := false
          table := table
          missingEol := missingEol
          cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
        }
    else
      return {
        id := 0
        filename := some filename
        dirty := false
        table := PieceTable.fromString ""
        missingEol := false
        cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
      }
  catch _ =>
    return {
      id := 0
      filename := some filename
      dirty := false
      table := PieceTable.fromString ""
      missingEol := false
      cache := { lineMap := Lean.RBMap.empty, rawLineMap := Lean.RBMap.empty, lineIndexMap := Lean.RBMap.empty }
    }

/-- Resolve startup arguments into workspace path and filename. -/
def resolveStartupTarget (filename : Option String) : IO (Option String × Option String) := do
  match filename with
  | some path =>
    let filePath := System.FilePath.mk path
    if ← filePath.pathExists then
      if ← filePath.isDir then
        -- It's a directory, use as workspace
        pure (some path, none)
      else
        -- It's a file, use its parent directory as workspace
        let parentDir := match filePath.parent with
          | some p => p.toString
          | none => "."
        pure (some parentDir, some path)
    else
      -- Path doesn't exist, treat as new file
      pure (none, some path)
  | none => pure (none, none)

  let (workspacePath, actualFilename) ← match filename with
    | some path =>
      let filePath := System.FilePath.mk path
      if ← filePath.pathExists then
        if ← filePath.isDir then
          -- It's a directory, use as workspace
          pure (some path, none)
        else
          -- It's a file
          pure (none, some path)
      else
        -- Path doesn't exist, treat as new file
        pure (none, some path)
    | none => pure (none, none)

  let (workspacePath, actualFilename) ← resolveStartupTarget filename

  let workspace := match workspacePath with
    | some path => { rootPath := some path }
    | none => ViE.defaultWorkspace

    workspace := workspace,

  -- Update the first workgroup with the initial buffer
  let state := state.updateCurrentWorkgroup fun wg =>
    { wg with buffers := [initialBuffer] }

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

import Test.Workspace
import Test.PreviewData
import Test.WorkgroupExplorer
import Test.ExplorerPreview

  Test.Workspace.test
  Test.PreviewData.test
  Test.WorkgroupExplorer.test
  Test.ExplorerPreview.test

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.

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))

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

#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;
}

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

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))

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

#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;
}

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

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.

#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;
}

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

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.

(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)

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.

(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)

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.

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 s0 := ViE.initialState
  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 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 enters command mode" Mode.command s8b.mode
  assertEqual "New workspace command prompt" "ws new " s8b.inputState.commandBuffer
  let s8c := s8.updateActiveView fun v => { v with cursor := {row := ⟨3⟩, col := 0} }
  let s8d ← ViE.Feature.handleExplorerEnter s8c
  assertEqual "Rename workspace enters command mode" Mode.command s8d.mode
  assertEqual "Rename workspace command prompt" true (s8d.inputState.commandBuffer.startsWith "ws rename ")
  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 sets workspace" (some dirOnly) wsDirOnly
  assertEqual "Directory arg has no file" none fileDirOnly
  let fileNested := s!"{base}/dir0/dir1/dir2/file0.txt"
  let (wsFileNested, fileFileNested) ← ViE.resolveStartupTarget (some fileNested)
  assertEqual "File arg sets workspace to parent dir" (some s!"{base}/dir0/dir1/dir2") wsFileNested
  assertEqual "File arg keeps filename" (some fileNested) fileFileNested
  let fileTop := s!"{base}/file0.txt"
  let (wsFileTop, fileFileTop) ← ViE.resolveStartupTarget (some fileTop)
  assertEqual "Top-level file sets workspace to base" (some base) wsFileTop
  assertEqual "Top-level file keeps filename" (some fileTop) fileFileTop
  IO.println "Starting Explorer Path Resolution Test..."
  let s13 := s12.updateCurrentWorkspace fun ws =>
    { ws with rootPath := some "Test", name := "Test" }
  let s14 ← ViE.Feature.openExplorer s13 "Test"
  assertEqual "Explorer opens workspace root without duplication" (some "explorer://Test") s14.getActiveBuffer.filename
  IO.println "WorkspaceTest passed!"
end Test.Workspace

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 s0 := ViE.initialState
  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 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
  assertEqual "New workgroup enters command mode" Mode.command s4.mode
  assertEqual "New workgroup command prompt" "wg new " s4.inputState.commandBuffer
  let s3b := setCursorRow s2 3
  let s4b ← ViE.Feature.handleExplorerEnter s3b
  assertEqual "Rename workgroup enters command mode" Mode.command s4b.mode
  assertEqual "Rename workgroup command prompt" true (s4b.inputState.commandBuffer.startsWith "wg rename ")
  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

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

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

  testWorkgroupSwitch

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 s0 := ViE.initialState
  let path := "Test/test_paths/dir0/dir1"
  let s1 ← ViE.Feature.openExplorer s0 path
  let buf := s1.getActiveBuffer
  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 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 s5b ← ViE.Feature.handleExplorerEnter s5a
      let idsAfterOpen := ViE.Window.getWindowIds s5b.getCurrentWorkspace.layout
      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