omq-cli 0.12.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf29033480f27f1a249d6f22b85a2f569687e79ed6ddde06a0ef74eacafa0863
-  data.tar.gz: 4d51ae13241f047758223a2b4f055721d2b1a8809c5ba7c1154868141b1e22e8
+  metadata.gz: b5a558fd06799fcf4bee5d5036a4cac86c8482554df3998e5f42171d04e520db
+  data.tar.gz: e53bb5236bb5bc660e04ad00c10aa0f3b1e4a848ed9d74363c3943f877bf210f
 SHA512:
-  metadata.gz: 254ca00deef4d9bd9e4bbafd3cd44f785c27f63446437367b178e76711cdeda33ab779f7880e71181d3d60198458bd1f5741f1890e0d9125d797282dbef96189
-  data.tar.gz: 642c4eebaedc3d3b606693e40c3cf6112ee4c06b60432c60831bd75b0d3be171d81a2f4232c27a49fbed9c287a061e490dc3a62ebdfd618cf0f7fa3ea9624fff
+  metadata.gz: 5841f42d980388be4ce4d0feea88b76a358e86f6ba6e64f6b1775dfdcad16dc349ba3866c824fa74ffb88005876e64c027de9fd93fa21417c8a5a53be3180861
+  data.tar.gz: 4b68d2c56882c87a06e75fa348eff4f9df75d5cd0c3a85c26e20e6676780c61c0413e329dff7bdbb082b861795cdf09bb30aa4b61c7279c88bbd2e29373d1552

data/CHANGELOG.md

@@ -1,5 +1,123 @@
 # Changelog
 
+## 0.14.0 — 2026-04-13
+
+### Added
+
+- **Receive-capable sockets decompress by default.** All socket types
+  except pure senders (`push`, `pub`, `scatter`, `radio`) now advertise
+  the ZMTP-Zstd profile in **passive mode** at startup, so they accept
+  compressed frames from any active-sender peer without requiring
+  `-z` on the receive side. They never compress their own outgoing
+  frames in this mode — use `-z` / `-Z` / `--compress=LEVEL` on the
+  sender to opt it in. A `push` piped into a `pull` with no flags on
+  either side stays uncompressed; `omq push -z | omq pull` compresses
+  on the wire and the pull side decodes transparently. This is the
+  RFC Sec. 6.4 "Passive senders" mode; requires omq-rfc-zstd >= 0.1.0.
+- **`-Z` flag for better-ratio compression (zstd level 3).** `-z`
+  remains the fast default (level -3) and `--compress=LEVEL` takes
+  a custom zstd level (e.g. `--compress=19`, `--compress=-1`). Short
+  bundling (`-zvvv`, `-Zvvv`) still works.
+- **`-vvv` logs `ZDICT` exchange.** When the auto-trained dictionary
+  is shipped/received, the trace prints `>> ZDICT (NB)` on the sender
+  and `<< ZDICT (NB)` on the receiver.
+- **`-vvv` wire-size annotation for compressed traces.** Message
+  previews on compressed sockets include the post-compression byte
+  count: `(280B wire=29B) ZZ…`. Plumbed from the ZMTP-Zstd wrapper
+  through the engine's verbose monitor.
+
+### Changed
+
+- **Compression backend switched from `rlz4` to `omq-rfc-zstd`.**
+  Compression is now a ZMTP wire-protocol extension negotiated via
+  the `X-Compression` READY property and applied below the
+  application API. Auto-trained dictionaries are shipped over a
+  `ZDICT` command frame once the sender has enough samples. The
+  `Formatter` no longer compresses or decompresses anything — it
+  only encodes/decodes wire formats. Pipe `-z` is no longer modal
+  (`compress_in`/`compress_out` removed) since compression is a
+  per-socket, send-side property negotiated with each peer.
+- **`-vvv` output ordering under compression.** At `-vvv`, the
+  monitor fiber now writes both the trace line and the plaintext
+  body, so trace-and-body pairs land on the tty in order instead of
+  interleaving between the recv pump and the app fiber.
+- **TCP host normalization moved into `OMQ::Transport::TCP`.** `omq`
+  v0.19.0 now handles `tcp://*:PORT`, `tcp://:PORT`, and
+  `tcp://localhost:PORT` natively (including dual-stack `*` binding
+  both IPv4 and IPv6 wildcards), so `CliParser` no longer rewrites
+  these URLs before handing them off. Removed
+  `CliParser.loopback_bind_host` and the `normalize_bind`/
+  `normalize_connect`/`normalize_ep` block. Requires `omq ~> 0.19`.
+- **Terminate on protocol errors instead of silent reconnect.** When
+  a peer sends a frame that violates the ZMTP wire protocol
+  (oversized, bad framing, zstd bytebomb, nonce exhaustion, …), the
+  library drops that one connection and reconnects — the libzmq
+  parity behavior. The CLI is a different audience: a persistent
+  protocol violation is almost always a misconfiguration the user
+  needs to see, not silently paper over. Every runner
+  (`BaseRunner`, `PipeRunner`, `ParallelWorker`, `PipeWorker`) now
+  attaches a monitor that watches for `:disconnected` events whose
+  `detail[:error]` is a `Protocol::ZMTP::Error`, prints
+  `omq: <reason>` to stderr, kills the socket, and exits with
+  status 1. Requires `omq ~> 0.19.2` for the new `:disconnected`
+  detail shape and `Socket#engine` accessor.
+- **`-vvv` disconnect events render the reason in parentheses.**
+  `Term.format_event` now pretty-prints `:disconnected` details
+  that contain a `:reason` key, e.g.
+  `disconnected tcp://:5555 (frame size 1024 exceeds max_message_size 32)`,
+  instead of dumping the raw hash.
+
+### Fixed
+
+- **`--recv-maxsz` is now actually applied in pipe and parallel
+  modes.** `PipeRunner`, `PipeWorker`, and `ParallelWorker` were
+  only calling `SocketSetup.apply_options` + `apply_compression`
+  and skipping `max_message_size` entirely — so the default 1 MiB
+  cap (and any `--recv-maxsz` override) silently had no effect on
+  `omq pipe` or `omq pull -P`. Extracted the logic into
+  `SocketSetup.apply_recv_maxsz` and wired it into all four setup
+  paths (sequential pull/rep, sequential pipe, parallel worker,
+  pipe worker). Oversized frames now drop the connection as
+  intended and — combined with the CLI termination policy above —
+  exit with a clear error instead of hanging in a reconnect loop.
+
+## 0.13.0 — 2026-04-12
+
+### Added
+
+- **`--timestamps[=PRECISION]` flag.** Prefix log lines with UTC
+  timestamps. Accepts `s`, `ms` (default), or `us`. Replaces the
+  former `-vvvv` special meaning, which has been removed.
+- **`-M` / `--marshal` preserves arbitrary objects on the wire.**
+  Eval results in `--format marshal` mode (e.g. `Time.now`, hashes,
+  UTF-16LE strings) are now passed through unchanged instead of
+  being coerced via `#to_s`. Affects both the main runner and
+  Ractor workers (`-P`).
+- **`-P0` ⇒ `nproc`.** `-P0` (or bare `-P`) spawns one Ractor worker
+  per CPU, capped at 16. Short-option clustering works: `-P0zvv`
+  expands to `-P 0 -z -v -v`.
+
+### Changed
+
+- **`-vvv` shows decompressed message previews.** When `--compress`
+  is active, message traces now log the decompressed parts and
+  include the on-wire size: `(5B wire=21B) hello`. Engine-level
+  message events are suppressed in compressed mode to avoid
+  double-logging compressed bytes.
+- **Truncation marker uses `…` (U+2026).** `Formatter.preview`
+  truncation now uses the real horizontal ellipsis character
+  instead of three ASCII dots.
+
+### Fixed
+
+- **`FrozenError` in eval handlers returning received parts.**
+  `ExpressionEvaluator` no longer mutates the result array with
+  `#map!`, which crashed when a script handler returned the frozen
+  parts array received from the socket.
+- **README:** fixed broken `if /regex/` examples (no implicit `$_`
+  match in `instance_exec`), broken `OMQ.incoming`/`OMQ.outgoing`
+  handler table, and `-P` examples that no longer parsed.
+
 ## 0.12.3 — 2026-04-10
 
 ### Fixed

data/README.md

