omq 0.6.5 → 0.8.0

data/lib/omq/cli/pipe.rb

@@ -24,9 +24,22 @@ module OMQ
       private
 
 
+      def resolve_endpoints
+        if config.in_endpoints.any?
+          [config.in_endpoints, config.out_endpoints]
+        else
+          [[config.endpoints[0]], [config.endpoints[1]]]
+        end
+      end
+
+
+      def attach_endpoints(sock, endpoints)
+        endpoints.each { |ep| ep.bind? ? sock.bind(ep.url) : sock.connect(ep.url) }
+      end
+
+
       def run_sequential(task)
-        pull_ep = config.endpoints[0]
-        push_ep = config.endpoints[1]
+        in_eps, out_eps = resolve_endpoints
 
         @pull = OMQ::PULL.new(linger: config.linger, recv_timeout: config.timeout)
         @push = OMQ::PUSH.new(linger: config.linger, send_timeout: config.timeout)
@@ -35,11 +48,11 @@ module OMQ
         @pull.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
         @push.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
 
-        pull_ep.bind? ? @pull.bind(pull_ep.url) : @pull.connect(pull_ep.url)
-        push_ep.bind? ? @push.bind(push_ep.url) : @push.connect(push_ep.url)
+        attach_endpoints(@pull, in_eps)
+        attach_endpoints(@push, out_eps)
 
         compile_expr
-        @sock = @pull  # for eval_expr instance_exec
+        @sock = @pull  # for eval instance_exec
 
         with_timeout(config.timeout) do
           @push.peer_connected.wait
@@ -54,7 +67,7 @@ module OMQ
           end
         end
 
-        @sock.instance_exec(&@begin_proc) if @begin_proc
+        @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
 
         n = config.count
         i = 0
@@ -62,7 +75,7 @@ module OMQ
           parts = @pull.receive
           break if parts.nil?
           parts = @fmt.decompress(parts)
-          parts = eval_expr(parts)
+          parts = eval_recv_expr(parts)
           if parts && !parts.empty?
             @push.send(@fmt.compress(parts))
           end
@@ -70,7 +83,7 @@ module OMQ
           break if n && n > 0 && i >= n
         end
 
-        @sock.instance_exec(&@end_proc) if @end_proc
+        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
       ensure
         @pull&.close
         @push&.close
@@ -86,7 +99,7 @@ module OMQ
             Sync do |task|
               # Parse BEGIN/END blocks and per-message expression
               begin_proc = end_proc = eval_proc = nil
