nnq 0.6.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19bceda0339689e8850efe39120590002821f5c859eaf33e4ea1065af317bcaa
-  data.tar.gz: 2a15dd79b5cf4f8a41c564e89cf40af7296de8765e8e070de12057b4bc0dedf9
+  metadata.gz: 19ad156b056b2948c31b8447aef51f07d6fde7838c7f448b13cf3ebcc0b84ccf
+  data.tar.gz: d781f021467df323ac687bd08247c503b018d2961d8499e3cce50504b7df70a8
 SHA512:
-  metadata.gz: 1e14a21e6d620df7770c27868f5fdb8ed945fb04137b8817c12fdaa2fdfca1e36a952e6fc4afc5be60562dfd1ff8f43d9d1781ce9a4fb6a1c3a8963cd3738233
-  data.tar.gz: 13aae01f03df0b0eca53aa0329d0f2d35b036b4f52744f83033cc46297eae39a60b2c639ad144c9ee3af63cee7d3780c3fff036d30f418e078ccb89253f70761
+  metadata.gz: f74b75020a0ae60b9caf974e92e85cf9fdbd56c7e0bb9e819a7ea0e783b0f7f2036112ed0698c723a699eb070bcac684ed354192c425d750c8e9e858c1d24561
+  data.tar.gz: 1d4e6ac56699c2ec8706c595f419ef8e39278e7aee4bc1d02fcf75ee31d91c167d182c74ab8176a3e41dbaaf029ca5b50d49fb0148bcc9d804278f229cb0049e

data/CHANGELOG.md

@@ -1,5 +1,95 @@
 # Changelog
 
+## 0.8.1 — 2026-04-19
+
+- **Fix close-race in `ConnectionLifecycle#tear_down!`.** The fd was
+  closed before sibling pumps were cancelled, which woke recv fibers
+  parked in `io_wait` with `IOError: stream closed in another thread`.
+  `@barrier.stop` now runs before `@conn.close`, so blocking reads
+  unwind via `Async::Stop` before the fd goes away.
+
+## 0.8.0 — 2026-04-19
+
+- **Uniform frozen + `BINARY` message contract across transports.**
+  `Socket#coerce_binary` replaces the old `frozen_binary` + `.b.freeze`
+  copy on the hot send path. Every send method runs its body through
+  `coerce_binary`, which:
+  - coerces non-String bodies via `#to_str` (nil / `42` / `:foo` raise
+    `NoMethodError` instead of producing a zero-byte frame);
+  - re-tags unfrozen non-BINARY bodies to `Encoding::BINARY` in place —
+    a flag flip, no copy;
+  - freezes the body.
+
+  Receivers always see a frozen BINARY-tagged body: TCP/IPC get it via
+  the recv-pump freeze, inproc gets it via `Pipe#send_message`, which
+  only allocates for the pathological case of a frozen non-BINARY body
+  (the typical `# frozen_string_literal: true` UTF-8 literal). Bodies
+  returned by REP/REQ/SURVEYOR/RESPONDENT (cooked and raw) are frozen
+  by `parse_backtrace` and the REQ/SURVEYOR id-parsing paths. Mutation
+  bugs surface as `FrozenError` instead of silently corrupting a shared
+  reference on the inproc fast path. Inproc throughput pays ~20-30%
+  for the contract; TCP/IPC unaffected.
+
+- **Benchmarks send fresh strings per iteration.** `BenchHelper.run`
+  passes an unfrozen `"x" * size` through to the burst closure; the
+  `measure` / `measure_roundtrip` bursts `.dup` it before each send.
+  More realistic than reusing one frozen payload and hitting every
+  fast path in `coerce_binary` + `Pipe#send_message`.
+
+## 0.7.0 — 2026-04-18
+
+- **Inproc transport now uses a queue-based `Inproc::Pipe`** instead
+  of a Unix `socketpair(2)` running the full SP protocol.
+  `NNQ::Transport::Inproc::Pipe` duck-types `NNQ::Connection` and
+  transfers frozen Strings through a pair of `Async::Queue`s (one
+  per direction). No framing, no handshake, no kernel buffer copy.
+  When a routing strategy supplies an SP backtrace header
+  (REQ/REP/SURVEYOR), it's prepended before enqueue so the receive
+  side sees the same layout as the TCP/IPC path and `parse_backtrace`
+  keeps working unchanged. The new `Engine#connection_ready(conn,
+  endpoint:)` and `ConnectionLifecycle#ready_direct!` entry points
+  register a pipe as ready without the SP handshake phase.
+- **Inproc direct-recv fast path.** When a routing strategy exposes a
+  `#direct_recv_for(conn)` hook, the peer pipe enqueues directly into
+  the routing recv queue via `Pipe#wire_direct_recv`, bypassing both
+  the intermediate pipe queue and the recv pump fiber. PULL, BUS,
+  PAIR, SUB, REP, RESPONDENT, SURVEYOR, and the `*_raw` variants all
+  implement the hook; REQ (promise-based) stays on the fiber path.
+  Cuts three fiber hops to one on the steady-state recv path.
+- **Routing pumps shed their `@pump_tasks` bookkeeping.** `bus`, `pub`,
+  `surveyor`, and `surveyor_raw` no longer track per-connection pump
+  tasks in a hash. Pumps are spawned under
+  `@engine.connections[conn].barrier`, so `ConnectionLifecycle#tear_down!`
+  already cascade-cancels them on `barrier.stop` — the hash was dead
+  weight.
+- **Transport registry is pluggable.** `NNQ::Engine.transports` is now a
+  mutable class-level `Hash` instead of a frozen constant; each built-in
+  transport (`tcp`, `ipc`, `inproc`) self-registers at load with
+  `Engine.transports["…"] = self`. External transports (e.g. `nnq-zstd`'s
+  `zstd+tcp://`) can register themselves the same way.
+- **`ConnectionLifecycle` calls `transport.wrap_connection(conn, engine)`
+  after handshake.** Transports that implement the hook can return a
+  delegating wrapper that layers compression / TLS / instrumentation
+  over the raw `NNQ::Connection` without the engine caring. Transports
+  without the hook (tcp/ipc/inproc) pass through unchanged.
+- **`lib/nnq.rb` restructured to mirror `lib/omq.rb`.** Requires split
+  into Core / Transport / Socket-types sections. New
+  `lib/nnq/constants.rb` owns `MonitorEvent`, the `CONNECTION_LOST` /
+  `CONNECTION_FAILED` error arrays, and `NNQ.freeze_for_ractors!` — all
+  previously scattered across `engine.rb`, `reconnect.rb`,
+  `monitor_event.rb`, and the top-level `nnq.rb`. `monitor_event.rb` is
+  removed (absorbed into constants).
+- **Benchmarks: richer scaffolding, measured via `Async::Clock`.**
+  `BenchHelper` gains `NNQ_BENCH_SIZES` / `NNQ_BENCH_TRANSPORTS` /
+  `NNQ_BENCH_PEERS` env overrides, a `measure_roundtrip` helper for
+  REQ/REP-style patterns, and a `wait_subscribed` helper that closes
+  the gap between TCP connect and SUBSCRIBE propagation. All elapsed
+  measurements use `Async::Clock.measure { … }` blocks instead of
+  `Process.clock_gettime`. `bench/report.rb --update-readme` now
+  falls back to the most recent row per cell across all history, so a
+  partial bench run refreshes only the cells it covers instead of
+  clobbering untouched cells with "—".
+
 ## 0.6.1 — 2026-04-15
 
 - **Verbose trace (`-vvv`) now fires for cooked REQ/REP/RESPONDENT

data/lib/nnq/bus.rb

@@ -13,7 +13,7 @@ module NNQ
   #
   class BUS0 < Socket
     def send(body)
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 

data/lib/nnq/constants.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "socket"
+require "io/stream"
+
+module NNQ
+  # Lifecycle event emitted by {Socket#monitor}.
+  #
+  # @!attribute [r] type
+  #   @return [Symbol] event type (:listening, :connected, :disconnected, ...)
+  # @!attribute [r] endpoint
+  #   @return [String, nil] the endpoint involved
+  # @!attribute [r] detail
+  #   @return [Hash, nil] extra context
+  #
+  MonitorEvent = Data.define(:type, :endpoint, :detail) do
+    def initialize(type:, endpoint: nil, detail: nil)
+      super
+    end
+  end
+
+
+  # Errors that indicate an established connection went away. Used by
+  # the recv loop, routing pumps, and connection lifecycle to silently
+  # terminate (the connection lifecycle's #lost! handler decides
+  # whether to reconnect). Not frozen at load time — transport plugins
+  # append to this before the first bind/connect, which freezes both
+  # arrays.
+  CONNECTION_LOST = [
+    EOFError,
+    IOError,
+    Errno::ECONNRESET,
+    Errno::EPIPE,
+  ]
+
+
+  # Errors raised when a peer cannot be reached. Triggers a reconnect
+  # retry rather than propagating.
+  CONNECTION_FAILED = [
+    Errno::ECONNREFUSED,
+    Errno::EHOSTUNREACH,
+    Errno::ENETUNREACH,
+    Errno::ENOENT,
+    Errno::EPIPE,
+    Errno::ETIMEDOUT,
+    Socket::ResolutionError,
+  ]
+
+
+  # Freezes module-level state so NNQ sockets can be used inside Ractors.
+  # Call this once before spawning any Ractors that create NNQ sockets.
+  #
+  def self.freeze_for_ractors!
+    CONNECTION_LOST.freeze
+    CONNECTION_FAILED.freeze
+    Engine.transports.freeze
+  end
+end

data/lib/nnq/engine/connection_lifecycle.rb

@@ -104,6 +104,15 @@ module NNQ
       end
 
 
+      # Registers an already-ready connection object (e.g. an
+      # {Transport::Inproc::Pipe}) without running the SP handshake.
+      # Transports that frame on the wire should call {#handshake!}
+      # instead.
+      def ready_direct!(conn)
+        ready!(conn)
+      end
+
+
       # Starts a supervisor for this connection. Must be called after
       # all per-connection pumps (recv loop, send pump) have been
       # spawned on the connection barrier. The supervisor blocks until
@@ -121,6 +130,7 @@ module NNQ
       private
 
       def ready!(conn)
+        conn                     = wrap_connection(conn)
         @conn                    = conn
         @engine.connections[conn] = self
         transition!(:ready)
@@ -141,6 +151,11 @@ module NNQ
       def tear_down!(reconnect: false)
         return if @state == :closed
         transition!(:closed)
+        # Cancel sibling pumps BEFORE closing the fd. If we close first,
+        # any pump still parked in io_wait wakes up with
+        # `IOError: stream closed in another thread`. The caller is the
+        # supervisor task, which is NOT in the barrier — no self-stop.
+        @barrier.stop
         if @conn
           @engine.connections.delete(@conn)
           @engine.routing.connection_removed(@conn) if @engine.routing.respond_to?(:connection_removed)
@@ -149,10 +164,6 @@ module NNQ
           @engine.resolve_all_peers_gone_if_empty
         end
         @engine.maybe_reconnect(@endpoint) if reconnect
-        # Cancel every sibling pump of this connection. The caller is
-        # the supervisor task, which is NOT in the barrier — so there
-        # is no self-stop risk.
-        @barrier.stop
       end
 
 
@@ -170,6 +181,19 @@ module NNQ
       end
 
 
+      # Post-handshake transport wrap. A transport that implements
+      # `wrap_connection(conn)` (e.g. nnq-zstd's zstd+tcp) returns a
+      # delegating wrapper that adds a layer (compression, TLS, …)
+      # without the engine caring. Unknown or hook-less transports pass
+      # through unchanged.
+      def wrap_connection(conn)
+        return conn unless @endpoint
+        transport = @engine.transport_for(@endpoint)
+        return conn unless transport.respond_to?(:wrap_connection)
+        transport.wrap_connection(conn, @engine)
+      end
+
+
       # Handshake timeout: same logic as TCP.connect_timeout — derived
       # from reconnect_interval (floor 0.5s). Prevents a hang when the
       # peer accepts the TCP connection but never sends an SP greeting.

data/lib/nnq/engine/reconnect.rb

@@ -2,31 +2,6 @@
 
 module NNQ
   class Engine
-    # Connection errors that should trigger a reconnect retry rather
-    # than propagate. Mutable at load time so plugins (e.g. a future
-    # TLS transport) can append their own error classes; frozen on
-    # first {Engine#connect}.
-    CONNECTION_FAILED = [
-      Errno::ECONNREFUSED,
-      Errno::EHOSTUNREACH,
-      Errno::ENETUNREACH,
-      Errno::ENOENT,
-      Errno::EPIPE,
-      Errno::ETIMEDOUT,
-      Socket::ResolutionError,
-    ]
-
-    # Errors that indicate an established connection went away. Used
-    # by the recv loop and pumps to silently terminate (the connection
-    # lifecycle's #lost! handler decides whether to reconnect).
-    CONNECTION_LOST = [
-      EOFError,
-      IOError,
-      Errno::ECONNRESET,
-      Errno::EPIPE,
-    ]
-
-
     # Schedules reconnect attempts with exponential back-off.
     #
     # Runs a background task that loops until a connection is
@@ -61,7 +36,7 @@ module NNQ
             sleep quantized_wait(delay) if delay > 0
             break if @engine.closed?
             begin
-              @engine.transport_for(@endpoint).connect(@endpoint, @engine)
+              @engine.transport_for(@endpoint).connect(@endpoint, @engine, **@engine.dial_opts_for(@endpoint))
               break
             rescue *CONNECTION_FAILED, *CONNECTION_LOST => e
               delay = next_delay(delay, max_delay)

data/lib/nnq/engine.rb

@@ -4,16 +4,9 @@ require "async"
 require "async/clock"
 require "set"
 require "protocol/sp"
-require_relative "error"
-require_relative "connection"
-require_relative "monitor_event"
-require_relative "reactor"
 require_relative "engine/socket_lifecycle"
 require_relative "engine/connection_lifecycle"
 require_relative "engine/reconnect"
-require_relative "transport/tcp"
-require_relative "transport/ipc"
-require_relative "transport/inproc"
 
 module NNQ
   # Per-socket orchestrator. Owns the listener set, the connection map
@@ -25,11 +18,18 @@ module NNQ
   # no HWM bookkeeping, no mechanisms, no heartbeat, no monitor queue.
   #
   class Engine
-    TRANSPORTS = {
-      "tcp"    => Transport::TCP,
-      "ipc"    => Transport::IPC,
-      "inproc" => Transport::Inproc,
-    }
+    # Scheme → transport module registry. Each transport file
+    # self-registers on require; plugins (e.g. nnq-zstd) add more:
+    #
+    #   NNQ::Engine.transports["zstd+tcp"] = NNQ::Transport::ZstdTcp
+    #
+    @transports = {}
+
+
+    class << self
+      # @return [Hash{String => Module}] registered transports
+      attr_reader :transports
+    end
 
 
     # @return [Integer] our SP protocol id (e.g. Protocols::PUSH_V0)
@@ -95,6 +95,7 @@ module NNQ
       @monitor_queue   = nil
       @verbose_monitor = false
       @dialed          = Set.new
+      @dial_opts       = {} # endpoint => kwargs for transport.connect on reconnect
       @routing         = yield(self)
     end
 
@@ -191,9 +192,9 @@ module NNQ
 
 
     # Binds to +endpoint+. Synchronous: errors propagate.
-    def bind(endpoint)
+    def bind(endpoint, **opts)
       transport = transport_for(endpoint)
-      listener  = transport.bind(endpoint, self)
+      listener  = transport.bind(endpoint, self, **opts)
       listener.start_accept_loop(@lifecycle.barrier) do |io, framing = :tcp|
         handle_accepted(io, endpoint: endpoint, framing: framing)
       end
@@ -207,12 +208,13 @@ module NNQ
     # actual dial happens inside a background reconnect task that
     # retries with exponential back-off until the peer becomes
     # reachable. Inproc connect is synchronous and instant.
-    def connect(endpoint)
+    def connect(endpoint, **opts)
       @dialed << endpoint
+      @dial_opts[endpoint] = opts unless opts.empty?
       @last_endpoint = endpoint
 
       if endpoint.start_with?("inproc://")
-        transport_for(endpoint).connect(endpoint, self)
+        transport_for(endpoint).connect(endpoint, self, **opts)
       else
         emit_monitor_event(:connect_delayed, endpoint: endpoint)
         Reconnect.schedule(endpoint, @options, @lifecycle.barrier, self, delay: 0)
@@ -220,6 +222,14 @@ module NNQ
     end
 
 
+    # Transport options captured from {#connect} for +endpoint+. Used by
+    # {Reconnect} to re-dial with the original kwargs. Empty hash for
+    # endpoints connected without extra options.
+    def dial_opts_for(endpoint)
+      @dial_opts[endpoint] || {}
+    end
+
+
     # Schedules a reconnect for +endpoint+ if auto-reconnect is enabled
     # and the endpoint is still in the dialed set. Called from the
     # connection lifecycle's `lost!` path.