@@ -127,8 +127,8 @@ Pipe creates an internal PULL → eval → PUSH pipeline:
 ```sh
 omq pipe -c@work -c@sink -e 'it.map(&:upcase)'
 
-# with Ractor workers for CPU parallelism
-omq pipe -c@work -c@sink -P 4 -r./fib.rb -e 'fib(Integer(it.first)).to_s'
+# with Ractor workers for CPU parallelism (-P0 = nproc)
+omq pipe -c@work -c@sink -P0 -r./fib.rb -e 'fib(Integer(it.first)).to_s'
 ```
 
 The first endpoint is the pull-side (input), the second is the push-side (output).
@@ -171,10 +171,10 @@ omq pull -b tcp://:5557 -e '|(key, value)| "#{key}=#{value}"'
 
 ```sh
 # skip messages matching a pattern
-omq pull -b tcp://:5557 -e 'next if /^#/; it'
+omq pull -b tcp://:5557 -e 'next if it.first.start_with?("#"); it'
 
 # stop on "quit"
-omq pull -b tcp://:5557 -e 'break if /quit/; it'
+omq pull -b tcp://:5557 -e 'break if it.first == "quit"; it'
 ```
 
 ### BEGIN/END blocks
@@ -244,8 +244,8 @@ omq req -c tcp://localhost:5555 -r./handler.rb
 
 | Method | Effect |
 |--------|--------|
-| `OMQ.outgoing { |msg| ... }` | Register outgoing message transform |
-| `OMQ.incoming { |msg| ... }` | Register incoming message transform |
+| `OMQ.outgoing { \|msg\| ... }` | Register outgoing message transform |
+| `OMQ.incoming { \|msg\| ... }` | Register incoming message transform |
 
 - use explicit block variable (like `msg`) or `it`
 - Setup: use local variables and closures at the top of the script
@@ -348,8 +348,16 @@ omq pull -b tcp://:5557 -t 5
 
 ## Compression
 
-Both sides must use `--compress` (`-z`). Uses LZ4 frame format, provided
-by the `rlz4` gem (Ractor-safe, Rust extension via `lz4_flex`).
+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.
 
 ```sh
 omq push -c tcp://remote:5557 -z < data.txt
@@ -441,11 +449,11 @@ Pipe creates an in-process PULL → eval → PUSH pipeline:
 # basic pipe (positional: first = input, second = output)
 omq pipe -c@work -c@sink -e 'it.map(&:upcase)'
 
-# parallel Ractor workers (default: all CPUs)
-omq pipe -c@work -c@sink -P -r./fib.rb -e 'fib(Integer(it.first)).to_s'
+# parallel Ractor workers (-P0 = nproc, also combinable: -P0zvv)
+omq pipe -c@work -c@sink -P0 -r./fib.rb -e 'fib(Integer(it.first)).to_s'
 
 # fixed number of workers
-omq pipe -c@work -c@sink -P 4 -e 'it.map(&:upcase)'
+omq pipe -c@work -c@sink -P4 -e 'it.map(&:upcase)'
 
 # exit when producer disconnects
 omq pipe -c@work -c@sink --transient -e 'it.map(&:upcase)'
@@ -467,7 +475,7 @@ omq pipe --in -b tcp://:5555 --out -c@sink1 -c@sink2 -e 'it'
 omq pipe --in -b tcp://:5555 -b tcp://:5556 --out -c tcp://sink:5557 -e 'it'
 
 # parallel workers with fan-in (all must be -c)
-omq pipe --in -c@a -c@b --out -c@sink -P 4 -e 'it'
+omq pipe --in -c@a -c@b --out -c@sink -P4 -e 'it'
 ```
 
 `-P`/`--parallel` requires all endpoints to be `--connect`. In parallel mode, each Ractor worker

data/lib/omq/cli/base_runner.rb

@@ -15,7 +15,7 @@ module OMQ
       def initialize(config, socket_class)
         @config = config
         @klass  = socket_class
-        @fmt    = Formatter.new(config.format, compress: config.compress)
+        @fmt    = Formatter.new(config.format)
       end
 
 
@@ -26,13 +26,17 @@ module OMQ
       def call(task)
         set_process_title
         setup_socket
-        start_event_monitor if config.verbose >= 2
+        start_event_monitor
         maybe_start_transient_monitor(task)
         sleep(config.delay) if config.delay && config.recv_only?
         wait_for_peer if needs_peer_wait?
         run_begin_blocks
         run_loop(task)
         run_end_blocks
