omq-cli 0.5.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c1b5dcd4986d66825e3111c70c7fdafacc726e0561974b134942365bc91513a
-  data.tar.gz: df996f5b87e3edbb171e4cbfc3ecdc64d6b6bd05d7e3d44dcab90d08b903ea58
+  metadata.gz: 8e3472d73b7d467c20072e00da82aa7222c1cc99cc99e4147f833cb010422e11
+  data.tar.gz: 0d2f5fff5723cc45af838de506d92d47581dbb24feb302d63b297565393cd182
 SHA512:
-  metadata.gz: abb90ac13df5ce70438110572e462e51420d2a3d8c9c3cc766a00bf2c1897952e6d75a4c7bd219c5c5cc25ef6ab5dafaea62ec6ebb3ed14633d70343a6edebd5
-  data.tar.gz: c86bae0d3eea9a489d6be29ad49a3eea56a0e6bc93dc62506d321a1ab84d7f61b8e6dbd9779805d365fcd85f6f213055ec2d0c41b84333ec26c65c56d8095e5a
+  metadata.gz: 10001c2717aded533e3c902c481d34bf5a6870e55207cec33b04c7043f7f19cfb71c68f99f467554ca619cebba352a6258bc634538d781caeeefb76cc0813b18
+  data.tar.gz: 1fd287acb7bd0fb85d7c260a74c7ef32208c4893b819f780e1a9b05e3ea7219619a4b00e41847ae03a2a5cb1356348416e17d4e74f1a5cb4c8fcf42cd5741013

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 0.7.0 — 2026-04-07
+
+### Changed
+
+- **`-P` restricted to pipe only** — parallel Ractor workers are no longer
+  available on recv-only socket types (pull, sub, gather, dish). Pipe workers
+  now use bare Ractors with their own Async reactors and OMQ sockets, removing
+  the `omq-ractor` dependency entirely.
+- **`-P` range capped to 1..16** — default is still `nproc`, clamped to 16.
+  `-P 1` is valid (single Ractor worker, no sockets on main thread).
+- **Removed `omq-ractor` dependency** — no longer needed.
+- **Removed `ParallelRecvRunner`** — the Ractor bridge infrastructure for
+  non-pipe socket types has been deleted.
+
+### Fixed
+
+- **Pipe `-P` END blocks execute after timeout** — worker recv loops now
+  catch `IO::TimeoutError` so BEGIN/END expressions run to completion.
+
+## 0.6.0 — 2026-04-07
+
+### Added
+
+- **Modal `--compress` for pipe `--in`/`--out`** — `--compress` after `--in`
+  decompresses input, after `--out` compresses output. Enables mixed pipelines
+  like plain input → compressed output:
+  `omq pipe --in -c src --out --compress -c dst`.
+  Without `--in`/`--out`, `--compress` applies to both directions as before.
+
+### Fixed
+
+- **Abort with clear message on decompression failure** — receiving an
+  uncompressed message with `--compress` now prints a hint instead of
+  silently killing the Async task with exit code 0.
+
 ## 0.5.4 — 2026-04-07
 
 ### Fixed

data/lib/omq/cli/base_runner.rb

@@ -51,7 +51,7 @@ module OMQ
 
       def setup_socket
         @sock = create_socket
-        attach_endpoints unless config.parallel
+        attach_endpoints
         setup_curve
         setup_subscriptions
         compile_expr
@@ -265,17 +265,6 @@ module OMQ
       end
 
 
-      # Parallel recv-eval: delegates to ParallelRecvRunner.
-      #
-      def run_parallel_recv(task)
-        # @sock was created by call() before run_loop; close it now so it doesn't
-        # steal messages from the N worker sockets ParallelRecvRunner creates.
-        @sock&.close
-        @sock = nil
-        ParallelRecvRunner.new(@klass, config, @fmt, method(:output)).run(task)
-      end
-
-
       def wait_for_loops(receiver, sender)
         if config.data || config.file || config.send_expr || config.recv_expr || config.target
           sender.wait

data/lib/omq/cli/cli_parser.rb

@@ -219,6 +219,8 @@ module OMQ
         rcvbuf:           nil,
         conflate:         false,
         compress:         false,
+        compress_in:      false,
+        compress_out:     false,
         send_expr:        nil,
         recv_expr:        nil,
         parallel:         nil,
@@ -346,7 +348,17 @@ module OMQ
           o.on("--conflate", "Keep only last message per subscriber (PUB/RADIO)") { opts[:conflate] = true }
 
           o.separator "\nCompression:"