-              if cfg.expr
+              if cfg.recv_expr
                 extract = ->(src, kw) {
                   s = src.index(/#{kw}\s*\{/)
                   return [src, nil] unless s
@@ -97,7 +110,7 @@ module OMQ
                   end
                   [src[0...s] + src[j..], src[(i + 1)..(j - 2)]]
                 }
-                expr, begin_body = extract.(cfg.expr, "BEGIN")
+                expr, begin_body = extract.(cfg.recv_expr, "BEGIN")
                 expr, end_body   = extract.(expr, "END")
                 begin_proc = eval("proc { #{begin_body} }") if begin_body
                 end_proc   = eval("proc { #{end_body} }")   if end_body
@@ -115,8 +128,10 @@ module OMQ
               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.connect(cfg.endpoints[0].url)
-              push.connect(cfg.endpoints[1].url)
+              in_eps  = cfg.in_endpoints.any? ? cfg.in_endpoints : [cfg.endpoints[0]]
+              out_eps = cfg.out_endpoints.any? ? cfg.out_endpoints : [cfg.endpoints[1]]
+              in_eps.each  { |ep| pull.connect(ep.url) }
+              out_eps.each { |ep| push.connect(ep.url) }
 
               if cfg.timeout
                 task.with_timeout(cfg.timeout) do
@@ -187,11 +202,12 @@ 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?
+        src = config.recv_expr
+        return unless src
+        expr, begin_body, end_body = extract_blocks(src)
+        @recv_begin_proc = eval("proc { #{begin_body} }") if begin_body
+        @recv_end_proc   = eval("proc { #{end_body} }")   if end_body
+        @recv_eval_proc  = eval("proc { $_ = $F&.first; #{expr} }") if expr && !expr.strip.empty?
       end
 
 
@@ -224,10 +240,10 @@ module OMQ
       end
 
 
-      def eval_expr(parts)
-        return parts unless @eval_proc
+      def eval_recv_expr(parts)
+        return parts unless @recv_eval_proc
         $F = parts
-        result = @sock.instance_exec(&@eval_proc)
+        result = @sock.instance_exec(&@recv_eval_proc)
         return nil if result.nil? || result.equal?(@sock)
         return [result] if config.format == :marshal
         case result
@@ -236,7 +252,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/req_rep.rb

@@ -14,10 +14,12 @@ module OMQ
           loop do
             parts = read_next
             break unless parts
+            parts = eval_send_expr(parts)
+            next unless parts
             send_msg(parts)
             reply = recv_msg
             break if reply.nil?
-            reply = eval_expr(reply)
+            reply = eval_recv_expr(reply)
             output(reply)
             i += 1
             break if n && n > 0 && i >= n
@@ -29,10 +31,12 @@ module OMQ
           loop do
             parts = read_next
             break unless parts
+            parts = eval_send_expr(parts)
+            next unless parts
             send_msg(parts)
             reply = recv_msg
             break if reply.nil?
-            reply = eval_expr(reply)
+            reply = eval_recv_expr(reply)
             output(reply)
             i += 1
             break if n && n > 0 && i >= n
@@ -53,8 +57,8 @@ module OMQ
         loop do
           msg = recv_msg
           break if msg.nil?
-          if config.expr
-            reply = eval_expr(msg)
+          if config.recv_expr || @recv_eval_proc
+            reply = eval_recv_expr(msg)
             unless reply.equal?(SENT)
               output(reply)
               send_msg(reply || [""])

data/lib/omq/cli/router_dealer.rb

@@ -20,7 +20,7 @@ module OMQ
             identity = parts.shift
             parts.shift if parts.first == ""
             parts = @fmt.decompress(parts)
-            result = eval_expr([display_routing_id(identity), *parts])
+            result = eval_recv_expr([display_routing_id(identity), *parts])
             output(result)
             i += 1
             break if n && n > 0 && i >= n
@@ -35,18 +35,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
@@ -57,8 +57,14 @@ 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
+          identity = resolve_target(parts.shift)
+          payload  = @fmt.compress(parts)
+          @sock.send([identity, "", *payload])
+        elsif config.target
           payload = @fmt.compress(parts)
           @sock.send([resolve_target(config.target), "", *payload])
         else

data/lib/omq/cli.rb

@@ -17,6 +17,15 @@ require_relative "cli/peer"
 require_relative "cli/pipe"
 
 module OMQ
+
+  class << self
+    attr_reader :outgoing_proc, :incoming_proc
+
+    def outgoing(&block) = @outgoing_proc = block
+    def incoming(&block) = @incoming_proc = block
+  end
+
+
   module CLI
     SOCKET_TYPE_NAMES = %w[
       req rep pub sub push pull pair dealer router
@@ -56,7 +65,7 @@ module OMQ
         └─────┘  "HELLO"    └─────┘
 
         # terminal 1: echo server
-        omq rep --bind tcp://:5555 --eval '$F.map(&:upcase)'
+        omq rep --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
 
         # terminal 2: send a request
         echo "hello" | omq req --connect tcp://localhost:5555
@@ -79,7 +88,7 @@ module OMQ
 
       ── Periodic Publish ───────────────────────────────────────────
 
-        ┌─────┐  "tick 1"   ┌─────┐
+        ┌─────┐  "tick 1"    ┌─────┐
         │ PUB │──(every 1s)─→│ SUB │
         └─────┘              └─────┘
 
@@ -121,27 +130,31 @@ module OMQ
 
         # terminal 2: worker — uppercase each message
         omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
-
         # terminal 3: collector
         omq pull --bind ipc://@sink
 
         # 4 Ractor workers in a single process (-P)
-        omq pipe -c ipc://@work -c ipc://@sink -P 4 \
-          -r ./fib.rb -e 'fib(Integer($_)).to_s'
+        omq pipe -c ipc://@work -c ipc://@sink -P4 -r./fib -e 'fib(Integer($_)).to_s'
 
         # exit when producer disconnects (--transient)
-        omq pipe -c ipc://@work -c ipc://@sink --transient \
-          -e '$F.map(&:upcase)'
+        omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F.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)'
+
+        # fan-out: one source → multiple sinks (round-robin)
+        omq pipe --in -b tcp://:5555 --out -c ipc://@sink1 -c ipc://@sink2 -e '$F'
 
       ── CLIENT / SERVER (draft) ──────────────────────────────────
 
         ┌────────┐  "hello"   ┌────────┐
-        │ CLIENT │───────────→│ SERVER │ --eval '$F.map(&:upcase)'
+        │ CLIENT │───────────→│ SERVER │ --recv-eval '$F.map(&:upcase)'
         │        │←───────────│        │
         └────────┘  "HELLO"   └────────┘
 
         # terminal 1: upcasing server
-        omq server --bind tcp://:5555 --eval '$F.map(&:upcase)'
+        omq server --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
 
         # terminal 2: client
         echo "hello" | omq client --connect tcp://localhost:5555
@@ -187,30 +200,45 @@ module OMQ
         omq router --bind tcp://:5555
 
         # terminal 2: dealer with identity
-        echo "hello" | omq dealer --connect tcp://localhost:5555 \
-          --identity worker-1
+        echo "hello" | omq dealer --connect tcp://localhost:5555 --identity worker-1
 
       ── Ruby Eval ────────────────────────────────────────────────
 
-        # filter: only pass messages containing "error"
-        omq pull --bind tcp://:5557 \
-          --eval '$F.first.include?("error") ? $F : nil'
+        # filter incoming: only pass messages containing "error"
+        omq pull -b tcp://:5557 --recv-eval '$F.first.include?("error") ? $F : nil'
 
-        # transform with gems
-        omq sub --connect tcp://localhost:5556 --require json \
-          --eval 'JSON.parse($F.first)["temperature"]'
+        # transform incoming with gems
+        omq sub -c tcp://localhost:5556 -rjson -e 'JSON.parse($F.first)["temperature"]'
 
-        # require a local file, use its methods in --eval
-        omq rep --bind tcp://:5555 --require ./transform.rb \
-          --eval 'upcase_all($F)'
+        # require a local file, use its methods
+        omq rep --bind tcp://:5555 --require ./transform.rb -e 'upcase_all($F)'
 
         # next skips, break stops — regexps match against $_
-        omq pull --bind tcp://:5557 \
-          --eval 'next if /^#/; break if /quit/; $F'
+        omq pull -b tcp://:5557 -e 'next if /^#/; break if /quit/; $F'
 
         # BEGIN/END blocks (like awk) — accumulate and summarize
-        omq pull --bind tcp://:5557 \
-          --eval 'BEGIN{ @sum = 0 } @sum += Integer($_); next END{ puts @sum }'
+        omq pull -b tcp://:5557 -e 'BEGIN{@sum = 0} @sum += Integer($_); nil END{puts @sum}'
+
+        # transform outgoing messages
+        echo hello | omq push -c tcp://localhost:5557 --send-eval '$F.map(&:upcase)'
+
+        # REQ: transform request and reply independently
+        echo hello | omq req -c tcp://localhost:5555 -E '$F.map(&:upcase)' -e '$_'
+
+      ── Script Handlers (-r) ────────────────────────────────────
+
+        # handler.rb — register transforms from a file
+        #   db = PG.connect("dbname=app")
+        #   OMQ.incoming { |first_part, _| db.exec(first_part).values.flatten }
+        #   at_exit { db.close }
+        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.outgoing { |msg| ... }   — registered outgoing transform
+        # OMQ.incoming { |msg| ... }   — registered incoming transform
+        # CLI flags (-e/-E) override registered handlers
     TEXT
 
     module_function
@@ -299,6 +327,8 @@ module OMQ
         endpoints:        [],
         connects:         [],
         binds:            [],
+        in_endpoints:     [],
+        out_endpoints:    [],
         data:             nil,
         file:             nil,
         format:           :ascii,
@@ -316,7 +346,8 @@ module OMQ
         heartbeat_ivl:    nil,
         conflate:         false,
         compress:         false,
-        expr:             nil,
+        send_expr:        nil,
+        recv_expr:        nil,
         parallel:         nil,
         transient:        false,
         verbose:          false,
@@ -326,6 +357,8 @@ module OMQ
         curve_server_key: nil,
       }
 
