muxr 0.1.11 → 0.2.0

data/lib/muxr/layout_manager.rb

@@ -10,22 +10,41 @@ module Muxr
       end
     end
 
-    LAYOUTS = %i[tall wide columns rows grid spiral centered stack monocle].freeze
+    LAYOUTS = %i[tall wide columns rows grid spiral centered stack monocle auto].freeze
+
+    AUTO_SPIRAL_MIN_COLS = 180
+    AUTO_SPIRAL_MIN_ROWS = 30
+
+    class << self
+      attr_writer :auto_spiral_min_cols, :auto_spiral_min_rows
+
+      def auto_spiral_min_cols
+        @auto_spiral_min_cols || AUTO_SPIRAL_MIN_COLS
+      end
+
+      def auto_spiral_min_rows
+        @auto_spiral_min_rows || AUTO_SPIRAL_MIN_ROWS
+      end
+    end
+
+    DEFAULT_RATIO = 0.5
+    RATIO_BOUNDS = (0.1..0.9)
 
     module_function
 
-    def compute(layout, count, area, focused_index: 0, master_index: 0)
+    def compute(layout, count, area, focused_index: 0, master_index: 0, ratio: DEFAULT_RATIO, nmaster: 1)
       return [] if count <= 0
       master_index = master_index.clamp(0, count - 1)
       focused_index = focused_index.clamp(0, count - 1)
-      case layout
-      when :tall     then tall(count, area, master_index)
-      when :wide     then wide(count, area, master_index)
+      ratio = ratio.to_f.clamp(RATIO_BOUNDS)
+      case resolve(layout, area)
+      when :tall     then tall(count, area, master_index, ratio, nmaster)
+      when :wide     then wide(count, area, master_index, ratio, nmaster)
       when :columns  then columns(count, area)
       when :rows     then rows(count, area)
       when :grid     then grid(count, area)
       when :spiral   then spiral(count, area)
-      when :centered then centered(count, area, master_index)
+      when :centered then centered(count, area, master_index, ratio, nmaster)
       when :stack    then stack(count, area, focused_index)
       when :monocle  then monocle(count, area, focused_index)
       else
@@ -33,54 +52,52 @@ module Muxr
       end
     end
 
-    # Master pane on the left taking half the width; remaining panes stack
-    # vertically on the right, dividing the remaining height evenly.
-    def tall(count, area, master_index = 0)
-      master_index = master_index.clamp(0, count - 1)
-      return [Rect.new(area.x, area.y, area.w, area.h)] if count == 1
+    def resolve(layout, area)
+      return layout unless layout == :auto
+      spiral_fits?(area) ? :spiral : :stack
+    end
 
-      master_w = [area.w / 2, 1].max
-      stack_w  = [area.w - master_w, 1].max
-      others   = (0...count).to_a - [master_index]
-      slave_count = others.length
-      base_h = area.h / slave_count
-      remainder = area.h - base_h * slave_count
+    def spiral_fits?(area)
+      area.w >= LayoutManager.auto_spiral_min_cols && area.h >= LayoutManager.auto_spiral_min_rows
+    end
 
-      rects = Array.new(count)
-      rects[master_index] = Rect.new(area.x, area.y, master_w, area.h)
+    def split_masters(count, master_index, nmaster)
+      ordered = [master_index] + ((0...count).to_a - [master_index])
+      n = nmaster.to_i.clamp(1, count)
+      [ordered.first(n), ordered.drop(n)]
+    end
 
-      y = area.y
-      others.each_with_index do |idx, i|
-        h = base_h + (i < remainder ? 1 : 0)
-        rects[idx] = Rect.new(area.x + master_w, y, stack_w, h)
-        y += h
-      end
-      rects
+    def master_extent(total, ratio)
+      (total * ratio).floor.clamp(1, [total - 1, 1].max)
     end
 
-    # The transpose of `tall`: master pane spans the full width across the top
-    # half; remaining panes sit side-by-side in the bottom half, dividing the
-    # remaining width evenly.
-    def wide(count, area, master_index = 0)
+    def tall(count, area, master_index = 0, ratio = DEFAULT_RATIO, nmaster = 1)
       master_index = master_index.clamp(0, count - 1)