-          o.on("-z", "--compress", "Zstandard compression per frame") { require "zstd-ruby"; opts[:compress] = true }
+          o.on("-z", "--compress", "Zstandard compression per frame (modal with --in/--out)") do
+            require "zstd-ruby"
+            case pipe_side
+            when :in
+              opts[:compress_in] = true
+            when :out
+              opts[:compress_out] = true
+            else
+              opts[:compress] = true
+            end
+          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 }
@@ -355,9 +367,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 (default: nproc); for non-pipe requires --recv-eval") { |v|
+          o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers for pipe (default: nproc, max 16)") { |v|
             require "etc"
-            opts[:parallel] = v || Etc.nprocessors
+            opts[:parallel] = [v || Etc.nprocessors, 16].min
           }
 
           o.separator "\nCURVE encryption (requires system libsodium):"
@@ -474,16 +486,10 @@ module OMQ
         abort "--send-eval and --target are mutually exclusive"  if opts[:send_expr] && opts[:target]
 
         if opts[:parallel]
-          abort "-P/--parallel must be >= 2" if opts[:parallel] < 2
-          if type_name == "pipe"
-            all_pipe_eps = opts[:in_endpoints] + opts[:out_endpoints] + opts[:endpoints]
-            abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if all_pipe_eps.any?(&:bind?)
-          elsif RECV_ONLY.include?(type_name)
-            abort "-P/--parallel on #{type_name} requires --recv-eval (-e)" unless opts[:recv_expr]
-            abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if opts[:binds].any?
-          else
-            abort "-P/--parallel is only valid for pipe or recv-only socket types (#{RECV_ONLY.join(', ')})"
-          end
+          abort "-P/--parallel is only valid for pipe" unless type_name == "pipe"
+          abort "-P/--parallel must be 1..16" unless (1..16).include?(opts[:parallel])
+          all_pipe_eps = opts[:in_endpoints] + opts[:out_endpoints] + opts[:endpoints]
+          abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if all_pipe_eps.any?(&:bind?)
         end
 
         (opts[:connects] + opts[:binds]).each do |url|

data/lib/omq/cli/config.rb

@@ -44,6 +44,8 @@ module OMQ
       :rcvbuf,
       :conflate,
       :compress,
+      :compress_in,
+      :compress_out,
       :send_expr,
       :recv_expr,
       :parallel,

data/lib/omq/cli/formatter.rb

@@ -95,6 +95,8 @@ module OMQ
       # @return [Array<String>] decompressed frames
       def decompress(parts)
         @compress ? parts.map { |p| Zstd.decompress(p) } : parts
+      rescue
+        abort "omq: decompression failed (did the sender use --compress?)"
       end
     end
   end

data/lib/omq/cli/pipe.rb

@@ -13,6 +13,8 @@ module OMQ
       def initialize(config)
         @config = config
         @fmt    = Formatter.new(config.format, compress: config.compress)
+        @fmt_in  = Formatter.new(config.format, compress: config.compress_in || config.compress)
+        @fmt_out = Formatter.new(config.format, compress: config.compress_out || config.compress)
       end
 
 
@@ -112,10 +114,10 @@ module OMQ
         loop do
           parts = @pull.receive
           break if parts.nil?
-          parts = @fmt.decompress(parts)
+          parts = @fmt_in.decompress(parts)
           parts = eval_recv_expr(parts)
           if parts && !parts.empty?
-            out = @fmt.compress(parts)
+            out = @fmt_out.compress(parts)
             @push.send(out)
           end
           i += 1
@@ -128,140 +130,113 @@ module OMQ
 
 
       def run_parallel(task)
+        OMQ.freeze_for_ractors!
         in_eps, out_eps = resolve_endpoints
-        pairs = build_socket_pairs(config.parallel, in_eps, out_eps)
-        wait_for_pairs(pairs)
-        setup_parallel_transient(task, pairs)
-        workers = spawn_workers(pairs, build_worker_data)
-        join_workers(workers)
-      ensure
-        pairs&.each do |pull, push|
-          pull&.close
-          push&.close
-        end
-      end
-
-
-      def build_socket_pairs(n_workers, in_eps, out_eps)
-        pull_opts = { linger: config.linger }
-        push_opts = { linger: config.linger }
-        pull_opts[:recv_timeout] = config.timeout if config.timeout
-        push_opts[:send_timeout] = config.timeout if config.timeout
-        n_workers.times.map { build_pull_push(pull_opts, push_opts, in_eps, out_eps) }
-      end
-
-
-      def wait_for_pairs(pairs)
-        with_timeout(config.timeout) do
-          Barrier do |barrier|
-            pairs.each do |pull, push|
-              barrier.async(annotation: "wait push peer") { push.peer_connected.wait }
-              barrier.async(annotation: "wait pull peer") { pull.peer_connected.wait }
-            end
-          end
-        end
-      end
-
-
-      def setup_parallel_transient(task, pairs)
-        return unless config.transient
-        task.async do
-          pairs[0][0].all_peers_gone.wait
-          pairs.each do |pull, _|
-            pull.reconnect_enabled = false
-            pull.close_read
-          end
+        workers = spawn_workers(config, in_eps, out_eps)
+        workers.each do |w|
+          w.join
+        rescue ::Ractor::RemoteError => e
+          $stderr.write("omq: Ractor error: #{e.cause&.message || e.message}\n")
         end
       end
 
 
