lua/modules/navigation.lua

@@ -1,2 +1,14 @@
-require('plugins.finder')
 require('plugins.filetree')
+require('plugins.finder').setup({
+  file_cmd = 'fdfind',
+  grep_cmd = 'rg',
+  debug = false,
+})
+
+vim.keymap.set('n', '<leader>f', function()
+  require('plugins.finder').files()
+end)
+
+vim.keymap.set('n', '<leader>g', function()
+  require('plugins.finder').grep()
+end)

lua/plugins/finder.lua

@@ -1,323 +1,692 @@
--- Minimal fuzzy finder + content search for Neovim 0.11+
--- Optional: `fdfind` or `fd` for file listing, and `rg` (ripgrep) for text search.
+-- finder.lua — Minimal async fuzzy finder + grep for Neovim ≥ 0.11
+-- Non-blocking, debounced, stable selection, correct scrolling, match highlights.
 
-local Fuzzy = {}
+local M = {}
 
---------------------------------------------------------------------
--- 🧩 Helpers
---------------------------------------------------------------------
+---------------------------------------------------------------------
+-- Config
+---------------------------------------------------------------------
+M.config = {
+  file_cmd = nil, -- "fd" | "fdfind" | nil (auto)
+  grep_cmd = 'rg', -- ripgrep binary
+  page_size = 60, -- soft cap; real viewport height is measured
+  debounce_ms = 80,
+  cache_ttl_sec = 20,
+  max_items = 5000, -- safety cap for massive outputs
+  debug = false,
+}
 
--- Collect all files (try fdfind/fd first, then globpath)
-local function get_file_list()
-  local handle = io.popen('fdfind --type f 2>/dev/null || fd --type f 2>/dev/null')
-  if handle then
-    local result = handle:read('*a')
-    handle:close()
-    if result and result ~= '' then
-      return vim.split(result, '\n', { trimempty = true })
-    end
-  end
-  return vim.fn.globpath('.', '**/*', false, true)
-end
+---------------------------------------------------------------------
+-- State
+---------------------------------------------------------------------
+local S = {
+  active = false,
+  mode = nil, -- "files" | "grep"
+  root = nil,
 
--- Create floating input + result windows
-local function open_float(prompt)
-  local input_buf = vim.api.nvim_create_buf(false, true)
-  local result_buf = vim.api.nvim_create_buf(false, true)
+  cache = {},
+  timer = nil,
+  ns = vim.api.nvim_create_namespace('finder_ns'),
+  aug = nil,
 
-  -- mark both buffers as scratch/unlisted
-  for _, b in ipairs({ input_buf, result_buf }) do
-    vim.bo[b].bufhidden = 'wipe'
-    vim.bo[b].buflisted = false
-    vim.bo[b].swapfile = false
-  end
-  vim.bo[input_buf].buftype = 'prompt'
-  vim.bo[result_buf].buftype = 'nofile'
+  -- UI
+  win_inp = nil,
+  buf_inp = nil,
+  win_res = nil,
+  buf_res = nil,
 
-  local width = math.floor(vim.o.columns * 0.7)
-  local height = 20
-  local row = math.floor((vim.o.lines - height) / 2)
-  local col = math.floor((vim.o.columns - width) / 2)
+  -- Data
+  query = '',
+  items = {}, -- full set (files or grep lines)
+  filtered = {}, -- current view
+  positions = {}, -- positions[i] = { {scol, ecol}, ... } for filtered[i]
+  select = 1, -- absolute index in filtered (1-based)
+  scroll = 0, -- top index (0-based)
+}
 
-  local input_win = vim.api.nvim_open_win(input_buf, true, {
-    relative = 'editor',
-    row = row,
-    col = col,
-    width = width,
-    height = 1,
-    style = 'minimal',
-    border = 'rounded',
-  })
-  vim.fn.prompt_setprompt(input_buf, prompt)
-
-  local result_win = vim.api.nvim_open_win(result_buf, false, {
-    relative = 'editor',
-    row = row + 2,
-    col = col,
-    width = width,
-    height = height - 2,
-    style = 'minimal',
-    border = 'single',
-  })
-
-  return input_buf, result_buf, input_win, result_win
-end
-
---------------------------------------------------------------------
--- 🔵 Highlight current selection
---------------------------------------------------------------------
-function Fuzzy:highlight_selection()
-  if not self.result_buf then
+---------------------------------------------------------------------
+-- Utils
+---------------------------------------------------------------------
+local function L(msg, data)
+  if not M.config.debug then
     return
   end