-      return [Rect.new(area.x, area.y, area.w, area.h)] if count == 1
+      masters, others = split_masters(count, master_index, nmaster)
+      rects = Array.new(count)
+      if others.empty?
+        stack_column(rects, masters, area.x, area.y, area.w, area.h)
+        return rects
+      end
 
-      master_h = [area.h / 2, 1].max
-      stack_h  = [area.h - master_h, 1].max
-      others   = (0...count).to_a - [master_index]
-      slave_count = others.length
-      base_w = area.w / slave_count
-      remainder = area.w - base_w * slave_count
+      master_w = master_extent(area.w, ratio)
+      stack_column(rects, masters, area.x, area.y, master_w, area.h)
+      stack_column(rects, others, area.x + master_w, area.y, [area.w - master_w, 1].max, area.h)
+      rects
+    end
 
+    def wide(count, area, master_index = 0, ratio = DEFAULT_RATIO, nmaster = 1)
+      master_index = master_index.clamp(0, count - 1)
+      masters, others = split_masters(count, master_index, nmaster)
       rects = Array.new(count)
-      rects[master_index] = Rect.new(area.x, area.y, area.w, master_h)
-
-      x = area.x
-      others.each_with_index do |idx, i|
-        w = base_w + (i < remainder ? 1 : 0)
-        rects[idx] = Rect.new(x, area.y + master_h, w, stack_h)
-        x += w
+      if others.empty?
+        spread_row(rects, masters, area.x, area.y, area.w, area.h)
+        return rects
       end
+
+      master_h = master_extent(area.h, ratio)
+      spread_row(rects, masters, area.x, area.y, area.w, master_h)
+      spread_row(rects, others, area.x, area.y + master_h, area.w, [area.h - master_h, 1].max)
       rects
     end
 
@@ -136,30 +153,27 @@ module Muxr
       rects
     end
 
-    # Three-column master: master occupies the centre column full-height; the
-    # remaining panes are dealt alternately to a left and a right column and
-    # stacked within each. With a single slave there is no symmetry to keep, so
-    # it falls back to a simple master/slave vertical split (like `tall`).
-    def centered(count, area, master_index = 0)
+    def centered(count, area, master_index = 0, ratio = DEFAULT_RATIO, nmaster = 1)
       master_index = master_index.clamp(0, count - 1)
-      return [Rect.new(area.x, area.y, area.w, area.h)] if count == 1
-
-      others = (0...count).to_a - [master_index]
-      rects  = Array.new(count)
+      masters, others = split_masters(count, master_index, nmaster)
+      rects = Array.new(count)
+      if others.empty?
+        stack_column(rects, masters, area.x, area.y, area.w, area.h)
+        return rects
+      end
 
+      master_w = master_extent(area.w, ratio)
       if others.length == 1
-        master_w = [area.w / 2, 1].max
-        rects[master_index] = Rect.new(area.x, area.y, master_w, area.h)
+        stack_column(rects, masters, area.x, area.y, master_w, area.h)
         rects[others[0]] = Rect.new(area.x + master_w, area.y, [area.w - master_w, 1].max, area.h)
         return rects
       end
 
-      master_w = [area.w / 2, 1].max
       side_w   = area.w - master_w
       left_w   = [side_w / 2, 1].max
       right_w  = [side_w - left_w, 1].max
 
-      rects[master_index] = Rect.new(area.x + left_w, area.y, master_w, area.h)
+      stack_column(rects, masters, area.x + left_w, area.y, master_w, area.h)
       left  = others.select.with_index { |_, i| i.even? }
       right = others.select.with_index { |_, i| i.odd? }
       stack_column(rects, left,  area.x, area.y, left_w, area.h)
@@ -205,6 +219,18 @@ module Muxr
       end
     end
 
+    def spread_row(rects, indices, x, y, total_w, h)
+      return if indices.empty?
+      base_w = total_w / indices.length
+      rem    = total_w - base_w * indices.length
+      cx = x
+      indices.each_with_index do |idx, i|
+        w = base_w + (i < rem ? 1 : 0)
+        rects[idx] = Rect.new(cx, y, w, h)
+        cx += w
+      end
+    end
+
     # Roughly square grid. Each row stretches its panes to fill the full width
     # so an underfull bottom row doesn't leave gaps.
     def grid(count, area)