+      pipe_side = nil  # nil = legacy positional mode; :in/:out = modal
+
       parser = OptionParser.new do |o|
         o.banner = "Usage: omq TYPE [options]\n\n" \
                    "Types:    req, rep, pub, sub, push, pull, pair, dealer, router\n" \
@@ -333,8 +366,24 @@ module OMQ
                    "Virtual:  pipe (PULL → eval → PUSH)\n\n"
 
         o.separator "Connection:"
-        o.on("-c", "--connect URL", "Connect to endpoint (repeatable)")   { |v| opts[:endpoints] << Endpoint.new(v, false); opts[:connects] << v }
-        o.on("-b", "--bind URL",    "Bind to endpoint (repeatable)")      { |v| opts[:endpoints] << Endpoint.new(v, true);  opts[:binds] << v }
+        o.on("-c", "--connect URL", "Connect to endpoint (repeatable)") { |v|
+          ep = Endpoint.new(v, false)
+          case pipe_side
+          when :in  then opts[:in_endpoints] << ep
+          when :out then opts[:out_endpoints] << ep
+          else           opts[:endpoints] << ep; opts[:connects] << v
+          end
+        }
+        o.on("-b", "--bind URL", "Bind to endpoint (repeatable)") { |v|
+          ep = Endpoint.new(v, true)
+          case pipe_side
+          when :in  then opts[:in_endpoints] << ep
+          when :out then opts[:out_endpoints] << ep
+          else           opts[:endpoints] << ep; opts[:binds] << v
+          end
+        }
+        o.on("--in",  "Pipe: subsequent -b/-c attach to input (PULL) side")  { pipe_side = :in }
+        o.on("--out", "Pipe: subsequent -b/-c attach to output (PUSH) side") { pipe_side = :out }
 
         o.separator "\nData source (REP: reply source):"
         o.on(      "--echo",        "Echo received messages back (REP)")   { opts[:echo] = true }
