omq-cli 0.11.4 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eec1276bfcd012427b39e93126e9b5315ab548be7a65f5a98e6a3629b2bb158f
-  data.tar.gz: bc0019ca1bc43a0fb590fc751fb1618a2c4c24b48bdf01439d48b2d0bf59081d
+  metadata.gz: 24cc89ae4c000ff153c8277b140b6ebf58cdcb4b9c7ad73acfc86edb35341ade
+  data.tar.gz: 0ab5cd61e2cb7cba892eeb7fa92761d2dd057d0e3ffe5ae217d88e5dd222cf43
 SHA512:
-  metadata.gz: e53d6a22109b9a653847a3691534bca375c7975788acd505d2efed425d67468e6b277d57927e3e94b54ea79f08903a97d22993026ffa3e575cc57a5a30a12a09
-  data.tar.gz: 5d33c5a8ce29e04b9547c07099bd31c4ed7fd6f12c7cd179b659bf1dd39c6cca59e37762a7001f83bb44d8d45db4c5c4eebea05e3b7ec62397378e3dfd86705a
+  metadata.gz: 1b4857e0c3388e32a24e1b415132266af442308494c569a7c5441c8b0cff87a8c5e872cda9f48568a3416e9f5030a6dab66fdc309212000f6c00cb293b5a3925
+  data.tar.gz: 6de453e861b990520665178dbe0066e8b18372dc224985cc3f66b3356d0d172a0fd02a2286e70885c92ee2acd9e61eb809bc607e8079ae2565d41a79cb11ea6d

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.12.1 — 2026-04-10
+
+### Changed
+
+- **`it` replaces `$F` and `$_` in eval expressions.** The `-e`/`-E`
+  message parts variable is now Ruby's default block variable `it`
+  instead of the `$F` global. `$_` is removed — use `it.first` instead.
+  This also simplifies Ractor worker compilation by removing the
+  `$F` → `__F` rewrite.
+
+- **Block parameter syntax in `-e`/`-E` expressions.** Expressions can
+  now declare parameters like Ruby blocks: `-e '|msg| msg.map(&:upcase)'`.
+  A single parameter receives the whole parts array. Use `|(a, b)|` for
+  destructuring.
+
+### Added
+
+- **`@name` endpoint shorthand.** `-c@work` and `-b@sink` expand to
+  `ipc://@work` and `ipc://@sink` (Linux abstract namespace). Only
+  triggers when the value starts with `@` and has no `://` scheme.
+
+### Fixed
+
+- **Flaky FFI backend tests.** Wait for both REP peers to be connected
+  before round-robining requests, instead of only waiting for the first.
+
+- **Improved verbose preview format.** Empty frames render as `''`
+  instead of `[0B]`. Multipart messages show frame count: `(18B 4F)`.
+
+- **Compression skips nil/empty frames.** `compress` passes `nil` parts
+  through (coerced to empty frames by the socket layer). `decompress`
+  skips empty frames instead of feeding them to LZ4.
+
+- **Pipe `--out` without `--in` promotes bare endpoints.** Bare `-c`/`-b`
+  before `--out` are now treated as `--in` endpoints (and vice versa),
+  fixing `pipe -c SRC --out -c DST` which previously errored.
+
+- **Pipe fan-out distributes across output peers.** Multi-output pipes
+  now yield after each send, giving send-pump fibers a turn to drain the
+  shared queue. Without this, one pump monopolized the queue via
+  `drain_send_queue_capped` when messages arrived in bursts.
+
+- **Pipe waits for all output peers with `--timeout`.** `wait_for_peers_with_timeout`
+  now waits for `connection_count >= out_eps.size` instead of just the first peer.
+
 ## 0.11.4 — 2026-04-10
 
 ### Fixed

data/README.md

@@ -25,7 +25,7 @@ omq rep -b tcp://:5555 --echo
 echo "hello" | omq req -c tcp://localhost:5555
 
 # Upcase server — -e evals Ruby on each incoming message
-omq rep -b tcp://:5555 -e '$F.map(&:upcase)'
+omq rep -b tcp://:5555 -e 'it.map(&:upcase)'
 ```
 
 ```
@@ -44,7 +44,7 @@ Every socket needs at least one `--bind` or `--connect`:
 omq pull --bind tcp://:5557          # listen on port 5557
 omq push --connect tcp://host:5557   # connect to host
 omq pull -b ipc:///tmp/feed.sock     # IPC (unix socket)