-      def build_worker_data
-        # Pack worker config into a shareable Hash passed via omq.data —
-        # Ruby 4.0 forbids Ractor blocks from closing over outer locals.
-        ::Ractor.make_shareable({
-          recv_src:   config.recv_expr,
-          fmt_format: config.format,
-          fmt_compr:  config.compress,
-          n_count:    config.count,
-        })
-      end
-
-
-      def spawn_workers(pairs, worker_data)
-        pairs.map do |pull, push|
-          OMQ::Ractor.new(pull, push, serialize: false, data: worker_data) do |omq|
-            pull_p, push_p = omq.sockets
-            d = omq.data
-
-            # Re-compile expression inside Ractor (Procs are not shareable)
-            begin_proc, end_proc, eval_proc =
-              OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(d[:recv_src])
-
-            formatter = OMQ::CLI::Formatter.new(d[:fmt_format], compress: d[:fmt_compr])
-            # Use a dedicated context object so @ivar expressions in BEGIN/END/eval
-            # work inside Ractors (self in a Ractor is shareable; Object.new is not).
-            _ctx = Object.new
-            _ctx.instance_exec(&begin_proc) if begin_proc
-
-            n_count = d[:n_count]
-            if eval_proc
-              if n_count && n_count > 0
-                n_count.times do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                    _ctx.instance_exec(formatter.decompress(parts), &eval_proc)
-                  )
-                  next if parts.nil?
-                  push_p << formatter.compress(parts) unless parts.empty?
-                end
-              else
-                loop do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                    _ctx.instance_exec(formatter.decompress(parts), &eval_proc)
-                  )
-                  next if parts.nil?
-                  push_p << formatter.compress(parts) unless parts.empty?
-                end
+      def spawn_workers(config, in_eps, out_eps)
+        config.parallel.times.map do
+          ::Ractor.new(config, in_eps, out_eps) do |cfg, ins, outs|
+            Async do
+              pull = OMQ::PULL.new(linger: cfg.linger)
+              push = OMQ::PUSH.new(linger: cfg.linger)
+              pull.recv_timeout      = cfg.timeout if cfg.timeout
+              push.send_timeout      = cfg.timeout if cfg.timeout
+              pull.reconnect_interval = cfg.reconnect_ivl if cfg.reconnect_ivl
+              push.reconnect_interval = cfg.reconnect_ivl if cfg.reconnect_ivl
+              pull.heartbeat_interval = cfg.heartbeat_ivl if cfg.heartbeat_ivl
+              push.heartbeat_interval = cfg.heartbeat_ivl if cfg.heartbeat_ivl
+              pull.send_hwm          = cfg.send_hwm if cfg.send_hwm
+              pull.recv_hwm          = cfg.recv_hwm if cfg.recv_hwm
+              push.send_hwm          = cfg.send_hwm if cfg.send_hwm
+              push.recv_hwm          = cfg.recv_hwm if cfg.recv_hwm
+              pull.sndbuf            = cfg.sndbuf if cfg.sndbuf
+              pull.rcvbuf            = cfg.rcvbuf if cfg.rcvbuf
+              push.sndbuf            = cfg.sndbuf if cfg.sndbuf
+              push.rcvbuf            = cfg.rcvbuf if cfg.rcvbuf
+
+              OMQ::CLI::SocketSetup.attach_endpoints(pull, ins, verbose: cfg.verbose >= 1)
+              OMQ::CLI::SocketSetup.attach_endpoints(push, outs, verbose: cfg.verbose >= 1)
+
+              Barrier do |barrier|
+                barrier.async { pull.peer_connected.wait }
+                barrier.async { push.peer_connected.wait }
               end