-  if not self.ns_id then
-    self.ns_id = vim.api.nvim_create_namespace('FuzzyHighlight')
-  end
-  vim.api.nvim_buf_clear_namespace(self.result_buf, self.ns_id, 0, -1)
-  if self.matches and self.matches[self.cursor] then
-    local rel_cursor = self.cursor - (self.scroll or 0)
-    if rel_cursor >= 1 and rel_cursor <= self.page_size then
-      vim.api.nvim_buf_set_extmark(self.result_buf, self.ns_id, rel_cursor - 1, 0, {
-        end_line = rel_cursor,
-        hl_group = 'Visual',
-        hl_eol = true,
-      })
-    end
+  local s = '[finder] ' .. msg
+  if data ~= nil then
+    s = s .. ' ' .. vim.inspect(data)
   end
+  vim.schedule(function()
+    vim.notify(s)
+  end)
 end
 
---------------------------------------------------------------------
--- 🔴 Close all floating windows
---------------------------------------------------------------------
-function Fuzzy.close()
-  local wins = { Fuzzy.input_win, Fuzzy.result_win }
-  for _, win in ipairs(wins) do
-    if win and vim.api.nvim_win_is_valid(win) then
-      vim.api.nvim_win_close(win, true)
-    end
-  end
-  Fuzzy.active = false
+local function now_sec()
+  return vim.loop.now() / 1000
+end
+local function clamp(v, lo, hi)
+  return (v < lo) and lo or ((v > hi) and hi or v)
+end
+local function cmd_exists(bin)
+  return vim.fn.executable(bin) == 1
 end
 
---------------------------------------------------------------------
--- 🟢 File finder
---------------------------------------------------------------------
-function Fuzzy.open()
-  if Fuzzy.active then
-    Fuzzy.close()
+local function debounce(fn, ms)
+  if S.timer then
+    S.timer:stop()
+    S.timer:close()
+    S.timer = nil
   end