-omq push -c ipc://@abstract          # IPC (abstract namespace, Linux)
+omq push -c@work                     # IPC abstract namespace (@name → ipc://@name)
 ```
 
 Multiple endpoints are allowed — `omq pull -b tcp://:5557 -b tcp://:5558` binds both.
@@ -82,7 +82,7 @@ omq pull -b tcp://:5557
 omq rep -b tcp://:5555 --echo
 
 # upcase server
-omq rep -b tcp://:5555 -e '$F.map(&:upcase)'
+omq rep -b tcp://:5555 -e 'it.map(&:upcase)'
 
 # client
 echo "hello" | omq req -c tcp://localhost:5555
@@ -115,7 +115,7 @@ omq router -b tcp://:5555
 omq router -b tcp://:5555 --target worker-1 -D "reply"
 
 # dynamic routing via send-eval (first element = identity)
-omq router -b tcp://:5555 -E '["worker-1", $_.upcase]'
+omq router -b tcp://:5555 -E '["worker-1", it.first.upcase]'
 ```
 
 `--target` and `--send-eval` are mutually exclusive on routing sockets.
@@ -125,10 +125,10 @@ omq router -b tcp://:5555 -E '["worker-1", $_.upcase]'
 Pipe creates an internal PULL → eval → PUSH pipeline:
 
 ```sh
-omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
+omq pipe -c@work -c@sink -e 'it.map(&:upcase)'
 
 # with Ractor workers for CPU parallelism
-omq pipe -c ipc://@work -c ipc://@sink -P 4 -r./fib.rb -e 'fib(Integer($_)).to_s'
+omq pipe -c@work -c@sink -P 4 -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).
@@ -139,12 +139,24 @@ Both must use `-c`.
 `-e` (alias `--recv-eval`) runs a Ruby expression for each **incoming** message.
 `-E` (alias `--send-eval`) runs a Ruby expression for each **outgoing** message.
 
-### Globals
+### Variables
 
 | Variable | Value |
 |----------|-------|
-| `$F` | Message parts (`Array<String>`) |
-| `$_` | First part (`$F.first`) — works in inline expressions |
+| `it` | Message parts (`Array<String>`) — Ruby's default block variable |
+
+### Block parameters
+
+Expressions support Ruby block parameter syntax. A single parameter receives
+the whole parts array; use `|(a, b)|` to destructure:
+
+```sh
+# single param = parts array
+omq pull -b tcp://:5557 -e '|msg| msg.map(&:upcase)'
+
+# destructure multipart messages
+omq pull -b tcp://:5557 -e '|(key, value)| "#{key}=#{value}"'
+```
 
 ### Return value
 
@@ -159,10 +171,10 @@ Both must use `-c`.
 
 ```sh
 # skip messages matching a pattern
-omq pull -b tcp://:5557 -e 'next if /^#/; $F'
+omq pull -b tcp://:5557 -e 'next if /^#/; it'
 
 # stop on "quit"
-omq pull -b tcp://:5557 -e 'break if /quit/; $F'
+omq pull -b tcp://:5557 -e 'break if /quit/; it'
 ```
 
 ### BEGIN/END blocks
@@ -170,7 +182,7 @@ omq pull -b tcp://:5557 -e 'break if /quit/; $F'
 Like awk — `BEGIN{}` runs once before the message loop, `END{}` runs after:
 
 ```sh
-omq pull -b tcp://:5557 -e 'BEGIN{ @sum = 0 } @sum += Integer($_); next END{ puts @sum }'
+omq pull -b tcp://:5557 -e 'BEGIN{ @sum = 0 } @sum += Integer(it.first); next END{ puts @sum }'
 ```
 
 Local variables won't work to share state between the blocks. Use `@ivars` instead.