+      rescue OMQ::SocketDeadError => error
+        reason = error.cause&.message || error.message
+        $stderr.write("omq: #{reason}\n")
+        exit 1
       ensure
         @sock&.close
       end
@@ -99,7 +103,7 @@ module OMQ
 
 
       def attach_endpoints
-        SocketSetup.attach(@sock, config, verbose: config.verbose)
+        SocketSetup.attach(@sock, config, verbose: config.verbose, timestamps: config.timestamps)
       end
 
 
@@ -314,16 +318,14 @@ module OMQ
       def send_msg(parts)
         return if parts.empty?
         parts = [Marshal.dump(parts)] if config.format == :marshal
-        parts = @fmt.compress(parts)
         @sock.send(parts)
         transient_ready!
       end
 
 
       def recv_msg
-        raw = @sock.receive
-        return nil if raw.nil?
-        parts = @fmt.decompress(raw)
+        parts = @sock.receive
+        return nil if parts.nil?
         parts = Marshal.load(parts.first) if config.format == :marshal
         transient_ready!
         parts
@@ -390,6 +392,10 @@ module OMQ
 
       def output(parts)
         return if config.quiet || parts.nil?
+        # At -vvv, the monitor fiber owns both the trace and the body
+        # output (see start_event_monitor). Skipping the app-side write
+        # avoids interleaving between the two fibers on a shared tty.
+        return if config.verbose >= 3
         $stdout.write(@fmt.encode(parts))
         $stdout.flush
       end
@@ -462,14 +468,38 @@ module OMQ
       end
 
 
-      # -vv: log connect/disconnect/retry/timeout events via Socket#monitor
-      # -vvv: also log message sent/received traces
-      # -vvvv: also prepend ISO8601 µs-precision timestamps
+      # Always attached so protocol-level disconnect events can kill
+      # the socket. Verbose gating lives inside the callback:
+      #   -vv  log connect/disconnect/retry/timeout events
+      #   -vvv also log message sent/received traces
+      # --timestamps[=s|ms|us]: prepend UTC timestamps to log lines
       def start_event_monitor
-        @sock.monitor(verbose: config.verbose >= 3) do |event|
-          Term.write_event(event, config.verbose)
+        trace        = config.verbose >= 3
+        log_events   = config.verbose >= 2
+        @sock.monitor(verbose: trace) do |event|
+          Term.write_event(event, config.timestamps) if log_events
+          if trace && event.type == :message_received && !config.quiet
+            $stdout.write(@fmt.encode(event.detail[:parts]))
+            $stdout.flush
+          end
+          kill_on_protocol_error(event)
         end
       end
+
+
+      # omq-cli policy: a peer that commits a protocol-level violation
+      # (Protocol::ZMTP::Error — oversized frame, decompression
+      # bytebomb, bad framing, …) is almost certainly a
+      # misconfiguration the user needs to see. Mark the socket dead
+      # so the next receive raises SocketDeadError. The library
+      # itself just drops the connection and keeps serving the
+      # others; this stricter policy is CLI-only.
+      def kill_on_protocol_error(event)
+        return unless event.type == :disconnected
+        error = event.detail && event.detail[:error]
+        return unless error.is_a?(Protocol::ZMTP::Error)
+        @sock.engine.signal_fatal_error(error)
+      end
     end
   end
 end

data/lib/omq/cli/cli_parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "socket"
+require "etc"
 
 module OMQ
   module CLI
@@ -124,8 +125,12 @@ module OMQ
 
         -- Compression ----------------------------------------------
 
-          # both sides must use --compress/-z
-          omq pull --bind tcp://:5557 --compress &
+          # ZMTP-Zstd is negotiated transparently during the handshake.
+          # Receive-capable sockets (pull, sub, rep, ...) advertise the
+          # profile by default in passive mode: they decode compressed
+          # frames from an active sender but never compress their own
+          # outgoing frames. Use -z / -Z on the sender to opt it in.
+          omq pull --bind tcp://:5557 &
           echo "compressible data" | omq push --connect tcp://localhost:5557 -z
 
         -- CURVE Encryption -----------------------------------------
@@ -224,13 +229,13 @@ module OMQ
         rcvbuf:           nil,
         conflate:         false,
         compress:         false,
-        compress_in:      false,
-        compress_out:     false,
+        compress_level:   nil,
         send_expr:        nil,
         recv_expr:        nil,
         parallel:         nil,
         transient:        false,
         verbose:          0,