-  Fuzzy.active = true
-
-  Fuzzy.files = get_file_list()
-  Fuzzy.matches = Fuzzy.files
-  Fuzzy.cursor = 1
-  Fuzzy.scroll = 0
-  Fuzzy.page_size = 50
-
-  Fuzzy.input_buf, Fuzzy.result_buf, Fuzzy.input_win, Fuzzy.result_win = open_float('Search: ')
-
-  local function render_results()
-    local total = #Fuzzy.matches
-    if total == 0 then
-      vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, { '-- no matches --' })
-      return
+  S.timer = vim.loop.new_timer()
+  S.timer:start(ms, 0, function()
+    if S.timer then
+      S.timer:stop()
+      S.timer:close()
+      S.timer = nil
     end
-    local start_idx = Fuzzy.scroll + 1
-    local end_idx = math.min(start_idx + Fuzzy.page_size - 1, total)
-    local display = {}
+    vim.schedule(fn)
+  end)
+end
+
+local function project_root()
+  local obj = vim.system({ 'git', 'rev-parse', '--show-toplevel' }, { text = true }):wait()
+  if obj.code == 0 and obj.stdout and obj.stdout ~= '' then
+    return vim.trim(obj.stdout)
+  end
+  return vim.loop.cwd()
+end
+
+local function resolve_file_cmd()
+  if M.config.file_cmd then
+    return M.config.file_cmd
+  end
+  if cmd_exists('fd') then
+    return 'fd'
+  end
+  if cmd_exists('fdfind') then
+    return 'fdfind'
+  end
+  return nil
+end
+
+local function page_rows()
+  if S.win_res and vim.api.nvim_win_is_valid(S.win_res) then
+    return vim.api.nvim_win_get_height(S.win_res)
+  end
+  return math.min(M.config.page_size, vim.o.lines)
+end
+
+---------------------------------------------------------------------
+-- Render helpers
+---------------------------------------------------------------------
+local function ensure_visible()
+  local page = page_rows()
+  local sel = clamp(S.select, 1, #S.filtered)
+  local top = S.scroll + 1
+  local bot = S.scroll + page
+  if sel < top then
+    S.scroll = sel - 1
+  elseif sel > bot then
+    S.scroll = sel - page
+  end
+  S.scroll = clamp(S.scroll, 0, math.max(#S.filtered - page, 0))
+end
+
+---------------------------------------------------------------------
+-- Render
+---------------------------------------------------------------------
+local function render()
+  if not (S.buf_res and vim.api.nvim_buf_is_valid(S.buf_res)) then
+    return
+  end
+
+  ensure_visible()
+
+  local total = #S.filtered
+  local view = {}
+  if total == 0 then
+    view = { '-- no matches --' }
+  else
+    local start_idx = S.scroll + 1
+    local end_idx = math.min(start_idx + page_rows() - 1, total)
     for i = start_idx, end_idx do
-      display[#display + 1] = Fuzzy.matches[i]
+      view[#view + 1] = S.filtered[i]
     end
-    vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, display)
-    Fuzzy:highlight_selection()
   end
 
-  local function update_results(text)
-    if text == '' then
-      Fuzzy.matches = Fuzzy.files
-    else
-      Fuzzy.matches = vim.fn.matchfuzzy(Fuzzy.files, text)
+  -- sanitize all lines to strings to avoid E5108 errors
+  for i = 1, #view do
+    if type(view[i]) ~= 'string' then
+      view[i] = tostring(view[i] or '')
     end
-    Fuzzy.cursor, Fuzzy.scroll = 1, 0
-    render_results()
   end
 
-  vim.api.nvim_create_autocmd({ 'TextChangedI', 'TextChangedP' }, {
-    buffer = Fuzzy.input_buf,
-    callback = function()
-      local text = vim.fn.getline('.'):gsub('^Search:%s*', '')
-      update_results(text)
-    end,
-  })
+  vim.bo[S.buf_res].modifiable = true
+  vim.bo[S.buf_res].readonly = false
+  vim.api.nvim_buf_set_lines(S.buf_res, 0, -1, false, view)
+  vim.api.nvim_buf_clear_namespace(S.buf_res, S.ns, 0, -1)
 
-  vim.keymap.set('i', '<C-n>', function()
-    if Fuzzy.cursor < #Fuzzy.matches then
-      Fuzzy.cursor = Fuzzy.cursor + 1
-      if Fuzzy.cursor > Fuzzy.scroll + Fuzzy.page_size then
-        Fuzzy.scroll = Fuzzy.scroll + 1
-      end
-      render_results()
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<C-p>', function()
-    if Fuzzy.cursor > 1 then
-      Fuzzy.cursor = Fuzzy.cursor - 1
-      if Fuzzy.cursor <= Fuzzy.scroll then
-        Fuzzy.scroll = math.max(Fuzzy.scroll - 1, 0)
-      end
-      render_results()
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<CR>', function()
-    local choice = Fuzzy.matches[Fuzzy.cursor]
-    if choice then
-      Fuzzy.close()
-      vim.cmd.edit(vim.fn.fnameescape(choice))
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<Esc>', Fuzzy.close, { buffer = Fuzzy.input_buf })
-  vim.keymap.set('i', '<C-c>', Fuzzy.close, { buffer = Fuzzy.input_buf })
-  vim.keymap.set('n', '<Esc>', Fuzzy.close, { buffer = Fuzzy.input_buf })
-  vim.keymap.set('n', 'q', Fuzzy.close, { buffer = Fuzzy.input_buf })
-
-  vim.cmd.startinsert()
-end
-
---------------------------------------------------------------------
--- 🟣 Ripgrep-based content search (scrolling + match highlighting)
---------------------------------------------------------------------
-function Fuzzy.open_grep()
-  if Fuzzy.active then
-    Fuzzy.close()
-  end
-  Fuzzy.active = true
-
-  Fuzzy.input_buf, Fuzzy.result_buf, Fuzzy.input_win, Fuzzy.result_win = open_float('Grep: ')
-  Fuzzy.matches, Fuzzy.cursor, Fuzzy.scroll = {}, 1, 0
-  Fuzzy.page_size = 50
-  Fuzzy.ns_id = vim.api.nvim_create_namespace('FuzzyHighlight')
-
-  local function render_results(query)
-    local total = #Fuzzy.matches
-    if total == 0 then
-      vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, { '-- no matches --' })
-      return
-    end
-
-    local start_idx = Fuzzy.scroll + 1
-    local end_idx = math.min(start_idx + Fuzzy.page_size - 1, total)
-    local display = {}
-    for i = start_idx, end_idx do
-      display[#display + 1] = Fuzzy.matches[i]
-    end
-
-    vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, display)
-    vim.api.nvim_buf_clear_namespace(Fuzzy.result_buf, Fuzzy.ns_id, 0, -1)
-
-    -- highlight selection
-    local rel_cursor = math.min(Fuzzy.cursor - Fuzzy.scroll, #display)
-    vim.api.nvim_buf_set_extmark(Fuzzy.result_buf, Fuzzy.ns_id, rel_cursor - 1, 0, {
-      end_line = rel_cursor,
-      hl_group = 'Visual',
-      hl_eol = true,
-    })
-
-    -- highlight query matches
-    if query and query ~= '' then
-      local pattern = vim.pesc(query)
-      for i, line in ipairs(display) do
-        for s, e in line:gmatch('()' .. pattern .. '()') do
-          vim.api.nvim_buf_set_extmark(Fuzzy.result_buf, Fuzzy.ns_id, i - 1, s - 1, {
-            end_col = e - 1,
-            hl_group = 'Search',
+  -- match highlights (visible window only)
+  vim.api.nvim_set_hl(0, 'FinderMatch', { link = 'Search', default = true })
+  for i, _ in ipairs(view) do
+    local idx = S.scroll + i
+    local spans = S.positions[idx]
+    if spans then
+      for _, se in ipairs(spans) do
+        local scol, ecol = se[1], se[2]
+        if ecol > scol then
+          vim.api.nvim_buf_set_extmark(S.buf_res, S.ns, i - 1, scol, {
+            end_col = ecol,
+            hl_group = 'FinderMatch',
           })
         end
       end
     end
   end
 
-  local function run_grep(query)
-    if query == '' then
-      vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, { '-- type to search --' })
-      return
-    end
-    local handle = io.popen('rg --vimgrep --hidden --smart-case ' .. vim.fn.shellescape(query))
-    if not handle then
-      return
-    end
-    local result = handle:read('*a')
-    handle:close()
-    Fuzzy.matches = vim.split(result, '\n', { trimempty = true })
-    Fuzzy.cursor, Fuzzy.scroll = 1, 0
-    render_results(query)
+  -- selection highlight
+  if total > 0 and #view > 0 then
+    vim.api.nvim_set_hl(0, 'FinderSelection', { link = 'CursorLine', default = true })
+    local rel = clamp(S.select - S.scroll, 1, #view)
+    vim.api.nvim_buf_set_extmark(S.buf_res, S.ns, rel - 1, 0, {
+      end_line = rel,
+      hl_group = 'FinderSelection',
+      hl_eol = true,
+    })
   end
 
-  vim.api.nvim_create_autocmd({ 'TextChangedI', 'TextChangedP' }, {
-    buffer = Fuzzy.input_buf,
+  vim.bo[S.buf_res].modifiable = false
+  L('render', { select = S.select, scroll = S.scroll, total = total, lines = #view })
+end
+
+---------------------------------------------------------------------
+-- Querying / Filtering
+---------------------------------------------------------------------
+local function compute_positions_files(items, q)
+  -- matchfuzzypos returns {items, positions}. Handle via single return table.
+  local ok, res = pcall(vim.fn.matchfuzzypos, items, q)
+  if not ok or type(res) ~= 'table' then
+    return {}, {}
+  end
+  local out_items = res[1] or {}
+  local pos = res[2] or {}
+
+  -- sanitize items to strings and build per-index spans
+  local filtered, positions = {}, {}
+  for i, v in ipairs(out_items) do
+    filtered[i] = (type(v) == 'string') and v or tostring(v or '')
+    local cols = pos[i] or {}
+    local spans = {}
+    for _, c in ipairs(cols) do
+      local start0 = (c > 0) and (c - 1) or 0 -- to 0-based
+      spans[#spans + 1] = { start0, start0 + 1 }
+    end
+    positions[i] = spans
+  end
+  return filtered, positions
+end
+
+local function compute_positions_grep(lines, q)
+  if q == '' then
+    return lines, {}
+  end
+  local pat = vim.pesc(q)
+  local positions = {}
+  for i, line in ipairs(lines) do
+    local sidx = 1
+    local spans = {}
+    if type(line) ~= 'string' then
+      line = tostring(line or '')
+    end
+    while true do
+      local s, e = string.find(line, pat, sidx, true)
+      if not s then
+        break
+      end
+      spans[#spans + 1] = { s - 1, e } -- 0-based start, exclusive end
+      sidx = e + 1
+      if #spans > 64 then
+        break
+      end
+    end
+    positions[i] = (#spans > 0) and spans or nil
+  end
+  return lines, positions
+end
+
+---------------------------------------------------------------------
+-- set_items
+---------------------------------------------------------------------
+local function set_items(list)
+  list = list or {}
+  if #list > M.config.max_items then
+    local tmp = {}
+    for i = 1, M.config.max_items do
+      tmp[i] = list[i]
+    end
+    list = tmp
+  end
+
+  -- sanitize to plain strings
+  for i, v in ipairs(list) do
+    if type(v) ~= 'string' then
+      list[i] = tostring(v or '')
+    end
+  end
+
+  S.items = list
+  S.filtered = list
+  S.positions = {}
+  S.select = 1
+  S.scroll = 0
+  render()
+end
+
+---------------------------------------------------------------------
+-- set_query
+---------------------------------------------------------------------
+local function set_query(q)
+  local prev_val = S.filtered[S.select]
+
+  S.query = q
+  if S.mode == 'grep' then
+    local filtered, pos = compute_positions_grep(S.items, q)
+    S.filtered, S.positions = filtered, pos
+  else
+    if q == '' then
+      S.filtered = S.items
+      S.positions = {}
+    else
+      local filtered, pos = compute_positions_files(S.items, q)
+      S.filtered, S.positions = filtered, pos
+    end
+  end
+
+  -- sanitize filtered list
+  for i, v in ipairs(S.filtered) do
+    if type(v) ~= 'string' then
+      S.filtered[i] = tostring(v or '')
+    end
+  end
+
+  -- preserve previous pick if still present
+  local idx = 1
+  if prev_val then
+    for i, v in ipairs(S.filtered) do
+      if v == prev_val then
+        idx = i
+        break
+      end
+    end
+  end
+  S.select = clamp(idx, 1, #S.filtered)
+  ensure_visible()
+  render()
+  L('set_query', { query = q, filtered = #S.filtered })
+end
+
+---------------------------------------------------------------------
+-- Move / Accept
+---------------------------------------------------------------------
+local function move_down()
+  if #S.filtered == 0 then
+    return
+  end
+  S.select = clamp(S.select + 1, 1, #S.filtered)
+  ensure_visible()
+  render()
+end
+
+local function move_up()
+  if #S.filtered == 0 then
+    return
+  end
+  S.select = clamp(S.select - 1, 1, #S.filtered)
+  ensure_visible()
+  render()
+end
+
+local function accept_selection_files()
+  local pick = S.filtered[S.select]
+  if not pick then
+    return
+  end
+  local file = pick
+  local edit_cb = function()
+    vim.cmd.edit(vim.fn.fnameescape(file))
+  end
+  M.close()
+  vim.schedule(edit_cb)
+end
+
+local function accept_selection_grep()
+  local pick = S.filtered[S.select]
+  if not pick then
+    return
+  end
+  local file, lnum = pick:match('^([^:]+):(%d+):')
+  if not file then
+    return
+  end
+  lnum = tonumber(lnum) or 1
+  local edit_cb = function()
+    vim.cmd.edit(vim.fn.fnameescape(file))
+    vim.api.nvim_win_set_cursor(0, { lnum, 0 })
+  end
+  M.close()
+  vim.schedule(edit_cb)
+end
+
+---------------------------------------------------------------------
+-- Backends
+---------------------------------------------------------------------
+local function collect_files_async(cb)
+  local root = S.root
+  local c = S.cache[root]
+  if c and c.files and now_sec() - c.files.at < M.config.cache_ttl_sec then
+    cb(c.files.list)
+    return
+  end
+
+  local file_cmd = resolve_file_cmd()
+  if file_cmd then
+    local args = { file_cmd, '--type', 'f', '--hidden', '--follow', '--color', 'never' }
+    if file_cmd == 'fd' or file_cmd == 'fdfind' then
+      table.insert(args, '--strip-cwd-prefix')
+    end
+    vim.system(args, { text = true, cwd = root }, function(obj)
+      local list
+      if obj.code == 0 and obj.stdout then
+        list = vim.split(obj.stdout, '\n', { trimempty = true })
+      else
+        list = vim.fn.globpath(root, '**/*', false, true)
+        list = vim.tbl_filter(function(p)
+          return vim.fn.isdirectory(p) == 0
+        end, list)
+      end
+      if #list > M.config.max_items then
+        local tmp = {}
+        for i = 1, M.config.max_items do
+          tmp[i] = list[i]
+        end
+        list = tmp
+      end
+      S.cache[root] = S.cache[root] or {}
+      S.cache[root].files = { list = list, at = now_sec() }
+      vim.schedule(function()
+        cb(list)
+      end)
+    end)
+  else
+    local list = vim.fn.globpath(root, '**/*', false, true)
+    list = vim.tbl_filter(function(p)
+      return vim.fn.isdirectory(p) == 0
+    end, list)
+    if #list > M.config.max_items then
+      local tmp = {}
+      for i = 1, M.config.max_items do
+        tmp[i] = list[i]
+      end
+      list = tmp
+    end
+    S.cache[root] = S.cache[root] or {}
+    S.cache[root].files = { list = list, at = now_sec() }
+    cb(list)
+  end
+end
+
+local function grep_async(query, cb)
+  if query == '' then
+    cb({})
+    return
+  end
+  local rg = M.config.grep_cmd
+  if rg ~= 'rg' and not cmd_exists(rg) then
+    rg = 'rg'
+  end
+  if not cmd_exists(rg) then
+    cb({})
+    return
+  end
+  local args = { rg, '--vimgrep', '--hidden', '--smart-case', '--no-heading', '--', query }
+  vim.system(args, { text = true, cwd = S.root }, function(obj)
+    local list = {}
+    if obj.code == 0 and obj.stdout then
+      list = vim.split(obj.stdout, '\n', { trimempty = true })
+    end
+    if #list > M.config.max_items then
+      local tmp = {}
+      for i = 1, M.config.max_items do
+        tmp[i] = list[i]
+      end
+      list = tmp
+    end
+    vim.schedule(function()
+      cb(list)
+    end)
+  end)
+end
+
+---------------------------------------------------------------------
+-- Layout
+---------------------------------------------------------------------
+local function open_layout(prompt)
+  S.buf_inp = vim.api.nvim_create_buf(false, true)
+  S.buf_res = vim.api.nvim_create_buf(false, true)
+
+  for _, b in ipairs({ S.buf_inp, S.buf_res }) do
+    vim.bo[b].buflisted = false
+    vim.bo[b].bufhidden = 'wipe'
+    vim.bo[b].swapfile = false
+  end
+  vim.bo[S.buf_inp].buftype = 'prompt'
+  vim.bo[S.buf_res].buftype = 'nofile'
+  vim.bo[S.buf_res].modifiable = false
+  vim.bo[S.buf_res].readonly = false
+
+  local width = math.floor(vim.o.columns * 0.8)
+  local height = math.min(math.floor(vim.o.lines * 0.5), M.config.page_size + 2)
+  local col = math.floor((vim.o.columns - width) / 2)
+  local row = math.floor((vim.o.lines - height) * 0.7)
+
+  S.win_inp = vim.api.nvim_open_win(S.buf_inp, true, {
+    relative = 'editor',
+    style = 'minimal',
+    border = 'rounded',
+    width = width,
+    height = 1,
+    col = col,
+    row = row,
+    focusable = true,
+    zindex = 200,
+  })
+  vim.fn.prompt_setprompt(S.buf_inp, prompt)
+
+  S.win_res = vim.api.nvim_open_win(S.buf_res, false, {
+    relative = 'editor',
+    style = 'minimal',
+    border = 'single',
+    width = width,
+    height = height - 2,
+    col = col,
+    row = row + 2,
+    focusable = false,
+    zindex = 199,
+  })
+  vim.wo[S.win_res].cursorline = false
+  vim.wo[S.win_res].cursorlineopt = 'line'
+
+  if S.aug then
+    pcall(vim.api.nvim_del_augroup_by_id, S.aug)
+  end
+  S.aug = vim.api.nvim_create_augroup('finder_session', { clear = true })
+
+  -- Close if focus enters a non-floating window that isn't ours
+  vim.api.nvim_create_autocmd('WinEnter', {
+    group = S.aug,
     callback = function()
-      local text = vim.fn.getline('.'):gsub('^Grep:%s*', '')
-      run_grep(text)
+      if not S.active then
+        return
+      end
+      local w = vim.api.nvim_get_current_win()
+      if w == S.win_inp or w == S.win_res then
+        return
+      end
+      local cfg = vim.api.nvim_win_get_config(w)
+      if cfg and cfg.relative == '' then
+        M.close()
+      end
     end,
   })
 
-  vim.keymap.set('i', '<C-n>', function()
-    if Fuzzy.cursor < #Fuzzy.matches then
-      Fuzzy.cursor = Fuzzy.cursor + 1
-      if Fuzzy.cursor > Fuzzy.scroll + Fuzzy.page_size then
-        Fuzzy.scroll = Fuzzy.scroll + 1
+  -- Close if prompt buffer hides or leaves
+  vim.api.nvim_create_autocmd({ 'BufHidden', 'BufLeave' }, {
+    group = S.aug,
+    buffer = S.buf_inp,
+    callback = function()
+      if S.active then
+        M.close()
       end
-      local query = vim.fn.getline('.'):gsub('^Grep:%s*', '')
-      render_results(query)
-    end
-  end, { buffer = Fuzzy.input_buf })
+    end,
+  })
 
-  vim.keymap.set('i', '<C-p>', function()
-    if Fuzzy.cursor > 1 then
-      Fuzzy.cursor = Fuzzy.cursor - 1
-      if Fuzzy.cursor <= Fuzzy.scroll then
-        Fuzzy.scroll = math.max(Fuzzy.scroll - 1, 0)
+  -- Re-render on resize to respect new viewport height
+  vim.api.nvim_create_autocmd('VimResized', {
+    group = S.aug,
+    callback = function()
+      if S.active then
+        render()
       end
-      local query = vim.fn.getline('.'):gsub('^Grep:%s*', '')
-      render_results(query)
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<CR>', function()
-    local line = Fuzzy.matches[Fuzzy.cursor]
-    if line then
-      local parts = vim.split(line, ':')
-      local file, lnum = parts[1], tonumber(parts[2]) or 1
-      Fuzzy.close()
-      vim.cmd.edit(vim.fn.fnameescape(file))
-      vim.api.nvim_win_set_cursor(0, { lnum, 0 })
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<Esc>', function()
-    Fuzzy.close()
-  end, { buffer = Fuzzy.input_buf })
+    end,
+  })
 
   vim.cmd.startinsert()
+  L('open_layout', { win_inp = S.win_inp, win_res = S.win_res })
 end
 
---------------------------------------------------------------------
--- 🧩 Commands & Keymaps
---------------------------------------------------------------------
-vim.api.nvim_create_user_command('FuzzyLive', function()
-  Fuzzy.open()
-end, {})
-vim.api.nvim_create_user_command('FuzzyGrep', function()
-  Fuzzy.open_grep()
-end, {})
+local function close_layout()
+  for _, win in ipairs({ S.win_inp, S.win_res }) do
+    if win and vim.api.nvim_win_is_valid(win) then
+      pcall(vim.api.nvim_win_close, win, true)
+    end
+  end
+  for _, buf in ipairs({ S.buf_inp, S.buf_res }) do
+    if buf and vim.api.nvim_buf_is_valid(buf) then
+      pcall(vim.api.nvim_buf_delete, buf, { force = true })
+    end
+  end
+  if S.aug then
+    pcall(vim.api.nvim_del_augroup_by_id, S.aug)
+    S.aug = nil
+  end
+  L('close_layout')
+end
 
-vim.keymap.set('n', '<leader>f', function()
-  vim.cmd.FuzzyLive()
-end, { desc = 'Open fuzzy file finder' })
-vim.keymap.set('n', '<leader>g', function()
-  vim.cmd.FuzzyGrep()
-end, { desc = 'Search file contents with ripgrep' })
+---------------------------------------------------------------------
+-- Input handlers
+---------------------------------------------------------------------
+local function attach_handlers()
+  local opts = { buffer = S.buf_inp, nowait = true, silent = true, noremap = true }
+  vim.keymap.set('i', '<C-n>', move_down, opts)
+  vim.keymap.set('i', '<C-p>', move_up, opts)
+  vim.keymap.set('i', '<Down>', move_down, opts)
+  vim.keymap.set('i', '<Up>', move_up, opts)
+  vim.keymap.set('i', '<CR>', function()
+    if S.mode == 'grep' then
+      accept_selection_grep()
+    else
+      accept_selection_files()
+    end
+  end, opts)
+  vim.keymap.set('i', '<Esc>', function()
+    M.close()
+  end, opts)
+  vim.keymap.set('i', '<C-c>', function()
+    M.close()
+  end, opts)
 
-return Fuzzy
+  vim.api.nvim_create_autocmd({ 'TextChangedI', 'TextChangedP' }, {
+    group = S.aug,
+    buffer = S.buf_inp,
+    callback = function()
+      debounce(function()
+        local raw = vim.fn.getline('.')
+        local prompt = (S.mode == 'files') and '^Search:%s*' or '^Grep:%s*'
+        local q = raw:gsub(prompt, '')
+        if S.mode == 'grep' then
+          grep_async(q, function(list)
+            S.items = list
+            set_query(q)
+          end)
+        else
+          set_query(q)
+        end
+      end, M.config.debounce_ms)
+    end,
+  })
+
+  L('keymaps attached', opts)
+end
+
+---------------------------------------------------------------------
+-- Public
+---------------------------------------------------------------------
+function M.files()
+  if S.active then
+    M.close()
+  end
+  S.active = true
+  S.mode = 'files'
+  S.root = project_root()
+  open_layout('Search: ')
+  attach_handlers()
+  collect_files_async(function(list)
+    set_items(list) -- use the helper
+    -- no need to call set_query('') here; set_items() renders initial list
+  end)
+end
+
+function M.grep()
+  if S.active then
+    M.close()
+  end
+  S.active = true
+  S.mode = 'grep'
+  S.root = project_root()
+  open_layout('Grep: ')
+  attach_handlers()
+  S.items = {}
+  set_query('')
+end
+
+function M.close()
+  if not S.active then
+    return
+  end
+  close_layout()
+  if S.timer then
+    S.timer:stop()
+    S.timer:close()
+    S.timer = nil
+  end
+  S.active = false
+  S.mode, S.root = nil, nil
+  S.items, S.filtered, S.positions = {}, {}, {}
+  S.query, S.select, S.scroll = '', 1, 0
+  L('session closed')
+end
+
+function M.setup(opts)
+  M.config = vim.tbl_deep_extend('force', M.config, opts or {})
+  if M.config.file_cmd and not cmd_exists(M.config.file_cmd) then
+    vim.notify(("finder: file_cmd '%s' not found"):format(M.config.file_cmd), vim.log.levels.WARN)
+  end
+  if M.config.grep_cmd and not cmd_exists(M.config.grep_cmd) then
+    vim.notify(
+      ("finder: grep_cmd '%s' not found, will try 'rg'"):format(M.config.grep_cmd),
+      vim.log.levels.WARN
+    )
+  end
+  L('setup', M.config)
+end
+
+return M