perf(renderer): avoid server round-trip on display toggles and incremental fold updates (#377)

* perf(renderer): avoid server round-trip on display toggles

Replace ui.render_output() with ui.render_output_from_cache() for
toggle_reasoning_output, toggle_tool_output, and toggle_max_messages.

Instead of fetching the full session from the server on every toggle,
re-render from state.messages that are already in memory. Falls back
to the server fetch if no cached messages are available.

* perf(renderer): incremental fold updates during streaming

Replace set_all_folds() with update_part_folds() in the streaming
update path to avoid rebuilding the entire fold list on every part
change. Maintain part_folds and global_folds caches in ctx for
incremental updates.

During streaming, only the affected part's fold ranges change - its
line_start stays the same. Update the cached entry for that part
and flatten the per-part cache rather than re-iterating all parts
in ctx.formatted_parts.

* perf(renderer): skip vim.deepcopy in cache re-render path

Add skip_deepcopy option to _render_full_session_data. The cache
re-render path (toggle) already owns the session_data reference and
executes synchronously, so deep copying is unnecessary overhead.

* perf(renderer): remove unnecessary vim.deepcopy in _render_full_session_data

All callers pass tables that are either fresh API responses (no other
references) or are used synchronously (no concurrent mutation window).
The deep copy served no actual protection - after storage, event handlers
mutate state.messages in-place anyway.

* fix(renderer): update fold ranges during append-only streaming

append_part_now writes new lines but did not update the part's fold
range, causing the fold's 'to' boundary to remain at its initial value.
As content grew during streaming, new lines appeared outside the fold.
Call update_part_folds after appending so the fold range tracks the
actual content extent.

* refactor(renderer): address review feedback - extract folds_equal, simplify update_part_folds loop

- Extract folds_equal() helper function with nil-guard
- Simplify update_part_folds loop by assigning ctx.part_folds first
- Add 3 test cases for update_part_folds: absolute range computation,
  unchanged fold short-circuit, and multi-part fold merging

* fix: sort folds by from value for deterministic output order

pairs() iteration order is non-deterministic across LuaJIT builds,
causing the merged fold list order to vary. Sort by from value so the
output is always predictable.

Also fix the merge test to use was_called_with with the sorted order.

Author: CnsMaple

lua/opencode/commands/handlers/workflow.lua

@@ -273,14 +273,14 @@ function M.actions.toggle_tool_output()
   local action_text = config.ui.output.tools.show_output and 'Hiding' or 'Showing'
   vim.notify(action_text .. ' tool output display', vim.log.levels.INFO)
   config.values.ui.output.tools.show_output = not config.ui.output.tools.show_output
-  ui.render_output()
+  ui.render_output_from_cache()
 end
 
 function M.actions.toggle_reasoning_output()
   local action_text = config.ui.output.tools.show_reasoning_output and 'Hiding' or 'Showing'
   vim.notify(action_text .. ' reasoning output display', vim.log.levels.INFO)
   config.values.ui.output.tools.show_reasoning_output = not config.ui.output.tools.show_reasoning_output
-  ui.render_output()
+  ui.render_output_from_cache()
 end
 
 local original_max_messages = config.ui.output.max_messages
@@ -297,7 +297,7 @@ function M.actions.toggle_max_messages()
   local val_text = next_val == nil and 'none' or tostring(next_val)
   vim.notify(action_text .. ' message limit to ' .. val_text, vim.log.levels.INFO)
   config.values.ui.output.max_messages = next_val
-  ui.render_output()
+  ui.render_output_from_cache()
 end
 
 M.actions.review = Promise.async(function(args)

lua/opencode/ui/renderer.lua

@@ -320,7 +320,7 @@ end
 function M._render_full_session_data(session_data, opts)
   opts = opts or {}
   M.reset()
-  state.renderer.set_messages(vim.deepcopy(session_data or {}))
+  state.renderer.set_messages(session_data or {})
 
   if not state.active_session or not state.messages then
     return
@@ -390,6 +390,23 @@ function M._render_full_session_data(session_data, opts)
   end
 end
 
+---Re-render from cached session data without a server round-trip.
+---Used for display-only changes (toggle folds, max_messages, etc.)
+---@param session_data OpencodeMessage[]
+function M.render_from_cache(session_data)
+  if not output_window.mounted() or not state.api_client then
+    return
+  end
+  M._render_full_session_data(session_data, {
+    restore_model_from_messages = true,
+  })
+  local active_session = state.active_session
+  if active_session and active_session.id then
+    require('opencode.ui.question_window').restore_pending_question(active_session.id)
+    permission_window.restore_pending_permissions(active_session.id)
+  end
+end
+
 ---Fetch the active session from the server and render it
 ---@return Promise<OpencodeMessage[]>
 function M.render_full_session()

lua/opencode/ui/renderer/buffer.lua

@@ -600,12 +600,12 @@ function M.upsert_part_now(part_id, message_id, formatted_data, previous_formatt
     set_part_extmark_state(part_id, formatted_data)
 
     if formatted_data.fold_ranges and #formatted_data.fold_ranges > 0 then
-      M.set_all_folds()
+      M.update_part_folds(part_id)
     end
 
     return true
   end
-  
+
 local insert_at = get_part_insertion_line(part_id, message_id)
   if not insert_at then
     return false
@@ -635,22 +635,75 @@ end
 
 function M.set_all_folds()
   local all_folds = {}
+  ctx.part_folds = {}
   for part_id_iter, data in pairs(ctx.formatted_parts) do
     if data.fold_ranges then
       local cached_part = ctx.render_state:get_part(part_id_iter)
       if cached_part and cached_part.line_start then
+        local part_abs_folds = {}
         for _, f in ipairs(data.fold_ranges) do
-          table.insert(all_folds, {
+          local abs = {
             from = cached_part.line_start + f.from - 1,
             to = cached_part.line_start + f.to - 1,
-          })
+          }
+          table.insert(part_abs_folds, abs)
+          table.insert(all_folds, abs)
         end
+        ctx.part_folds[part_id_iter] = part_abs_folds
       end
     end
   end
+  ctx.global_folds = all_folds
   output_window.set_folds(all_folds)
 end
 
+local function folds_equal(a, b)
+  if not a or not b then return false end
+  if #a ~= #b then return false end
+  for i = 1, #a do
+    if a[i].from ~= b[i].from or a[i].to ~= b[i].to then return false end
+  end
+  return true
+end
+
+---Update folds for a single part during streaming, avoiding a full rebuild.
+---@param part_id string
+function M.update_part_folds(part_id)
+  local formatted_data = ctx.formatted_parts[part_id]
+  if not formatted_data or not formatted_data.fold_ranges then
+    ctx.part_folds[part_id] = nil
+    M.set_all_folds()
+    return
+  end
+  local cached_part = ctx.render_state:get_part(part_id)
+  if not cached_part or not cached_part.line_start then
+    return
+  end
+
+  local new_folds = {}
+  for _, f in ipairs(formatted_data.fold_ranges) do
+    table.insert(new_folds, {
+      from = cached_part.line_start + f.from - 1,
+      to = cached_part.line_start + f.to - 1,
+    })
+  end
+
+  if folds_equal(ctx.part_folds[part_id], new_folds) then
+    return
+  end
+
+  ctx.part_folds[part_id] = new_folds
+  local new_global = {}
+  for _, pf in pairs(ctx.part_folds) do
+    for _, f in ipairs(pf) do
+      table.insert(new_global, f)
+    end
+  end
+  table.sort(new_global, function(a, b) return a.from < b.from end)
+  ctx.global_folds = new_global
+  output_window.set_folds(new_global)
+end
+
 
 ---@param part_id string
 ---@param extra_lines string[]
@@ -676,6 +729,9 @@ function M.append_part_now(part_id, extra_lines, extra_extmarks, previous_format
     apply_part_actions(part_id, formatted_data, cached.line_start)
     apply_extmarks(previous_formatted, formatted_data, cached.line_start, old_line_end, new_line_end)
     set_part_extmark_state(part_id, formatted_data)
+    if formatted_data.fold_ranges then
+      M.update_part_folds(part_id)
+    end
   elseif has_extmarks(extra_extmarks) then
     output_window.set_extmarks(extra_extmarks, insert_at)
   end

lua/opencode/ui/renderer/ctx.lua

@@ -29,6 +29,10 @@ local ctx = {
   bulk_buffer_lines = {},
   bulk_extmarks_by_line = {},
   bulk_folds = {},
+  ---@type {from: number, to: number}[]
+  global_folds = {},
+  ---@type table<string, {from: number, to: number}[]>
+  part_folds = {},
 }
 
 ---Reset all renderer caches and pending state.
@@ -50,6 +54,8 @@ function ctx:reset()
   }
   self.flush_scheduled = false
   self.markdown_render_scheduled = false
+  self.global_folds = {}
+  self.part_folds = {}
   self:bulk_reset()
 end
 

lua/opencode/ui/ui.lua

@@ -484,6 +484,19 @@ function M.clear_output()
   -- state.restore_points = {}
 end
 
+---Re-render the output buffer from cached session data, avoiding a server round-trip.
+---Used for display-only toggles (show_reasoning_output, show_output, max_messages).
+---Falls back to render_output() if no cached messages are available.
+---@param opts? {force_scroll?: boolean}
+function M.render_output_from_cache(opts)
+  local session_data = state.messages
+  if not session_data or not next(session_data) then
+    M.render_output(false, opts)
+    return
+  end
+  renderer.render_from_cache(session_data)
+end
+
 ---Force a full rerender of the output buffer. Should be done synchronously if
 ---called before submitting input or doing something that might generate events
 ---from opencode

tests/unit/renderer_buffer_spec.lua

@@ -126,3 +126,66 @@ describe('renderer.buffer extmarks', function()
     assert_called_before(call_order, 'clear_extmarks', 'set_lines')
   end)
 end)
+
+describe('update_part_folds', function()
+  local set_folds_stub
+
+  before_each(function()
+    ctx:reset()
+    set_folds_stub = stub(output_window, 'set_folds')
+    ctx.global_folds = {}
+    ctx.part_folds = {}
+  end)
+
+  after_each(function()
+    set_folds_stub:revert()
+    ctx:reset()
+  end)
+
+  it('computes absolute fold ranges for a single part', function()
+    ctx.formatted_parts['part_a'] = {
+      lines = { 'title', '', 'content', 'more' },
+      fold_ranges = { { from = 1, to = 4 } },
+    }
+    ctx.render_state:set_part({ id = 'part_a', messageID = 'msg_1', type = 'text' }, 10, 14)
+
+    buffer.update_part_folds('part_a')
+
+    assert.stub(set_folds_stub).was_called_with({
+      { from = 10, to = 13 },
+    })
+  end)
+
+  it('skips set_folds when fold ranges have not changed', function()
+    ctx.formatted_parts['part_a'] = {
+      lines = { 'title', '', 'content', 'more' },
+      fold_ranges = { { from = 1, to = 4 } },
+    }
+    ctx.render_state:set_part({ id = 'part_a', messageID = 'msg_1', type = 'text' }, 10, 14)
+
+    buffer.update_part_folds('part_a')
+    set_folds_stub:clear()
+
+    buffer.update_part_folds('part_a')
+
+    assert.stub(set_folds_stub).was_not_called()
+  end)
+
+  it('merges existing folds from other parts', function()
+    ctx.part_folds['part_b'] = { { from = 5, to = 8 } }
+    ctx.global_folds = { { from = 5, to = 8 } }
+
+    ctx.formatted_parts['part_a'] = {
+      lines = { 'title', '', 'content', 'more' },
+      fold_ranges = { { from = 1, to = 4 } },
+    }
+    ctx.render_state:set_part({ id = 'part_a', messageID = 'msg_1', type = 'text' }, 10, 14)
+
+    buffer.update_part_folds('part_a')
+
+    assert.stub(set_folds_stub).was_called_with({
+      { from = 5, to = 8 },
+      { from = 10, to = 13 },
+    })
+  end)
+end)