refactor(renderer): componentize renderer, add scheduler and revisioned cache

Introduce a structured renderer split into smaller components and a
scheduling system to support incremental, throttled rendering:

This refactor improves renderer performance and makes incremental
updates more deterministic and testable.

Author: sudo-tee

lua/opencode/ui/renderer.lua

@@ -7,9 +7,99 @@ local Promise = require('opencode.promise')
 local ctx = require('opencode.ui.renderer.ctx')
 local buf = require('opencode.ui.renderer.buffer')
 local events = require('opencode.ui.renderer.events')
+local session_view = require('opencode.ui.renderer.session_view')
+local virtualize = require('opencode.ui.renderer.virtualize')
+local backend = require('opencode.ui.renderer.backend')
+local overlays = require('opencode.ui.renderer.components.overlays')
+local scheduler = require('opencode.ui.renderer.scheduler')
 
 local M = {}
 
+local DEFAULT_MAX_RENDERED_MESSAGES = 80
+
+local function update_current_message_state(messages)
+  local current_message = nil
+  local last_user_message = nil
+
+  for _, message in ipairs(messages or {}) do
+    if message and message.info and message.info.id then
+      current_message = message
+      if message.info.role == 'user' then
+        last_user_message = message
+      end
+    end
+  end
+
+  state.renderer.set_current_message(current_message)
+  state.renderer.set_last_user_message(last_user_message)
+end
+
+local function find_revert_index(messages)
+  if not state.active_session or not state.active_session.revert then
+    return nil
+  end
+
+  local revert_message_id = state.active_session.revert.messageID
+  if not revert_message_id then
+    return nil
+  end
+
+  for i, message in ipairs(messages or {}) do
+    if message and message.info and message.info.id == revert_message_id then
+      return i
+    end
+  end
+
+  return nil
+end
+
+local function build_full_session_output(messages)
+  local revert_index = find_revert_index(messages)
+  local max_messages = config.ui.output.max_rendered_messages or DEFAULT_MAX_RENDERED_MESSAGES
+  local hidden_message_count = math.max(#(messages or {}) - max_messages, 0)
+  local base_blocks = session_view.build_blocks(messages, {
+    max_messages = max_messages,
+    get_child_parts = function(session_id)
+      return ctx.render_state:get_child_session_parts(session_id)
+    end,
+    include_revert_overlay = revert_index ~= nil,
+    revert_index = revert_index,
+    revert_info = state.active_session and state.active_session.revert or nil,
+  })
+
+  local visible_render = virtualize.select_visible_blocks(base_blocks, {
+    max_lines = config.ui.output.max_rendered_lines,
+  })
+
+  if hidden_message_count > 0 then
+    local hidden_block = overlays.render_hidden_history({
+      hidden_count = hidden_message_count,
+    })
+    if hidden_block then
+      table.insert(visible_render.blocks, 1, hidden_block)
+      visible_render.visible_line_count = visible_render.visible_line_count + (hidden_block.line_count or 0)
+    end
+  end
+
+  visible_render.hidden_message_count = hidden_message_count
+
+  return visible_render
+end
+
+local function apply_visible_render(visible_render, should_scroll)
+  backend.apply_full(visible_render)
+
+  local visible_keys = {}
+  for _, block in ipairs(visible_render.blocks or {}) do
+    visible_keys[#visible_keys + 1] = block.key
+  end
+  ctx.prev_visible_keys = visible_keys
+
+  if should_scroll then
+    M.scroll_to_bottom()
+  end
+end
+
 -- Expose event handlers on M so tests can call them directly and subscriptions
 -- can be stubbed cleanly (e.g. stub(renderer, '_render_full_session_data'))
 M.on_session_updated = events.on_session_updated
@@ -134,38 +224,42 @@ end
 function M._render_full_session_data(session_data)
   M.reset()
 
-  if not state.active_session or not state.messages then
+  if not state.active_session then
     return
   end
 
-  local revert_index = nil
-  local set_mode_from_messages = not state.current_model
-
-  for i, msg in ipairs(session_data) do
-    if state.active_session.revert and state.active_session.revert.messageID == msg.info.id then
-      revert_index = i
-    end
-    events.on_message_updated({ info = msg.info }, revert_index)
-    for _, part in ipairs(msg.parts or {}) do
-      events.on_part_updated({ part = part }, revert_index)
-    end
+  state.renderer.set_messages(session_data or {})
+  if not state.messages then
+    return
   end
 
-  if revert_index then
-    buf.write_formatted_data(formatter._format_revert_message(state.messages, revert_index))
-  end
+  local set_mode_from_messages = not state.current_model
+
+  update_current_message_state(state.messages)
+  local visible_render = build_full_session_output(state.messages)
+  apply_visible_render(visible_render, true)
 
   if set_mode_from_messages then
     set_model_and_mode_from_messages()
   end
 
-  M.scroll_to_bottom(true)
-
   if config.hooks and config.hooks.on_session_loaded then
     pcall(config.hooks.on_session_loaded, state.active_session)
   end
 end
 
+---@param snapshot? { full_render?: boolean, dirty_messages?: table<string, boolean>, dirty_parts?: table<string, boolean> }
+function M.perform_scheduled_render(snapshot)
+  if not output_window.mounted() or not state.active_session or not state.messages then
+    return
+  end
+
+  local should_scroll = snapshot == nil or snapshot.full_render == true or next(snapshot.dirty_messages or {}) ~= nil
+  update_current_message_state(state.messages)
+  local visible_render = build_full_session_output(state.messages)
+  apply_visible_render(visible_render, should_scroll)
+end
+
 ---Fetch the active session from the server and render it
 ---@return Promise<OpencodeMessage[]>
 function M.render_full_session()
@@ -259,6 +353,7 @@ end
 
 ---Scroll to bottom after all queued events have been processed
 function M.on_emit_events_finished()
+  scheduler.flush()
   M.scroll_to_bottom()
 end
 

lua/opencode/ui/renderer/backend.lua

@@ -1,7 +1,14 @@
+local buffer = require('opencode.ui.renderer.buffer')
+
 local M = {}
 
+---@param visible_render { blocks?: RenderBlock[] }
+function M.flatten_visible_render(visible_render)
+  return buffer.flatten_visible_render(visible_render)
+end
+
 function M.apply_full(visible_render)
-  return visible_render
+  return buffer.apply_full(visible_render)
 end
 
 return M

lua/opencode/ui/renderer/buffer.lua

@@ -2,6 +2,7 @@ local ctx = require('opencode.ui.renderer.ctx')
 local state = require('opencode.state')
 local formatter = require('opencode.ui.formatter')
 local output_window = require('opencode.ui.output_window')
+local Output = require('opencode.ui.output')
 
 local M = {}
 
@@ -13,6 +14,138 @@ local function has_actions(actions)
   return type(actions) == 'table' and #actions > 0
 end
 
+local function merge_output(target, source)
+  if not source then
+    return
+  end
+
+  local line_offset = target:get_line_count()
+  target:add_lines(source.lines or {})
+
+  for line_idx, extmarks in pairs(source.extmarks or {}) do
+    for _, extmark in ipairs(extmarks) do
+      target:add_extmark(line_idx + line_offset, vim.deepcopy(extmark))
+    end
+  end
+
+  for _, action in ipairs(source.actions or {}) do
+    local next_action = vim.deepcopy(action)
+    if next_action.display_line ~= nil then
+      next_action.display_line = next_action.display_line + line_offset
+    end
+    if next_action.range then
+      next_action.range = {
+        from = next_action.range.from + line_offset,
+        to = next_action.range.to + line_offset,
+      }
+    end
+    target:add_action(next_action)
+  end
+end
+
+local function get_message_by_id(message_id)
+  for _, message in ipairs(state.messages or {}) do
+    if message and message.info and message.info.id == message_id then
+      return message
+    end
+  end
+
+  return nil
+end
+
+local function index_message_block(block, line_cursor)
+  local message_id = block.message_id
+  if not message_id then
+    return line_cursor
+  end
+
+  local rendered_message = get_message_by_id(message_id)
+  if not rendered_message then
+    return line_cursor
+  end
+
+  local header_line_count = block.header_line_count or 0
+  local header_line_start = line_cursor
+  local header_line_end = header_line_start + math.max(header_line_count - 1, 0)
+  local message_line_end = line_cursor + math.max((block.line_count or 0) - 1, 0)
+
+  ctx.render_state:set_message(rendered_message, header_line_start, header_line_end)
+  ctx.render_state:set_message_block(rendered_message, block, header_line_start, message_line_end)
+
+  local part_line_cursor = header_line_end + 1
+  for _, part_block in ipairs(block.parts or {}) do
+    local part = nil
+    for _, candidate in ipairs(rendered_message.parts or {}) do
+      if candidate.id == part_block.part_id then
+        part = candidate
+        break
+      end
+    end
+
+    if part then
+      local part_line_start = part_line_cursor
+      local part_line_end = part_line_start + (part_block.line_count or 0) - 1
+      ctx.render_state:set_part(part, part_line_start, part_line_end)
+      ctx.render_state:set_part_block(part, part_block, part_line_start, part_line_end)
+      ctx.render_state:clear_actions(part.id)
+      ctx.render_state:add_actions(part.id, vim.deepcopy(part_block.output.actions or {}), part_line_start)
+      local rendered_part = ctx.render_state:get_part(part.id)
+      if rendered_part then
+        rendered_part.has_extmarks = part_block.output.extmarks and next(part_block.output.extmarks) ~= nil or false
+      end
+      part_line_cursor = part_line_end + 1
+    end
+  end
+
+  return message_line_end + 1
+end
+
+local function rebuild_render_state_from_blocks(blocks)
+  local line_cursor = 0
+
+  for _, block in ipairs(blocks or {}) do
+    local line_count = block.line_count or 0
+    local line_end = line_cursor + math.max(line_count - 1, 0)
+
+    ctx.render_state:set_block(block, line_cursor, line_end)
+
+    if block.kind == 'message' then
+      line_cursor = index_message_block(block, line_cursor)
+    else
+      line_cursor = line_end + 1
+    end
+  end
+end
+
+---@param visible_render { blocks?: RenderBlock[] }
+---@return Output
+function M.flatten_visible_render(visible_render)
+  local output = Output.new()
+
+  for _, block in ipairs((visible_render and visible_render.blocks) or {}) do
+    merge_output(output, block.output)
+  end
+
+  return output
+end
+
+---@param visible_render { blocks?: RenderBlock[] }
+---@return Output
+function M.apply_full(visible_render)
+  local output = M.flatten_visible_render(visible_render)
+
+  if output_window.buffer_valid() then
+    output_window.begin_update()
+    output_window.set_lines(output.lines or {})
+    output_window.clear_extmarks(0, -1, true)
+    output_window.set_extmarks(output.extmarks)
+    output_window.end_update()
+  end
+
+  rebuild_render_state_from_blocks(visible_render and visible_render.blocks or {})
+  return output
+end
+
 ---@param old_lines string[]
 ---@param new_lines string[]
 ---@return integer, integer