@@ -191,23 +203,23 @@ Local variables won't work to share state between the blocks. Use `@ivars` inste
 
 ```sh
 # upcase echo server
-omq rep -b tcp://:5555 -e '$F.map(&:upcase)'
+omq rep -b tcp://:5555 -e 'it.map(&:upcase)'
 
 # transform before sending
-echo hello | omq push -c tcp://localhost:5557 -E '$F.map(&:upcase)'
+echo hello | omq push -c tcp://localhost:5557 -E 'it.map(&:upcase)'
 
 # filter incoming
-omq pull -b tcp://:5557 -e '$F.first.include?("error") ? $F : nil'
+omq pull -b tcp://:5557 -e 'it.first.include?("error") ? it : nil'
 
 # REQ: different transforms per direction
 echo hello | omq req -c tcp://localhost:5555 \
-  -E '$F.map(&:upcase)' -e '$F.map(&:reverse)'
+  -E 'it.map(&:upcase)' -e 'it.map(&:reverse)'
 
 # generate messages without stdin
 omq pub -c tcp://localhost:5556 -E 'Time.now.to_s' -i 1
 
 # use gems
-omq sub -c tcp://localhost:5556 -s "" -rjson -e 'JSON.parse($F.first)["temperature"]'
+omq sub -c tcp://localhost:5556 -s "" -rjson -e 'JSON.parse(it.first)["temperature"]'
 ```
 
 ## Script handlers (-r)
@@ -235,7 +247,7 @@ omq req -c tcp://localhost:5555 -r./handler.rb
 | `OMQ.outgoing { |msg| ... }` | Register outgoing message transform |
 | `OMQ.incoming { |msg| ... }` | Register incoming message transform |
 
-- use explicit block variable (like `msg`) instead of `$F`/`$_`
+- use explicit block variable (like `msg`) or `it`
 - Setup: use local variables and closures at the top of the script
 - Teardown: use Ruby's `at_exit { ... }`
 - CLI flags (`-e`/`-E`) override script-registered handlers for the same direction
@@ -243,7 +255,7 @@ omq req -c tcp://localhost:5555 -r./handler.rb
 
 ```sh
 # handler.rb registers recv_eval, CLI adds send_eval
-omq req -c tcp://localhost:5555 -r./handler.rb -E '$F.map(&:upcase)'
+omq req -c tcp://localhost:5555 -r./handler.rb -E 'it.map(&:upcase)'
 ```
 
 ### Script handler examples
@@ -415,7 +427,7 @@ omq router -b tcp://:5555
 omq router -b tcp://:5555 --target worker-1 -D "reply"
 
 # ROUTER dynamic routing via -E (first element = routing identity)
-omq router -b tcp://:5555 -E '["worker-1", $_.upcase]'
+omq router -b tcp://:5555 -E '["worker-1", it.first.upcase]'
 
 # binary routing IDs (0x prefix)
 omq router -b tcp://:5555 --target 0xdeadbeef -D "reply"
@@ -427,16 +439,16 @@ Pipe creates an in-process PULL → eval → PUSH pipeline:
 
 ```sh
 # basic pipe (positional: first = input, second = output)
-omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
+omq pipe -c@work -c@sink -e 'it.map(&:upcase)'
 
 # parallel Ractor workers (default: all CPUs)
-omq pipe -c ipc://@work -c ipc://@sink -P -r./fib.rb -e 'fib(Integer($_)).to_s'
+omq pipe -c@work -c@sink -P -r./fib.rb -e 'fib(Integer(it.first)).to_s'
 
 # fixed number of workers
-omq pipe -c ipc://@work -c ipc://@sink -P 4 -e '$F.map(&:upcase)'
+omq pipe -c@work -c@sink -P 4 -e 'it.map(&:upcase)'
 
 # exit when producer disconnects
-omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F.map(&:upcase)'
+omq pipe -c@work -c@sink --transient -e 'it.map(&:upcase)'
 ```
 
 ### Multi-peer pipe with `--in`/`--out`
@@ -446,16 +458,16 @@ Use `--in` and `--out` to attach multiple endpoints per side. These are modal sw
 
 ```sh
 # fan-in: 2 producers → 1 consumer
-omq pipe --in -c ipc://@work1 -c ipc://@work2 --out -c ipc://@sink -e '$F'
+omq pipe --in -c@work1 -c@work2 --out -c@sink -e 'it'
 
 # fan-out: 1 producer → 2 consumers (round-robin)
-omq pipe --in -b tcp://:5555 --out -c ipc://@sink1 -c ipc://@sink2 -e '$F'
+omq pipe --in -b tcp://:5555 --out -c@sink1 -c@sink2 -e 'it'
 
 # bind on input, connect on output
-omq pipe --in -b tcp://:5555 -b tcp://:5556 --out -c tcp://sink:5557 -e '$F'
+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 ipc://@a -c ipc://@b --out -c ipc://@sink -P 4 -e '$F'
+omq pipe --in -c@a -c@b --out -c@sink -P 4 -e 'it'
 ```
 
 `-P`/`--parallel` requires all endpoints to be `--connect`. In parallel mode, each Ractor worker