data/lib/muxr/mouse_report.rb

@@ -0,0 +1,24 @@
+module Muxr
+  module MouseReport
+    WHEEL_UP = 64
+    WHEEL_DOWN = 65
+    X10_COORD_MAX = 223
+
+    module_function
+
+    def wheel(direction, row:, col:, encoding: :sgr)
+      button = direction == :up ? WHEEL_UP : WHEEL_DOWN
+      encoding == :sgr ? sgr(button, row, col) : x10(button, row, col)
+    end
+
+    def sgr(button, row, col)
+      "\e[<#{button};#{[col, 1].max};#{[row, 1].max}M".b
+    end
+
+    def x10(button, row, col)
+      c = col.clamp(1, X10_COORD_MAX)
+      r = row.clamp(1, X10_COORD_MAX)
+      "\e[M#{(32 + button).chr}#{(32 + c).chr}#{(32 + r).chr}".b
+    end
+  end
+end

data/lib/muxr/pane.rb

@@ -14,6 +14,12 @@ module Muxr
   class Pane
     attr_reader :id, :terminal, :process
     attr_accessor :rect
+    # "<session>:<pane id>" when this pane mirrors a pane owned by another muxr
+    # server; nil for a locally-owned PTY.
+    attr_accessor :origin
+    # Smallest viewport any remote mirror is showing this pane through, as
+    # [rows, cols], or nil when nobody is mirroring.
+    attr_accessor :mirror_size
     # Last value written by Application's foreground poller thread. nil when
     # the shell itself is foreground (the common empty-prompt case) or when
     # the lookup hasn't run / couldn't read. Renderer surfaces this in the
@@ -36,6 +42,17 @@ module Muxr
       @initial_cwd = cwd || @process.cwd
       @private_flag = false
       @foreground_command = nil
+      @origin = nil
+      @mirror_size = nil
+      @activity = false
+      @bell = false
+      @silent = false
+      @silence_after = nil
+      hush!
+    end
+
+    def mirror?
+      @process.respond_to?(:mirror?) && @process.mirror?
     end
 
     def pid
@@ -89,6 +106,77 @@ module Muxr
     # 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.
+    ATTENTION_GRACE = 1.5
+    NAME_MAX = 24
+
+    attr_reader :name
+
+    def name=(value)
+      text = value.to_s.gsub(/[[:cntrl:]]/, "").strip[0, NAME_MAX]
+      @name = text.empty? ? nil : text
+    end
+
+    def label
+      @name || @id.to_s
+    end
+
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def activity?
+      @activity
+    end
+
+    def bell?
+      @bell
+    end
+
+    def silent?
+      @silent
+    end
+
+    attr_reader :silence_after
+
+    def note_output(now = Pane.now, attended: false)
+      return if now < @quiet_until
+      @last_output_at = now
+      @silent = false
+      @silence_reported = false
+      @activity = true unless attended
+    end
+
+    def watch_silence(seconds, now = Pane.now)
+      @silence_after = seconds
+      @last_output_at = now
+      @silent = false
+      @silence_reported = false
+    end
+
+    def silence_due?(now = Pane.now)
+      return false unless @silence_after
+      !@silence_reported && now - @last_output_at >= @silence_after
+    end
+
+    def note_silence!
+      @silent = true
+      @silence_reported = true
+    end
+
+    def note_bell
+      @bell = true
+    end
+
+    def clear_attention!
+      @activity = false
+      @bell = false
+      @silent = false
+    end
+
+    def hush!(now = Pane.now)
+      @quiet_until = now + ATTENTION_GRACE
+    end
+
     READ_BUDGET = 1 << 20 # 1 MiB
     def read_from_pty
       total = 0
@@ -96,13 +184,16 @@ module Muxr
         chunk = @process.read_nonblock
         break unless chunk
         @terminal.feed(chunk)
+        yield chunk if block_given?
         total += chunk.bytesize
       end
       # The emulator may owe the inner program a reply (DSR / CPR — see
       # Terminal#take_pending_replies!). Ship it back through the PTY's
       # input side as if it had been typed. Failure here is non-fatal: the