-            else
-              if n_count && n_count > 0
-                n_count.times do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  push_p << formatter.compress(formatter.decompress(parts))
-                end
-              else
-                loop do
-                  parts = pull_p.receive
-                  break if parts.nil?
-                  push_p << formatter.compress(formatter.decompress(parts))
+
+              begin_proc, end_proc, eval_proc =
+                OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(cfg.recv_expr)
+
+              fmt_in  = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress_in || cfg.compress)
+              fmt_out = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress_out || cfg.compress)
+
+              _ctx = Object.new
+              _ctx.instance_exec(&begin_proc) if begin_proc
+
+              n_count = cfg.count
+              begin
+                if eval_proc
+                  if n_count && n_count > 0
+                    n_count.times do
+                      parts = pull.receive
+                      break if parts.nil?
+                      parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                        _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
+                      )
+                      next if parts.nil?
+                      push << fmt_out.compress(parts) unless parts.empty?
+                    end
+                  else
+                    loop do
+                      parts = pull.receive
+                      break if parts.nil?
+                      parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                        _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
+                      )
+                      next if parts.nil?
+                      push << fmt_out.compress(parts) unless parts.empty?
+                    end
+                  end
+                else
+                  if n_count && n_count > 0
+                    n_count.times do
+                      parts = pull.receive
+                      break if parts.nil?
+                      push << fmt_out.compress(fmt_in.decompress(parts))
+                    end
+                  else
+                    loop do
+                      parts = pull.receive
+                      break if parts.nil?
+                      push << fmt_out.compress(fmt_in.decompress(parts))
+                    end
+                  end
                 end
+              rescue IO::TimeoutError, Async::TimeoutError
+                # recv timed out — fall through to END block
               end
-            end
 
-            if end_proc
-              out = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                _ctx.instance_exec(&end_proc)
-              )
-              push_p << formatter.compress(out) if out && !out.empty?
+              if end_proc
+                out = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                  _ctx.instance_exec(&end_proc)
+                )
+                push << fmt_out.compress(out) if out && !out.empty?
+              end
+            ensure
+              pull&.close
+              push&.close
             end
           end
         end
       end
 
 
-      def join_workers(workers)
-        workers.each do |w|
-          w.value
-        rescue Ractor::RemoteError => e
-          $stderr.write("omq: Ractor error: #{e.cause&.message || e.message}\n")
-        end
-      end
-
-
       # ── Shared helpers ────────────────────────────────────────────────
 
 

data/lib/omq/cli/pub_sub.rb

@@ -10,9 +10,7 @@ module OMQ
 
     # Runner for SUB sockets (subscribe and receive published messages).
     class SubRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/push_pull.rb

@@ -10,9 +10,7 @@ module OMQ
 
     # Runner for PULL sockets (receive-only pipeline consumer).
     class PullRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/radio_dish.rb

@@ -23,9 +23,7 @@ module OMQ
 
     # Runner for DISH sockets (draft; group-based subscribe).
     class DishRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/scatter_gather.rb

@@ -10,9 +10,7 @@ module OMQ
 
     # Runner for GATHER sockets (draft; fan-in receive).
     class GatherRunner < BaseRunner
-      def run_loop(task)
-        config.parallel ? run_parallel_recv(task) : run_recv_logic
-      end
+      def run_loop(task) = run_recv_logic
     end
   end
 end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.5.4"
+    VERSION = "0.7.0"
   end
 end

data/lib/omq/cli.rb

@@ -9,7 +9,6 @@ require_relative "cli/expression_evaluator"
 require_relative "cli/socket_setup"
 require_relative "cli/routing_helper"
 require_relative "cli/transient_monitor"
-require_relative "cli/parallel_recv_runner"
 require_relative "cli/base_runner"
 require_relative "cli/push_pull"
 require_relative "cli/pub_sub"
@@ -199,8 +198,6 @@ module OMQ
       require "console"
 
       CliParser.validate_gems!(config)
