omq-cli 0.15.3 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b503b668b3427210a067278ba175bbda172e98ccf19df42f4dcf4cc84cd1dd4
-  data.tar.gz: 9861f0dd910a0ca723b97043996a8c5e47c2222efd77321f8f1e43efdc872818
+  metadata.gz: 65853ffed26725eec94127f166458f4358e3bc0217ac608f729361f76bf81595
+  data.tar.gz: 85378ff431328f8e8c0ca03c7f9ea561771d598fa4c25c2824c3f8e4aa8b310d
 SHA512:
-  metadata.gz: 82972297897d9ea36f3a10ecad3372b476ae935e9b4d20ff312f23db5ecee438b52b0a443d814048f4dab8d5e5243e927509a994917b4926058d80c3f314188b
-  data.tar.gz: cbca40c66d0061a3d51782e3b1cf001aad9d44596f2b9203a7d6837c087049227565456f07646de7e2788d827ce91a1ba5290fa7c8792f103475b867ee663c28
+  metadata.gz: 4d5f29b3fe396efb10031ff2d98ba97424798a3345c13be6f8c419affcce467a3c1196faa6b31a9c741ce3577328e9e9e2df86a031cd1fb2e9865cf162945ce4
+  data.tar.gz: 95e41fe15805c6d123f60cbe8fe451749b21e8666165ec5390553bdf141c398a51706351bb387e46ac797d71fdf984b87187c72cdf4095aefb980ffbdaf69734

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.16.2 — 2026-04-18
+
+- **Use omq ~> v0.24.0 and omq-ffi >= v0.3.1**
+
+## 0.16.1 — 2026-04-18
+
+- **Use zstd ~> v0.4.0**
+
+## 0.16.0 — 2026-04-18
+
+- **Compression: switch from `OMQ::Compression::Zstd` helpers to the
+  `zstd+tcp://` transport.** `-z` now upgrades `tcp://` URLs to
+  `zstd+tcp://` and passes compression kwargs (`level:`) at bind /
+  connect time. Pipe runners and parallel workers take `config:` to
+  thread the flag through. Removes the passive/active distinction
+  and the pure-send opt-out list — the transport handles framing.
+- **`SocketSetup.attach` / `#attach_endpoints` use URI return values
+  from `Socket#bind`.** Drops reliance on the dropped
+  `Socket#last_endpoint` accessor (omq 0.12 change). Tests capture
+  the resolved URI from `#bind` directly.
+- **Dependencies consolidated.** Drops the five `omq-rfc-*` socket-type
+  gems (`clientserver`, `radiodish`, `scattergather`, `channel`, `p2p`)
+  — those socket types are now bundled with `omq` itself and opted
+  into via `require "omq/<name>"`. Renames `omq-rfc-zstd` → `omq-zstd`
+  and switches the require from `omq/rfc/zstd` to `omq/zstd`. Bumps
+  `omq` to `~> 0.23` and `omq-ffi` to `~> 0.3`.
+
+### Added
+
+- **Formatter preview: per-frame byte budget scales with part count.**
+  Single-part messages show 40 bytes; 2-part show 40 each; 3+ parts
+  show 12 bytes per frame (the previous fixed limit).
+
 ## 0.15.3 — 2026-04-16
 
 ### Changed
@@ -8,8 +41,6 @@
   `ParallelWorker#compute_reply` now memoize the decoded result
   instead of re-decoding the same literal on every iteration.
 
-## Unreleased
-
 ### Added
 
 - **REQ generator mode (`-E`/`-e` with no stdin).** `omq req` now

data/README.md

@@ -396,22 +396,45 @@ omq pub -c tcp://localhost:5556 -D "tick" -i 1 -n 10 -d 1
 omq pull -b tcp://:5557 -t 5
 ```
 
+## Limits
+
+| Flag | Effect |
+|------|--------|
+| `--recv-maxsz SIZE` | Max inbound message size (default `1M`; `0` = unlimited). Larger messages drop the connection. Accepts `4096`, `64K`, `1M`, `2G`. |
+| `--hwm N` | High water mark per socket (default 64; `0` = unbounded) |
+| `--sndbuf SIZE` / `--rcvbuf SIZE` | `SO_SNDBUF` / `SO_RCVBUF` kernel buffer sizes |
+
+The CLI defaults `--recv-maxsz` to `1 MiB` so that a misconfigured or
+malicious peer can't force unbounded memory allocation in a terminal
+session — note that the `omq` library itself defaults to unlimited.
+Bump it with `--recv-maxsz 64M` for large payloads, or disable it with
+`--recv-maxsz 0`. When combined with `-z`, this also caps the total
+**decompressed** size of all parts in a `zstd+tcp://` message.
+
 ## Compression
 