-      # process can have exited between read and write.
-      if (reply = @terminal.take_pending_replies!)
+      # process can have exited between read and write. A mirror stays quiet:
+      # the pane's owner already answered, and a second answer would reach the
+      # program as spurious keystrokes.
+      if (reply = @terminal.take_pending_replies!) && !mirror?
         begin
           @process.write(reply)
         rescue Errno::EIO, Errno::EPIPE
@@ -111,8 +202,33 @@ module Muxr
       total.positive? ? total : nil
     end
 
+    # A mirror's grid is sized by the pane's owner: the relayed stream carries
+    # absolute cursor addresses for *that* geometry. We only forward the
+    # viewport we can offer and wait for the size the owner settles on.
     def resize(rows, cols)
+      if mirror?
+        hush! unless rows == @terminal.rows && cols == @terminal.cols
+        return @process.resize(rows, cols)
+      end
+      rows, cols = fit_to_mirrors(rows, cols)
+      return if rows == @terminal.rows && cols == @terminal.cols
+      hush!
+      @terminal.resize(rows, cols)
+      @process.resize(rows, cols)
+    end
+
+    def fit_to_mirrors(rows, cols)
+      return [rows, cols] unless @mirror_size
+      [[rows, @mirror_size[0]].min.clamp(1, rows), [cols, @mirror_size[1]].min.clamp(1, cols)]
+    end
+
+    # Shrink to fit a mirror that just arrived, without waiting for a render —
+    # this session may be detached, in which case no render is coming. Growing
+    # back is the layout's call on the next frame it draws.
+    def clamp_to_mirrors!
+      rows, cols = fit_to_mirrors(@terminal.rows, @terminal.cols)
       return if rows == @terminal.rows && cols == @terminal.cols
+      hush!
       @terminal.resize(rows, cols)
       @process.resize(rows, cols)
     end
@@ -131,6 +247,10 @@ module Muxr
       @process.cwd || @initial_cwd
     end
 
+    def relinquish!
+      @process.relinquish! if @process.respond_to?(:relinquish!)
+    end
+
     def close
       @process.close
     end

data/lib/muxr/pane_picker.rb

@@ -0,0 +1,49 @@
+module Muxr
+  # Selection state for the attach overlay: a flat, navigable list of every
+  # pane offered by the other muxr servers on this machine, with session
+  # headings interleaved so the list reads as a grouped tree while the cursor
+  # only ever lands on something selectable.
+  class PanePicker
+    Row = Struct.new(:kind, :session, :entry) do
+      def selectable?
+        kind == :pane
+      end
+    end
+
+    attr_reader :rows, :index
+
+    def initialize(entries)
+      @rows = build_rows(entries)
+      @index = @rows.index(&:selectable?) || 0
+    end
+
+    def empty?
+      @rows.none?(&:selectable?)
+    end
+
+    def selected
+      row = @rows[@index]
+      row&.selectable? ? row.entry : nil
+    end
+
+    def move(delta)
+      return if empty?
+      i = @index
+      @rows.length.times do
+        i = (i + delta) % @rows.length
+        next unless @rows[i].selectable?
+        @index = i
+        return
+      end
+    end
+
+    private
+
+    def build_rows(entries)
+      entries.group_by(&:session).flat_map do |session, panes|
+        [Row.new(:session, session, nil)] +
+          panes.map { |entry| Row.new(:pane, session, entry) }
+      end
+    end
+  end
+end

data/lib/muxr/pane_transfer.rb