@@ -235,7 +245,7 @@ module NNQ
     # transport from the URL each iteration.
     def transport_for(endpoint)
       scheme = endpoint[/\A([a-z+]+):\/\//i, 1] or raise Error, "no scheme: #{endpoint}"
-      TRANSPORTS[scheme] or raise Error, "unsupported transport: #{scheme}"
+      Engine.transports[scheme] or raise Error, "unsupported transport: #{scheme}"
     end
 
 
@@ -263,6 +273,19 @@ module NNQ
     end
 
 
+    # Registers an already-connected, framing-free pipe (inproc). Skips
+    # the SP handshake entirely — {Transport::Inproc::Pipe} is a Ruby
+    # duck-type for {NNQ::Connection} and has no wire protocol.
+    def connection_ready(conn, endpoint:)
+      lifecycle = ConnectionLifecycle.new(self, endpoint: endpoint, framing: :inproc)
+      lifecycle.ready_direct!(conn)
+      spawn_recv_loop(conn) if @routing.respond_to?(:enqueue) && @connections.key?(conn)
+      lifecycle.start_supervisor!
+    rescue ConnectionRejected
+      # routing rejected this peer (e.g. PAIR already bonded)
+    end
+
+
     # Spawns a task under the given parent barrier (defaults to the
     # socket-level barrier). Used by routing strategies (e.g. PUSH send
     # pump) to attach long-lived fibers to the engine's lifecycle. The
@@ -345,9 +368,21 @@ module NNQ
 
 
     def spawn_recv_loop(conn)
+      # Inproc fast-path: wire the peer pipe to enqueue directly into
+      # the routing recv queue, skipping both the recv pump fiber and
+      # the intermediate pipe queue. Cuts three fiber hops to one on
+      # PUSH/PULL and peers.
+      if conn.is_a?(Transport::Inproc::Pipe) && conn.peer && @routing.respond_to?(:direct_recv_for)
+        queue, transform = @routing.direct_recv_for(conn)
+        if queue
+          conn.peer.wire_direct_recv(queue, transform)
+          return
+        end
+      end
+
       @connections[conn].barrier.async(annotation: "nnq recv #{conn.endpoint}") do
         loop do
-          body = conn.receive_message
+          body = conn.receive_message.freeze
           if @verbose_monitor
             preview = @routing.respond_to?(:preview_body) ? @routing.preview_body(body) : body
             emit_verbose_msg_received(preview)

data/lib/nnq/pair.rb

@@ -10,7 +10,7 @@ module NNQ
   #
   class PAIR0 < Socket
     def send(body)
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 

data/lib/nnq/pub_sub.rb

@@ -12,7 +12,7 @@ module NNQ
   #
   class PUB0 < Socket
     def send(body)
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 

data/lib/nnq/push_pull.rb

@@ -11,7 +11,7 @@ module NNQ
   #
   class PUSH0 < Socket
     def send(body)
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 

data/lib/nnq/req_rep.rb

@@ -18,7 +18,7 @@ module NNQ
     # raw mode — use {#send} / {#receive} there.
     def send_request(body)
       raise Error, "REQ#send_request not available in raw mode" if raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send_request(body) }
     end
 
@@ -29,7 +29,7 @@ module NNQ
     # cooked mode.
     def send(body, header:)
       raise Error, "REQ#send not available in cooked mode" unless raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body, header: header) }
     end
 
@@ -74,7 +74,7 @@ module NNQ
     # came from. Raises in raw mode.
     def send_reply(body)
       raise Error, "REP#send_reply not available in raw mode" if raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send_reply(body) }
     end
 
@@ -84,7 +84,7 @@ module NNQ
     # tuple). Silent drop if +to+ is closed. Raises in cooked mode.
     def send(body, to:, header:)
       raise Error, "REP#send not available in cooked mode" unless raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body, to: to, header: header) }
     end
 

data/lib/nnq/routing/backtrace.rb

@@ -27,7 +27,7 @@ module NNQ
           hops   += 1
 
           if word.getbyte(0) & 0x80 != 0
-            return [body.byteslice(0, offset), body.byteslice(offset..)]
+            return [body.byteslice(0, offset).freeze, body.byteslice(offset..).freeze]
           end
         end
 

data/lib/nnq/routing/bus.rb

@@ -22,7 +22,6 @@ module NNQ
       def initialize(engine)
         @engine     = engine
         @queues     = {} # conn => Async::LimitedQueue
-        @pump_tasks = {} # conn => Async::Task
         @recv_queue = Async::Queue.new
       end
 
