perf(stars): Cache leading-star positions

The on_line hook ran a tree query per visible line per redraw,
making leading-star highlighting a hot path while typing.

Cache end_col per buffer line. Shift/drop entries on buffer
edits via nvim_buf_attach (on_bytes/on_reload), and rebuild
the changed ranges from on_changedtree once the parser has
produced a new tree. on_line is now a plain table lookup.

Mirrors the cache pattern already used by foldtext.

Author: seflue

lua/orgmode/colors/highlighter/init.lua

@@ -72,6 +72,7 @@ function OrgHighlighter:_on_win(_, win, bufnr, topline, botline)
   self.foldtext:on_win(bufnr, win, topline, botline)
   if not self.buffers[bufnr] then
     self.buffers[bufnr] = { language_tree = vim.treesitter.get_parser(bufnr, 'org') }
+    self.stars:attach(bufnr, self.buffers[bufnr].language_tree)
     self:_parse_tree(bufnr, win, false)
     self.buffers[bufnr].language_tree:register_cbs({
       on_detach = function(buf)

lua/orgmode/colors/highlighter/stars.lua

@@ -1,37 +1,140 @@
-local ts_utils = require('orgmode.utils.treesitter')
 local config = require('orgmode.config')
 
+local query = vim.treesitter.query.parse('org', '(stars) @stars')
+
 ---@class OrgStarsHighlighter
 ---@field highlighter OrgHighlighter
+---@field private cache table<number, table<number, number>>
+---@field private attached table<number, boolean>
 local OrgStars = {}
 
 ---@param opts { highlighter: OrgHighlighter }
 function OrgStars:new(opts)
   local data = {
     highlighter = opts.highlighter,
+    cache = setmetatable({}, { __mode = 'k' }),
+    attached = {},
   }
   setmetatable(data, self)
   self.__index = self
   return data
 end
 
-function OrgStars:on_line(bufnr, line)
-  if not config:hide_leading_stars(bufnr) then
+---Mirror of foldtext._apply_change: drop entries in the changed range and
+---shift entries after the boundary by the row delta. Keeps cached end_col of
+---unchanged headlines valid across edits without a tree query.
+---For single-line edits past the cached `(stars)` end_col, the entry is kept:
+---those edits cannot affect the leading-star span, so dropping it would only
+---cause a one-frame flicker until on_changedtree rebuilds.
+---@param bufnr number
+---@param start_row number 0-based
+---@param start_col number 0-based byte column of the first changed byte
+---@param old_end_row number rows in old range (relative to start_row)
+---@param new_end_row number rows in new range (relative to start_row)
+function OrgStars:_apply_change(bufnr, start_row, start_col, old_end_row, new_end_row)
+  local cache = self.cache[bufnr]
+  if not cache then
     return
   end
 
-  local node = ts_utils.get_node({
-    bufnr = bufnr,
-    pos = { line, 0 },
+  if old_end_row == new_end_row then
+    for line = start_row, start_row + old_end_row do
+      local cached = cache[line]
+      if not cached or line ~= start_row or start_col <= cached then
+        cache[line] = nil
+      end
+    end
+    return
+  end
+
+  local delta = new_end_row - old_end_row
+  local boundary = start_row + old_end_row
+  local shifted = {}
+  for k, v in pairs(cache) do
+    if k < start_row then
+      shifted[k] = v
+    elseif k > boundary then
+      shifted[k + delta] = v
+    end
+  end
+  self.cache[bufnr] = shifted
+end
+
+---Re-query the tree for `(stars)` nodes within each changed range. Fires
+---after the parser produced a new tree, so ranges are in new-tree coordinates
+---and the lookup is authoritative.
+---@param bufnr number
+---@param tree TSTree
+---@param changes Range6[]
+function OrgStars:_apply_changedtree(bufnr, tree, changes)
+  if not self.attached[bufnr] then
+    return
+  end
+  local cache = self.cache[bufnr]
+  if not cache then
+    cache = {}
+    self.cache[bufnr] = cache
+  end
+  local root = tree:root()
+  for _, range in ipairs(changes) do
+    local start_row, end_row = range[1], range[4]
+    for line = start_row, end_row do
+      cache[line] = nil
+    end
+    for _, node in query:iter_captures(root, bufnr, start_row, end_row + 1) do
+      local sr, _, er, ec = node:range()
+      if sr == er and ec > 0 then
+        cache[sr] = ec
+      end
+    end
+  end
+end
+
+---Attach buffer + language_tree listeners. Idempotent per buffer.
+---@param bufnr number
+---@param language_tree vim.treesitter.LanguageTree
+function OrgStars:attach(bufnr, language_tree)
+  if self.attached[bufnr] then
+    return
+  end
+  local ok = vim.api.nvim_buf_attach(bufnr, false, {
+    on_bytes = function(_, b, _tick, start_row, start_col, _, old_end_row, _, _, new_end_row)
+      self:_apply_change(b, start_row, start_col, old_end_row, new_end_row)
+    end,
+    on_reload = function(_, b)
+      self.cache[b] = nil
+    end,
+    on_detach = function(_, b)
+      self:on_detach(b)
+    end,
   })
+  if not ok then
+    return
+  end
+  self.attached[bufnr] = true
+  language_tree:register_cbs({
+    on_changedtree = function(changes, tree)
+      if tree then
+        self:_apply_changedtree(bufnr, tree, changes)
+      end
+    end,
+  })
+end
 
-  if not node or node:type() ~= 'stars' then
+---@param bufnr number
+---@param line number
+function OrgStars:on_line(bufnr, line)
+  if not config:hide_leading_stars(bufnr) then
     return
   end
 
-  local _, end_col = node:end_()
+  local cache = self.cache[bufnr]
+  if not cache then
+    return
+  end
 
-  if end_col <= 0 then
+  local end_col = cache[line]
+  if not end_col or end_col <= 0 then
     return
   end
 
@@ -43,4 +146,10 @@ function OrgStars:on_line(bufnr, line)
   })
 end
 
+---@param bufnr number
+function OrgStars:on_detach(bufnr)
+  self.cache[bufnr] = nil
+  self.attached[bufnr] = nil
+end
+
 return OrgStars