feat: convert latex asynchronously

## Details

This change speeds up rendering `latex`, especially noticeable when
there are many in the document. This is done by kicking off the jobs to
do the conversion for all formulas in one batch, then waiting for them
all to complete. This relies on the `vim.system` API so requires
`0.10.0`, the old `vim.fn.system` based approach is kept for backwards
compatibility, but will not have any performance improvements.

In order to do this we need access to all the `latex` nodes at one point
in time. This is done by storing them in the buffer level `Context`
module. Then we take advantage of the new `last` parameter given to the
handler to perform rendering for all the nodes. Before we reach `last`
we simply append to the list and return an empty collection of marks.
This will likely complicate debugging efforts in the future as
computations are no longer neatly ordered by the node they are operating
on, but I think this is a reasonable trade off.

Once we start processing the nodes we create all the tasks with
`vim.system`, then await the results of each, reducing the amount we are
blocking as work can continue in the background. The results are stored
in the existing `cache`, while rendering we get the cached value which
should always be available.

The `latex` nodes are retrieved as a list of lists, the initial level
indicates that the following nodes all start on the same row. Currently
this allows us to skip some duplicate work like calculating the `indent`
level which will be the same for all `latex` nodes on the same row. In
general this is a pretty insignificant gain, but still nice. In the
future we can use this to combine virtual lines for multiple formulas to
improve the overall rendering, currently the virtual lines just get
stacked on top of each other.

Semi-related changes:

- update `log_runtime` to limit elapsed time to 10,000 instead of 1,000
- add `copy` method to `Line` module

## Results

On my machine (M2 max) with about 100 formulas on screen to render
looking at the runtime for the initial render.

- default converter (`latex2text`): 1500ms -> 300ms (5x faster)
- faster converter (`utftex`): 225ms -> 85ms (2.5x faster)

Author: MeanderingProgrammer

doc/render-markdown.txt

@@ -1,4 +1,4 @@
-*render-markdown.txt*      For NVIM v0.11.4     Last change: 2025 September 09
+*render-markdown.txt*      For NVIM v0.11.4     Last change: 2025 September 10
 
 ==============================================================================
 Table of Contents                          *render-markdown-table-of-contents*

lua/render-markdown/core/log.lua

@@ -59,9 +59,9 @@ function M.runtime(name, callback)
             callback()
             local end_time = compat.uv.hrtime()
             local elapsed = (end_time - start_time) / 1e+6
-            assert(elapsed < 1000, 'invalid elapsed time')
+            assert(elapsed < 10000, 'invalid elapsed time')
             -- selene: allow(deprecated)
-            vim.print(('%8s : %5.1f ms'):format(name:upper(), elapsed))
+            vim.print(('%8s : %6.1f ms'):format(name:upper(), elapsed))
         end
     else
         return callback

lua/render-markdown/handler/latex.lua

@@ -8,6 +8,7 @@ local str = require('render-markdown.lib.str')
 
 ---@class render.md.handler.buf.Latex
 ---@field private context render.md.request.Context
+---@field private marks render.md.Marks
 ---@field private config render.md.latex.Config
 local Handler = {}
 Handler.__index = Handler
@@ -21,100 +22,138 @@ Handler.cache = {}
 function Handler.new(buf)
     local self = setmetatable({}, Handler)
     self.context = Context.get(buf)
+    self.marks = Marks.new(self.context, true)
     self.config = self.context.config.latex
     return self
 end
 
 ---@param root TSNode
+---@param last boolean
 ---@return render.md.Mark[]
-function Handler:run(root)
+function Handler:run(root, last)
     if not self.config.enabled then
         return {}
     end
     if vim.fn.executable(self.config.converter) ~= 1 then
         log.add('debug', 'ConverterNotFound', self.config.converter)
         return {}
     end
-
     local node = Node.new(self.context.buf, root)
     log.node('latex', node)
+    self.context.latex:add(node)
+    if last then
+        local rows = self.context.latex:get()
+        self:convert(rows)
+        for _, nodes in ipairs(rows) do
+            self:render(nodes)
+        end
+    end
+    return self.marks:get()
+end
 