@@ -380,9 +429,11 @@ module OMQ
         o.separator "\nCompression:"
         o.on("-z", "--compress", "Zstandard compression per frame") { opts[:compress] = true }
 
-        o.separator "\nProcessing:"
-        o.on("-e", "--eval EXPR",    "Eval Ruby for each message ($F = parts)") { |v| opts[:expr] = v }
-        o.on("-r", "--require LIB",  "Require library or file (-r./lib.rb)")    { |v|
+        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("-r", "--require LIB",  "Require lib/file; scripts can register OMQ.outgoing/incoming") { |v|
+          require_relative "../omq" unless defined?(OMQ::VERSION)
           v.start_with?("./", "../") ? require(File.expand_path(v)) : require(v)
         }
         o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers (pipe only, default: nproc)") { |v|
@@ -421,10 +472,13 @@ module OMQ
 
       opts[:type_name] = type_name.downcase
 
-      normalize = ->(url) { url.sub(%r{\Atcp://\*:}, "tcp://0.0.0.0:").sub(%r{\Atcp://:}, "tcp://localhost:") }
+      normalize    = ->(url) { url.sub(%r{\Atcp://\*:}, "tcp://0.0.0.0:").sub(%r{\Atcp://:}, "tcp://localhost:") }
+      normalize_ep = ->(ep) { Endpoint.new(normalize.call(ep.url), ep.bind?) }
       opts[:binds].map!(&normalize)
       opts[:connects].map!(&normalize)
-      opts[:endpoints].map! { |ep| Endpoint.new(normalize.call(ep.url), ep.bind?) }
+      opts[:endpoints].map!(&normalize_ep)
+      opts[:in_endpoints].map!(&normalize_ep)
+      opts[:out_endpoints].map!(&normalize_ep)
 
       opts
     end
@@ -436,8 +490,16 @@ module OMQ
       type_name = opts[:type_name]
 
       if type_name == "pipe"
-        abort "pipe requires exactly 2 endpoints (pull-side and push-side)" if opts[:endpoints].size != 2
+        has_in_out = opts[:in_endpoints].any? || opts[:out_endpoints].any?
+        if has_in_out
+          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?
+        else
+          abort "pipe requires exactly 2 endpoints (pull-side and push-side), or use --in/--out" if opts[:endpoints].size != 2
+        end
       else
+        abort "--in/--out are only valid for pipe" if opts[:in_endpoints].any? || opts[:out_endpoints].any?
         abort "At least one --connect or --bind is required" if opts[:connects].empty? && opts[:binds].empty?
       end
       abort "--data and --file are mutually exclusive"        if opts[:data] && opts[:file]
@@ -447,11 +509,15 @@ module OMQ
       abort "--identity is only valid for DEALER/ROUTER"      if opts[:identity] && !%w[dealer router].include?(type_name)
       abort "--target is only valid for ROUTER/SERVER/PEER"   if opts[:target] && !%w[router server peer].include?(type_name)
       abort "--conflate is only valid for PUB/RADIO"          if opts[:conflate] && !%w[pub radio].include?(type_name)
+      abort "--recv-eval is not valid for send-only sockets (use --send-eval / -E)" if opts[:recv_expr] && SEND_ONLY.include?(type_name)
+      abort "--send-eval is not valid for recv-only sockets (use --recv-eval / -e)" if opts[:send_expr] && RECV_ONLY.include?(type_name)
+      abort "--send-eval and --target are mutually exclusive"  if opts[:send_expr] && opts[:target]
 
       if opts[:parallel]
         abort "-P/--parallel is only valid for pipe"                                    unless type_name == "pipe"
         abort "-P/--parallel must be >= 2"                                              if opts[:parallel] < 2
-        abort "-P/--parallel requires both endpoints to use --connect (not --bind)" if opts[:endpoints].any?(&:bind?)
+        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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.6.5"
+  VERSION = "0.8.0"
 end

data/lib/omq/zmtp/engine.rb

@@ -215,29 +215,50 @@ module OMQ
       # fast path when the connection is a DirectPipe.
       #
       # @param conn [Connection, Transport::Inproc::DirectPipe]
+      # Starts a recv pump that dequeues messages from a connection
+      # and enqueues them into the routing strategy's recv queue.
+      #
+      # When a block is given, each message is yielded for transformation
+      # before enqueueing. The block is compiled at the call site, giving
+      # YJIT a monomorphic call per routing strategy instead of a shared
+      # megamorphic `transform.call` dispatch.
+      #
+      # @param conn [Connection, Transport::Inproc::DirectPipe]
       # @param recv_queue [Async::LimitedQueue] routing strategy's recv queue
-      # @param transform [#call, nil] optional message transform
+      # @yield [msg] optional per-message transform
       # @return [#stop, nil] pump task handle, or nil for DirectPipe bypass
       #
-      def start_recv_pump(conn, recv_queue, transform: nil)
+      def start_recv_pump(conn, recv_queue, &transform)
         if conn.is_a?(Transport::Inproc::DirectPipe) && conn.peer
           conn.peer.direct_recv_queue = recv_queue
           conn.peer.direct_recv_transform = transform
           return nil
         end
 
-        Reactor.spawn_pump(annotation: "recv pump") do
-          loop do
-            msg = conn.receive_message
-            msg = transform ? transform.call(msg).freeze : msg
-            recv_queue.enqueue(msg)
+        if transform
+          Reactor.spawn_pump(annotation: "recv pump") do
+            loop do
+              msg = conn.receive_message
+              msg = transform.call(msg).freeze
+              recv_queue.enqueue(msg)
+            end
+          rescue Async::Stop
+          rescue ProtocolError, *CONNECTION_LOST
+            connection_lost(conn)
+          rescue => error
+            signal_fatal_error(error)
+          end
+        else
+          Reactor.spawn_pump(annotation: "recv pump") do
+            loop do
+              recv_queue.enqueue(conn.receive_message)
+            end
+          rescue Async::Stop
+          rescue ProtocolError, *CONNECTION_LOST
+            connection_lost(conn)
+          rescue => error
+            signal_fatal_error(error)
           end
-        rescue Async::Stop
-          # normal shutdown
-        rescue ProtocolError, *CONNECTION_LOST
-          connection_lost(conn)
-        rescue => error
-          signal_fatal_error(error)
         end
       end
 
@@ -411,17 +432,14 @@ module OMQ
       def setup_connection(io, as_server:, endpoint: nil, done: nil)
         conn = Connection.new(
           io,
-          socket_type:        @socket_type.to_s,
-          identity:           @options.identity,
-          as_server:          as_server,
-          mechanism:          @options.mechanism,
-          heartbeat_interval: @options.heartbeat_interval,
-          heartbeat_ttl:      @options.heartbeat_ttl,
-          heartbeat_timeout:  @options.heartbeat_timeout,
-          max_message_size:   @options.max_message_size,
+          socket_type:      @socket_type.to_s,
+          identity:         @options.identity,
+          as_server:        as_server,
+          mechanism:        @options.mechanism&.dup,
+          max_message_size: @options.max_message_size,
         )
         conn.handshake!
-        conn.start_heartbeat
+        start_heartbeat(conn)
         @connections << conn
         @connection_endpoints[conn] = endpoint if endpoint
         @connection_promises[conn]  = done if done
@@ -433,6 +451,35 @@ module OMQ
       end
 
 
+      # Spawns a heartbeat task for the connection.
+      # The connection only tracks timestamps — the engine drives the loop.
+      #
+      # @param conn [Connection]
+      # @return [void]
+      #
+      def start_heartbeat(conn)
+        interval = @options.heartbeat_interval
+        return unless interval
+
+        ttl     = @options.heartbeat_ttl || interval
+        timeout = @options.heartbeat_timeout || interval
+        conn.touch_heartbeat
+
+        @tasks << Reactor.spawn_pump(annotation: "heartbeat") do
+          loop do
+            sleep interval
+            conn.send_command(Codec::Command.ping(ttl: ttl, context: "".b))
+            if conn.heartbeat_expired?(timeout)
+              conn.close
+              break
+            end
+          end
+        rescue *CONNECTION_LOST
+          # connection closed
+        end
+      end
+
+
       # Spawns a background task that reconnects to the given endpoint
       # with exponential back-off based on the reconnect_interval option.
       #

data/lib/omq/zmtp/routing/peer.rb

@@ -34,8 +34,9 @@ module OMQ
           routing_id = SecureRandom.bytes(4)
           @connections_by_routing_id[routing_id] = connection
 
-          task = @engine.start_recv_pump(connection, @recv_queue,
-                   transform: ->(msg) { [routing_id, *msg] })
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+            [routing_id, *msg]
+          end
           @tasks << task if task
 
           start_send_pump unless @send_pump_started

data/lib/omq/zmtp/routing/rep.rb

@@ -29,14 +29,13 @@ module OMQ
         # @param connection [Connection]
         #
         def connection_added(connection)
-          transform = ->(msg) {
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
             delimiter = msg.index(&:empty?) || msg.size
             envelope  = msg[0, delimiter]
             body      = msg[(delimiter + 1)..] || []
             @pending_replies << { conn: connection, envelope: envelope }
             body
-          }
-          task = @engine.start_recv_pump(connection, @recv_queue, transform: transform)
+          end
           @tasks << task if task
           start_send_pump unless @send_pump_started
         end

data/lib/omq/zmtp/routing/req.rb

@@ -28,8 +28,9 @@ module OMQ
         def connection_added(connection)
           @connections << connection
           signal_connection_available
-          task = @engine.start_recv_pump(connection, @recv_queue,
-                   transform: method(:transform_recv))
+          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
+            msg.first&.empty? ? msg[1..] : msg
+          end
           @tasks << task if task
           start_send_pump unless @send_pump_started
         end
@@ -58,11 +59,6 @@ module OMQ
         #
         def transform_send(parts) = ["".b, *parts]
 
-        # REQ strips the leading empty delimiter frame on receive.
-        #
-        def transform_recv(msg)
-          msg.first&.empty? ? msg[1..] : msg
-        end
       end
     end
   end