@@ -467,7 +479,7 @@ gets its own PULL/PUSH pair connecting to all endpoints.
 
 ```sh
 # worker exits when producer is done
-omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F.map(&:upcase)'
+omq pipe -c@work -c@sink --transient -e 'it.map(&:upcase)'
 
 # sink exits when all workers disconnect
 omq pull -b tcp://:5557 --transient

data/lib/omq/cli/cli_parser.rb

@@ -10,13 +10,13 @@ module OMQ
       EXAMPLES = <<~'TEXT'
         -- Request / Reply ------------------------------------------
 
-          +-----+  "hello"    +-----+
+          +-----+   "hello"    +-----+
           | REQ |------------->| REP |
           |     |<-------------|     |
-          +-----+  "HELLO"    +-----+
+          +-----+   "HELLO"    +-----+
 
           # terminal 1: echo server
-          omq rep --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
+          omq rep --bind tcp://:5555 --recv-eval 'it.map(&:upcase)'
 
           # terminal 2: send a request
           echo "hello" | omq req --connect tcp://localhost:5555
@@ -28,7 +28,7 @@ module OMQ
         -- Publish / Subscribe --------------------------------------
 
           +-----+  "weather.nyc 72F"  +-----+
-          | PUB |--------------------->| SUB | --subscribe "weather."
+          | PUB |-------------------->| SUB | --subscribe "weather."
           +-----+                     +-----+
 
           # terminal 1: subscriber (all topics by default)
@@ -39,25 +39,23 @@ module OMQ
 
         -- Periodic Publish -------------------------------------------
 
-          +-----+  "tick 1"    +-----+
+          +-----+   "tick 1"    +-----+
           | PUB |--(every 1s)-->| SUB |
-          +-----+              +-----+
+          +-----+               +-----+
 
           # terminal 1: subscriber
           omq sub --bind tcp://:5556
 
           # terminal 2: publish a tick every second (wall-clock aligned)
-          omq pub --connect tcp://localhost:5556 --delay 1 \
-            --data "tick" --interval 1
+          omq pub --connect tcp://localhost:5556 --delay 1 --data "tick" --interval 1
 
           # 5 ticks, then exit
-          omq pub --connect tcp://localhost:5556 --delay 1 \
-            --data "tick" --interval 1 --count 5
+          omq pub --connect tcp://localhost:5556 -d1 -D "tick" -i0.5 --count 5
 
         -- Pipeline -------------------------------------------------
 
           +------+           +------+
-          | PUSH |----------->| PULL |
+          | PUSH |---------->| PULL |
           +------+           +------+
 
           # terminal 1: worker
@@ -73,39 +71,38 @@ module OMQ
         -- Pipe (PULL -> eval -> PUSH) --------------------------------
 
           +------+         +------+         +------+
-          | PUSH |--------->| pipe |--------->| PULL |
+          | PUSH |-------->| pipe |-------->| PULL |
           +------+         +------+         +------+
 
           # terminal 1: producer
-          echo -e "hello\nworld" | omq push --bind ipc://@work
+          echo -e "hello\nworld" | omq push -b@work
 
           # terminal 2: worker -- uppercase each message
-          omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
+          omq pipe -c@work -c@sink -e 'it.map(&:upcase)'
           # terminal 3: collector
-          omq pull --bind ipc://@sink
+          omq pull -b@sink
 
           # 4 Ractor workers in a single process (-P)
-          omq pipe -c ipc://@work -c ipc://@sink -P4 -r./fib -e 'fib(Integer($_)).to_s'
+          omq pipe -c@work -c@sink -P4 -r./fib -e 'fib(it.first.to_i).to_s'
 
           # exit when producer disconnects (--transient)
-          omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F.map(&:upcase)'
+          omq pipe -c@work -c@sink --transient -e 'it.map(&:upcase)'
 
           # fan-in: multiple sources -> one sink
-          omq pipe --in -c ipc://@work1 -c ipc://@work2 \
-            --out -c ipc://@sink -e '$F.map(&:upcase)'
+          omq pipe --in -c@work1 -c@work2 --out -c@sink -e 'it.map(&:upcase)'
 
           # fan-out: one source -> multiple sinks (round-robin)
-          omq pipe --in -b tcp://:5555 --out -c ipc://@sink1 -c ipc://@sink2 -e '$F'
+          omq pipe --in -b tcp://:5555 --out -c@sink1 -c@sink2 -e 'it'
 
         -- CLIENT / SERVER (draft) ----------------------------------
 
-          +--------+  "hello"   +--------+
-          | CLIENT |------------>| SERVER | --recv-eval '$F.map(&:upcase)'
+          +--------+   "hello"   +--------+
+          | CLIENT |------------>| SERVER | --recv-eval 'it.map(&:upcase)'
           |        |<------------|        |
-          +--------+  "HELLO"   +--------+
+          +--------+   "HELLO"   +--------+
 
           # terminal 1: upcasing server
-          omq server --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
+          omq server --bind tcp://:5555 --recv-eval 'it.map(&:upcase)'
 
           # terminal 2: client
           echo "hello" | omq client --connect tcp://localhost:5555
@@ -127,9 +124,9 @@ module OMQ
 
         -- Compression ----------------------------------------------
 
-          # both sides must use --compress
+          # both sides must use --compress/-z
           omq pull --bind tcp://:5557 --compress &
-          echo "compressible data" | omq push --connect tcp://localhost:5557 --compress
+          echo "compressible data" | omq push --connect tcp://localhost:5557 -z
 
         -- CURVE Encryption -----------------------------------------
 
@@ -143,7 +140,7 @@ module OMQ
         -- ROUTER / DEALER ------------------------------------------
 
           +--------+          +--------+
-          | DEALER |---------->| ROUTER |
+          | DEALER |--------->| ROUTER |
           | id=w1  |          |        |
           +--------+          +--------+
 
@@ -156,25 +153,31 @@ module OMQ
         -- Ruby Eval ------------------------------------------------
 
           # filter incoming: only pass messages containing "error"
-          omq pull -b tcp://:5557 --recv-eval '$F.first.include?("error") ? $F : nil'
+          omq pull -b tcp://:5557 --recv-eval 'it.first.include?("error") ? it : nil'
 
           # transform incoming with gems
-          omq sub -c tcp://localhost:5556 -rjson -e 'JSON.parse($F.first)["temperature"]'
+          omq sub -c tcp://localhost:5556 -rjson -e 'JSON.parse(it.first)["temperature"]'
 
           # require a local file, use its methods
-          omq rep --bind tcp://:5555 --require ./transform.rb -e 'upcase_all($F)'
+          omq rep --bind tcp://:5555 --require ./transform.rb -e 'upcase_all(it)'
 
-          # next skips, break stops -- regexps match against $_
-          omq pull -b tcp://:5557 -e 'next if /^#/; break if /quit/; $F'
+          # next skips, break stops
+          omq pull -b tcp://:5557 -e 'next if it.first =~ /^#/; break if it.first =~ /quit/; it'
 
           # BEGIN/END blocks (like awk) -- accumulate and summarize
-          omq pull -b tcp://:5557 -e 'BEGIN{@sum = 0} @sum += Integer($_); nil END{puts @sum}'
+          omq pull -b tcp://:5557 -e 'BEGIN{@sum = 0} @sum += it.first.to_i; nil END{puts @sum}'
 
           # transform outgoing messages
-          echo hello | omq push -c tcp://localhost:5557 --send-eval '$F.map(&:upcase)'
+          echo hello | omq push -c tcp://localhost:5557 --send-eval 'it.map(&:upcase)'
 
           # REQ: transform request and reply independently
-          echo hello | omq req -c tcp://localhost:5555 -E '$F.map(&:upcase)' -e '$_'
+          echo hello | omq req -c tcp://localhost:5555 -E 'it.map(&:upcase)' -e 'it.first'
+
+          # block parameter: single param receives parts array
+          omq pull -b tcp://:5557 -e '|msg| msg.map(&:upcase)'
+
+          # destructure multipart messages with parens
+          omq pull -b tcp://:5557 -e '|(key, value)| "#{key}=#{value}"'
 
         -- Script Handlers (-r) ------------------------------------
 
@@ -185,7 +188,7 @@ module OMQ
           omq pull --bind tcp://:5557 -r./handler.rb
 
           # combine script handlers with inline eval
-          omq req -c tcp://localhost:5555 -r./handler.rb -E '$F.map(&:upcase)'
+          omq req -c tcp://localhost:5555 -r./handler.rb -E 'it.map(&:upcase)'
 
           # OMQ.outgoing { |msg| ... }   -- registered outgoing transform
           # OMQ.incoming { |msg| ... }   -- registered incoming transform
@@ -278,6 +281,7 @@ module OMQ
 
           o.separator "Connection:"
           o.on("-c", "--connect URL", "Connect to endpoint (repeatable)") { |v|
+            v = expand_endpoint(v)
             ep = Endpoint.new(v, false)
             case pipe_side
             when :in
@@ -290,6 +294,7 @@ module OMQ
             end
           }
           o.on("-b", "--bind URL", "Bind to endpoint (repeatable)") { |v|
+            v = expand_endpoint(v)
             ep = Endpoint.new(v, true)
             case pipe_side
             when :in
@@ -373,8 +378,8 @@ module OMQ
           end
 
           o.separator "\nProcessing (-e = incoming, -E = outgoing):"
-          o.on("-e", "--recv-eval EXPR", "Eval Ruby for each incoming message ($F = parts)") { |v| opts[:recv_expr] = v }
-          o.on("-E", "--send-eval EXPR", "Eval Ruby for each outgoing message ($F = parts)") { |v| opts[:send_expr] = v }
+          o.on("-e", "--recv-eval EXPR", "Eval Ruby for each incoming message (it = parts, or |a, b|)") { |v| opts[:recv_expr] = v }
+          o.on("-E", "--send-eval EXPR", "Eval Ruby for each outgoing message (it = parts, or |a, b|)") { |v| opts[:send_expr] = v }
           o.on("-r", "--require LIB",  "Require lib/file in Async context; use '-' for stdin. Scripts can register OMQ.outgoing/incoming") { |v|
             require "omq" unless defined?(OMQ::VERSION)
             opts[:scripts] << (v == "-" ? :stdin : (v.start_with?("./", "../") ? File.expand_path(v) : v))
@@ -495,6 +500,15 @@ module OMQ
         if type_name == "pipe"
           has_in_out = opts[:in_endpoints].any? || opts[:out_endpoints].any?
           if has_in_out
+            # Promote bare endpoints into the missing side:
+            # `pipe -c SRC --out -c DST` → bare SRC becomes --in
+            if opts[:in_endpoints].empty? && opts[:endpoints].any?
+              opts[:in_endpoints] = opts[:endpoints]
+              opts[:endpoints]    = []
+            elsif opts[:out_endpoints].empty? && opts[:endpoints].any?
+              opts[:out_endpoints] = opts[:endpoints]
+              opts[:endpoints]     = []
+            end
             abort "pipe --in requires at least one endpoint"             if opts[:in_endpoints].empty?
             abort "pipe --out requires at least one endpoint"            if opts[:out_endpoints].empty?
             abort "pipe: don't mix --in/--out with bare -b/-c endpoints" unless opts[:endpoints].empty?
@@ -543,6 +557,14 @@ module OMQ
       end
 
 
+      # Expands shorthand `@name` to `ipc://@name` (Linux abstract namespace).
+      # Only triggers when the value starts with `@` and has no `://` scheme.
+      #
+      def expand_endpoint(url)
+        url.start_with?("@") && !url.include?("://") ? "ipc://#{url}" : url
+      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.

