refactor(renderer/flush): suppress output-window autocmds and ensure update cleanup

Add a with_suppressed_output_autocmds helper that temporarily sets
eventignorewin on the output window, wraps output_window.begin_update /
end_update with xpcall to guarantee cleanup, and restores the original
state even if the wrapped operation errors.

Use the helper in apply_pending and end_bulk_mode so writes and part/message
updates won't trigger autocmds mid-write and cleanup always runs. Re-throw
errors after restoring state.

Add unit tests exercising failure during bulk writes to verify eventignore
is restored, end_update is called, and bulk mode state is cleared.

Author: sudo-tee

lua/opencode/ui/renderer/flush.lua

@@ -9,6 +9,44 @@ local append = require('opencode.ui.renderer.append')
 
 local M = {}
 
+local function with_suppressed_output_autocmds(fn)
+  local output_win = state.windows and state.windows.output_win
+  local has_output_win = output_win and vim.api.nvim_win_is_valid(output_win)
+  local saved_eventignorewin = has_output_win and vim.api.nvim_get_option_value('eventignorewin', { win = output_win })
+    or nil
+
+  if has_output_win then
+    vim.api.nvim_set_option_value('eventignorewin', 'all', { win = output_win, scope = 'local' })
+  end
+
+  local begin_ok, began_update = xpcall(output_window.begin_update, debug.traceback)
+  if not begin_ok then
+    if has_output_win then
+      vim.api.nvim_set_option_value('eventignorewin', saved_eventignorewin, { win = output_win, scope = 'local' })
+    end
+    error(began_update)
+  end
+
+  local ok, result = xpcall(fn, debug.traceback)
+  local end_ok, end_err = true, nil
+
+  if began_update then
+    end_ok, end_err = xpcall(output_window.end_update, debug.traceback)
+  end
+  if has_output_win then
+    vim.api.nvim_set_option_value('eventignorewin', saved_eventignorewin, { win = output_win, scope = 'local' })
+  end
+
+  if not ok then
+    error(result)
+  end
+  if not end_ok then
+    error(end_err)
+  end
+
+  return result
+end
+
 local function lines_equal(a, b)
   a = a or {}
   b = b or {}
@@ -282,50 +320,46 @@ local function apply_pending(pending)
   end
 
   local scroll_snapshot = scroll.pre_flush(buf)
-  local saved_eventignore = vim.o.eventignore
-  vim.o.eventignore = 'all'
-  output_window.begin_update()
-
-  for _, part_id in ipairs(pending.removed_part_order) do
-    if pending.removed_parts[part_id] then
-      buffer.remove_part_now(part_id)
+  with_suppressed_output_autocmds(function()
+    for _, part_id in ipairs(pending.removed_part_order) do
+      if pending.removed_parts[part_id] then
+        buffer.remove_part_now(part_id)
+      end
     end
-  end
 
-  for _, message_id in ipairs(pending.removed_message_order) do
-    if pending.removed_messages[message_id] then
-      buffer.remove_message_now(message_id)
+    for _, message_id in ipairs(pending.removed_message_order) do
+      if pending.removed_messages[message_id] then
+        buffer.remove_message_now(message_id)
+      end
     end
-  end
 
-  for _, message_id in ipairs(pending.dirty_message_order) do
-    if pending.dirty_messages[message_id] then
-      apply_message(message_id)
-    end
+    for _, message_id in ipairs(pending.dirty_message_order) do
+      if pending.dirty_messages[message_id] then
+        apply_message(message_id)
+      end
 
-    local dirty_parts = pending.dirty_part_by_message[message_id]
-    if dirty_parts then
-      local message = ctx.render_state:get_message(message_id)
-      local parts = message and message.message and message.message.parts or {}
-      for _, part in ipairs(parts or {}) do
-        if part.id and dirty_parts[part.id] then
-          apply_part(part.id, message_id)
-          dirty_parts[part.id] = nil
-          pending.dirty_parts[part.id] = nil
+      local dirty_parts = pending.dirty_part_by_message[message_id]
+      if dirty_parts then
+        local message = ctx.render_state:get_message(message_id)
+        local parts = message and message.message and message.message.parts or {}
+        for _, part in ipairs(parts or {}) do
+          if part.id and dirty_parts[part.id] then
+            apply_part(part.id, message_id)
+            dirty_parts[part.id] = nil
+            pending.dirty_parts[part.id] = nil
+          end
         end
       end
     end
-  end
 
-  for _, part_id in ipairs(pending.dirty_part_order) do
-    local message_id = pending.dirty_parts[part_id]
-    if message_id then
-      apply_part(part_id, message_id)
+    for _, part_id in ipairs(pending.dirty_part_order) do
+      local message_id = pending.dirty_parts[part_id]
+      if message_id then
+        apply_part(part_id, message_id)
+      end
     end
-  end
+  end)
 