-Set `--compress` (`-z`) on either or both sides. The flag enables
-ZMTP-Zstd (provided by `omq-rfc-zstd`), a wire-protocol extension
-that negotiates Zstandard compression during the ZMTP handshake via
-an `X-Compression` READY metadata field. If both peers advertise it,
-each side compresses its outgoing frames; if only one side does, the
-connection stays plaintext (no error). The extension uses the
-auto-trained dictionary mode: the sender feeds the first messages
-into a dictionary trainer, ships the trained dictionary over a
-ZDICT command frame, then switches to dict-bound compression for
-the rest of the connection.
+`-z` enables Zstandard compression on the wire. It rewrites the
+endpoint's `tcp://` scheme to `zstd+tcp://`, the dedicated compressed
+TCP transport provided by [`omq-zstd`](https://github.com/paddor/omq-zstd).
+Both peers must pass `-z` (or otherwise opt into `zstd+tcp://`).
+
+| Flag | Effect |
+|------|--------|
+| `-z` | Compression at level **-3** (Zstd's fast strategy) |
+| `-Z` | Compression at level **3** (better ratio, more CPU) |
+| `--compress=LEVEL` | Custom level, e.g. `9`, `19`, `-1` |
+
+The sender auto-trains a dictionary from the first up-to-1000
+outgoing messages (or 100 KiB, whichever hits first), ships it inline
+to the receiver, and then switches to dictionary-bound
+compression for the rest of the connection.
+
+`-z` is a no-op for non-TCP endpoints (`ipc://`, `inproc://`); those
+stay unchanged.
 
 ```sh
+omq pull -b tcp://:5557 -z &
 omq push -c tcp://remote:5557 -z < data.txt
-omq pull -b tcp://:5557 -z
 ```
 
 ## Key generation

data/lib/omq/cli/cli_parser.rb

@@ -144,10 +144,10 @@ module OMQ
 
         -- Compression ----------------------------------------------
 
-          # ZMTP-Zstd is negotiated during the handshake.
-          # Recv sockets advertise it passively by default.
-          # Use -z on the sender to compress outgoing frames.
-          omq pull --bind tcp://:5557 &
+          # -z rewrites tcp:// endpoints to zstd+tcp:// (the dedicated
+          # compressed TCP transport from omq-zstd). Both peers must
+          # pass -z; non-TCP endpoints are unaffected.
+          omq pull --bind tcp://:5557 -z &
           echo "compressible data" | omq push --connect tcp://localhost:5557 -z
 
         -- CURVE Encryption -----------------------------------------

data/lib/omq/cli/formatter.rb

@@ -3,9 +3,7 @@
 module OMQ
   module CLI
     # Handles encoding/decoding messages in the configured format.
-    # Compression is handled below the application API by ZMTP-Zstd
-    # (omq-rfc-zstd) once enabled via +socket.compression=+; the
-    # formatter sees plaintext frames in both directions.
+    #
     class Formatter
       # @param format [Symbol] wire format (:ascii, :quoted, :raw, :jsonl, :msgpack, :marshal)
       def initialize(format)
@@ -93,7 +91,7 @@ module OMQ
 
 
       # Formats message parts for human-readable preview (logging).
-      # When +wire_size+ is given (ZMTP-Zstd negotiated), the header
+      # When +wire_size+ is given (`omq-zstd`), the header
       # also shows the compressed on-the-wire size: "(29B wire=12B)".
       # Accepts either wire-side Array<String> (monitor events) or
       # post-decode app parts that may contain non-String objects
@@ -147,7 +145,9 @@ module OMQ
 
       def self.frames_preview(parts, format:, wire_size:)
         nparts = parts.size
-        shown  = parts.first(3).map { |p| preview_frame(p) }
+        # Budget per frame: fewer parts → more room for each preview.
+        limit  = nparts <= 2 ? 40 : 12
+        shown  = parts.first(3).map { |p| preview_frame(p, limit: limit) }
         tail   = nparts > 3 ? "|…" : ""
         total  = parts.all?(String) ? parts.sum { |p| p.bytesize } : nil
         size   = if wire_size && total
@@ -165,16 +165,17 @@ module OMQ
 
 
       # Renders one frame or decoded object for {Formatter.preview}.
-      # Strings are sanitized byte-wise (first 12 bytes); non-String
+      # Strings are sanitized byte-wise (first +limit+ bytes); non-String
       # objects fall back to #inspect (always single-line) truncated
-      # at 24 bytes.
+      # at +limit+ bytes.
       #
       # @param part [String, Object]
+      # @param limit [Integer] max bytes to show (default 12)
       # @return [String]
-      def self.preview_frame(part)
+      def self.preview_frame(part, limit: 12)
         unless part.is_a?(String)
           s = part.inspect
-          return s.bytesize > 24 ? "#{s.byteslice(0, 24)}…" : s
+          return s.bytesize > limit ? "#{s.byteslice(0, limit)}…" : s
         end
 
         bytes = part.b
@@ -184,12 +185,12 @@ module OMQ
         # wire frame is an empty delimiter.
         return "''" if bytes.empty?
 
-        sample    = bytes[0, 12]
+        sample    = bytes[0, limit]
         printable = sample.count("\x20-\x7e")
 
         if printable < sample.bytesize / 2
           "[#{bytes.bytesize}B]"
-        elsif bytes.bytesize > 12
+        elsif bytes.bytesize > limit
           "#{sanitize(sample)}…"
         else
           sanitize(sample)

data/lib/omq/cli/parallel_worker.rb

@@ -51,9 +51,8 @@ module OMQ
         @sock = @config.ffi ? OMQ.const_get(@socket_sym).new(backend: :ffi) : OMQ.const_get(@socket_sym).new
         OMQ::CLI::SocketSetup.apply_options(@sock, @config)
         OMQ::CLI::SocketSetup.apply_recv_maxsz(@sock, @config)
-        OMQ::CLI::SocketSetup.apply_compression(@sock, @config, @config.type_name)
         @sock.identity = @config.identity if @config.identity
-        OMQ::CLI::SocketSetup.attach_endpoints(@sock, @endpoints, verbose: 0)
+        OMQ::CLI::SocketSetup.attach_endpoints(@sock, @endpoints, config: @config, verbose: 0)
       end
 
 

data/lib/omq/cli/pipe.rb

@@ -84,21 +84,31 @@ module OMQ
 
       def build_pull_push(in_eps, out_eps)
         kwargs = config.ffi ? { backend: :ffi } : {}
-        pull = OMQ::PULL.new(**kwargs)
-        push = OMQ::PUSH.new(**kwargs)
-        SocketSetup.apply_options(pull, config)
-        SocketSetup.apply_options(push, config)
-        SocketSetup.apply_recv_maxsz(pull, config)
-        SocketSetup.apply_compression(pull, config, "pull")
-        SocketSetup.apply_compression(push, config, "push")
-        SocketSetup.attach_endpoints(pull, in_eps, verbose: config.verbose, timestamps: config.timestamps)
-        SocketSetup.attach_endpoints(push, out_eps, verbose: config.verbose, timestamps: config.timestamps)
+
+        pull = OMQ::PULL.new(**kwargs).tap do |sock|
+          SocketSetup.apply_options(sock, config)
+          SocketSetup.apply_recv_maxsz(sock, config)
+          SocketSetup.attach_endpoints sock, in_eps,
+            config:     config,
+            verbose:    config.verbose,
+            timestamps: config.timestamps
+        end
+
+        push = OMQ::PUSH.new(**kwargs).tap do |sock|
+          SocketSetup.apply_options(sock, config)
+          SocketSetup.attach_endpoints sock, out_eps,
+            config:     config,
+            verbose:    config.verbose,
+            timestamps: config.timestamps
+        end
+
         [pull, push]
       end
 
 
       def setup_sequential_transient(task)
         return unless config.transient
+
         task.async do
           @pull.all_peers_gone.wait
           @pull.reconnect_enabled = false
@@ -110,21 +120,27 @@ module OMQ
       def sequential_message_loop(fan_out: false)
         n = config.count
         i = 0
+
         loop do
-          parts = @pull.receive
-          break if parts.nil?
+          parts = @pull.receive or break
           parts = eval_recv_expr(parts)
+
           if parts && !parts.empty?
             @push.send(parts)
           end
+
           # Yield after send so send-pump fibers can drain the queue
           # before the next message is enqueued. Without this, one pump
           # monopolizes the shared queue via drain_send_queue_capped when
           # messages arrive in bursts (recv prefetch). Only needed for
           # multi-output pipes; single-output has no fairness concern.
           Async::Task.current.yield if fan_out
+
           i += 1
-          break if n && n > 0 && i >= n
+
+          if n && n > 0 && i >= n
+            break
+          end
         end
       end
 
@@ -135,22 +151,25 @@ module OMQ
       def run_parallel(task)
         set_pipe_process_title
         OMQ.freeze_for_ractors!
-        in_eps, out_eps = resolve_endpoints
-        in_eps  = RactorHelpers.preresolve_tcp(in_eps)
-        out_eps = RactorHelpers.preresolve_tcp(out_eps)
+
+        in_eps, out_eps      = resolve_endpoints
+        in_eps               = RactorHelpers.preresolve_tcp(in_eps)
+        out_eps              = RactorHelpers.preresolve_tcp(out_eps)
         log_port, log_thread = RactorHelpers.start_log_consumer
-        error_port = Ractor::Port.new
-        error_thread = Thread.new(error_port) do |p|
+        error_port           = Ractor::Port.new
+        error_thread         = Thread.new(error_port) do |p|
           msg = p.receive
           abort "omq: #{msg}" unless msg.equal?(RactorHelpers::SHUTDOWN)
         rescue Ractor::ClosedError
           # port closed, no error
         end
+
         workers = config.parallel.times.map do
           ::Ractor.new(config, in_eps, out_eps, log_port, error_port) do |cfg, ins, outs, lport, eport|
             PipeWorker.new(cfg, ins, outs, lport, eport).call
           end
         end
+
         workers.each do |w|
           w.join
         rescue ::Ractor::RemoteError => e
@@ -173,6 +192,7 @@ module OMQ
         title.concat(in_eps.map(&:url))
         title << "->"
         title.concat(out_eps.map(&:url))
+
         Process.setproctitle(title.join(" "))
       end
 
@@ -207,6 +227,7 @@ module OMQ
           end
         end
       end
+
     end
   end
 end

data/lib/omq/cli/pipe_worker.rb

@@ -44,10 +44,8 @@ module OMQ
         OMQ::CLI::SocketSetup.apply_options(@pull, @config)
         OMQ::CLI::SocketSetup.apply_options(@push, @config)
         OMQ::CLI::SocketSetup.apply_recv_maxsz(@pull, @config)
-        OMQ::CLI::SocketSetup.apply_compression(@pull, @config, "pull")
-        OMQ::CLI::SocketSetup.apply_compression(@push, @config, "push")
-        OMQ::CLI::SocketSetup.attach_endpoints(@pull, @in_eps, verbose: 0)
-        OMQ::CLI::SocketSetup.attach_endpoints(@push, @out_eps, verbose: 0)
+        OMQ::CLI::SocketSetup.attach_endpoints(@pull, @in_eps, config: @config, verbose: 0)
+        OMQ::CLI::SocketSetup.attach_endpoints(@push, @out_eps, config: @config, verbose: 0)
       end
 
 

data/lib/omq/cli/socket_setup.rb

@@ -22,37 +22,23 @@ module OMQ
       # it entirely with --recv-maxsz 0.
       DEFAULT_RECV_MAXSZ = 1 << 20
 
-      # Socket types that never receive application data. These opt
-      # out of the default passive-compression behavior -- they would
-      # otherwise advertise a profile and wrap every outgoing frame in
-      # a 4-byte uncompressed sentinel for no benefit, since there's
-      # nothing to decompress in return.
-      PURE_SEND_TYPES = %w[push pub scatter radio].freeze
+      # Upgrades a +tcp://+ URL to +zstd+tcp://+ when compression is enabled.
+      # Returns the URL unchanged for non-TCP or when compression is off.
+      #
+      def self.compress_url(url, config)
+        return url unless config.compress
+        return url unless url.start_with?("tcp://")
 
+        url.sub("tcp://", "zstd+tcp://")
+      end
 
-      # Installs ZMTP-Zstd compression on +sock+ based on +type_name+
-      # and the explicit flags in +config+. Three outcomes:
-      #
-      # * +config.compress+ is true --> active compression (auto-dict).
-      #   Outgoing frames are compressed; incoming are decoded.
-      # * +config.compress+ is false and +type_name+ can receive -->
-      #   passive compression (RFC Sec. 6.4). The socket advertises the
-      #   profile so an active peer can compress on the wire and we can
-      #   decode it, but we never compress our own outgoing frames.
-      # * +config.compress+ is false and +type_name+ is in
-      #   +PURE_SEND_TYPES+ --> no compression. Pure senders have no
-      #   incoming traffic to decompress, so passive mode is pure
-      #   overhead on outgoing.
+
+      # Returns bind/connect kwargs for compression (level:) when enabled.
       #
-      # Callers pass +type_name+ explicitly (rather than reading it off
-      # +config+) so the pipe runners can install different modes on
-      # their push/pull ends of a single pipe.
-      def self.apply_compression(sock, config, type_name)
-        if config.compress
-          sock.compression = OMQ::Compression::Zstd.auto(level: config.compress_level || -3)
-        elsif !PURE_SEND_TYPES.include?(type_name)
-          sock.compression = OMQ::Compression::Zstd.auto(passive: true)
-        end
+      def self.compress_opts(config)
+        return {} unless config.compress
+
+        { level: config.compress_level || -3 }
       end
 
 
@@ -81,7 +67,6 @@ module OMQ
         apply_recv_maxsz(sock, config)
         sock.identity         = config.identity   if config.identity
         sock.router_mandatory = true if config.type_name == "router"
-        apply_compression(sock, config, config.type_name)
         sock
       end
 
@@ -101,12 +86,15 @@ module OMQ
       # +verbose+ gates logging (>= 1), +timestamps+ controls prefix.
       #
       def self.attach(sock, config, verbose: 0, timestamps: nil)
+        opts = compress_opts(config)
+
         config.binds.each do |url|
-          sock.bind(url)
-          CLI::Term.write_attach(:bind, sock.last_endpoint, timestamps) if verbose >= 1
+          uri = sock.bind(compress_url(url, config), **opts)
+          CLI::Term.write_attach(:bind, uri.to_s, timestamps) if verbose >= 1
         end
+
         config.connects.each do |url|
-          sock.connect(url)
+          sock.connect(compress_url(url, config), **opts)
           CLI::Term.write_attach(:connect, url, timestamps) if verbose >= 1
         end
       end
@@ -116,13 +104,17 @@ module OMQ
       # Used by PipeRunner, which works with structured endpoint lists.
       # +verbose+ gates logging (>= 1), +timestamps+ controls prefix.
       #
-      def self.attach_endpoints(sock, endpoints, verbose: 0, timestamps: nil)
+      def self.attach_endpoints(sock, endpoints, config: nil, verbose: 0, timestamps: nil)
+        opts = config ? compress_opts(config) : {}
+
         endpoints.each do |ep|
+          url = config ? compress_url(ep.url, config) : ep.url
+
           if ep.bind?
-            sock.bind(ep.url)
-            CLI::Term.write_attach(:bind, sock.last_endpoint, timestamps) if verbose >= 1
+            uri = sock.bind(url, **opts)
+            CLI::Term.write_attach(:bind, uri.to_s, timestamps) if verbose >= 1
           else
-            sock.connect(ep.url)
+            sock.connect(url, **opts)
             CLI::Term.write_attach(:connect, ep.url, timestamps) if verbose >= 1
           end
         end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.15.3"
+    VERSION = "0.16.2"
   end
 end

data/lib/omq/cli.rb

@@ -201,12 +201,12 @@ module OMQ
       config = build_config(argv)
 
       require "omq"
-      require "omq/rfc/clientserver"
-      require "omq/rfc/radiodish"
-      require "omq/rfc/scattergather"
-      require "omq/rfc/channel"
-      require "omq/rfc/p2p"
-      require "omq/rfc/zstd"
+      require "omq/client_server"
+      require "omq/radio_dish"
+      require "omq/scatter_gather"
+      require "omq/channel"
+      require "omq/peer"
+      require "omq/zstd"
       require "async"
       require "json"
       require "console"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.16.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -15,112 +15,48 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '0.24'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '0.24'
 - !ruby/object:Gem::Dependency
   name: omq-ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: omq-rfc-clientserver
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: omq-rfc-radiodish
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: omq-rfc-scattergather
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: omq-rfc-channel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: '0.3'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 0.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: omq-rfc-p2p
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: '0.3'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 0.3.1
 - !ruby/object:Gem::Dependency
-  name: omq-rfc-zstd
+  name: omq-zstd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement