muxr 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61893be4e6b1d4a0ce7d3c785ffc60e45d5b272ede1ce267a751760cf81ee442
-  data.tar.gz: d426522851cd327c560e7f384799749f6b575785a8e9b75ab15349494fa1edaa
+  metadata.gz: d19432b15ff535a2ce8f4bfb5b759ddd3599b4fb0af949d7871cf1059497c483
+  data.tar.gz: ce58f726a5a9dc186deb042c0d0e31fa8694676d0cdb4c496cfb57668d5fd4c1
 SHA512:
-  metadata.gz: f511b20a929bb4eb65d8a804bcf51b113357ad921eed44b1c4305aade2d78de07f158b4a84c5916a83405709417df569cd213aca9c5422610d51fa7b2a4aeed0
-  data.tar.gz: 357d7142c4087eae0833889893a9ed6080401ef7ba580f0d1fa7e8d0c94b8d69bb73a8f2f5ef76ee7397cfee1653c2eb11e8a38e00dff6f016ad9c0b8534a5c0
+  metadata.gz: 5b96c66aa1b96e853e7d268c012f8bc5e62fdf77c1e3d4e89360b764d4cfc1d20bdb271be81acad05f26417d09e17fe27f437680cb00a33fcf6f2c934600fef2
+  data.tar.gz: '045758a0d3ec1e4f2d6bfe4bb887743cc2ab80310bd842190b362e9a9976fd023b8818c35d13f80478839bbbb12d91372b22ddabc91ee430afda8c3ce3b0853a'

data/CHANGELOG.md