@@ -0,0 +1,172 @@
+require "json"
+require "socket"
+
+module Muxr
+  # Takes a pane away from another muxr server for good. Where RemotePane
+  # borrows a pane by relaying its bytes, this moves the pane itself: the
+  # master pty file descriptor crosses the Unix socket via SCM_RIGHTS, so the
+  # shell that was running keeps running, with its jobs, its environment and
+  # whatever it had on screen, and simply belongs to us afterwards.
+  #
+  # Two things shape the wire order. The fd has to arrive *before* the bulky
+  # emulator state, because pulling it out of the socket needs recvmsg and any
+  # plain read that swallows the carrier byte first drops the fd on the floor.
+  # And a short preamble has to arrive before *that*, because a refusal (the
+  # pane is private, or the last one in its session) has no fd to send and we
+  # would otherwise block forever waiting for one. So: preamble, fd, state.
+  #
+  # The move is two-phase. Nothing is torn down on the far side until we have
+  # a working pane here and say so, and a failure anywhere leaves the pane
+  # exactly where it was rather than dropping a live shell between servers.
+  module PaneTransfer
+    class Error < StandardError; end
+
+    TIMEOUT = 5.0
+
+    Result = Struct.new(:pane, :session, keyword_init: true)
+
+    def self.claim(socket_path:, pane_id:)
+      socket = connect(socket_path)
+      begin
+        request(socket, 1, "pane.move", "pane" => pane_id)
+        await_preamble(socket)
+        io = receive_fd(socket)
+        begin
+          state = await_state(socket)
+          pane = build_pane(io, state)
+        rescue StandardError => e
+          io.close rescue nil
+          notify(socket, "pane.move_abort")
+          raise e.is_a?(Error) ? e : Error.new(e.message)
+        end
+        request(socket, 2, "pane.move_commit")
+        await_result(socket, 2)
+        Result.new(pane: pane, session: state["session"].to_s)
+      ensure
+        socket.close rescue nil
+      end
+    end
+
+    def self.build_pane(io, state)
+      rows = state["rows"].to_i
+      cols = state["cols"].to_i
+      raise Error, "owner sent a nonsense pane size (#{rows}x#{cols})" unless rows.positive? && cols.positive?
+      process = PTYProcess.new(
+        rows: rows, cols: cols,
+        adopt_io: io, adopt_pid: state["pid"]
+      )
+      pane = Pane.new(id: state["pane"].to_s, rows: rows, cols: cols, cwd: state["cwd"], process: process)
+      pane.terminal.restore_transfer!(state)
+      pane.name = state["name"] if state["name"]
+      pane
+    end
+
+    def self.connect(socket_path)
+      UNIXSocket.new(socket_path)
+    rescue SystemCallError => e
+      raise Error, "cannot reach session socket: #{e.message}"
+    end
+
+    def self.request(socket, id, method, params = {})
+      socket.write(JSON.generate("id" => id, "method" => method, "params" => params) + "\n")
+    rescue SystemCallError, IOError => e
+      raise Error, e.message
+    end
+
+    def self.notify(socket, method, params = {})
+      socket.write(JSON.generate("method" => method, "params" => params) + "\n")
+    rescue SystemCallError, IOError
+      # Owner will time the half-finished move out on its own.
+    end
+
+    # Read the preamble a byte at a time. Reading ahead here would be a bug,
+    # not an optimization: the very next thing on the socket is the fd, and a
+    # buffered read past the newline would consume its carrier byte.
+    def self.await_preamble(socket)
+      line = +""
+      deadline = now + TIMEOUT
+      until line.end_with?("\n")
+        raise Error, "timed out waiting for the owning session" unless wait_readable(socket, deadline)
+        byte = begin
+          socket.read_nonblock(1)
+        rescue IO::WaitReadable
+          next
+        rescue EOFError, SystemCallError, IOError
+          raise Error, "owning session closed the connection"
+        end
+        line << byte
+        raise Error, "owning session sent an oversized reply" if line.bytesize > 8192
+      end
+      check(parse(line))
+    end
+
+    def self.receive_fd(socket)
+      raise Error, "timed out waiting for the pane's terminal" unless wait_readable(socket, now + TIMEOUT)
+      socket.recv_io(IO, "r+")
+    rescue SystemCallError, IOError => e
+      raise Error, "could not take over the pane's terminal: #{e.message}"
+    end
+
+    # Safe to buffer freely now — the fd is out of the socket and the state
+    # line is the last thing the owner sends before we commit.
+    def self.await_state(socket)
+      buffer = +""
+      deadline = now + TIMEOUT
+      until (nl = buffer.index("\n"))
+        raise Error, "timed out waiting for the pane's contents" unless wait_readable(socket, deadline)
+        begin
+          buffer << socket.read_nonblock(READ_CHUNK)
+        rescue IO::WaitReadable
+          next
+        rescue EOFError, SystemCallError, IOError
+          raise Error, "owning session closed the connection"
+        end
+      end
+      check(parse(buffer.byteslice(0, nl + 1)))
+    end
+
+    def self.await_result(socket, id)
+      buffer = +""
+      deadline = now + TIMEOUT
+      loop do
+        while (nl = buffer.index("\n"))
+          line = buffer.slice!(0..nl)
+          msg = parse(line)
+          next unless msg["id"] == id
+          return check(msg)
+        end
+        raise Error, "timed out completing the move" unless wait_readable(socket, deadline)
+        begin
+          buffer << socket.read_nonblock(READ_CHUNK)
+        rescue IO::WaitReadable
+          next
+        rescue EOFError, SystemCallError, IOError
+          raise Error, "owning session closed the connection"
+        end
+      end
+    end
+
+    READ_CHUNK = 64 * 1024
+
+    def self.check(msg)
+      raise Error, msg["error"]["message"].to_s if msg["error"]
+      msg["result"] || {}
+    end
+
+    def self.parse(line)
+      JSON.parse(line)
+    rescue JSON::ParserError
+      raise Error, "owning session sent something that isn't JSON"
+    end
+
+    def self.wait_readable(socket, deadline)
+      remaining = deadline - now
+      return false if remaining <= 0
+      !!IO.select([socket], nil, nil, remaining)
+    end
+
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/muxr/protocol.rb