-  output_window.end_update()
-  vim.o.eventignore = saved_eventignore
   scroll.post_flush(scroll_snapshot, buf)
   return true
 end
@@ -396,21 +430,23 @@ function M.end_bulk_mode()
   end
 
   -- Write all lines at once. Suppress autocmds so render-markdown and similar
-  -- plugins don't fire mid-write; we trigger them explicitly via vim.schedule
-  -- below. begin_update/end_update handles the modifiable toggle.
-  local saved_eventignore = vim.o.eventignore
-  vim.o.eventignore = 'all'
-  output_window.begin_update()
-  output_window.set_lines(lines, 0, -1)
-  output_window.end_update()
-  vim.o.eventignore = saved_eventignore
-
-  if next(ctx.bulk_extmarks_by_line) then
-    output_window.set_extmarks(ctx.bulk_extmarks_by_line, 0)
-  end
+  -- plugins don't fire mid-write; restore state even if the write fails.
+  local ok, err = xpcall(function()
+    with_suppressed_output_autocmds(function()
+      output_window.set_lines(lines, 0, -1)
+    end)
+
+    if next(ctx.bulk_extmarks_by_line) then
+      output_window.set_extmarks(ctx.bulk_extmarks_by_line, 0)
+    end
+  end, debug.traceback)
 
   ctx:bulk_reset()
 
+  if not ok then
+    error(err)
+  end
+
   vim.schedule(function()
     M.request_on_data_rendered(true)
   end)

tests/unit/output_window_spec.lua

@@ -1,6 +1,7 @@
 local config = require('opencode.config')
 local state = require('opencode.state')
 local output_window = require('opencode.ui.output_window')
+local flush = require('opencode.ui.renderer.flush')
 local stub = require('luassert.stub')
 
 describe('output_window.create_buf', function()
@@ -180,3 +181,73 @@ describe('output_window extmarks', function()
     assert.equals(1, marks[2][2])
   end)
 end)
+
+describe('renderer flush cleanup', function()
+  local buf
+  local win
+  local original_eventignore
+  local original_eventignorewin
+  local begin_update_stub
+  local end_update_stub
+  local set_lines_stub
+  local set_extmarks_stub
+
+  before_each(function()
+    buf = vim.api.nvim_create_buf(false, true)
+    win = vim.api.nvim_open_win(buf, true, {
+      relative = 'editor',
+      width = 80,
+      height = 10,
+      row = 0,
+      col = 0,
+    })
+    state.ui.set_windows({ output_buf = buf, output_win = win })
+    original_eventignore = vim.o.eventignore
+    original_eventignorewin = vim.api.nvim_get_option_value('eventignorewin', { win = win })
+    begin_update_stub = stub(output_window, 'begin_update').returns(true)
+    end_update_stub = stub(output_window, 'end_update')
+    set_lines_stub = stub(output_window, 'set_lines').invokes(function()
+      error('boom')
+    end)
+    set_extmarks_stub = stub(output_window, 'set_extmarks')
+  end)
+
+  after_each(function()
+    if set_extmarks_stub then
+      set_extmarks_stub:revert()
+    end
+    if set_lines_stub then
+      set_lines_stub:revert()
+    end
+    if end_update_stub then
+      end_update_stub:revert()
+    end
+    if begin_update_stub then
+      begin_update_stub:revert()
+    end
+    vim.o.eventignore = original_eventignore
+    if win and vim.api.nvim_win_is_valid(win) then
+      vim.api.nvim_set_option_value('eventignorewin', original_eventignorewin, { win = win, scope = 'local' })
+    end
+    state.ui.set_windows(nil)
+    pcall(vim.api.nvim_win_close, win, true)
+    pcall(vim.api.nvim_buf_delete, buf, { force = true })
+  end)
+
+  it('restores output window eventignorewin and ends updates when bulk writes fail', function()
+    flush.begin_bulk_mode()
+    local ctx = require('opencode.ui.renderer.ctx')
+    ctx.bulk_buffer_lines = { 'line 1' }
+
+    local ok, err = pcall(flush.end_bulk_mode)
+
+    assert.is_false(ok)
+    assert.matches('boom', err)
+    assert.equals(original_eventignore, vim.o.eventignore)
+    assert.equals(original_eventignorewin, vim.api.nvim_get_option_value('eventignorewin', { win = win }))
+    assert.stub(begin_update_stub).was_called(1)
+    assert.stub(end_update_stub).was_called(1)
+    assert.is_false(ctx.bulk_mode)
+    assert.stub(set_extmarks_stub).was_not_called()
+  end)
+end)