-    local marks = Marks.new(self.context, true)
-    local output = str.split(self:convert(node.text), '\n', true)
-    if self.config.virtual or #output > 1 then
-        local col = node.start_col
-        local _, first = node:line('first', 0)
-        local prefix = str.pad(first and str.width(first:sub(1, col)) or col)
-        local width = vim.fn.max(iter.list.map(output, str.width))
-
-        local text = {} ---@type string[]
-        for _ = 1, self.config.top_pad do
-            text[#text + 1] = ''
+---@private
+---@param rows render.md.Node[][]
+function Handler:convert(rows)
+    local cmd = self.config.converter
+    local inputs = {} ---@type string[]
+    for _, nodes in ipairs(rows) do
+        for _, node in ipairs(nodes) do
+            local text = node.text
+            local new = not Handler.cache[text]
+            local unique = not vim.tbl_contains(inputs, text)
+            if new and unique then
+                inputs[#inputs + 1] = text
+            end
         end
-        for _, line in ipairs(output) do
-            local suffix = str.pad(width - str.width(line))
-            text[#text + 1] = prefix .. line .. suffix
+    end
+    if vim.system then
+        local tasks = {} ---@type table<string, vim.SystemObj>
+        for _, text in ipairs(inputs) do
+            tasks[text] = vim.system({ cmd }, { stdin = text, text = true })
         end
-        for _ = 1, self.config.bottom_pad do
-            text[#text + 1] = ''
+        for text, task in pairs(tasks) do
+            local output = task:wait()
+            local result = output.stdout
+            if output.code ~= 0 or not result then
+                log.add('error', 'ConverterFailed', cmd, result)
+                result = 'error'
+            end
+            Handler.cache[text] = result
         end
-
-        local indent = self:indent(node.start_row, col)
-        local lines = iter.list.map(text, function(part)
-            local line = vim.list_extend({}, indent) ---@type render.md.mark.Line
-            line[#line + 1] = { part, self.config.highlight }
-            return line
-        end)
-
-        local above = self.config.position == 'above'
-        local row = above and node.start_row or node.end_row
-
-        marks:add(self.config, 'virtual_lines', row, 0, {
-            virt_lines = lines,
-            virt_lines_above = above,
-        })
     else
-        marks:over(self.config, true, node, {
-            virt_text = { { output[1], self.config.highlight } },
-            virt_text_pos = 'inline',
-            conceal = '',
-        })
+        for _, text in ipairs(inputs) do
+            local result = vim.fn.system(cmd, text)
+            if vim.v.shell_error == 1 then
+                log.add('error', 'ConverterFailed', cmd, result)
+                result = 'error'
+            end
+            Handler.cache[text] = result
+        end
     end
-    return marks:get()
 end
 
 ---@private
----@param text string
----@return string
-function Handler:convert(text)
-    local result = Handler.cache[text]
-    if not result then
-        local converter = self.config.converter
-        result = vim.fn.system(converter, text)
-        if vim.v.shell_error == 1 then
-            log.add('error', 'ConverterFailed', converter, result)
-            result = 'error'
+---@param nodes render.md.Node[]
+function Handler:render(nodes)
+    local first = nodes[1]
+    local indent = self:indent(first)
+    local _, line = first:line('first', 0)
+
+    for _, node in ipairs(nodes) do
+        local output = str.split(Handler.cache[node.text], '\n', true)
+        if self.config.virtual or #output > 1 then
+            local col = node.start_col
+            local prefix = str.pad(line and str.width(line:sub(1, col)) or col)
+            local width = vim.fn.max(iter.list.map(output, str.width))
+
+            local texts = {} ---@type string[]
+            for _ = 1, self.config.top_pad do
+                texts[#texts + 1] = ''
+            end
+            for _, text in ipairs(output) do
+                local suffix = str.pad(width - str.width(text))
+                texts[#texts + 1] = prefix .. text .. suffix
+            end
+            for _ = 1, self.config.bottom_pad do
+                texts[#texts + 1] = ''
+            end
+
+            local lines = iter.list.map(texts, function(text)
+                return indent:copy():text(text, self.config.highlight):get()
+            end)
+
+            local above = self.config.position == 'above'
+            local row = above and node.start_row or node.end_row
+
+            self.marks:add(self.config, 'virtual_lines', row, 0, {
+                virt_lines = lines,
+                virt_lines_above = above,
+            })
+        else
+            self.marks:over(self.config, true, node, {
+                virt_text = { { output[1], self.config.highlight } },
+                virt_text_pos = 'inline',
+                conceal = '',
+            })
         end
-        Handler.cache[text] = result
     end
-    return result
 end
 
 ---@private
----@param row integer
----@param col integer
----@return render.md.mark.Line
-function Handler:indent(row, col)
+---@param node render.md.Node
+---@return render.md.Line
+function Handler:indent(node)
     local buf = self.context.buf
-    local node = vim.treesitter.get_node({
+    local markdown = vim.treesitter.get_node({
         bufnr = buf,
-        pos = { row, col },
+        pos = { node.start_row, node.start_col },
         lang = 'markdown',
     })
-    if not node then
-        return {}
+    if not markdown then
+        return self.context.config:line()
+    else
+        return Indent.new(self.context, Node.new(buf, markdown)):line(true)
     end
-    return Indent.new(self.context, Node.new(buf, node)):line(true):get()
 end
 
 ---@class render.md.handler.Latex: render.md.Handler
@@ -123,7 +162,7 @@ local M = {}
 ---@param ctx render.md.handler.Context
 ---@return render.md.Mark[]
 function M.parse(ctx)
-    return Handler.new(ctx.buf):run(ctx.root)
+    return Handler.new(ctx.buf):run(ctx.root, ctx.last)
 end
 
 return M

lua/render-markdown/health.lua

@@ -5,7 +5,7 @@ local state = require('render-markdown.state')
 local M = {}
 
 ---@private
-M.version = '8.8.2'
+M.version = '8.8.3'
 
 function M.check()
     M.start('versions')

lua/render-markdown/lib/line.lua

@@ -37,6 +37,14 @@ function Line:extend(other)
     return self
 end
 
+---@return render.md.Line
+function Line:copy()
+    local result = setmetatable({}, Line)
+    result.highlight = self.highlight
+    result.line = vim.list_extend({}, self.line)
+    return result
+end
+
 ---@param s string
 ---@param highlight? render.md.mark.Hl
 ---@return render.md.Line

lua/render-markdown/request/context.lua

@@ -1,6 +1,7 @@
 local Callout = require('render-markdown.request.callout')
 local Checkbox = require('render-markdown.request.checkbox')
 local Conceal = require('render-markdown.request.conceal')
+local Latex = require('render-markdown.request.latex')
 local Offset = require('render-markdown.request.offset')
 local Used = require('render-markdown.request.used')
 local View = require('render-markdown.request.view')
@@ -14,6 +15,7 @@ local str = require('render-markdown.lib.str')
 ---@field conceal render.md.request.Conceal
 ---@field callout render.md.request.Callout
 ---@field checkbox render.md.request.Checkbox
+---@field latex render.md.request.Latex
 ---@field offset render.md.request.Offset
 ---@field used render.md.request.Used
 local Context = {}
@@ -33,6 +35,7 @@ function Context.new(buf, win, config, view)
     self.conceal = Conceal.new(buf, win, view)
     self.callout = Callout.new()
     self.checkbox = Checkbox.new()
+    self.latex = Latex.new()
     self.offset = Offset.new()
     self.used = Used.new()
     return self

lua/render-markdown/request/latex.lua

@@ -0,0 +1,34 @@
+---@class render.md.request.Latex
+---@field private nodes render.md.Node[]
+local Latex = {}
+Latex.__index = Latex
+
+---@return render.md.request.Latex
+function Latex.new()
+    local self = setmetatable({}, Latex)
+    self.nodes = {}
+    return self
+end
+
+---@param node render.md.Node
+function Latex:add(node)
+    self.nodes[#self.nodes + 1] = node
+end
+
+---@return render.md.Node[][]
+function Latex:get()
+    table.sort(self.nodes)
+    local result = {} ---@type render.md.Node[][]
+    result[#result + 1] = { self.nodes[1] }
+    for i = 2, #self.nodes do
+        local node, last = self.nodes[i], result[#result]
+        if node.start_row == last[#last].start_row then
+            last[#last + 1] = node
+        else
+            result[#result + 1] = { node }
+        end
+    end
+    return result
+end
+
+return Latex

neovim.yml

@@ -38,3 +38,8 @@ globals:
       - type: bool
       - type: string
         required: false
+  assert.not_nil:
+    args:
+      - type: any
+      - type: string
+        required: false

tests/helpers/system.lua

@@ -0,0 +1,42 @@
+---@module 'luassert'
+
+local stub = require('luassert.stub')
+
+---@class render.md.test.Task: vim.SystemObj
+---@field private stdout string
+local Task = {}
+Task.__index = Task
+
+---@param stdout string
+---@return render.md.test.Task
+function Task.new(stdout)
+    local self = setmetatable({}, Task)
+    self.stdout = stdout
+    return self
+end
+
+---@return vim.SystemCompleted
+function Task:wait()
+    ---@type vim.SystemCompleted
+    return { code = 0, signal = 0, stdout = self.stdout }
+end
+
+---@class render.md.test.System
+local M = {}
+
+---@param command string
+---@param outputs table<string, string>
+function M.mock(command, outputs)
+    stub.new(vim.fn, 'executable', function(expr)
+        assert.same(command, expr)
+        return 1
+    end)
+    stub.new(vim, 'system', function(cmd, opts)
+        assert.same({ command }, cmd)
+        local output = outputs[opts.stdin]
+        assert.not_nil(output, ('missing output: %s'):format(opts.stdin))
+        return Task.new(output)
+    end)
+end
+
+return M