@@ -55,21 +55,67 @@ module Muxr
       buf
     end
 
-    # Encodes a "ROWS COLS" string for HELLO / RESIZE payloads.
-    def self.encode_size(rows, cols)
-      "#{rows.to_i} #{cols.to_i}"
+    # Encodes a "ROWS COLS" string for HELLO / RESIZE payloads. Optional
+    # capabilities (from the width probe) ride along as trailing "key=val"
+    # tokens, e.g. "48 200 ambiguous=2". Older servers that split on the first
+    # two tokens still read the size correctly, and a server that doesn't know a
+    # given cap simply ignores it.
+    def self.encode_size(rows, cols, caps = nil)
+      base = "#{rows.to_i} #{cols.to_i}"
+      return base if caps.nil? || caps.empty?
+      base + " " + encode_caps(caps)
     end
 
-    # Returns [rows, cols] or nil if malformed.
+    # Serializes a caps hash to whitespace-free "key=value" tokens. Integer
+    # values encode as "ambiguous=2"; a codepoint=>width map (the width probe's
+    # per-glyph overrides) encodes as "glyphs=23fa:2,273b:1" with hex codepoints.
+    def self.encode_caps(caps)
+      caps.filter_map do |k, v|
+        if v.is_a?(Hash)
+          next if v.empty?
+          "#{k}=" + v.map { |cp, w| "#{cp.to_s(16)}:#{w.to_i}" }.join(",")
+        else
+          "#{k}=#{v.to_i}"
+        end
+      end.join(" ")
+    end
+
+    # Returns [rows, cols] from a HELLO/RESIZE payload, or nil if malformed.
+    # Tolerates trailing caps tokens by reading only the first two integers.
     def self.decode_size(payload)
       parts = payload.to_s.strip.split(/\s+/)
-      return nil unless parts.length == 2
+      return nil unless parts.length >= 2
       r = Integer(parts[0]) rescue nil
       c = Integer(parts[1]) rescue nil
       return nil unless r && c
       [r, c]
     end
 
+    # Pulls the trailing "key=val" capability tokens out of a HELLO payload into
+    # a symbol-keyed hash. Plain integer values decode to Integer; a value with
+    # "hex:width" pairs decodes to a {codepoint => width} hash (inverse of
+    # encode_caps). Unknown / malformed tokens are skipped, never raised on.
+    def self.decode_caps(payload)
+      caps = {}
+      payload.to_s.strip.split(/\s+/).each do |tok|
+        next unless tok.include?("=")
+        k, v = tok.split("=", 2)
+        next unless k =~ /\A[a-z_]+\z/
+        if v.include?(":")
+          map = {}
+          v.split(",").each do |pair|
+            cp, w = pair.split(":", 2)
+            next unless cp =~ /\A[0-9a-fA-F]+\z/ && w =~ /\A\d+\z/
+            map[cp.to_i(16)] = w.to_i
+          end
+          caps[k.to_sym] = map unless map.empty?
+        elsif v =~ /\A-?\d+\z/
+          caps[k.to_sym] = v.to_i
+        end
+      end
+      caps
+    end
+
     def self.read_exact(io, n)
       buf = +""
       while buf.bytesize < n