muxr 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab53a383e7781f83ff106e503047cf5952b12193d0d65e2b29631f2beda6bcf5
-  data.tar.gz: 0fcef17549ae1745d76fe530a97f12740c9556704bbe724f1b4690932c7cabc5
+  metadata.gz: a22c29848cc6a0454f9be515cbc0f654537e37f9fbde37902f55dd34c103ce21
+  data.tar.gz: b96e180cc3750f1f0d3f72fc822669acaf68cc33c65b312029664b36981794cb
 SHA512:
-  metadata.gz: 4440cb89e4295407dce42ca26c474c64441ff556cb285769b085e0474448132085d9bb6ad9af91699e6349a915c90fe6ebd33825d7ee68f315cafc26ccac5244
-  data.tar.gz: e17c2f092dcd76ca617bfbfd6acdf1e5475ea9fd7afe0a7458539af95eaa32b0282d499a094f19a6887b6fd228f03d470d5a8c6b9b167b9838e6989edd20ee74
+  metadata.gz: 9139072cdc6e55e0ab94c7144d492858cdb3fa75bf59f5009b925d7f4e6659d8228f64987aba7c08fdff119dbcbb480511969cc64c0904e96a3ae95cb8456ddc
+  data.tar.gz: 77028f21adf1d5a7710f952af3dfc0621223b4aa0cbb70ff15436c54e797d8d3809885b50d31a71c5f417afaae2bb153bbf149379110813beeb23ba716cefe25

data/CHANGELOG.md

@@ -6,6 +6,47 @@ 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
+- 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
@@ -67,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
@@ -57,9 +62,11 @@ 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 = +""
+      @last_render_at = nil
     end
 
     attr_reader :paste_buffer
@@ -401,12 +408,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
@@ -479,25 +503,54 @@ 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
+        # 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|
+          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
 
@@ -509,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
@@ -579,6 +657,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?
@@ -612,6 +697,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
@@ -621,6 +711,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

@@ -85,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,15 +20,38 @@ 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
 
+    # 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/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

@@ -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.2"
+  VERSION = "0.1.4"
 end

metadata

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