data/lib/omq/cli/expression_evaluator.rb

@@ -26,16 +26,13 @@ module OMQ
 
         if src
           expr, begin_body, end_body = extract_blocks(src)
-          @begin_proc = eval("proc { #{begin_body} }") if begin_body # rubocop:disable Security/Eval
-          @end_proc   = eval("proc { #{end_body} }")   if end_body   # rubocop:disable Security/Eval
+          @begin_proc = eval("proc { #{begin_body} }") if begin_body
+          @end_proc   = eval("proc { #{end_body} }")   if end_body
           if expr && !expr.strip.empty?
-            @eval_proc = eval("proc { $_ = $F&.first; #{expr} }") # rubocop:disable Security/Eval
+            @eval_proc = eval("proc { #{expr} }")
           end
         elsif fallback_proc
-          @eval_proc = proc { |msg|
-            $_ = msg&.first
-            fallback_proc.call(msg)
-          }
+          @eval_proc = proc { fallback_proc.call(it) }
         end
       end
 
@@ -46,7 +43,6 @@ module OMQ
       def call(parts, context)
         return parts unless @eval_proc
 
-        $F     = parts
         result = context.instance_exec(parts, &@eval_proc)
         return nil  if result.nil?
         return SENT if result.equal?(context)
@@ -108,12 +104,11 @@ module OMQ
         expr, begin_body = extract.(src, "BEGIN")
         expr, end_body   = extract.(expr, "END")
 
