omq 0.6.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94402697e206444e39655869c1382cea2a2839732d373d6cbcc237dcb125cd44
-  data.tar.gz: dbcaa10eb1213e935325d0290611716552d28394dd479d8fc79564a0af6f0e4d
+  metadata.gz: 852e5a45a7b9f61b32004aa2079e1289291c3ac2ecc5efeb78911d88d3b63b2e
+  data.tar.gz: b475a15807b8e98d4a852ec78b07ecaa4a0b15e68d3aec2fd9b2702533cb5d5f
 SHA512:
-  metadata.gz: 9a4b4eab9767b52f874bf85816589558bf42e9730da827220490e80ca9dd499ae5ae604c06022d3db07402042a1b52ea1c88737e2c1556b4d78af90391dc1d2f
-  data.tar.gz: e2db5e6aaea16af48024be90af8353a81f4d77a4b0b1973131f74dbd915b9aaf52fdd06d08cc57749ffb74b6bd70214ffb2ab04063925887c8a1b72afd4582cb
+  metadata.gz: 0afb8f440937ae11bebe4ce3ecc1df599103f27300ed721b14437d708bd1cba1cd5b0aeb6873bd7281d054c42f6353abc29b1c8c542f4708152c2ad6b047b5f0
+  data.tar.gz: b3477d54c520f7ed09dc4647b84841c9937d863036c4301afc3110bd959fd794bbd91db56d0204f317cd66ef62bf63ad8b1772521dc48f96912ae01e9bea8f81

data/CHANGELOG.md

@@ -1,5 +1,82 @@
 # Changelog
 
