muxr 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b49dc8c773efbfdca08e50511ca4c66b7ef9026d5873e7f0d0f6f9adb24f946
-  data.tar.gz: 1d9db1a9dd14bfeb6e84646c91ff2c0804bff406d9e7716bf59f6b0dd2a4cbba
+  metadata.gz: d0bd4e1e9036cc3f25aaa50e92b4183eb123230b3c33877d369d5350b1de8cc4
+  data.tar.gz: 55cd2910b19e1f546e6278c7d4532f34f4627be5e30866420e3ebe6b1997f3d1
 SHA512:
-  metadata.gz: 3147be5a9ab44a49eb9df20d69ea39a91218f8df5d182de13f141f1dcac2cc3f43ddf157dc1ef8f6088f1852aeeef130ce3b835476f317e2a41b8f331ac5b068
-  data.tar.gz: 847059de7300b33d2b9c84ab46d5505ca15b70211a9f1588418c8112ba4c20ac495f7964a7ea181e2246a3e9542acb26df149bad0097164332f8eb629cfc1a19
+  metadata.gz: 4782c572a8e4ab2ba193bfd38edb0f11c37e8033decc79b5ebda1b2e2629c56adc8363e9ac000c7314eec508faf98f8b6c40fa9dfa03570ed42e9ccee0c2cfca
+  data.tar.gz: 9f39b068f63bfcae8f72dd7caba1a539723d98534d34cac0b15048f902df3440f3e4c51ac18fa6cf8154fc4eecfec8bc7eacc2c692cbe7ca03774db6cb2bc8bb

data/CHANGELOG.md

@@ -6,6 +6,50 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.11] - 2026-06-11
+
+### Added
+- Wide (CJK/emoji) and combining character support in the emulator.
+  `Terminal.char_width` classifies codepoints as 0/1/2 columns; a width-2
+  glyph occupies a lead cell plus an empty continuation cell, and
+  zero-width marks fold onto the preceding cell. Search highlights and
+  synthetic URL hyperlinks stay aligned on rows containing wide or
+  combining glyphs.
+- `r` / `Ctrl-a r` refresh keybinding: a SIGWINCH winsize-wiggle nudges
+  the focused program to repaint itself, and a forced full re-emit
+  repaints the outer terminal — recovering from display drift whichever
+  layer is at fault.
+- Scrollback is now pane-bound: `Ctrl-a` works from inside scrollback
+  and selection so pane-switch bindings work without leaving the mode,
+  focus returning to a scrolled-back pane resumes where you were
+  reading, yank returns to scrollback instead of snapping to the live
+  bottom, and `i` drops into insert without losing your place.
+- Opt-in `MUXR_TRACE_OUTPUT` tap: when the env var names a writable
+  path, the server appends every byte it sends to the client, so a
+  rendering bug can be reproduced from the byte stream alone.
+
+### Fixed
+- The diff renderer now forces an absolute cursor move after
+  width-ambiguous glyphs (East Asian Ambiguous symbols, CJK, emoji)
+  instead of trusting cursor contiguity, so a width disagreement with
+  the outer terminal clips a single glyph rather than shifting the
+  entire rest of the line — the "text doesn't line up until I resize"
+  bug. Verified against pyte as a reference emulator.
+- Bracketed-paste markers (`\e[200~`/`\e[201~`) are stripped before
+  writing to panes whose program never enabled the mode, so pastes no
+  longer show literal `^[[200~` text; programs that did enable it still
+  receive the markers, and markers split across read boundaries are
+  recombined.
+
+### Changed
+- `spiral` is the default layout for new windows (was `tall`). Saved
+  sessions are unaffected.
+- New panes and the drawer start in the session origin cwd — the
+  directory `bin/muxr` was launched from — instead of the focused
+  pane's live cwd. Explicit cwds (MCP `panes.create`, restored
+  sessions) still win, and pane creation no longer pays the synchronous
+  ~100–300ms `lsof` call on macOS.
+
 ## [0.1.10] - 2026-05-29
 
 ### Added
@@ -288,7 +332,13 @@ Initial release.
   boundaries.
 - Renderer that composes one frame and diff-emits ANSI to STDOUT.
 