-        begin_proc = eval("proc { #{begin_body} }") if begin_body # rubocop:disable Security/Eval
-        end_proc   = eval("proc { #{end_body} }")   if end_body   # rubocop:disable Security/Eval
+        begin_proc = eval("proc { #{begin_body} }") if begin_body
+        end_proc   = eval("proc { #{end_body} }")   if end_body
         eval_proc  = nil
         if expr && !expr.strip.empty?
-          ractor_expr = expr.gsub(/\$F\b/, "__F")
-          eval_proc   = eval("proc { |__F| $_ = __F&.first; #{ractor_expr} }") # rubocop:disable Security/Eval
+          eval_proc = eval("proc { #{expr} }")
         end
 
         [begin_proc, end_proc, eval_proc]

data/lib/omq/cli/formatter.rb

@@ -88,16 +88,17 @@ module OMQ
       # @param parts [Array<String>] message frames
       # @return [Array<String>] optionally compressed frames
       def compress(parts)
-        @compress ? parts.map { |p| RLZ4.compress(p) } : 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| RLZ4.decompress(p) } : 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
@@ -108,11 +109,13 @@ module OMQ
       # @param parts [Array<String>] message frames
       # @return [String] truncated preview of each frame joined by |
       def self.preview(parts)
-        total = parts.sum(&:bytesize)
-        shown = parts.first(3).map { |p| preview_frame(p) }
-        tail  = parts.size > 3 ? "|...(#{parts.size} parts)" : ""
+        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)"
 