+        timestamps:       nil,
         quiet:            false,
         echo:             false,
         scripts:          [],
@@ -249,6 +254,25 @@ module OMQ
       end
 
 
+      # Splits short-option clusters of the form `-P[digits][letters]`
+      # so OptionParser sees `-P[digits]` followed by `-[letters]`.
+      # Lets `-P0zvv` mean `-P0 -z -v -v` (portable & combinable).
+      # Also rewrites bare `--timestamps` to `--timestamps=ms` so
+      # OptionParser doesn't consume the next positional token as its
+      # argument.
+      #
+      def split_parallel_cluster(argv)
+        argv.flat_map { |a|
+          if a =~ /\A-P(\d*)([a-zA-Z].*)\z/
+            n, rest = $1, $2
+            n.empty? ? ["-P", "-#{rest}"] : ["-P#{n}", "-#{rest}"]
+          else
+            a
+          end
+        }.map { |a| a == "--timestamps" ? "--timestamps=ms" : a }
+      end
+
+
       # Validates option combinations, aborting on bad combos.
       #
       def self.validate!(opts)
@@ -365,16 +389,17 @@ module OMQ
           o.on("--conflate", "Keep only last message per subscriber (PUB/RADIO)") { opts[:conflate] = true }
 
           o.separator "\nCompression:"
-          o.on("-z", "--compress", "LZ4 compression per frame (modal with --in/--out)") do
-            require "rlz4"
-            case pipe_side
-            when :in
-              opts[:compress_in] = true
-            when :out
-              opts[:compress_out] = true
-            else
-              opts[:compress] = true
-            end
+          o.on("-z", "Zstd compression (level -3, fast)") do
+            opts[:compress] = true
+            opts[:compress_level] = -3
+          end
+          o.on("-Z", "Zstd compression (level 3, better ratio)") do
+            opts[:compress] = true
+            opts[:compress_level] = 3
+          end
+          o.on("--compress=LEVEL", Integer, "Zstd compression with custom level (e.g. 19, -1)") do |v|
+            opts[:compress] = true
+            opts[:compress_level] = v
           end
 
           o.separator "\nProcessing (-e = incoming, -E = outgoing):"
@@ -384,8 +409,9 @@ module OMQ
             require "omq" unless defined?(OMQ::VERSION)
             opts[:scripts] << (v == "-" ? :stdin : (v.start_with?("./", "../") ? File.expand_path(v) : v))
           }
-          o.on("-P", "--parallel N", Integer, "Parallel Ractor workers (max 16)") { |v|
-            opts[:parallel] = [v, 16].min
+          o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers (0 = nproc, max 16)") { |v|
+            n = v.nil? || v.zero? ? Etc.nprocessors : v
+            opts[:parallel] = [n, 16].min
           }
 
           o.separator "\nCURVE encryption (requires system libsodium):"
@@ -397,7 +423,10 @@ module OMQ
           o.separator "            OMQ_CRYPTO (backend: rbnacl or nuckle)"
 
           o.separator "\nOther:"
-          o.on("-v", "--verbose",   "Verbosity: -v endpoints, -vv events, -vvv messages, -vvvv timestamps") { opts[:verbose] += 1 }
+          o.on("-v", "--verbose",   "Verbosity: -v endpoints, -vv events, -vvv messages") { opts[:verbose] += 1 }
+          o.on(      "--timestamps PRECISION", %w[s ms us], "Prefix log lines with UTC timestamp (s/ms/us, default ms)") { |v|
+            opts[:timestamps] = v.to_sym
+          }
           o.on("-q", "--quiet",     "Suppress message output")           { opts[:quiet] = true }
           o.on(      "--transient", "Exit when all peers disconnect")    { opts[:transient] = true }
           o.on(      "--ffi",       "Use libzmq FFI backend (requires omq-ffi gem + system libzmq 4.x)") do
@@ -427,6 +456,8 @@ module OMQ
           o.separator "\nExit codes: 0 = success, 1 = error, 2 = timeout"
         end
 
+        argv = split_parallel_cluster(argv)
+
         begin
           parser.parse!(argv)
         rescue OptionParser::ParseError => e
@@ -443,26 +474,9 @@ module OMQ
           opts[:type_name] = type_name.downcase
         end
 