+## 0.8.0 — 2026-03-31
+
+### Breaking
+
+- **CURVE mechanism moved to protocol-zmtp** — `OMQ::ZMTP::Mechanism::Curve`
+  is now `Protocol::ZMTP::Mechanism::Curve` with a required `crypto:` parameter.
+  Pass `crypto: RbNaCl` (libsodium) or `crypto: Nuckle` (pure Ruby). The
+  omq-curve and omq-kurve gems are superseded.
+
+  ```ruby
+  # Before (omq-curve)
+  require "omq/curve"
+  rep.mechanism = OMQ::Curve.server(pub, sec)
+
+  # After (protocol-zmtp + any NaCl backend)
+  require "protocol/zmtp/mechanism/curve"
+  require "nuckle"  # or: require "rbnacl"
+  rep.mechanism = Protocol::ZMTP::Mechanism::Curve.server(pub, sec, crypto: Nuckle)
+  ```
+
+### Changed
+
+- **Protocol layer extracted into protocol-zmtp gem** — Codec (Frame,
+  Greeting, Command), Connection, Mechanism::Null, Mechanism::Curve,
+  ValidPeers, and Z85 now live in the
+  [protocol-zmtp](https://github.com/paddor/protocol-zmtp) gem. OMQ
+  re-exports them under `OMQ::ZMTP::` for backwards compatibility.
+  protocol-zmtp has zero runtime dependencies.
+- **Unified CURVE mechanism** — one implementation with a pluggable
+  `crypto:` backend replaces the two near-identical copies in omq-curve
+  (RbNaCl) and omq-kurve (Nuckle). 1,088 → 467 lines (57% reduction).
+- **Heartbeat ownership** — `Connection#start_heartbeat` removed.
+  Connection tracks timestamps only; the engine drives the PING/PONG loop.
+- **CI no longer needs libsodium** — CURVE tests use
+  [nuckle](https://github.com/paddor/nuckle) (pure Ruby) by default.
+  Cross-backend interop tests run when rbnacl is available.
+
+## 0.7.0 — 2026-03-30
+
+### Breaking
+
+- **`-e` is now `--recv-eval`** — evaluates incoming messages only.
+  Send-only sockets (PUSH, PUB, SCATTER, RADIO) must use `-E` /
+  `--send-eval` instead of `-e`.
+
+### Added
+
+- **`-E` / `--send-eval`** — eval Ruby for each outgoing message.
+  REQ can now transform requests independently from replies.
+  ROUTER/SERVER/PEER: `-E` does dynamic routing (first element =
+  identity), mutually exclusive with `--target`.
+- **`OMQ.outgoing` / `OMQ.incoming`** — registration API for script
+  handlers loaded via `-r`. Blocks receive message parts as a block
+  argument (`|msg|`). Setup via closures, teardown via `at_exit`.
+  CLI flags override registered handlers.
+- **[CLI.md](CLI.md)** — comprehensive CLI documentation.
+- **[GETTING_STARTED.md](GETTING_STARTED.md)** — renamed from
+  `ZGUIDE_SUMMARY.md` for discoverability.
+- **Multi-peer pipe with `--in`/`--out`** — modal switches that assign
+  subsequent `-b`/`-c` to the PULL (input) or PUSH (output) side.
+  Enables fan-in, fan-out, and mixed bind/connect per side.
+  Backward compatible — without `--in`/`--out`, the positional
+  2-endpoint syntax works as before.
+
+### Improved
+
+- **YJIT recv pump** — replaced lambda/proc `transform:` parameter in
+  `Engine#start_recv_pump` with block captures. No-transform path
+  (PUSH/PULL, PUB/SUB) is now branch-free. ~2.5x YJIT speedup on
+  inproc, ~2x on ipc/tcp.
+
+### Fixed
+
+- **Frozen array from `recv_msg_raw`** — ROUTER/SERVER receiver crashed
+  with `FrozenError` when shifting identity off frozen message arrays.
+  `#recv_msg_raw` now dups the array.
+
 ## 0.6.5 — 2026-03-30
 
 ### Fixed
@@ -462,4 +539,4 @@ Initial release. Pure Ruby implementation of ZMTP 3.1 (ZeroMQ) using Async.
 - Linger on close (drain send queue before closing)
 - `max_message_size` enforcement
 - Works inside Async reactors or standalone (shared IO thread)
-- Optional CURVE encryption via the [omq-curve](https://github.com/zeromq/omq-curve) gem
+- Optional CURVE encryption via the [protocol-zmtp](https://github.com/paddor/protocol-zmtp) gem

data/README.md

@@ -1,39 +1,44 @@
-# OMQ! Where did the C dependency go?!
+# OMQ — ZeroMQ in pure Ruby
 
 [![CI](https://github.com/zeromq/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq/actions/workflows/ci.yml)
 [![Gem Version](https://img.shields.io/gem/v/omq?color=e9573f)](https://rubygems.org/gems/omq)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
 
-Pure Ruby implementation of the [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) wire protocol ([ZeroMQ](https://zeromq.org/)) using the [Async](https://github.com/socketry/async) gem. No native libraries required.
+`gem install omq` — that's it. No libzmq, no compiler, no system packages. Just Ruby.
 
-> **244k msg/s** inproc | **47k msg/s** ipc | **36k msg/s** tcp
+OMQ implements the [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) wire protocol from scratch using [Async](https://github.com/socketry/async) fibers. It speaks native ZeroMQ on the wire and interoperates with libzmq, pyzmq, CZMQ, and everything else in the ZMQ ecosystem.
+
+> **234k msg/s** inproc | **49k msg/s** ipc | **36k msg/s** tcp
 >
-> **9 µs** inproc latency | **47 µs** ipc | **61 µs** tcp
+> **12 µs** inproc latency | **51 µs** ipc | **62 µs** tcp
 >
-> Ruby 4.0 + YJIT on a Linux VM on a 2019 MacBook Pro (Intel) — [~340k msg/s with io_uring](bench/README.md#io_uring)
+> Ruby 4.0 + YJIT on a Linux VM — see [`bench/`](bench/) for full results
 
 ---
 
-## Highlights
+## What is ZeroMQ?
+
+Brokerless message-oriented middleware. No central server, no extra hop — processes talk directly to each other, cutting latency in half compared to broker-based systems. You get the patterns you'd normally build on top of RabbitMQ or Redis — pub/sub, work distribution, request/reply, fan-out — but decentralized, with no single point of failure.
 
-- **Pure Ruby** — no C extensions, no FFI, no libzmq/libczmq dependency
-- **All socket types** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair + draft types (client/server, radio/dish, scatter/gather, peer, channel)
-- **Async-native** — built on [Async](https://github.com/socketry/async) fibers, also works with plain threads
-- **Ruby-idiomatic API** — messages as `Array<String>`, errors as exceptions, timeouts as `IO::TimeoutError`
-- **All transports** — tcp, ipc, inproc
+Networking is hard. ZeroMQ abstracts away reconnection, queuing, load balancing, and framing so you can focus on what your system actually does. Start with threads talking over `inproc://`, split into processes with `ipc://`, scale across machines with `tcp://` — same code, same API, just change the URL.
 
-## Why pure Ruby?
+If you've ever wired up services with raw TCP, HTTP polling, or Redis pub/sub and wished it was simpler, this is what you've been looking for.
 
-Modern Ruby has closed the gap:
+See [GETTING_STARTED.md](GETTING_STARTED.md) for a ~30 min walkthrough of all major patterns with working code.
 
-- **YJIT** — JIT-compiled hot paths close the throughput gap with C extensions
-- **Fiber Scheduler** — non-blocking I/O without callbacks or threads (`Async` builds on this)
-- **`io-stream`** — buffered I/O with read-ahead, from the Async ecosystem
+## Highlights
 
-When [CZTop](https://github.com/paddor/cztop) was written, none of this existed. Today, a pure Ruby ZMTP implementation is fast enough for production use — and you get `gem install` with no compiler toolchain, no system packages, and no segfaults.
+- **Zero dependencies on C** — no extensions, no FFI, no libzmq. `gem install` just works everywhere
+- **Fast** — YJIT-optimized hot paths, batched sends, 234k msg/s inproc with 12 µs latency
+- **`omq` CLI** — pipe, filter, and transform messages from the terminal with Ruby eval, Ractor parallelism, and [script handlers](CLI.md#script-handlers--r)
+- **Every socket pattern** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair, and all draft types
+- **Every transport** — tcp, ipc (Unix domain sockets), inproc (in-process queues)
+- **Async-native** — built on fibers, non-blocking from the ground up. A shared IO thread handles sockets outside of Async — no reactor needed for simple scripts
+- **Wire-compatible** — interoperates with libzmq, pyzmq, CZMQ over tcp and ipc
+- **Bind/connect order doesn't matter** — connect before bind, bind before connect, peers come and go. ZeroMQ reconnects and requeues automatically
 
-See [DESIGN.md](DESIGN.md) for architecture details: task trees, send pump batching, the ZMTP wire protocol, and how OMQ handles the fallacies of distributed computing.
+For architecture internals, see [DESIGN.md](DESIGN.md).
 
 ## Install
 
@@ -45,10 +50,6 @@ gem install omq
 gem 'omq'
 ```
 
-## Learning ZeroMQ
-
-New to ZeroMQ? See [ZGUIDE_SUMMARY.md](ZGUIDE_SUMMARY.md) — a ~30 min read covering all major patterns with working OMQ code examples.
-
 ## Quick Start
 
 ### Request / Reply
@@ -67,7 +68,7 @@ Async do |task|
   end
 
   req << 'hello'
-  puts req.receive.inspect  # => ["HELLO"]
+  p req.receive  # => ["HELLO"]
 ensure
   req&.close
   rep&.close
@@ -83,7 +84,7 @@ Async do |task|
   sub.subscribe('')  # subscribe to all
 
   task.async { pub << 'news flash' }
-  puts sub.receive.inspect  # => ["news flash"]
+  p sub.receive  # => ["news flash"]
 ensure
   pub&.close
   sub&.close
@@ -98,51 +99,56 @@ Async do
   pull = OMQ::PULL.bind('inproc://pipeline')
 
   push << 'work item'
-  puts pull.receive.inspect  # => ["work item"]
+  p pull.receive  # => ["work item"]
 ensure
   push&.close
   pull&.close
 end
 ```
 
-## Socket Types
+### Without Async (IO thread)
 
-| Pattern | Classes | Direction | Multipart |
-|---------|---------|-----------|-----------|
-| Request/Reply | `REQ`, `REP` | bidirectional | yes |
-| Publish/Subscribe | `PUB`, `SUB`, `XPUB`, `XSUB` | unidirectional | yes |
-| Pipeline | `PUSH`, `PULL` | unidirectional | yes |
-| Routing | `DEALER`, `ROUTER` | bidirectional | yes |
-| Exclusive pair | `PAIR` | bidirectional | yes |
-| Client/Server | `CLIENT`, `SERVER` | bidirectional | no |
-| Group messaging | `RADIO`, `DISH` | unidirectional | no |
-| Pipeline (draft) | `SCATTER`, `GATHER` | unidirectional | no |
-| Peer-to-peer | `PEER` | bidirectional | no |
-| Channel (draft) | `CHANNEL` | bidirectional | no |
-
-All classes live under `OMQ::`. For the purists, `ØMQ` is an alias:
+OMQ spawns a shared `omq-io` thread when used outside an Async reactor — no boilerplate needed:
 
 ```ruby
-req = ØMQ::REQ.new(">tcp://localhost:5555")
+require 'omq'
+
+push = OMQ::PUSH.bind('tcp://127.0.0.1:5557')
+pull = OMQ::PULL.connect('tcp://127.0.0.1:5557')
+
+push << 'hello'
+p pull.receive  # => ["hello"]
+
+push.close
+pull.close
 ```
 
-## Performance
+The IO thread runs all pumps, reconnection, and heartbeating in the background. When you're inside an `Async` block, OMQ uses the existing reactor instead.
 
-Benchmarked with benchmark-ips on Linux x86_64 (Ruby 4.0.2 +YJIT):
+## Socket Types
 
-#### Throughput (push/pull, 64 B messages)
+All sockets are thread-safe. Default HWM is 1000 messages per socket. Classes live under `OMQ::` (alias: `ØMQ`).
 
-| inproc | ipc | tcp |
-|--------|-----|-----|
-| 244k/s | 47k/s | 36k/s |
+#### Standard (multipart messages)
 
-#### Latency (req/rep roundtrip)
+| Pattern | Send | Receive | When HWM full |
+|---------|------|---------|---------------|
+| **REQ** / **REP** | Round-robin / route-back | Fair-queue | Block |
+| **PUB** / **SUB** | Fan-out to subscribers | Subscription filter | Drop |
+| **PUSH** / **PULL** | Round-robin to workers | Fair-queue | Block |
+| **DEALER** / **ROUTER** | Round-robin / identity-route | Fair-queue | Block |
+| **XPUB** / **XSUB** | Fan-out (subscription events) | Fair-queue | Drop |
+| **PAIR** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
 
-| inproc | ipc | tcp |
-|--------|-----|-----|
-| 9 µs | 47 µs | 61 µs |
+#### Draft (single-frame only)
 
-See [`bench/`](bench/) for full results and scripts.
+| Pattern | Send | Receive | When HWM full |
+|---------|------|---------|---------------|
+| **CLIENT** / **SERVER** | Round-robin / routing-ID | Fair-queue | Block |
+| **RADIO** / **DISH** | Group fan-out | Group filter | Drop |
+| **SCATTER** / **GATHER** | Round-robin | Fair-queue | Block |
+| **PEER** | Routing-ID | Fair-queue | Block |
+| **CHANNEL** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
 
 ## omq — CLI tool
 
@@ -152,7 +158,7 @@ See [`bench/`](bench/) for full results and scripts.
 # Echo server
 omq rep -b tcp://:5555 --echo
 
-# Upcase server in one line
+# Upcase server — -e evals Ruby on each incoming message
 omq rep -b tcp://:5555 -e '$F.map(&:upcase)'
 
 # Client
@@ -163,50 +169,39 @@ echo "hello" | omq req -c tcp://localhost:5555
 omq sub -b tcp://:5556 -s "weather."  &
 echo "weather.nyc 72F" | omq pub -c tcp://localhost:5556 -d 0.3
 
-# Pipeline with filtering ($F = message parts, $_ = first part)
-# /regexp/ matches against $_, next skips, break stops
+# Pipeline with filtering
 tail -f /var/log/syslog | omq push -c tcp://collector:5557
 omq pull -b tcp://:5557 -e 'next unless /error/; $F'
 
+# Transform outgoing messages with -E
+echo hello | omq push -c tcp://localhost:5557 -E '$F.map(&:upcase)'
+
+# REQ: transform request and reply independently
+echo hello | omq req -c tcp://localhost:5555 \
+  -E '$F.map(&:upcase)' -e '$F.map(&:reverse)'
+
 # Pipe: PULL → eval → PUSH in one process
 omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
 
 # Pipe with Ractor workers for CPU parallelism (-P = all CPUs)
 omq pipe -c ipc://@work -c ipc://@sink -P -r./fib -e 'fib(Integer($_)).to_s'
+```
 
-# Exit when all peers disconnect (pipeline workers, sinks)
-omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F'
-
-# JSONL for structured data
-echo '["key","value"]' | omq push -c tcp://localhost:5557 -J
-omq pull -b tcp://:5557 -J
+`-e` (recv-eval) transforms incoming messages, `-E` (send-eval) transforms outgoing messages. `$F` is the message parts array, `$_` is the first part. Use `-r` to require gems or load scripts that register handlers via `OMQ.incoming` / `OMQ.outgoing`:
 
-# Zstandard compression
-omq push -c tcp://remote:5557 -z < data.txt
-omq pull -b tcp://:5557 -z
+```ruby
+# my_handler.rb
+db = DB.connect("postgres://localhost/app")
 
-# CURVE encryption
-omq rep -b tcp://:5555 -D "secret" --curve-server
-# prints: OMQ_SERVER_KEY='...'
-omq req -c tcp://localhost:5555 --curve-server-key '...'
+OMQ.incoming { db.query($F.first) }
+at_exit { db.close }
 ```
 
-The `-e` flag runs Ruby inside the socket instance — the full socket API (`self <<`, `send`, `subscribe`, ...) is available. `$F` is the message parts array, `$_` is the first part. Use `-r` to require gems:
-
 ```sh
-omq sub -c tcp://localhost:5556 -s "" -r json \
-  -e 'JSON.parse($F.first)["temperature"]'
-
-# BEGIN/END blocks (like awk) — accumulate and summarize
-omq pull -b tcp://:5557 \
-  -e 'BEGIN{ @sum = 0 } @sum += Integer($_); next END{ puts @sum }'
+omq pull -b tcp://:5557 -r./my_handler.rb
 ```
 
-Formats: `--ascii` (default, tab-separated), `--quoted`, `--raw`, `--jsonl`, `--msgpack`, `--marshal`. See `omq --help` for all options.
-
-## Interop with native ZMQ
-
-OMQ speaks ZMTP 3.1 on the wire and interoperates with libzmq, CZMQ, pyzmq, etc. over **tcp** and **ipc**. The `inproc://` transport is OMQ-internal (in-process Ruby queues) and is not visible to native ZMQ running in the same process — use `ipc://` to talk across library boundaries.
+See [CLI.md](CLI.md) for full documentation, or `omq --help` / `omq --examples`.
 
 ## Development
 

data/lib/omq/cli/base_runner.rb

@@ -28,9 +28,11 @@ module OMQ
         sleep(config.delay) if config.delay && config.recv_only?
         wait_for_peer if needs_peer_wait?
 
-        @sock.instance_exec(&@begin_proc) if @begin_proc
+        @sock.instance_exec(&@send_begin_proc) if @send_begin_proc
+        @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
         run_loop(task)
-        @sock.instance_exec(&@end_proc) if @end_proc
+        @sock.instance_exec(&@send_end_proc) if @send_end_proc
+        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
       ensure
         @sock&.close
       end
@@ -201,19 +203,19 @@ module OMQ
             end
           end
         elsif config.data || config.file
-          parts = eval_expr(read_next)
+          parts = eval_send_expr(read_next)
           send_msg(parts) if parts
         elsif stdin_ready?
           loop do
             parts = read_next
             break unless parts
-            parts = eval_expr(parts)
+            parts = eval_send_expr(parts)
             send_msg(parts) if parts
             i += 1
             break if n && n > 0 && i >= n
           end
-        elsif @eval_proc
-          parts = eval_expr(nil)
+        elsif @send_eval_proc
+          parts = eval_send_expr(nil)
           send_msg(parts) if parts
         end
       end
@@ -221,11 +223,11 @@ module OMQ
 
       def send_tick
         raw = read_next_or_nil
-        if raw.nil? && !@eval_proc
+        if raw.nil? && !@send_eval_proc
           @send_tick_eof = true
           return 0
         end
-        parts = eval_expr(raw)
+        parts = eval_send_expr(raw)
         send_msg(parts) if parts
         1
       end
@@ -237,7 +239,7 @@ module OMQ
         loop do
           parts = recv_msg
           break if parts.nil?
-          parts = eval_expr(parts)
+          parts = eval_recv_expr(parts)
           output(parts)
           i += 1
           break if n && n > 0 && i >= n
@@ -246,7 +248,7 @@ module OMQ
 
 
       def wait_for_loops(receiver, sender)
-        if config.data || config.file || config.expr || config.target
+        if config.data || config.file || config.send_expr || config.recv_expr || config.target
           sender.wait
           receiver.stop
         elsif config.count && config.count > 0
@@ -281,7 +283,8 @@ module OMQ
 
 
       def recv_msg_raw
-        @sock.receive
+        msg = @sock.receive
+        msg&.dup
       end
 
 
@@ -320,7 +323,7 @@ module OMQ
       def read_next_or_nil
         if config.data || config.file
           read_next
-        elsif @eval_proc
+        elsif @send_eval_proc
           nil
         else
           read_next
@@ -358,11 +361,30 @@ module OMQ
 
 
       def compile_expr
-        return unless config.expr
-        expr, begin_body, end_body = extract_blocks(config.expr)
-        @begin_proc = eval("proc { #{begin_body} }") if begin_body
-        @end_proc   = eval("proc { #{end_body} }")   if end_body
-        @eval_proc  = eval("proc { $_ = $F&.first; #{expr} }") if expr && !expr.strip.empty?
+        compile_one_expr(:send, config.send_expr)
+        compile_one_expr(:recv, config.recv_expr)
+        @send_eval_proc ||= wrap_registered_proc(OMQ.outgoing_proc)
+        @recv_eval_proc ||= wrap_registered_proc(OMQ.incoming_proc)
+      end
+
+
+      def wrap_registered_proc(block)
+        return unless block
+        proc do |msg|
+          $_ = msg&.first
+          block.call(msg)
+        end
+      end
+
+
+      def compile_one_expr(direction, src)
+        return unless src
+        expr, begin_body, end_body = extract_blocks(src)
+        instance_variable_set(:"@#{direction}_begin_proc", eval("proc { #{begin_body} }")) if begin_body
+        instance_variable_set(:"@#{direction}_end_proc",   eval("proc { #{end_body} }"))   if end_body
+        if expr && !expr.strip.empty?
+          instance_variable_set(:"@#{direction}_eval_proc", eval("proc { $_ = $F&.first; #{expr} }"))
+        end
       end
 
 
@@ -398,10 +420,21 @@ module OMQ
 
       SENT = Object.new.freeze # sentinel: eval already sent the reply
 
-      def eval_expr(parts)
-        return parts unless @eval_proc
+      def eval_send_expr(parts)
+        return parts unless @send_eval_proc
+        run_eval(@send_eval_proc, parts)
+      end
+
+
+      def eval_recv_expr(parts)
+        return parts unless @recv_eval_proc
+        run_eval(@recv_eval_proc, parts)
+      end
+
+
+      def run_eval(eval_proc, parts)
         $F = parts
-        result = @sock.instance_exec(&@eval_proc)
+        result = @sock.instance_exec(parts, &eval_proc)
         return nil if result.nil?
         return SENT if result.equal?(@sock)
         return [result] if config.format == :marshal
@@ -411,7 +444,7 @@ module OMQ
         else             [result.to_str]
         end
       rescue => e
-        $stderr.puts "omq: -e error: #{e.message} (#{e.class})"
+        $stderr.puts "omq: eval error: #{e.message} (#{e.class})"
         exit 3
       end
 

data/lib/omq/cli/client_server.rb

@@ -11,7 +11,7 @@ module OMQ
 
 
       def run_loop(task)
-        if config.echo || config.expr || config.data || config.file || !config.stdin_is_tty
+        if config.echo || config.recv_expr || @recv_eval_proc || config.data || config.file || !config.stdin_is_tty
           reply_loop
         else
           monitor_loop(task)
@@ -28,8 +28,8 @@ module OMQ
           routing_id = parts.shift
           body       = @fmt.decompress(parts)
 
-          if config.expr
-            reply = eval_expr(body)
+          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)
           elsif config.echo
@@ -56,7 +56,7 @@ module OMQ
             break if parts.nil?
             routing_id = parts.shift
             parts      = @fmt.decompress(parts)
-            result = eval_expr([display_routing_id(routing_id), *parts])
+            result = eval_recv_expr([display_routing_id(routing_id), *parts])
             output(result)
             i += 1
             break if n && n > 0 && i >= n
@@ -71,18 +71,18 @@ module OMQ
             Async::Loop.quantized(interval: config.interval) do
               parts = read_next
               break unless parts
-              send_targeted_or_plain(parts)
+              send_targeted_or_eval(parts)
               i += 1
               break if n && n > 0 && i >= n
             end
           elsif config.data || config.file
             parts = read_next
-            send_targeted_or_plain(parts) if parts
+            send_targeted_or_eval(parts) if parts
           else
             loop do
               parts = read_next
               break unless parts
-              send_targeted_or_plain(parts)
+              send_targeted_or_eval(parts)
               i += 1
               break if n && n > 0 && i >= n
             end
@@ -93,8 +93,13 @@ module OMQ
       end
 
 
-      def send_targeted_or_plain(parts)
-        if config.target
+      def send_targeted_or_eval(parts)
+        if @send_eval_proc
+          parts = eval_send_expr(parts)
+          return unless parts
+          routing_id = resolve_target(parts.shift)
+          @sock.send_to(routing_id, @fmt.compress(parts).first || "")
+        elsif config.target
           parts = @fmt.compress(parts)
           @sock.send_to(resolve_target(config.target), parts.first || "")
         else

data/lib/omq/cli/config.rb

@@ -2,6 +2,9 @@
 
 module OMQ
   module CLI
+    SEND_ONLY = %w[pub push scatter radio].freeze
+    RECV_ONLY = %w[sub pull gather dish].freeze
+
     Endpoint = Data.define(:url, :bind?) do
       def connect? = !bind?
     end
@@ -12,6 +15,8 @@ module OMQ
       :endpoints,
       :connects,
       :binds,
+      :in_endpoints,
+      :out_endpoints,
       :data,
       :file,
       :format,
@@ -29,7 +34,8 @@ module OMQ
       :heartbeat_ivl,
       :conflate,
       :compress,
-      :expr,
+      :send_expr,
+      :recv_expr,
       :parallel,
       :transient,
       :verbose,
@@ -41,9 +47,6 @@ module OMQ
       :has_zstd,
       :stdin_is_tty,
     ) do
-      SEND_ONLY = %w[pub push scatter radio].freeze
-      RECV_ONLY = %w[sub pull gather dish].freeze
-
       def send_only? = SEND_ONLY.include?(type_name)
       def recv_only? = RECV_ONLY.include?(type_name)
     end

data/lib/omq/cli/pair.rb

@@ -13,7 +13,7 @@ module OMQ
           loop do
             parts = recv_msg
             break if parts.nil?
-            parts = eval_expr(parts)
+            parts = eval_recv_expr(parts)
             output(parts)
             i += 1
             break if n && n > 0 && i >= n