-[Unreleased]: https://github.com/roelbondoc/muxr/compare/v0.1.5...HEAD
+[Unreleased]: https://github.com/roelbondoc/muxr/compare/v0.1.11...HEAD
+[0.1.11]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.11
+[0.1.10]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.10
+[0.1.9]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.9
+[0.1.8]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.8
+[0.1.7]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.7
+[0.1.6]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.6
 [0.1.5]: https://github.com/roelbondoc/muxr/releases/tag/v0.1.5
 [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

data/lib/muxr/application.rb

@@ -67,12 +67,36 @@ module Muxr
       @current_client = nil
       @client_write_buffer = +"".b
       @listening_socket = nil
+      # The directory bin/muxr was launched from — Process.daemon(true, ...)
+      # preserves it across daemonization. Every new pane (and the drawer)
+      # starts here, treating it as the session's project root regardless of
+      # where the focused pane's shell has wandered.
+      @origin_cwd = Dir.pwd
       @socket_path = self.class.socket_path_for(@session_name)
       @control_socket_path = self.class.control_socket_path_for(@session_name)
       @control_server = nil
       @paste_buffer = +""
+      # Trailing bytes of an in-flight INPUT chunk that look like the start of
+      # a bracketed-paste marker but were cut off by the 4 KiB read boundary.
+      # Held back and prepended to the next chunk so a split marker still gets
+      # recognized — see #strip_bracketed_paste_markers.
+      @paste_marker_tail = +"".b
       @last_render_at = nil
       @foreground_poller = nil
+      # Opt-in diagnostic tap. When MUXR_TRACE_OUTPUT names a writable path, the
+      # server appends every byte it sends to the client — i.e. exactly what the
+      # outer terminal receives. Replaying it (`cat` it into a fresh terminal, or
+      # feed it to a reference emulator) reproduces a rendering bug from the byte
+      # stream alone, which tells us whether corruption is in muxr's emitted
+      # output or somewhere downstream. Off unless the env var is set.
+      @trace_output = open_trace(ENV["MUXR_TRACE_OUTPUT"])
+    end
+
+    def open_trace(path)
+      return nil if path.nil? || path.empty?
+      File.open(path, "ab")
+    rescue SystemCallError
+      nil
     end
 
     # Interval for the background thread that refreshes each pane's
@@ -94,13 +118,65 @@ module Muxr
 
     # ---------- public action API (called from InputHandler / CommandDispatcher) ----------
 
+    # Bytes the outer terminal wraps around a paste once bracketed-paste mode
+    # is on (the client enables it unconditionally — see
+    # Client#enter_terminal_mode).
+    BRACKETED_PASTE_MARKERS = ["\e[200~".b, "\e[201~".b].freeze
+
     def send_to_focused(data)
       target = focused_target
-      target&.write(data)
+      return unless target
+      data = strip_bracketed_paste_markers(data, target)
+      target.write(data) unless data.empty?
+    end
+
+    # The client turns bracketed-paste mode on for the *outer* terminal so big
+    # pastes arrive wrapped in \e[200~…\e[201~ (which lets shells/editors that
+    # speak the protocol collapse them). But the focused program may not speak
+    # it — in that case the markers would print as a literal "^[[200~" before
+    # and after the text. So: forward the markers untouched when the focused
+    # program enabled DECSET 2004, strip them otherwise.
+    #
+    # A marker can straddle a 4 KiB read boundary, so any trailing bytes that
+    # form a partial marker (but not a bare ESC, which must reach the program
+    # immediately as the Escape key) are held back and prepended next chunk.
+    def strip_bracketed_paste_markers(data, target)
+      data = data.b
+      term = target.respond_to?(:terminal) ? target.terminal : nil
+      buf = @paste_marker_tail + data
+      @paste_marker_tail = +"".b
+
+      if term&.bracketed_paste?
+        # Program wants the markers — hand back everything, partial included.
+        return buf
+      end
+
+      hold = pending_marker_prefix(buf)
+      if hold.positive?
+        @paste_marker_tail = buf.byteslice(buf.bytesize - hold, hold)
+        buf = buf.byteslice(0, buf.bytesize - hold) || +"".b
+      end
+      BRACKETED_PASTE_MARKERS.each { |m| buf = buf.gsub(m, "") }
+      buf
+    end
+
+    # Length (2..5) of the longest suffix of `buf` that is a proper prefix of a
+    # bracketed-paste marker, so the remainder can arrive in the next chunk. A
+    # bare trailing ESC (length 1) is deliberately not held: it's almost always
+    # the Escape key and the program must see it without waiting on the next
+    # keystroke. Worst case a marker split right after its ESC leaks a few
+    # bytes, which the program reads as a harmless unknown escape.
+    def pending_marker_prefix(buf)
+      max = [buf.bytesize, 5].min
+      max.downto(2) do |k|
+        tail = buf.byteslice(buf.bytesize - k, k)
+        return k if BRACKETED_PASTE_MARKERS.any? { |m| m.byteslice(0, k) == tail }
+      end
+      0
     end
 
     def new_pane(cwd: nil)
-      cwd ||= focused_pane&.cwd
+      cwd ||= @origin_cwd
       pane = make_pane(cwd: cwd)
       @session.window.add_pane(pane)
       @session.focus_drawer = false
@@ -116,6 +192,7 @@ module Muxr
       else
         @session.window.focus_next
       end
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -126,6 +203,7 @@ module Muxr
       else
         @session.window.focus_prev
       end
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -136,6 +214,7 @@ module Muxr
       else
         @session.window.focus_last
       end
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -145,9 +224,23 @@ module Muxr
       return unless idx >= 0 && idx < @session.window.panes.length
       @session.focus_drawer = false
       @session.window.focus_index(idx)
+      sync_input_mode_to_focus
       invalidate
     end
 
+    # After a focus change, reconcile the input mode with the newly-focused
+    # pane: if it was left scrolled back, re-enter scrollback so the user
+    # lands exactly where they were reading ("navigating back to the scrolled
+    # pane puts you back into scrollback"). We only ever auto-ENTER here —
+    # the InputHandler's @prefix_return is what keeps you in scrollback when
+    # you hop onto a live pane, so we never auto-leave.
+    def sync_input_mode_to_focus
+      target = focused_target
+      return unless target&.terminal&.scrolled_back?
+      @input.enter_scrollback_mode
+      @renderer.reset_frame!
+    end
+
     # Move focus to the pane spatially adjacent in `direction` (:left/:right/
     # :up/:down). Called by the normal-mode hjkl bindings. Pulling the live
     # layout rects keeps this in sync with whatever the renderer is showing.
@@ -168,12 +261,14 @@ module Muxr
         when :right, :down then win.focus_next
         when :left, :up    then win.focus_prev
         end
+        sync_input_mode_to_focus
         invalidate
         return
       end
 
       return unless idx
       win.focus_index(idx)
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -275,6 +370,23 @@ module Muxr
       invalidate
     end
 
+    # Bound to `r` (normal) / `Ctrl-a r` (passthrough). Two-layer repaint to
+    # recover from a corrupted display, whichever layer drifted:
+    #   1. Nudge the focused program to redraw itself (SIGWINCH wiggle). This
+    #      fixes muxr's own Terminal grid when an unhandled or wide glyph
+    #      desynced the cursor — reset_frame! alone can't, since it would just
+    #      faithfully re-emit the wrong grid.
+    #   2. Force a full re-emit of our composed frame to the outer terminal,
+    #      fixing the case where the outer display lost/garbled bytes but our
+    #      grid is correct.
+    def refresh_focused
+      target = focused_target
+      target.request_redraw if target.respond_to?(:request_redraw)
+      @renderer.reset_frame!
+      flash("refreshed")
+      invalidate
+    end
+
     def promote_master
       @session.window.promote_to_master
       invalidate
@@ -502,7 +614,6 @@ module Muxr
     def exit_selection(yank:)
       target = focused_target
       term = target&.terminal
-      yanked = false
       if yank
         # No anchor → no-op. User is still positioning; they can press v
         # first, then yank. Esc/q is the way to exit from navigation.
@@ -512,18 +623,14 @@ module Muxr
           @paste_buffer = text
           spawn_pbcopy(text)
           flash("yanked #{text.bytesize} bytes")
-          yanked = true
         end
       end
       term&.clear_selection
-      if yanked
-        # vim-style: yanking drops you straight back to "normal" (idle),
-        # not back into scrollback navigation.
-        term&.scroll_to_bottom
-        @input.enter_idle_mode
-      else
-        @input.enter_scrollback_mode
-      end
+      # Drop back into scrollback at the current position whether or not we
+      # yanked. We no longer snap to the live bottom on yank — the user stays
+      # where they were reading so they can keep selecting or scrolling, and
+      # `q`/Esc is still there when they want to return to the bottom.
+      @input.enter_scrollback_mode
       @renderer.reset_frame!
       invalidate
     end
@@ -610,6 +717,9 @@ module Muxr
     # the server is also trying to read from that same client.
     def deliver_output(bytes)
       return unless @current_client
+      if @trace_output
+        @trace_output.write(bytes) rescue nil
+      end
       @client_write_buffer << Protocol.frame(Protocol::OUTPUT, bytes)
       drain_client_writes
     end
@@ -718,6 +828,10 @@ module Muxr
       end
       @session&.window&.panes&.each(&:close)
       @session&.drawer&.close
+      if @trace_output
+        @trace_output.close rescue nil
+        @trace_output = nil
+      end
     end
 
     def loop_forever
@@ -1049,7 +1163,7 @@ module Muxr
 
     def ensure_drawer(command: nil)
       return if @session.drawer
-      cwd = focused_pane&.cwd
+      cwd = @origin_cwd
       pane = Pane.new(
         id: :drawer,
         rows: 10,

data/lib/muxr/input_handler.rb

@@ -19,6 +19,15 @@ module Muxr
   # finish. :scrollback and :selection also return to @base_mode so that
   # exiting back from a scroll/yank lands you back in passthrough if that's
   # where you came from.
+  #
+  # Scrollback is effectively pane-bound. Ctrl-a is honored from inside
+  # :scrollback and :selection — it drops into :prefix (with @prefix_return
+  # = :scrollback) so a pane switch keeps you in scrollback on the pane you
+  # move to, while the pane you left keeps its own scroll position. Coming
+  # the other way, the Application re-enters scrollback whenever you focus a
+  # pane that was left scrolled back. `i` from scrollback drops to insert
+  # (passthrough) without snapping to the bottom; only `q`/Esc returns the
+  # pane to the live bottom.
   class InputHandler
     PREFIX = "\x01".freeze # Ctrl-a
 
@@ -51,6 +60,7 @@ module Muxr
       "K"  => [:move_direction, :up],
       "L"  => [:move_direction, :right],
       "a"  => :focus_last,
+      "r"  => :refresh_focused,
       "~"  => :toggle_drawer,
       "C"  => :toggle_claude_drawer,
       "P"  => :toggle_private_focused,
@@ -66,6 +76,7 @@ module Muxr
       "n"    => :focus_next,
       "p"    => :focus_prev,
       "a"    => :focus_last,
+      "r"    => :refresh_focused,
       "x"    => :request_close,
       "\t"   => :cycle_layout,
       "\r"   => :promote_master,
@@ -158,6 +169,11 @@ module Muxr
       @command_buffer = +""
       @search_buffer = +""
       @search_direction = :forward
+      # When the prefix state is entered from scrollback/selection (Ctrl-a),
+      # this records :scrollback so that a pane switch lands you back in
+      # scrollback on the newly-focused pane instead of dropping to the base
+      # mode. nil means "use @base_mode" (the normal passthrough behavior).
+      @prefix_return = nil
     end
 
     def feed(data)
@@ -305,6 +321,12 @@ module Muxr
     end
 
     def handle_prefix(ch)
+      # Where to land once the prefix binding finishes. Normally the base
+      # mode, but :scrollback when we entered the prefix from scrollback /
+      # selection so a pane switch keeps you in scrollback on the new pane.
+      # Consume it immediately so it never leaks into the next prefix.
+      ret = @prefix_return || @base_mode
+      @prefix_return = nil
       action = PREFIX_BINDINGS[ch]
       case
       when ch == "\e"
@@ -321,15 +343,18 @@ module Muxr
         @state = @base_mode
       when DIGIT_RE.match?(ch)
         @app.focus_pane_number(ch.to_i)
-        @state = @base_mode
+        # The focus action may auto-enter scrollback (landing on a pane that
+        # was left scrolled). Only fall back to `ret` if it didn't.
+        @state = ret if @state == :prefix
       when action
         @app.public_send(action)
         # The action may have set a new state (confirm_quit, confirm_close,
-        # scrollback, help). Only revert to base mode if we're still in :prefix.
-        @state = @base_mode if @state == :prefix
+        # scrollback via auto-enter, help). Only fall back to `ret` if we're
+        # still in :prefix.
+        @state = ret if @state == :prefix
       else
-        # Unknown prefix key: return to base mode silently.
-        @state = @base_mode
+        # Unknown prefix key: return to where we came from silently.
+        @state = ret
       end
     end
 
@@ -352,6 +377,25 @@ module Muxr
     end
 
     def handle_scrollback_input(ch)
+      if ch == PREFIX
+        # Ctrl-a is the escape hatch even from scrollback: drop into the
+        # prefix state so the user can switch panes (Ctrl-a n/p/a/1-9) or
+        # run any other prefix binding without first leaving scrollback.
+        # @prefix_return = :scrollback keeps the user in scrollback on the
+        # pane they switch to; the source pane keeps its scroll position so
+        # it stays put. Scrollback is effectively pane-bound now.
+        @prefix_return = :scrollback
+        @state = :prefix
+        return
+      end
+      if ch == "i"
+        # Drop straight into insert (passthrough) without snapping to the
+        # live bottom — the pane stays where it's scrolled. Mirrors the
+        # normal-mode `i` so "type now" is one key from scrollback too.
+        enter_passthrough_mode
+        @app.enter_passthrough_mode
+        return
+      end
       if SCROLLBACK_EXITS.include?(ch)
         enter_idle_mode
         @app.exit_scrollback
@@ -434,6 +478,16 @@ module Muxr
     end
 
     def handle_selection_input(ch)
+      if ch == PREFIX
+        # Same escape hatch as scrollback: Ctrl-a enters the prefix state so
+        # pane switching (and any other prefix binding) works mid-selection.
+        # We return to :scrollback (not :selection) on the new pane — you
+        # don't want to be mid-select on a pane you just arrived at — while
+        # the source pane keeps its scroll position and selection intact.
+        @prefix_return = :scrollback
+        @state = :prefix
+        return
+      end
       if SELECTION_YANK.include?(ch)
         @app.exit_selection(yank: true)
         return

data/lib/muxr/pane.rb

@@ -117,6 +117,12 @@ module Muxr
       @process.resize(rows, cols)
     end
 
+    # Force the inner program to repaint itself (see PTYProcess#nudge_redraw).
+    # Used by the refresh keybinding to recover from emulation drift.
+    def request_redraw
+      @process.nudge_redraw
+    end
+
     def alive?
       @process.alive?
     end

data/lib/muxr/pty_process.rb

@@ -81,6 +81,26 @@ module Muxr
       end
     end
 
+    # Coax the foreground program into repainting from scratch by briefly
+    # toggling the PTY window size, which delivers SIGWINCH to the tty's
+    # foreground process group. Full-screen TUIs (vim, htop, less, fzf) redraw
+    # on WINCH, which rewrites muxr's Terminal grid and clears any emulation
+    # drift (e.g. a wide glyph that desynced the cursor). The size is restored
+    # immediately, so the program redraws at the real dimensions: it reads the
+    # current (restored) winsize in its handler and never observes the
+    # transient size. No-op when the pane is too narrow to wiggle.
+    def nudge_redraw
+      return if @exited
+      smaller = [@cols - 1, 1].max
+      return if smaller == @cols
+      begin
+        @reader.winsize = [@rows, smaller, 0, 0]
+        @reader.winsize = [@rows, @cols, 0, 0]
+      rescue StandardError
+        # Some platforms reject winsize pokes; reset_frame! still re-emits.
+      end
+    end
+
     def alive?
       return false if @exited
       Process.kill(0, @pid)

data/lib/muxr/renderer.rb

@@ -395,6 +395,7 @@ module Muxr
       "  | - f e S       layout: columns / rows / spiral / centered / stack",
       "  Tab / Enter     cycle layout / promote to master",
       "  a / 1..9        last pane / jump by number",
+      "  r               refresh / redraw (fixes a corrupted pane)",
       "  s               enter scrollback",
       "  ~ / C / P       drawer / Claude drawer / toggle private",
       "  : / ?           command prompt / toggle this help",
@@ -405,14 +406,18 @@ module Muxr
       "  C-a c x t w g m same as normal-mode bindings",
       "  C-a Tab Enter   cycle layout / promote master",
       "  C-a n / p / a   next / prev / last pane",
+      "  C-a r           refresh / redraw (fixes a corrupted pane)",
       "  C-a [ ]         scrollback / paste buffer",
       "  C-a C-a         send literal Ctrl-a to focused pane",
       "",
-      "SCROLLBACK mode (exits to the mode you came from)",
+      "SCROLLBACK mode (pane-bound: follows you as you switch panes)",
       "  j/k ↑/↓ d/u f/b g/G  scroll  C-b/C-f page  v→cursor",
       "  / search-fwd  ? search-back  n/N next/prev match",
+      "  C-a n/p/a/1-9   switch pane, stay in scrollback (each keeps its pos)",
+      "  i   insert here (keeps scroll pos)   q/Esc  exit to live bottom",
       "  cursor: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
-      "          v select, C-v block, y/Enter yank, q/Esc cancel",
+      "          v select, C-v block, y/Enter yank (stays in scrollback)",
+      "          q/Esc cancel   C-a n/p/a/1-9 switch pane",
       "",
       "Commands: layout {tall|wide|columns|rows|grid|spiral|centered|stack|monocle},",
       "          drawer {toggle|show|hide|reset},",
@@ -543,6 +548,11 @@ module Muxr
           if same_size && @prev[y][x] == cell
             next
           end
+          # The right half of a wide glyph (char "") is painted by its lead
+          # cell to the left, which spans both columns in the outer terminal.
+          # Emitting anything here would clobber that glyph, so skip it — and
+          # leave last_x untouched, since we didn't move the outer cursor.
+          next if cell.char.empty?
           if last_y != y || last_x != x
             out << "\e[#{y + 1};#{x + 1}H"
           end
@@ -559,7 +569,19 @@ module Muxr
           end
           out << cell.char
           last_y = y
-          last_x = x + cell.char.length
+          if contiguous_after?(cell.char)
+            # Advance by the glyph's display width, not its codepoint count: a
+            # wide char ("中") moves the outer cursor two columns though it's
+            # one codepoint, and a base+combining cell ("é") moves one though
+            # it's two. Keeping last_x in sync with the real cursor lets the
+            # next cell skip a redundant CUP.
+            last_x = x + Terminal.char_width(cell.char.ord)
+          else
+            # The outer terminal might advance its cursor by a different number
+            # of columns than we think for this glyph — force an absolute
+            # reposition for the next cell so the disagreement can't cascade.
+            last_x = nil
+          end
         end
       end
       out << "\e]8;;\e\\" if cur_hyperlink
@@ -573,6 +595,24 @@ module Muxr
       @prev_h = frame.length
     end
 
+    # Whether we can trust the outer terminal's cursor to be exactly one
+    # display-width past this glyph, so the next contiguous cell needs no
+    # cursor-position escape. Safe only for glyphs whose width every terminal
+    # agrees on: ASCII (always one column), and the box-drawing / block-element
+    # band 0x2500–0x259F (reliably one column, and we emit a lot of them for
+    # borders, so keeping them contiguous matters). Everything else non-ASCII —
+    # CJK, emoji, and East Asian Ambiguous symbols like ·, …, ●, arrows, and
+    # the ⏺/✻/❯ glyphs Claude Code's UI is full of — can be drawn two columns
+    # wide by some terminals. We can't know which, so we force an absolute
+    # reposition after them: a width disagreement then clips a single glyph
+    # instead of shifting the whole rest of the line. A base+combining cell
+    # (multi-codepoint) is treated the same way out of caution.
+    def contiguous_after?(char)
+      return false if char.length > 1
+      cp = char.ord
+      cp < 0x80 || (cp >= 0x2500 && cp <= 0x259F)
+    end
+
     def cursor_position(session, input_state:, command_buffer:, search_buffer: "")
       if input_state == :command
         col = 1 + command_buffer.length + 1 # ':' + buffer

data/lib/muxr/terminal.rb

@@ -12,6 +12,67 @@ module Muxr
 
     SCROLLBACK_MAX = 5000
 
+    # Codepoint ranges that occupy two display columns (East Asian Wide /
+    # Fullwidth per UAX #11, plus the common emoji blocks). A wide glyph is
+    # stored in its lead cell with a continuation cell (char "") to its right
+    # reserving the second column — see #put_char. Kept as a flat, sorted list
+    # of ranges; #char_width only consults it for codepoints >= 0x300, so the
+    # ASCII/Latin-1 fast path never pays for the scan.
+    WIDE_RANGES = [
+      0x1100..0x115F,   # Hangul Jamo
+      0x2329..0x232A,   # angle brackets
+      0x2E80..0x303E,   # CJK radicals, Kangxi, CJK symbols & punctuation
+      0x3041..0x33FF,   # Hiragana … CJK compatibility
+      0x3400..0x4DBF,   # CJK Unified Ext A
+      0x4E00..0x9FFF,   # CJK Unified Ideographs
+      0xA000..0xA4CF,   # Yi
+      0xA960..0xA97F,   # Hangul Jamo Ext-A
+      0xAC00..0xD7A3,   # Hangul Syllables
+      0xF900..0xFAFF,   # CJK Compatibility Ideographs
+      0xFE10..0xFE19,   # vertical forms
+      0xFE30..0xFE6F,   # CJK compatibility / small form variants
+      0xFF00..0xFF60,   # Fullwidth Forms
+      0xFFE0..0xFFE6,   # Fullwidth signs
+      0x1B000..0x1B16F, # Kana supplement / extended
+      0x1F300..0x1F64F, # Misc symbols & pictographs, emoticons
+      0x1F680..0x1F6FF, # transport & map symbols
+      0x1F900..0x1F9FF, # supplemental symbols & pictographs
+      0x1FA70..0x1FAFF, # symbols & pictographs extended-A
+      0x20000..0x3FFFD  # CJK Unified Ext B and beyond
+    ].freeze
+
+    # Codepoint ranges that occupy zero display columns: combining marks,
+    # variation selectors, and zero-width formatting characters. These fold
+    # onto the preceding glyph rather than consuming a column (#attach_combining)
+    # so the cursor stays aligned with what a real terminal would do.
+    ZERO_WIDTH_RANGES = [
+      0x0300..0x036F,     # combining diacritical marks
+      0x0483..0x0489,     # Cyrillic combining
+      0x0591..0x05BD, 0x05BF..0x05BF, 0x05C1..0x05C2, 0x05C4..0x05C5,
+      0x0610..0x061A, 0x064B..0x065F, 0x0670..0x0670,
+      0x06D6..0x06DC, 0x06DF..0x06E4, 0x06E7..0x06E8, 0x06EA..0x06ED,
+      0x0711..0x0711, 0x0730..0x074A,
+      0x200B..0x200F,     # zero-width space/joiner/non-joiner, marks
+      0x2028..0x202E, 0x2060..0x2064,
+      0x20D0..0x20FF,     # combining marks for symbols
+      0x1AB0..0x1AFF, 0x1DC0..0x1DFF, # combining extensions
+      0xFE00..0xFE0F,     # variation selectors
+      0xFE20..0xFE2F,     # combining half marks
+      0xFEFF..0xFEFF,     # BOM / zero-width no-break space
+      0xE0100..0xE01EF    # variation selectors supplement
+    ].freeze
+
+    # Display width of a codepoint in terminal columns: 0 (combining /
+    # zero-width), 2 (East Asian wide / emoji), or 1 (everything else). The
+    # Renderer uses this to advance its emit cursor by the right number of
+    # columns; #put_char uses it to lay glyphs into the grid.
+    def self.char_width(cp)
+      return 1 if cp < 0x0300
+      return 0 if ZERO_WIDTH_RANGES.any? { |r| r.cover?(cp) }
+      return 2 if WIDE_RANGES.any? { |r| r.cover?(cp) }
+      1
+    end
+
     # Cap on the OSC payload we buffer before parsing. URLs in OSC 8 can be
     # long but rarely exceed a few hundred bytes; 4 KiB lets the parser stay
     # tolerant of weird inputs without giving an attacker an unbounded sink.
@@ -96,6 +157,11 @@ module Muxr
       @selection_mode = :linear
       @sync_pending = false
       @sync_started_at = nil
+      # True once the inner program enables bracketed-paste mode (DECSET
+      # 2004). The Application consults this to decide whether to forward the
+      # \e[200~…\e[201~ paste markers the outer terminal wraps around a paste
+      # or strip them — see Application#send_to_focused.
+      @bracketed_paste = false
       @pending_replies = +"".b
       @search_query = nil
       @search_direction = :forward
@@ -134,6 +200,14 @@ module Muxr
       @sync_started_at + SYNC_TIMEOUT
     end
 
+    # True iff the inner program has enabled bracketed-paste mode (DECSET
+    # 2004). When false, the Application strips paste markers before writing
+    # so a program that doesn't speak bracketed paste never prints a literal
+    # "^[[200~".
+    def bracketed_paste?
+      @bracketed_paste
+    end
+
     attr_reader :selection_mode
 
     def cell(r, c)
@@ -578,12 +652,20 @@ module Muxr
         end
       end
 
+      # Build the scan text alongside a codepoint→cell map. A wide
+      # continuation half (char "") contributes no codepoints, and a
+      # base+combining cell contributes more than one, so we can't assume the
+      # old 1:1 cell↔codepoint indexing — map every codepoint back to its
+      # source cell instead. URLs are ASCII, but a wide glyph earlier on the
+      # line would otherwise shift every later offset off its cell.
       text = String.new(capacity: rows.length * @cols)
       cells = []
       rows.each do |row|
         row.each do |cell|
-          text << cell.char
-          cells << cell
+          ch = cell.char
+          next if ch.empty?
+          ch.each_char { cells << cell }
+          text << ch
         end
       end
 
@@ -773,19 +855,20 @@ module Muxr
       when ">", "<", "=", "!"
         return
       when "?"
-        # 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.
+        # DEC private modes — most we treat as no-ops, but two we track:
+        #   2026 (Synchronized Output) — a render-timing hint we honor so the
+        #        outer paint lands on fully-formed frames from fzf/nvim/helix.
+        #   2004 (Bracketed Paste) — whether the inner program wants pastes
+        #        wrapped in \e[200~…\e[201~; the Application strips those
+        #        markers when it's off (see Application#send_to_focused).
         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
+          enabled = (final == "h")
+          params = csi_params
+          if params.include?(2026)
+            @sync_pending = enabled
+            @sync_started_at = enabled ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : nil
           end
+          @bracketed_paste = enabled if params.include?(2004)
         end
         return
       end
@@ -879,22 +962,65 @@ module Muxr
     end
 
     def put_char(ch)
+      width = self.class.char_width(ch.ord)
+
+      # Zero-width: fold the mark onto the preceding glyph instead of taking a
+      # column, so the cursor stays where a real terminal would leave it.
+      return attach_combining(ch) if width.zero?
+
       if @autowrap_pending
         @cursor_col = 0
         line_feed
         @autowrap_pending = false
       end
-      cell = @buffer[@cursor_row][@cursor_col]
+
+      # A wide glyph needs two columns; if only the last column is free, leave
+      # it blank and wrap first (matching xterm/VTE deferral behavior).
+      if width == 2 && @cursor_col == @cols - 1
+        @buffer[@cursor_row][@cursor_col].reset!
+        @cursor_col = 0
+        line_feed
+      end
+
+      c = @cursor_col
+      write_cell(@buffer[@cursor_row][c], ch)
+      if width == 2
+        # The continuation half carries no glyph (char "") but inherits the
+        # lead's colors so a styled wide cell paints both columns; the Renderer
+        # skips emitting it since the lead already covers both columns.
+        write_cell(@buffer[@cursor_row][c + 1], "")
+      end
+
+      last_col = c + width - 1
+      if last_col >= @cols - 1
+        @cursor_col = @cols - 1
+        @autowrap_pending = true
+      else
+        @cursor_col = last_col + 1
+      end
+    end
+
+    def write_cell(cell, ch)
       cell.char = ch
       cell.fg = @fg
       cell.bg = @bg
       cell.attrs = @attrs
       cell.hyperlink = @current_hyperlink
-      if @cursor_col >= @cols - 1
-        @autowrap_pending = true
-      else
-        @cursor_col += 1
-      end
+    end
+
+    # Fold a zero-width mark (combining accent, variation selector, …) onto the
+    # glyph in the cell the cursor just left, so the outer terminal composes
+    # them (e + ◌́ → é) without the mark consuming a column. Marks with nothing
+    # to attach to — start of line, or landing on a wide continuation half —
+    # are dropped; column alignment matters more than the lost accent.
+    def attach_combining(ch)
+      target =
+        if @autowrap_pending then @buffer[@cursor_row][@cols - 1]
+        elsif @cursor_col > 0 then @buffer[@cursor_row][@cursor_col - 1]
+        end
+      return unless target
+      return if target.char.empty?
+      target.char += ch
     end
 
     def line_feed
@@ -1035,12 +1161,25 @@ module Muxr
       timeline_size.times do |tr|
         row = timeline_row(tr)
         next if row.nil?
+        # Build the row text and a parallel codepoint→column map so matches can
+        # be reported in column coordinates even when wide glyphs (one cell, two
+        # columns) and combining marks (multi-codepoint, one cell) break the
+        # 1:1 char-index↔column relationship. For all-ASCII rows col_at[i] == i,
+        # so this is identical to the old behavior on the common path.
         line = String.new(capacity: @cols)
-        @cols.times { |c| line << (row[c]&.char || " ") }
+        col_at = []
+        @cols.times do |c|
+          ch = row[c]&.char
+          next if ch == "" # wide continuation half — occupies no text slot
+          ch = " " if ch.nil?
+          ch.each_char { col_at << c }
+          line << ch
+        end
         haystack = case_sensitive ? line : line.downcase
         start = 0
         while (idx = haystack.index(needle, start))
-          matches << [tr, idx, idx + needle.length - 1]
+          last = idx + needle.length - 1
+          matches << [tr, col_at[idx], col_at[last] || col_at.last || idx]
           # Advance past the start of this match so overlapping needles
           # ("aa" in "aaaa") still emit one match per starting position.
           start = idx + 1

data/lib/muxr/version.rb

@@ -1,3 +1,3 @@
 module Muxr
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

data/lib/muxr/window.rb

@@ -14,7 +14,7 @@ module Muxr
       @focused_index = 0
       @last_focused_pane = nil
       @master_index = 0
-      @layout = :tall
+      @layout = :spiral
     end
 
     # Setter records the outgoing focused pane (by reference) so focus_last can

metadata

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