muxr 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d19432b15ff535a2ce8f4bfb5b759ddd3599b4fb0af949d7871cf1059497c483
-  data.tar.gz: ce58f726a5a9dc186deb042c0d0e31fa8694676d0cdb4c496cfb57668d5fd4c1
+  metadata.gz: a22c29848cc6a0454f9be515cbc0f654537e37f9fbde37902f55dd34c103ce21
+  data.tar.gz: b96e180cc3750f1f0d3f72fc822669acaf68cc33c65b312029664b36981794cb
 SHA512:
-  metadata.gz: 5b96c66aa1b96e853e7d268c012f8bc5e62fdf77c1e3d4e89360b764d4cfc1d20bdb271be81acad05f26417d09e17fe27f437680cb00a33fcf6f2c934600fef2
-  data.tar.gz: '045758a0d3ec1e4f2d6bfe4bb887743cc2ab80310bd842190b362e9a9976fd023b8818c35d13f80478839bbbb12d91372b22ddabc91ee430afda8c3ce3b0853a'
+  metadata.gz: 9139072cdc6e55e0ab94c7144d492858cdb3fa75bf59f5009b925d7f4e6659d8228f64987aba7c08fdff119dbcbb480511969cc64c0904e96a3ae95cb8456ddc
+  data.tar.gz: 77028f21adf1d5a7710f952af3dfc0621223b4aa0cbb70ff15436c54e797d8d3809885b50d31a71c5f417afaae2bb153bbf149379110813beeb23ba716cefe25

data/CHANGELOG.md

@@ -6,6 +6,23 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.4] - 2026-05-13
+
+### Fixed
+- Render flicker on large screens and during fzf-style redraws. Each
+  Renderer frame is now wrapped in DEC 2026 synchronized output (with
+  the cursor hidden for the duration of the diff), so terminals that
+  support it (Ghostty, kitty, iTerm2 ≥3.5, WezTerm, Alacritty ≥0.13,
+  foot) present the frame atomically instead of repainting cell by
+  cell. `Pane#read_from_pty` now drains the PTY to `EAGAIN` per tick,
+  collapsing multi-chunk bursts (vim cursor+status redraw, fzf
+  candidate list) into a single render, and the event loop caps
+  repaints at ~60 Hz while trimming `IO.select`'s timeout so deferred
+  frames still land on time. The Terminal emulator also honors
+  `\e[?2026h` / `\e[?2026l` from inner programs (fzf ≥0.41, neovim,
+  helix) as a render-timing hint — the outer paint is held until the
+  close sequence arrives or a 200 ms safety timeout expires.
+
 ## [0.1.3] - 2026-05-11
 
 ### Fixed
@@ -91,7 +108,9 @@ Initial release.
   boundaries.
 - Renderer that composes one frame and diff-emits ANSI to STDOUT.
 
-[Unreleased]: https://github.com/roelbondoc/muxr/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/roelbondoc/muxr/compare/v0.1.4...HEAD
+[0.1.4]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.4
+[0.1.3]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.3
 [0.1.2]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.2
 [0.1.1]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.1
 [0.1.0]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.0

data/lib/muxr/application.rb

@@ -16,6 +16,11 @@ module Muxr
   # attach via Renderer#reset_frame!.
   class Application
     SELECT_TIMEOUT = 0.05
+    # ~60 Hz cap on full repaints. Keystrokes in fzf or vim navigation can
+    # trigger PTY bursts faster than the terminal can usefully display them;
+    # the cap collapses those bursts and stops intermediate frames from
+    # showing through.
+    MIN_FRAME_INTERVAL = 1.0 / 60
     SOCKETS_DIR    = File.join(Dir.home, ".muxr", "sockets").freeze
     DEFAULT_WIDTH  = 80
     DEFAULT_HEIGHT = 24
@@ -61,6 +66,7 @@ module Muxr
       @listening_socket = nil
       @socket_path = self.class.socket_path_for(@session_name)
       @paste_buffer = +""
+      @last_render_at = nil
     end
 
     attr_reader :paste_buffer
@@ -513,6 +519,20 @@ module Muxr
         write_ios << @current_client if @current_client && !@client_write_buffer.empty?
 
         timeout = @message ? 0.25 : SELECT_TIMEOUT
+        # If a render is queued but we're inside the frame-rate budget, wake
+        # up as soon as the budget expires so the deferred paint lands on time.
+        if @current_client && @needs_render && @last_render_at
+          budget = MIN_FRAME_INTERVAL - (monotonic_now - @last_render_at)
+          timeout = budget.clamp(0, timeout) if budget < timeout
+        end
+        # If a pane is mid-synchronized-output (DEC 2026), wake up no later
+        # than its safety deadline so a crashed inner program can't wedge
+        # rendering past Terminal::SYNC_TIMEOUT.
+        deadline = nearest_sync_deadline
+        if deadline
+          remaining = deadline - monotonic_now
+          timeout = remaining.clamp(0, timeout) if remaining < timeout
+        end
         ready_r, ready_w, = IO.select(read_ios, write_ios, nil, timeout)
 
         ready_r&.each do |io|
@@ -542,13 +562,38 @@ module Muxr
           break
         end
 