-        "(#{total}B) #{shown.join("|")}#{tail}"
+        "#{header} #{shown.join("|")}#{tail}"
       end
 
 
@@ -122,7 +125,7 @@ module OMQ
         # string — otherwise joining with "|" would produce misleading
         # output like "|body" for REP/REQ-style envelopes where the first
         # wire frame is an empty delimiter.
-        return "[0B]" if bytes.empty?
+        return "''" if bytes.empty?
 
         sample    = bytes[0, 12]
         printable = sample.count("\x20-\x7e")

data/lib/omq/cli/pipe.rb

@@ -55,7 +55,7 @@ module OMQ
         wait_for_peers_with_timeout if config.timeout
         setup_sequential_transient(task)
         @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
-        sequential_message_loop
+        sequential_message_loop(fan_out: out_eps.size > 1)
         @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
       ensure
         @pull&.close
@@ -67,10 +67,13 @@ module OMQ
       # it, there's no point waiting: PULL#receive blocks naturally
       # and PUSH buffers up to send_hwm when no peer is present.
       def wait_for_peers_with_timeout
+        _, out_eps = resolve_endpoints
         Fiber.scheduler.with_timeout(config.timeout) do
           Barrier do |barrier|
-            barrier.async(annotation: "wait push peer") { @push.peer_connected.wait }
             barrier.async(annotation: "wait pull peer") { @pull.peer_connected.wait }
+            barrier.async(annotation: "wait push peers") do
+              sleep 0.01 until @push.connection_count >= out_eps.size
+            end
           end
         end
       end
@@ -98,7 +101,7 @@ module OMQ
       end
 
 
-      def sequential_message_loop
+      def sequential_message_loop(fan_out: false)
         n = config.count
         i = 0
         loop do
@@ -109,6 +112,12 @@ module OMQ
           if parts && !parts.empty?
             @push.send(@fmt_out.compress(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
         end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.11.4"
+    VERSION = "0.12.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 0.12.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -18,7 +18,7 @@ dependencies:
         version: '0.17'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.6
+        version: 0.17.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.17'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.6
+        version: 0.17.8
 - !ruby/object:Gem::Dependency
   name: omq-ffi
   requirement: !ruby/object:Gem::Requirement