-      require "omq/ractor" if config.parallel
-
       trap("INT")  { Process.exit!(0) }
       trap("TERM") { Process.exit!(0) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.7.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -16,6 +16,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -23,20 +26,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
-- !ruby/object:Gem::Dependency
-  name: omq-ractor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.15.2
 - !ruby/object:Gem::Dependency
   name: omq-rfc-clientserver
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +165,6 @@ files:
 - lib/omq/cli/expression_evaluator.rb
 - lib/omq/cli/formatter.rb
 - lib/omq/cli/pair.rb
-- lib/omq/cli/parallel_recv_runner.rb
 - lib/omq/cli/pipe.rb
 - lib/omq/cli/pub_sub.rb
 - lib/omq/cli/push_pull.rb

data/lib/omq/cli/parallel_recv_runner.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module CLI
-    # Manages N OMQ::Ractor workers for parallel recv-eval.
-    #
-    # Each worker gets its own input socket connecting to the external
-    # endpoints; ZMQ distributes work naturally. Results are collected via
-    # an inproc PULL back to the main task for output.
-    #
-    class ParallelRecvRunner
-      # @param klass [Class] OMQ socket class for worker input sockets
-      # @param config [Config] frozen CLI configuration
-      # @param fmt [Formatter] message formatter
-      # @param output_fn [Method] callable for writing output
-      def initialize(klass, config, fmt, output_fn)
-        @klass     = klass
-        @config    = config
-        @fmt       = fmt
-        @output_fn = output_fn
-      end
-
-
-      # Spawns N Ractor workers, distributes incoming messages, and collects results.
-      #
-      # @param task [Async::Task] parent async task
-      # @return [void]
-      def run(task)
-        cfg       = @config
-        n_workers = cfg.parallel
-        inproc    = "inproc://omq-out-#{object_id}"
-
-        # Pack worker config into a shareable Hash passed via omq.data —
-        # Ruby 4.0 forbids Ractor blocks from closing over outer locals.
-        worker_data = ::Ractor.make_shareable({
-          recv_src:  cfg.recv_expr,
-          fmt_sym:   cfg.format,
-          fmt_compr: cfg.compress,
-        })
-
-        # Create N input sockets in the main Async context
-        input_socks = n_workers.times.map do
-          sock = SocketSetup.build(@klass, cfg)
-          SocketSetup.setup_subscriptions(sock, cfg)
-          cfg.connects.each { |url| sock.connect(url) }
-          sock
-        end
-
-        with_timeout(cfg.timeout) { input_socks.each { |s| s.peer_connected.wait } }
-
-        # Inproc collector: one bound PULL to receive all worker output
-        collector = OMQ::PULL.new(linger: cfg.linger)
-        collector.recv_timeout = cfg.timeout if cfg.timeout
-        collector.bind(inproc)
-
-        # N output sockets connecting to the collector
-        output_socks = n_workers.times.map do
-          s = OMQ::PUSH.new(linger: cfg.linger)
-          s.connect(inproc)
-          s
-        end
-
-        workers = n_workers.times.map do |i|
-          OMQ::Ractor.new(input_socks[i], output_socks[i], serialize: false, data: worker_data) do |omq|
-            pull_p, push_p = omq.sockets
-            d = omq.data
-
-            # Re-compile expression inside Ractor (Procs are not shareable)
-            begin_proc, end_proc, eval_proc =
-              OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(d[:recv_src])
-
-            formatter = OMQ::CLI::Formatter.new(d[:fmt_sym], compress: d[:fmt_compr])
-            # Use a dedicated context object so @ivar expressions in BEGIN/END/eval
-            # work inside Ractors (self in a Ractor is shareable; Object.new is not).
-            _ctx = Object.new
-            _ctx.instance_exec(&begin_proc) if begin_proc
-
-            if eval_proc
-              loop do
-                parts = pull_p.receive
-                break if parts.nil?
-                parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                  _ctx.instance_exec(formatter.decompress(parts), &eval_proc)
-                )
-                next if parts.nil?
-                push_p << parts unless parts.empty?
-              end
-            else
-              loop do
-                parts = pull_p.receive
-                break if parts.nil?
-                push_p << formatter.decompress(parts)
-              end
-            end
-
-            if end_proc
-              out = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                _ctx.instance_exec(&end_proc)
-              )
-              push_p << out if out && !out.empty?
-            end
-          end
-        end
-
-
-        # Collect loop: drain inproc PULL → output
-        n_count = cfg.count
-        if n_count && n_count > 0
-          n_count.times do
-            parts = collector.receive
-            break if parts.nil?
-            @output_fn.call(parts)
-          end
-        else
-          loop do
-            parts = collector.receive
-            break if parts.nil?
-            @output_fn.call(parts)
-          end
-        end
-
-
-        # Inject nil into each worker's input port so it exits its loop
-        # without waiting for recv_timeout (workers don't self-terminate
-        # when the collect loop exits on count).
-        workers.each do |w|
-          w.close
-        rescue Ractor::RemoteError => e
-          $stderr.puts "omq: Ractor error: #{e.cause&.message || e.message}"
-        end
-      ensure
-        input_socks&.each(&:close)
-        output_socks&.each(&:close)
-        collector&.close
-      end
-
-
-      private
-
-
-      def with_timeout(seconds)
-        if seconds
-          Async::Task.current.with_timeout(seconds) { yield }
-        else
-          yield
-        end
-      end
-    end
-  end
-end