-        if @current_client && @needs_render
-          render
-          @needs_render = false
+        if @current_client && @needs_render && !any_pane_syncing?
+          now = monotonic_now
+          if @last_render_at.nil? || (now - @last_render_at) >= MIN_FRAME_INTERVAL
+            render
+            @last_render_at = now
+            @needs_render = false
+          end
         end
       end
     end
 
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # True iff any pane (or the drawer) has opened a DEC 2026 synchronized
+    # output block that hasn't yet closed or timed out. Used to defer the
+    # outer paint so it lands on a fully-formed inner frame.
+    def any_pane_syncing?
+      return true if @session.window.panes.any? { |p| p.terminal.sync_pending? }
+      drawer = @session.drawer&.pane
+      return true if drawer && drawer.terminal.sync_pending?
+      false
+    end
+
+    def nearest_sync_deadline
+      deadlines = @session.window.panes.filter_map { |p| p.terminal.sync_deadline }
+      d = @session.drawer&.pane&.terminal&.sync_deadline
+      deadlines << d if d
+      deadlines.min
+    end
+
     def accept_client
       sock = @listening_socket.accept
       if @current_client

data/lib/muxr/pane.rb

@@ -36,11 +36,22 @@ module Muxr
       @process.write(data)
     end
 
+    # Drain everything currently in the PTY's kernel read buffer, feeding
+    # each chunk to the Terminal. Coalescing reads here means we render once
+    # per fully-formed output burst (fzf re-render, vim cursor+status redraw,
+    # etc.) instead of once per ~8 KiB chunk — the latter shows intermediate
+    # frames and is the main source of in-pane flicker. Bounded by a byte cap
+    # so a runaway producer can't starve other panes on a single tick.
+    READ_BUDGET = 1 << 20 # 1 MiB
     def read_from_pty
-      data = @process.read_nonblock
-      return nil unless data
-      @terminal.feed(data)
-      data
+      total = 0
+      while total < READ_BUDGET
+        chunk = @process.read_nonblock
+        break unless chunk
+        @terminal.feed(chunk)
+        total += chunk.bytesize
+      end
+      total.positive? ? total : nil
     end
 
     def resize(rows, cols)

data/lib/muxr/renderer.rb

@@ -371,7 +371,13 @@ module Muxr
     end
 
     def emit_frame(frame, session, input_state:, command_buffer:)
-      out = String.new("\e[0m")
+      # \e[?2026h enters synchronized-output mode so terminals that support it
+      # (Ghostty, kitty, iTerm2 ≥3.5, WezTerm, Alacritty ≥0.13, foot) present
+      # the whole frame atomically instead of repainting incrementally as bytes
+      # arrive. \e[?25l hides the cursor for the duration of the diff so it
+      # doesn't smear across every \e[y;xH position; cursor_position turns it
+      # back on at the final spot.
+      out = String.new("\e[?2026h\e[?25l\e[0m")
       same_size = @prev && @prev_w == frame[0].length && @prev_h == frame.length
       cur_fg = :unset
       cur_bg = :unset
@@ -400,6 +406,7 @@ module Muxr
       end
       out << "\e[0m"
       out << cursor_position(session, input_state: input_state, command_buffer: command_buffer)
+      out << "\e[?2026l"
       @out.write(out)
       @out.flush
       @prev = frame.map { |row| row.map(&:dup) }

data/lib/muxr/terminal.rb

@@ -12,6 +12,14 @@ module Muxr
 
     SCROLLBACK_MAX = 5000
 
+    # Inner programs (fzf ≥ 0.41, neovim, helix, …) bracket coherent screen
+    # updates with `\e[?2026h … \e[?2026l` (DECSET 2026 — "Synchronized
+    # Output"). When we see the open, we know more bytes are coming that
+    # belong to the same logical frame; rendering before the close shows a
+    # half-painted state. SYNC_TIMEOUT is the safety cap so a crashed inner
+    # program (which left ?2026h open) cannot wedge the pane indefinitely.
+    SYNC_TIMEOUT = 0.2
+
     Cell = Struct.new(:char, :fg, :bg, :attrs) do
       def reset!
         self.char = " "
@@ -52,6 +60,27 @@ module Muxr
       @selection_anchor = nil
       @selection_cursor = nil
       @selection_mode = :linear
+      @sync_pending = false
+      @sync_started_at = nil
+    end
+
+    # True iff the inner program has opened a synchronized-output block
+    # (\e[?2026h) and not yet closed it, and the safety timeout has not
+    # elapsed. The Application uses this to defer rendering so the diff lands
+    # on a fully-formed frame instead of a half-painted one.
+    def sync_pending?
+      return false unless @sync_pending
+      if @sync_started_at && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @sync_started_at) > SYNC_TIMEOUT
+        @sync_pending = false
+        @sync_started_at = nil
+        return false
+      end
+      true
+    end
+
+    def sync_deadline
+      return nil unless @sync_pending && @sync_started_at
+      @sync_started_at + SYNC_TIMEOUT
     end
 
     attr_reader :selection_mode
@@ -527,8 +556,20 @@ module Muxr
       when ">", "<", "=", "!"
         return
       when "?"
-        # DEC private modes — we treat `h`/`l` as no-ops anyway, so dropping
-        # everything is safe and avoids `\e[?Nr` colliding with DECSTBM.
+        # DEC private modes — most we treat as no-ops, but mode 2026
+        # (Synchronized Output) is a render-timing hint we honor so the
+        # outer paint lands on fully-formed frames from fzf/nvim/helix.
+        if final == "h" || final == "l"
+          if csi_params.include?(2026)
+            if final == "h"
+              @sync_pending = true
+              @sync_started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            else
+              @sync_pending = false
+              @sync_started_at = nil
+            end
+          end
+        end
         return
       end
 

data/lib/muxr/version.rb

@@ -1,3 +1,3 @@
 module Muxr
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: muxr
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Roel Bondoc