@@ -6,6 +6,46 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.3] - 2026-05-11
+
+### Fixed
+- Large pastes into a pane no longer hang the server. PTY writes are now
+  non-blocking and buffered per pane, with the writer fd added to the
+  event loop's `IO.select` write set so back-pressure from a slow reader
+  (e.g. Claude Code processing a multi-KB paste) can't deadlock the
+  single-threaded server. Idle pass-through input is also batched into a
+  single `send_to_focused` chunk instead of one call per byte.
+- Client↔server socket writes are now non-blocking too, with per-side
+  outgoing buffers and the socket added to `IO.select`'s write set when
+  there's queued data. The previous blocking `Protocol.write` could
+  deadlock both ends when a paste produced enough redraw traffic to fill
+  both directions of the unix-socket kernel buffer at once (vim and
+  Claude Code both reproduced this).
+
+### Added
+- Enable bracketed paste mode (`\e[?2004h`) on the outer terminal when
+  the client attaches. The terminal emulator now wraps pastes with
+  `\e[200~...\e[201~`, those markers flow through muxr to the focused
+  pane, and apps that opt in (Claude Code, vim, modern readline) again
+  recognise the input as a paste — Claude Code collapses it to
+  `[Pasted text +N lines]` instead of typing the whole thing out.
+
+## [0.1.2] - 2026-05-11
+
+### Added
+- Vim-style word and viewport motions in copy-mode selection cursor:
+  `w`/`W`/`e`/`E`/`b`/`B` walk word and WORD boundaries, `^` jumps to
+  the first non-blank on the line, and `H`/`M`/`L` land on the visible
+  top/middle/bottom rows. Yanking now drops straight back to the live
+  shell (matching vim's `v…y` returning to normal mode); the tmux-style
+  `b` alias for page-back is now `Ctrl-b` only.
+
+### Fixed
+- Honor SGR 2 (dim) so faint text actually renders faint. The emulator
+  was silently dropping the attribute, which left Claude Code's
+  suggested-prompt placeholder rendering at normal intensity. SGR 22
+  now correctly clears both bold and dim per spec.
+
 ## [0.1.1] - 2026-05-11
 
 ### Fixed
@@ -51,6 +91,7 @@ Initial release.
   boundaries.
 - Renderer that composes one frame and diff-emits ANSI to STDOUT.
 
-[Unreleased]: https://github.com/roelbondoc/muxr/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/roelbondoc/muxr/compare/v0.1.2...HEAD
+[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/README.md

@@ -20,6 +20,27 @@ the active layout decides geometry.
  [default] panes:3 layout:tall focused:#1 drawer:shown     muxr ^a ?
 ```
 
+## Screenshots
+
+The three built-in layouts (cycle with `C-a Tab`):
+
+<table>
+  <tr>
+    <td align="center"><strong>tall</strong><br/>master + stacked slaves</td>
+    <td align="center"><strong>grid</strong><br/>even tiling</td>
+    <td align="center"><strong>monocle</strong><br/>focused pane fullscreen</td>
+  </tr>
+  <tr>
+    <td><img src="docs/screenshots/01-layout-tall.png" alt="tall layout"></td>
+    <td><img src="docs/screenshots/02-layout-grid.png" alt="grid layout"></td>
+    <td><img src="docs/screenshots/03-layout-monocle.png" alt="monocle layout"></td>
+  </tr>
+</table>
+
+The Quake-style drawer overlay (`C-a ~`):
+
+![drawer overlay](docs/screenshots/04-drawer.png)
+
 ## Install / run
 
 ```bash
@@ -70,17 +91,33 @@ the pane title gains `[scrollback N/M]`.
 |-------------------------|-------------------------------------|
 | `j` / `k`               | scroll one line                     |
 | `d` / `u` (or `C-d`/`C-u`) | half page                        |
-| `f` / `b` / Space (or `C-f`/`C-b`) | full page                |
+| `f` / Space (or `C-f`/`C-b`) | full page                      |
 | `g` / `G`               | top / bottom                        |
 | `q` / `Esc` / `C-c`     | exit back to live view              |
 
-Press `v` inside scrollback to enter a movable-cursor selection mode
-(`h j k l`, `0`/`$`, `g`/`G`, `C-d`/`C-u`, `C-f`/`C-b`, Space). Press `v`
-again to anchor a character selection or `C-v` to anchor a block
-(rectangular) selection — toggling between the two preserves the anchor.
-`y` or Enter yanks the selection into an internal buffer and pipes it to
-`pbcopy` in the background (silent no-op when `pbcopy` is unavailable).
-`C-a ]` writes the yank buffer back into the focused pane.
+Press `v` inside scrollback to enter a movable-cursor selection mode.
+Vim-style motions are supported:
+
+| Keys                    | Action                              |
+|-------------------------|-------------------------------------|
+| `h` / `j` / `k` / `l`   | left / down / up / right            |
+| `0` / `^` / `$`         | line start / first non-blank / line end |
+| `w` / `W`               | next word / WORD start              |
+| `e` / `E`               | next word / WORD end                |
+| `b` / `B`               | previous word / WORD start          |
+| `g` / `G`               | top / bottom of timeline            |
+| `H` / `M` / `L`         | top / middle / bottom of viewport   |
+| `C-d`/`C-u`, `C-f`/`C-b`, Space | half / full page             |
+| `v` / `C-v`             | anchor char / block selection (toggle) |
+| `y` or Enter            | yank and exit to live shell         |
+| `q` / `Esc` / `C-c`     | cancel back to scrollback           |
+
+`v` and `C-v` toggle between character and block (rectangular) selection
+— switching between the two preserves the anchor. `y` or Enter yanks the
+selection into an internal buffer, pipes it to `pbcopy` in the background
+(silent no-op when `pbcopy` is unavailable), and drops you straight back
+to the live shell. `C-a ]` writes the yank buffer back into the focused
+pane.
 
 ## Commands (typed after `C-a :`)
 

data/lib/muxr/application.rb

@@ -57,6 +57,7 @@ module Muxr
       @help_visible = false
       @next_pane_id = 0
       @current_client = nil
+      @client_write_buffer = +"".b
       @listening_socket = nil
       @socket_path = self.class.socket_path_for(@session_name)
       @paste_buffer = +""
@@ -302,6 +303,7 @@ 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.
@@ -311,10 +313,18 @@ module Muxr
           @paste_buffer = text
           spawn_pbcopy(text)
           flash("yanked #{text.bytesize} bytes")
+          yanked = true
         end
       end
       term&.clear_selection
-      @input.enter_scrollback_mode
+      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
       @renderer.reset_frame!
       invalidate
     end
@@ -336,8 +346,18 @@ module Muxr
       when :full_down  then term.move_selection_cursor_by([rows - 1, 1].max, 0)
       when :line_start then term.selection_cursor_to_line_start
       when :line_end   then term.selection_cursor_to_line_end
-      when :top        then term.selection_cursor_to_top
-      when :bottom     then term.selection_cursor_to_bottom
+      when :line_first_nonblank then term.selection_cursor_to_first_non_blank
+      when :top              then term.selection_cursor_to_top
+      when :bottom           then term.selection_cursor_to_bottom
+      when :screen_top       then term.selection_cursor_to_viewport(:top)
+      when :screen_middle    then term.selection_cursor_to_viewport(:middle)
+      when :screen_bottom    then term.selection_cursor_to_viewport(:bottom)
+      when :word_forward      then term.selection_cursor_word_forward(big: false)
+      when :word_forward_big  then term.selection_cursor_word_forward(big: true)
+      when :word_end          then term.selection_cursor_word_end(big: false)
+      when :word_end_big      then term.selection_cursor_word_end(big: true)
+      when :word_backward     then term.selection_cursor_word_backward(big: false)
+      when :word_backward_big then term.selection_cursor_word_backward(big: true)
       end
       invalidate
     end
@@ -382,12 +402,29 @@ module Muxr
       end
     end
 
-    # Called by the FramedOutput adapter; ships one OUTPUT frame to the
-    # currently attached client. No-op when nobody is attached.
+    # Called by the FramedOutput adapter; queues one OUTPUT frame to the
+    # currently attached client and tries to push as much as the socket
+    # will take without blocking. Anything left over stays in
+    # @client_write_buffer and gets flushed by the event loop when the
+    # socket reports writable. This prevents a slow client (or slow
+    # terminal upstream of the client) from deadlocking the server when
+    # the server is also trying to read from that same client.
     def deliver_output(bytes)
-      sock = @current_client
-      return unless sock
-      Protocol.write(sock, Protocol::OUTPUT, bytes)
+      return unless @current_client
+      @client_write_buffer << Protocol.frame(Protocol::OUTPUT, bytes)
+      drain_client_writes
+    end
+
+    def drain_client_writes
+      return unless @current_client
+      return if @client_write_buffer.empty?
+      loop do
+        n = @current_client.write_nonblock(@client_write_buffer)
+        @client_write_buffer = @client_write_buffer.byteslice(n..-1) || +"".b
+        break if @client_write_buffer.empty?
+      end
+    rescue IO::WaitWritable
+      # Socket send buffer is full; the rest stays queued.
     rescue Errno::EPIPE, Errno::ECONNRESET, IOError
       drop_client_silently
     end
@@ -460,25 +497,40 @@ module Muxr
 
     def loop_forever
       while @running
-        ready_ios = [@listening_socket]
-        ready_ios << @current_client if @current_client
-        @session.window.panes.each { |p| ready_ios << p.io if p.alive? }
-        if @session.drawer&.pane && @session.drawer.pane.alive?
-          ready_ios << @session.drawer.pane.io
+        read_ios  = [@listening_socket]
+        read_ios << @current_client if @current_client
+        @session.window.panes.each { |p| read_ios << p.io if p.alive? }
+        drawer_pane = @session.drawer&.pane
+        read_ios << drawer_pane.io if drawer_pane&.alive?
+
+        write_ios = []
+        @session.window.panes.each do |p|
+          write_ios << p.writer_io if p.alive? && p.pending_write?
         end
+        if drawer_pane&.alive? && drawer_pane.pending_write?
+          write_ios << drawer_pane.writer_io
+        end
+        write_ios << @current_client if @current_client && !@client_write_buffer.empty?
 
         timeout = @message ? 0.25 : SELECT_TIMEOUT
-        ready, = IO.select(ready_ios, nil, nil, timeout)
-
-        if ready
-          ready.each do |io|
-            if io == @listening_socket
-              accept_client
-            elsif io == @current_client
-              consume_client_frame
-            else
-              consume_pane_io(io)
-            end
+        ready_r, ready_w, = IO.select(read_ios, write_ios, nil, timeout)
+
+        ready_r&.each do |io|
+          if io == @listening_socket
+            accept_client
+          elsif io == @current_client
+            consume_client_frame
+          else
+            consume_pane_io(io)
+          end
+        end
+
+        ready_w&.each do |io|
+          if io == @current_client
+            drain_client_writes
+          else
+            pane = pane_for_writer_io(io)
+            pane&.drain_writes
           end
         end
 
@@ -560,6 +612,13 @@ module Muxr
       nil
     end
 
+    def pane_for_writer_io(io)
+      pane = @session.window.panes.find { |p| p.writer_io == io }
+      return pane if pane
+      return @session.drawer.pane if @session.drawer&.pane && @session.drawer.pane.writer_io == io
+      nil
+    end
+
     def prune_dead_panes
       dead = @session.window.panes.reject(&:alive?)
       return if dead.empty?
@@ -593,6 +652,11 @@ module Muxr
 
     def disconnect_client(reason: nil)
       return unless @current_client
+      # Best-effort: drop any queued OUTPUT (the client is going away),
+      # send a final BYE, then close. BYE is small enough that one
+      # blocking write won't meaningfully wedge anything even if the
+      # client's recv is sluggish.
+      @client_write_buffer = +"".b
       safe_protocol_write(@current_client, Protocol::BYE, reason || "")
       @current_client.close rescue nil
       @current_client = nil
@@ -602,6 +666,7 @@ module Muxr
       return unless @current_client
       @current_client.close rescue nil
       @current_client = nil
+      @client_write_buffer = +"".b
     end
 
     def safe_protocol_write(io, type, payload = "")

data/lib/muxr/client.rb

@@ -24,6 +24,7 @@ module Muxr
       @resize_pending = false
       @exit_code = 0
       @bye_reason = nil
+      @write_buffer = +"".b
     end
 
     # Opens the socket. Returns true on success. Raises Errno::ENOENT /
@@ -62,28 +63,55 @@ module Muxr
           send_resize
         end
 
-        ready, = IO.select([STDIN, @sock], nil, nil, SELECT_TIMEOUT)
-        next unless ready
+        write_ios = @write_buffer.empty? ? nil : [@sock]
+        ready_r, ready_w, = IO.select([STDIN, @sock], write_ios, nil, SELECT_TIMEOUT)
+        next unless ready_r || ready_w
 
-        ready.each do |io|
+        ready_r&.each do |io|
           if io == STDIN
             forward_stdin
           else
             consume_server_frame
           end
         end
+
+        drain_writes if ready_w&.include?(@sock)
       end
     end
 
     def forward_stdin
       data = STDIN.read_nonblock(4096)
-      Protocol.write(@sock, Protocol::INPUT, data)
+      queue_frame(Protocol::INPUT, data)
     rescue IO::WaitReadable
       # spurious wake-up; nothing to do.
     rescue EOFError, Errno::EPIPE, Errno::ECONNRESET, IOError
       @running = false
     end
 
+    def queue_frame(type, payload)
+      @write_buffer << Protocol.frame(type, payload)
+      drain_writes
+    end
+
+    # Push as much of @write_buffer to the server as the socket will
+    # accept without blocking. Anything left over stays queued and the
+    # event loop picks it back up when select reports the socket
+    # writable. Mirrors the server-side OUTPUT drain — without it, a
+    # busy server (rendering large vim/Claude-code redraws) could fill
+    # this socket's send buffer and wedge the client mid-paste.
+    def drain_writes
+      return if @write_buffer.empty?
+      loop do
+        n = @sock.write_nonblock(@write_buffer)
+        @write_buffer = @write_buffer.byteslice(n..-1) || +"".b
+        break if @write_buffer.empty?
+      end
+    rescue IO::WaitWritable
+      # Socket send buffer full; remainder stays queued.
+    rescue Errno::EPIPE, Errno::ECONNRESET, IOError
+      @running = false
+    end
+
     def consume_server_frame
       type, payload = Protocol.read(@sock)
       if type.nil?
@@ -106,7 +134,7 @@ module Muxr
 
     def send_resize
       rows, cols = terminal_size
-      Protocol.write(@sock, Protocol::RESIZE, Protocol.encode_size(rows, cols))
+      queue_frame(Protocol::RESIZE, Protocol.encode_size(rows, cols))
     rescue Errno::EPIPE, Errno::ECONNRESET, IOError
       @running = false
     end
@@ -124,12 +152,17 @@ module Muxr
     def enter_terminal_mode
       STDIN.raw!
       STDIN.echo = false
-      STDOUT.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m")
+      # Enable bracketed paste on the outer terminal so iTerm/Terminal/etc.
+      # wrap pastes with \e[200~...\e[201~. Those markers flow through
+      # untouched to the focused pane's PTY, which lets Claude Code, vim,
+      # modern bash, etc. recognise the input as a paste and collapse it
+      # instead of typing it out character-by-character.
+      STDOUT.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m\e[?2004h")
       STDOUT.flush
     end
 
     def leave_terminal_mode
-      STDOUT.write("\e[0m\e[?25h\e[?1049l")
+      STDOUT.write("\e[?2004l\e[0m\e[?25h\e[?1049l")
       STDOUT.flush
       begin
         STDIN.cooked!

data/lib/muxr/input_handler.rb

@@ -48,8 +48,19 @@ module Muxr
       "k"    => :up,
       "0"    => :line_start,
       "$"    => :line_end,
+      "^"    => :line_first_nonblank,
       "g"    => :top,
       "G"    => :bottom,
+      "H"    => :screen_top,
+      "M"    => :screen_middle,
+      "L"    => :screen_bottom,
+      "w"    => :word_forward,
+      "W"    => :word_forward_big,
+      "e"    => :word_end,
+      "E"    => :word_end_big,
+      # `b` is vim word-back here; the tmux-style page-back alias lives on Ctrl-b.
+      "b"    => :word_backward,
+      "B"    => :word_backward_big,
       "\x04" => :half_down, # Ctrl-d
       "\x15" => :half_up,   # Ctrl-u
       "d"    => :half_down,
@@ -57,7 +68,6 @@ module Muxr
       "\x06" => :full_down, # Ctrl-f
       "\x02" => :full_up,   # Ctrl-b
       "f"    => :full_down,
-      "b"    => :full_up,
       " "    => :full_down
     }.freeze
 
@@ -75,19 +85,32 @@ module Muxr
     end
 
     def feed(data)
-      data.each_char do |ch|
+      remaining = data
+      until remaining.empty?
+        if @state == :idle
+          # Fast path for pass-through: forward everything up to the next
+          # Ctrl-a as a single chunk so a large paste doesn't turn into one
+          # PTY write per byte. PREFIX is single-byte ASCII (\x01) and never
+          # appears mid-UTF-8, so byte/char index match.
+          idx = remaining.index(PREFIX)
+          if idx.nil?
+            @app.send_to_focused(remaining)
+            return
+          end
+          @app.send_to_focused(remaining[0...idx]) if idx > 0
+          @state = :prefix
+          remaining = remaining[(idx + 1)..] || ""
+          next
+        end
+
+        ch = remaining[0]
+        remaining = remaining[1..] || ""
         case @state
         when :help
           @app.dismiss_help
           @state = :idle
         when :confirm_quit
           handle_confirm_quit(ch)
-        when :idle
-          if ch == PREFIX
-            @state = :prefix
-          else
-            @app.send_to_focused(ch)
-          end
         when :prefix
           handle_prefix(ch)
         when :command

data/lib/muxr/pane.rb

@@ -20,6 +20,18 @@ module Muxr
       @process.io
     end
 
+    def writer_io
+      @process.writer_io
+    end
+
+    def pending_write?
+      @process.pending_write?
+    end
+
+    def drain_writes
+      @process.drain
+    end
+
     def write(data)
       @process.write(data)
     end

data/lib/muxr/protocol.rb

@@ -39,9 +39,20 @@ module Muxr
 
     # Writes one framed message. +payload+ is treated as raw bytes (binary).
     def self.write(io, type, payload = "")
+      io.write(frame(type, payload))
+    end
+
+    # Builds the on-the-wire bytes for a single frame without writing them.
+    # Lets callers append to an outgoing buffer (for non-blocking flushes
+    # later) instead of doing a synchronous io.write.
+    def self.frame(type, payload = "")
       raise ArgumentError, "type must be a single byte" unless type.is_a?(String) && type.bytesize == 1
       bytes = payload.to_s.b
-      io.write(type + [bytes.bytesize].pack("N") + bytes)
+      buf = +"".b
+      buf << type.b
+      buf << [bytes.bytesize].pack("N")
+      buf << bytes
+      buf
     end
 
     # Encodes a "ROWS COLS" string for HELLO / RESIZE payloads.

data/lib/muxr/pty_process.rb

@@ -10,6 +10,7 @@ module Muxr
       @rows = rows
       @cols = cols
       @exited = false
+      @write_buffer = +"".b
 
       shell = command || ENV["SHELL"] || "/bin/sh"
       env = ENV.to_h.merge("TERM" => "xterm-256color").merge(env_overrides)
@@ -23,11 +24,42 @@ module Muxr
       resize(rows, cols)
     end
 
+    # Appends bytes to the per-process outgoing buffer and tries to flush as
+    # many as the PTY will accept right now. Any remainder stays buffered;
+    # the event loop drains it later when the writer fd is reported writable.
+    # This avoids deadlocking the single-threaded server when the inner
+    # program is slow to read (large pastes were the original motivating
+    # case — see CHANGELOG 0.1.3).
     def write(data)
-      @writer.write(data)
-      @writer.flush
+      return if @exited
+      return if data.nil? || data.empty?
+      @write_buffer << data.b
+      drain
+    end
+
+    # Push as much of @write_buffer through the PTY as it'll take without
+    # blocking. Safe to call repeatedly — both from write() and from the
+    # event loop when select reports the writer fd writable.
+    def drain
+      return if @exited || @write_buffer.empty?
+      loop do
+        n = @writer.write_nonblock(@write_buffer)
+        @write_buffer = @write_buffer.byteslice(n..-1) || +"".b
+        break if @write_buffer.empty?
+      end
+    rescue IO::WaitWritable
+      # Kernel buffer full; the rest stays queued.
     rescue Errno::EIO, IOError, Errno::EPIPE
       @exited = true
+      @write_buffer.clear
+    end
+
+    def pending_write?
+      !@write_buffer.empty?
+    end
+
+    def writer_io
+      @writer
     end
 
     def read_nonblock(max = 8192)

data/lib/muxr/renderer.rb

@@ -264,8 +264,9 @@ module Muxr
       "  C-a Tab     cycle layout (tall → grid → monocle)",
       "  C-a Enter   promote focused pane to master",
       "  C-a ~       toggle drawer",
-      "  C-a [       enter scrollback (j/k d/u f/b g/G; v→cursor, q quits)",
-      "              in cursor mode: v char-select, C-v block-select, y yank",
+      "  C-a [       enter scrollback (j/k d/u f g/G C-b/C-f; v→cursor, q quits)",
+      "              cursor: v select, C-v block, y yank, q cancel",
+      "              motions: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
       "  C-a ]       paste internal copy buffer",
       "  C-a d       detach (server keeps running)",
       "  C-a q       kill session (asks y/n)",
@@ -439,6 +440,7 @@ module Muxr
       parts = ["0"]
       attrs = cell.attrs.to_i
       parts << "1" if (attrs & Terminal::BOLD) != 0
+      parts << "2" if (attrs & Terminal::DIM) != 0
       parts << "4" if (attrs & Terminal::UNDERLINE) != 0
       parts << "7" if (attrs & Terminal::REVERSE) != 0
       append_color(parts, cell.fg, true)

data/lib/muxr/terminal.rb

@@ -8,6 +8,7 @@ module Muxr
     BOLD      = 1
     UNDERLINE = 2
     REVERSE   = 4
+    DIM       = 8
 
     SCROLLBACK_MAX = 5000
 
@@ -183,6 +184,96 @@ module Muxr
       selection_cursor_to(timeline_size - 1, @cols - 1)
     end
 
+    def selection_cursor_to_first_non_blank
+      return unless @selection_cursor
+      tr = @selection_cursor[0]
+      selection_cursor_to(tr, first_non_blank_col(tr))
+    end
+
+    # Jump to top/middle/bottom of the visible viewport (vim H/M/L), landing
+    # on the first non-blank column of the destination line.
+    def selection_cursor_to_viewport(where)
+      return unless @selection_cursor
+      vr = case where
+           when :top    then 0
+           when :middle then @rows / 2
+           when :bottom then @rows - 1
+           end
+      return if vr.nil?
+      tr = timeline_row_for_visible(vr).clamp(0, timeline_size - 1)
+      selection_cursor_to(tr, first_non_blank_col(tr))
+    end
+
+    def selection_cursor_word_forward(big: false)
+      return unless @selection_cursor
+      tr, tc = @selection_cursor
+      prev_cls = char_class_at(tr, tc, big: big)
+      loop do
+        nxt = step_forward(tr, tc)
+        break unless nxt
+        ntr, ntc = nxt
+        cur_cls = char_class_at(ntr, ntc, big: big)
+        # Row boundaries act as whitespace breaks even when the row is fully
+        # packed (no trailing pad) — visually the user sees a new line.
+        effective_prev = (ntr != tr) ? :space : prev_cls
+        if effective_prev != cur_cls && cur_cls != :space
+          selection_cursor_to(ntr, ntc)
+          return
+        end
+        tr, tc = ntr, ntc
+        prev_cls = cur_cls
+      end
+      selection_cursor_to(timeline_size - 1, @cols - 1)
+    end
+
+    def selection_cursor_word_end(big: false)
+      return unless @selection_cursor
+      tr, tc = @selection_cursor
+      pos = step_forward(tr, tc)
+      return unless pos
+      tr, tc = pos
+      while char_class_at(tr, tc, big: big) == :space
+        pos = step_forward(tr, tc)
+        break unless pos
+        tr, tc = pos
+      end
+      return if char_class_at(tr, tc, big: big) == :space
+      cls = char_class_at(tr, tc, big: big)
+      loop do
+        pos = step_forward(tr, tc)
+        if pos.nil? || pos[0] != tr || char_class_at(pos[0], pos[1], big: big) != cls
+          selection_cursor_to(tr, tc)
+          return
+        end
+        tr, tc = pos
+      end
+    end
+
+    def selection_cursor_word_backward(big: false)
+      return unless @selection_cursor
+      tr, tc = @selection_cursor
+      pos = step_backward(tr, tc)
+      return unless pos
+      tr, tc = pos
+      while char_class_at(tr, tc, big: big) == :space
+        pos = step_backward(tr, tc)
+        unless pos
+          selection_cursor_to(tr, tc)
+          return
+        end
+        tr, tc = pos
+      end
+      cls = char_class_at(tr, tc, big: big)
+      loop do
+        pos = step_backward(tr, tc)
+        if pos.nil? || pos[0] != tr || char_class_at(pos[0], pos[1], big: big) != cls
+          selection_cursor_to(tr, tc)
+          return
+        end
+        tr, tc = pos
+      end
+    end
+
     def clear_selection
       return unless @selection_anchor
       @selection_anchor = nil
@@ -594,6 +685,44 @@ module Muxr
       @scrollback.size - @view_offset + r
     end
 
+    def first_non_blank_col(tr)
+      row = timeline_row(tr)
+      return 0 unless row
+      @cols.times do |c|
+        ch = row[c]&.char
+        return c if ch && ch != " " && ch != "\t"
+      end
+      0
+    end
+
+    def char_class_at(tr, tc, big:)
+      row = timeline_row(tr)
+      classify_char(row && row[tc] && row[tc].char, big: big)
+    end
+
+    # vim "word" = run of \w (alnum + _); "WORD" = any run of non-whitespace.
+    def classify_char(ch, big:)
+      return :space if ch.nil? || ch == " " || ch == "\t" || ch == ""
+      return :word if big
+      ch.match?(/\A\w\z/) ? :word : :punct
+    end
+
+    def step_forward(tr, tc)
+      if tc + 1 < @cols
+        [tr, tc + 1]
+      elsif tr + 1 < timeline_size
+        [tr + 1, 0]
+      end
+    end
+
+    def step_backward(tr, tc)
+      if tc > 0
+        [tr, tc - 1]
+      elsif tr > 0
+        [tr - 1, @cols - 1]
+      end
+    end
+
     def ordered_selection
       a = @selection_anchor
       b = @selection_cursor
@@ -719,9 +848,10 @@ module Muxr
           @bg = nil
           @attrs = 0
         when 1 then @attrs |= BOLD
+        when 2 then @attrs |= DIM
         when 4 then @attrs |= UNDERLINE
         when 7 then @attrs |= REVERSE
-        when 22 then @attrs &= ~BOLD
+        when 22 then @attrs &= ~(BOLD | DIM)
         when 24 then @attrs &= ~UNDERLINE
         when 27 then @attrs &= ~REVERSE
         when 30..37 then @fg = p - 30

data/lib/muxr/version.rb

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

metadata

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