@@ -44,6 +43,13 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook: peer pipe enqueues directly into the
+      # shared recv queue — identity transform, no backtrace or filter.
+      def direct_recv_for(_conn)
+        [@recv_queue, nil]
+      end
+
+
       # @return [String, nil] message body, or nil once the socket is closed
       def receive
         @recv_queue.dequeue
@@ -52,18 +58,13 @@ module NNQ
 
       def connection_added(conn)
         queue = Async::LimitedQueue.new(@engine.options.send_hwm)
-        @queues[conn]     = queue
-        @pump_tasks[conn] = spawn_pump(conn, queue)
+        @queues[conn] = queue
+        spawn_pump(conn, queue)
       end
 
 
       def connection_removed(conn)
         @queues.delete(conn)
-        task = @pump_tasks.delete(conn)
-        return unless task
-        return if task == Async::Task.current
-        task.stop
-      rescue IOError, Errno::EPIPE
       end
 
 
@@ -73,8 +74,6 @@ module NNQ
 
 
       def close
-        @pump_tasks.each_value(&:stop)
-        @pump_tasks.clear
         @queues.clear
         @recv_queue.enqueue(nil)
       end

data/lib/nnq/routing/pair.rb

@@ -48,6 +48,13 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook: peer pipe enqueues straight into the
+      # local recv queue.
+      def direct_recv_for(_conn)
+        [@recv_queue, nil]
+      end
+
+
       # First-pipe-wins. Raising {ConnectionRejected} tells the
       # ConnectionLifecycle to tear down the just-registered connection
       # without ever exposing it to pumps.

data/lib/nnq/routing/pub.rb

@@ -19,9 +19,8 @@ module NNQ
     #
     class Pub
       def initialize(engine)
-        @engine     = engine
-        @queues     = {} # conn => Async::LimitedQueue
-        @pump_tasks = {} # conn => Async::Task
+        @engine = engine
+        @queues = {} # conn => Async::LimitedQueue
       end
 
 
@@ -42,19 +41,13 @@ module NNQ
         # control into the new task body, which parks on queue.dequeue;
         # at that park the publisher fiber can run and must already see
         # this peer's queue.
-        @queues[conn]     = queue
-        @pump_tasks[conn] = spawn_pump(conn, queue)
+        @queues[conn] = queue
+        spawn_pump(conn, queue)
       end
 
 
       def connection_removed(conn)
         @queues.delete(conn)
-        task = @pump_tasks.delete(conn)
-        return unless task
-        return if task == Async::Task.current
-        task.stop
-      rescue IOError, Errno::EPIPE
-        # pump was mid-flush; already unwinding
       end
 
 
@@ -65,8 +58,6 @@ module NNQ
 
 
       def close
-        @pump_tasks.each_value(&:stop)
-        @pump_tasks.clear
         @queues.clear
       end
 

data/lib/nnq/routing/pull.rb

@@ -22,6 +22,14 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook: return the routing recv queue so the
+      # peer pipe can enqueue directly, skipping the recv pump fiber.
+      # Identity transform — PULL bodies are the user payload already.
+      def direct_recv_for(_conn)
+        [@queue, nil]
+      end
+
+
       # @return [String, nil] message body, or nil if the queue was closed
       def receive
         @queue.dequeue

data/lib/nnq/routing/rep.rb

@@ -89,6 +89,17 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook: peer pipe parses the backtrace and
+      # enqueues the same [conn, btrace, payload] tuple the pump would.
+      def direct_recv_for(conn)
+        transform = lambda do |body|
+          btrace, payload = parse_backtrace(body)
+          btrace ? [conn, btrace, payload] : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       def connection_removed(conn)
         @mutex.synchronize do
           @pending = nil if @pending && @pending[0] == conn

data/lib/nnq/routing/rep_raw.rb

@@ -56,6 +56,16 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook.
+      def direct_recv_for(conn)
+        transform = lambda do |wire_bytes|
+          header, payload = parse_backtrace(wire_bytes)
+          header ? [conn, header, payload] : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       def close
         @recv_queue.enqueue(nil)
       end

data/lib/nnq/routing/req.rb

@@ -71,7 +71,7 @@ module NNQ
       def enqueue(body, _conn)
         return if body.bytesize < 4
         id      = body.unpack1("N")
-        payload = body.byteslice(4..)
+        payload = body.byteslice(4..).freeze
 
         @mutex.synchronize do
           if @outstanding && @outstanding[0] == id