-        # Normalize shorthand hostnames to concrete addresses.
-        #
-        # Binds:    tcp://:PORT  → loopback (::1 if IPv6 available, else 127.0.0.1)
-        #           tcp://*:PORT → 0.0.0.0 (all interfaces, IPv4)
-        #           tcp://0.0.0.0:PORT, tcp://[::]:PORT → pass through
-        #
-        # Connects: tcp://:PORT  → localhost (Happy Eyeballs)
-        #           tcp://*:PORT → localhost
-        #
-        # The hang on macOS (IPv6 connect(2) not getting ECONNREFUSED via
-        # kqueue) is fixed by the connect timeout in Engine::Reconnect.
-        loopback        = self.class.loopback_bind_host
-        normalize_bind    = ->(url) { url.sub(%r{\Atcp://\*:}, "tcp://0.0.0.0:").sub(%r{\Atcp://:}, "tcp://#{loopback}:") }
-        normalize_connect = ->(url) { url.sub(%r{\Atcp://(\*|):}, "tcp://localhost:") }
-        normalize_ep      = ->(ep)  { Endpoint.new(ep.bind? ? normalize_bind.call(ep.url) : normalize_connect.call(ep.url), ep.bind?) }
-        opts[:binds].map!(&normalize_bind)
-        opts[:connects].map!(&normalize_connect)
-        opts[:endpoints].map!(&normalize_ep)
-        opts[:in_endpoints].map!(&normalize_ep)
-        opts[:out_endpoints].map!(&normalize_ep)
+        # Host shorthand (tcp://*:PORT, tcp://:PORT, tcp://localhost:PORT)
+        # is normalized inside OMQ::Transport::TCP — see its
+        # #normalize_bind_host / #normalize_connect_host / #loopback_host.
 
         opts
       end
@@ -565,19 +579,6 @@ module OMQ
       end
 
 
-      # Returns the loopback address for bind normalization.
-      # Prefers IPv6 loopback ([::1]) when the host has at least one
-      # non-loopback, non-link-local IPv6 address, otherwise 127.0.0.1.
-      #
-      def self.loopback_bind_host
-        @loopback_bind_host ||= begin
-          has_ipv6 = ::Socket.getifaddrs.any? { |ifa|
-            addr = ifa.addr
-            addr&.ipv6? && !addr.ipv6_loopback? && !addr.ipv6_linklocal?
-          }
-          has_ipv6 ? "[::1]" : "127.0.0.1"
-        end
-      end
     end
   end
 end

data/lib/omq/cli/client_server.rb

@@ -25,8 +25,7 @@ module OMQ
           parts = recv_msg_raw
           break if parts.nil?
           routing_id = parts.shift
-          body       = @fmt.decompress(parts)
-          break unless handle_server_request(routing_id, body)
+          break unless handle_server_request(routing_id, parts)
           i += 1
           break if n && n > 0 && i >= n
         end
@@ -37,15 +36,15 @@ module OMQ
         if config.recv_expr || @recv_eval_proc
           reply = eval_recv_expr(body)
           output([display_routing_id(routing_id), *(reply || [""])])
-          @sock.send_to(routing_id, @fmt.compress(reply || [""]).first)
+          @sock.send_to(routing_id, (reply || [""]).first)
         elsif config.echo
           output([display_routing_id(routing_id), *body])
-          @sock.send_to(routing_id, @fmt.compress(body).first || "")
+          @sock.send_to(routing_id, body.first || "")
         elsif config.data || config.file || !config.stdin_is_tty
           reply = read_next
           return false unless reply
           output([display_routing_id(routing_id), *body])
-          @sock.send_to(routing_id, @fmt.compress(reply).first || "")
+          @sock.send_to(routing_id, reply.first || "")
         end
         true
       end
@@ -66,7 +65,6 @@ module OMQ
             parts = recv_msg_raw
             break if parts.nil?
             routing_id = parts.shift
-            parts      = @fmt.decompress(parts)
             result = eval_recv_expr([display_routing_id(routing_id), *parts])
             output(result)
             i += 1
@@ -77,7 +75,7 @@ module OMQ
 
 
       def send_to_peer(id, parts)
-        @sock.send_to(id, @fmt.compress(parts).first || "")
+        @sock.send_to(id, parts.first || "")
       end
     end
   end

data/lib/omq/cli/config.rb

@@ -44,13 +44,13 @@ module OMQ
       :rcvbuf,
       :conflate,
       :compress,
-      :compress_in,
-      :compress_out,
+      :compress_level,
       :send_expr,
       :recv_expr,
       :parallel,
       :transient,
       :verbose,
+      :timestamps,
       :quiet,
       :echo,
       :scripts,

data/lib/omq/cli/expression_evaluator.rb

@@ -49,20 +49,23 @@ module OMQ
         return [result] if @format == :marshal
 
         result = result.is_a?(Array) ? result : [result]
-        result.map!(&:to_s)
+        result.map(&:to_s)
       rescue => e
         $stderr.puts "omq: eval error: #{e.message} (#{e.class})"
         exit 3
       end
 
 
-      # Normalises an eval result to nil (skip) or an Array of strings.
+      # Normalises an eval result to nil (skip) or an Array.
       # Used inside Ractor worker blocks where instance methods are unavailable.
+      # When +format+ is :marshal, arbitrary objects are preserved (wrapped
+      # in a one-element Array so the wire path can Marshal.dump them).
       #
-      def self.normalize_result(result)
+      def self.normalize_result(result, format: nil)
         return nil if result.nil?
+        return [result] if format == :marshal
         result = result.is_a?(Array) ? result : [result]
-        result.map!(&:to_s)
+        result.map(&:to_s)
       end
 
 

data/lib/omq/cli/formatter.rb

@@ -2,17 +2,14 @@
 
 module OMQ
   module CLI
-    # Raised when LZ4 decompression fails.
-    class DecompressError < RuntimeError; end
-
-    # Handles encoding/decoding messages in the configured format,
-    # plus optional LZ4 compression.
+    # 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)
-      # @param compress [Boolean] whether to apply LZ4 compression per frame
-      def initialize(format, compress: false)
-        @format   = format
-        @compress = compress
+      def initialize(format)
+        @format = format
       end
 
 
@@ -83,37 +80,20 @@ module OMQ
       end
 
 
-      # Compresses each frame with LZ4 if compression is enabled.
-      #
-      # @param parts [Array<String>] message frames
-      # @return [Array<String>] optionally compressed frames
-      def compress(parts)
-        @compress ? parts.map { |p| RLZ4.compress(p) if p } : parts
-      end
-
-
-      # Decompresses each frame with LZ4 if compression is enabled.
-      # nil/empty frames pass through — they were nil before send coercion.
-      #
-      # @param parts [Array<String>] possibly compressed message frames
-      # @return [Array<String>] decompressed frames
-      def decompress(parts)
-        @compress ? parts.map { |p| p && !p.empty? ? RLZ4.decompress(p) : p } : parts
-      rescue RLZ4::DecompressError
-        raise DecompressError, "decompression failed (did the sender use --compress?)"
-      end
-
-
       # Formats message parts for human-readable preview (logging).
+      # When +wire_size+ is given (ZMTP-Zstd negotiated), the header
+      # also shows the compressed on-the-wire size: "(29B wire=12B)".
       #
-      # @param parts [Array<String>] message frames
+      # @param parts [Array<String>] plaintext message frames
+      # @param wire_size [Integer, nil] compressed bytes on the wire
       # @return [String] truncated preview of each frame joined by |
-      def self.preview(parts)
+      def self.preview(parts, wire_size: nil)
         total  = parts.sum(&:bytesize)
         nparts = parts.size
         shown  = parts.first(3).map { |p| preview_frame(p) }
-        tail   = nparts > 3 ? "|..." : ""
-        header = nparts > 1 ? "(#{total}B #{nparts}F)" : "(#{total}B)"
+        tail   = nparts > 3 ? "|…" : ""
+        size   = wire_size ? "#{total}B wire=#{wire_size}B" : "#{total}B"
+        header = nparts > 1 ? "(#{size} #{nparts}F)" : "(#{size})"
 
         "#{header} #{shown.join("|")}#{tail}"
       end
@@ -133,7 +113,7 @@ module OMQ
         if printable < sample.bytesize / 2
           "[#{bytes.bytesize}B]"
         elsif bytes.bytesize > 12
-          "#{sample.gsub(/[^[:print:]]/, ".")}..."
+          "#{sample.gsub(/[^[:print:]]/, ".")}…"
         else
           sample.gsub(/[^[:print:]]/, ".")
         end