comq 0.22.0 → 0.24.0

package/discussions/amqp-1.0.md

@@ -0,0 +1,127 @@
+# AMQP 1.0
+
+**comq stays on AMQP 0-9-1 over [amqplib](https://github.com/amqp-node/amqplib).**
+
+RabbitMQ 4 speaks AMQP 1.0 natively and keeps 0-9-1 as a first-class protocol; both are
+supported out of the box and neither is on its way out. The choice is therefore comq's to make on
+what each protocol and each client gives it, and the answer today is that 1.0 costs a rewrite of
+the transport layer, changes comq's public API, breaks the wire between comq versions, and
+returns nothing comq uses.
+
+Two separate questions hide in "switch to the official client", and they have different answers.
+The client is unusable for comq today. The protocol is usable and in places cleaner, and still
+does not pay for itself.
+
+Measured on 2026-09-20 against RabbitMQ 4.3.6, with `rabbitmq-amqp-js-client` 1.0.0, `rhea` 3.0.5
+and `amqplib` 2.0.1.
+
+## The client
+
+[`rabbitmq-amqp-js-client`](https://github.com/coders51/rabbitmq-amqp-js-client) is listed among
+RabbitMQ's AMQP 1.0 client libraries and is maintained by coders51 rather than by the RabbitMQ
+team, unlike the Java, .NET, Go and Python clients. It is a thin wrapper over
+[rhea](https://github.com/amqp/rhea), which does the protocol.
+
+What it offers an application is a connection, a publisher, a consumer and a management link.
+What comq needs from a client, it does not reach:
+
+| comq | the client |
+|---|---|
+| 16 [diagnostic events](../readme.md#diagnostics) | connection, publisher and consumer state changes are unobservable ([#40](https://github.com/coders51/rabbitmq-amqp-js-client/issues/40)) |
+| [`seal`](../readme.md#sealing) stops consuming and waits | `Consumer.close` is synchronous and returns nothing ([#34](https://github.com/coders51/rabbitmq-amqp-js-client/issues/34)) |
+| topology recovered after a reconnect | the links come back, the topology does not ([#42](https://github.com/coders51/rabbitmq-amqp-js-client/issues/42)) |
+| prefetch 300, per channel | rhea's default credit window of 1000, fixed |
+| Requests and Replies are published unconfirmed | `publish` always awaits settlement |
+| `amqp://user:pass@host/vhost`, heartbeat 15s | host, port, username, password |
+
+Three defects it has today would each stop comq on its own:
+
+- **A publish to a queue that does not exist never settles.** The broker refuses the attach with
+  `amqp:not-found`; `createPublisher` resolves regardless, and the `publish` promise stays
+  pending forever.
+- **Attaching to another connection's exclusive queue kills the process.** `createConsumer`
+  resolves, the broker ends the session, and rhea emits an unhandled `error` on a container the
+  client keeps private. That is exactly what [`back`](../readme.md#addressed-requests) does on
+  every key already held.
+- **Every body goes out as an `amqp-value` section**, Buffers included, so a 0-9-1 consumer
+  receives the section bytes in front of the payload and `type: 'amqp-1.0'` among the properties.
+  A process on 0-9-1 and a process on the client cannot exchange a message, which rules out a
+  rolling migration. rhea with an explicit `data_section` interoperates cleanly, so this is the
+  client's message model rather than the protocol.
+
+Queue `arguments` are typed `Record<string, string>` while the broker requires integers for
+`x-message-ttl` (`expected integer, got longstr`) and accepts the numbers the typing forbids. The
+dependency on rhea is `github:amqp/rhea` — a git reference that resolves to `git+ssh` in a
+lockfile and builds on install, which would land in comq's dependency tree and in every CI that
+installs comq.
+
+Adopted with those gaps filled locally, "the official client" becomes "rhea, plus a management
+link we wrote" — which is the layer comq already is, over a client with fifteen years behind it.
+
+## The protocol
+
+Everything comq does is expressible over AMQP 1.0, and three mechanisms fit it better than 0-9-1
+does:
+
+- **An unroutable publish comes back as a `RELEASED` outcome on the send itself**, where 0-9-1
+  reports it asynchronously through `mandatory` and `basic.return` and comq has to correlate it.
+- **The `ttl` header is honoured per message**, so a [`call`](../readme.md#timeout)'s expiration
+  carries unchanged.
+- **Credit is granted per link**, which is what comq's [channel segregation](../readme.md#channels)
+  approximates with a prefetch count per channel.
+
+The rest holds: an exclusive queue declared over the management link is refused to a second
+connection (`400 cannot obtain exclusive access`), so `back` still holds a Key; numeric queue
+arguments are accepted, so the [retry ladder](../readme.md#retries) and `comq.parked` are
+unchanged. Streams with offsets and server-side filters are the one capability 0-9-1 cannot match,
+and comq consumes no streams.
+
+### What it costs
+
+**comq's public API is shaped by 0-9-1.** `Properties` is in the consumer signature, `emit`,
+`enqueue` and `route` take publish options, and `discard`, `retry` and `return` hand listeners a
+raw amqplib message. Every one of those changes, and so does what reads them — `@toa.io/bindings.amqp`
+reads `message.properties.correlationId` and `properties.headers`.
+
+**Message properties land elsewhere.** A 0-9-1 header prefixed `x-` arrives over 1.0 as a message
+annotation rather than an application property, beside the broker's own `x-exchange` and
+`x-routing-key`; `replyTo: 'rq'` arrives as `/queues/rq`. comq's [`x-comq-*` headers](../docs/headers.md)
+move with them.
+
+**The management UI and API stop reporting message rates** for AMQP 1.0 connections; queue depth
+survives, `message_stats` is null. Frame-intercepting plugins and transactions are 0-9-1 only,
+and comq uses neither.
+
+**The work is the transport layer and the unit suite.** `source/connection.js` and
+`source/channel.js` are 1,256 lines written against amqplib's channel API, `source/io.js` another
+797 that speak its vocabulary, and `test/` is built on `test/amqplib.mock.js` — some 6,400 lines
+that go with the thing they mock. The 88 scenarios in `features/` are behaviour-level and would
+carry over, which makes them the whole safety net for the change.
+
+### What it does not buy
+
+Throughput is level and the latency comq optimises for is worse. Same broker over loopback,
+20,000 messages of ~180 bytes, three runs, `TCP_NODELAY` on both:
+
+| | amqplib | rhea |
+|---|---|---|
+| publish, awaiting confirmation or settlement | 77–88k msg/s | 79–103k msg/s |
+| consume and acknowledge | 121–143k msg/s | 110–128k msg/s |
+
+Sequential request and reply, 2,000 round trips, one in flight:
+
+| | p50 | p99 |
+|---|---|---|
+| amqplib | 0.20 ms | 0.36–0.41 ms |
+| rhea | 0.26–0.29 ms | 0.51–0.57 ms |
+
+rhea enables `TCP_NODELAY` when a receiver is attached and leaves it to the `tcp_no_delay` option
+otherwise, so a connection that only publishes is left to Nagle — the same delay comq took out of
+amqplib in 0.20.1, and worth 22 ms per round trip when it is missed.
+
+## What would reverse this
+
+- comq needs RabbitMQ streams with server-side filtering.
+- The client exposes connection and link state, a consumer close that waits, a credit setting and
+  a vhost — the four things its own issues already name.
+- RabbitMQ announces an end for AMQP 0-9-1.

package/discussions/one-parking-queue.md

@@ -0,0 +1,63 @@
+# One parking queue
+
+> Supersedes the parking queue's naming and lifetime in
+> [poison message handling](./poison-message-handling.md), Part 1. Everything else about
+> parking — when a message is parked, what it carries, what is published before what — is
+> unchanged.
+
+Everything a consumer could not process is kept in one queue, `comq.parked`, whatever it was
+consumed from. It is durable, it is declared once per channel beside the retry queues, and comq
+never removes it or what is in it.
+
+A parked message already says where it came from. `x-comq-queue` is the queue it was consumed
+from, `x-comq-exchange` and `x-comq-key` where it was originally published, and all three are
+recorded on the first failure rather than read at parking time. Reading one source's parked
+messages is a match on `x-comq-queue`.
+
+## What this changes
+
+| | before | after |
+|---|---|---|
+| parking queues | one per consumed queue | one |
+| its lifetime | the lifetime of the queue it served | durable, always |
+| what a groupless subscriber parks | went with its connection | kept |
+| scales with | how many queues the connection consumes | nothing |
+
+## Why the queue per source goes
+
+**It was measured.** The cost of this design was worked through when it was made, at 200 source
+queues and 200 parking queues, and accepted. In a deployment of about forty processes the
+parking queues came to 1318 of 2731 queues on the broker — 48 % — and every one of them was
+empty, with no consumer and no message it had ever held. At about 70 KB of broker memory per
+queue, that is the largest single item on a broker that had been blocking publishers on a memory
+alarm.
+
+The count is what makes it grow: one per consumed queue means the broker pays for how widely an
+application is decomposed, forever, whether or not anything ever fails.
+
+**Depth per source survives.** The reason recorded for the queue per source was that depth per
+consumer is how anyone notices a problem. What notices a problem is the `discard` diagnostic,
+which fires per parked message and names the queue it came from. Depth in `comq.parked` still
+says how much is waiting, and `x-comq-queue` still says what for.
+
+**The lifetime rule goes with it.** The parking queue mirrored its source's durability so that a
+durable parking queue would not be left behind an exclusive `amq.gen-*` source — one leaked per
+restart, forever. With a fixed name there is nothing to leak, and the rule that prevented the
+leak was throwing away the evidence it was meant to keep: a groupless subscriber's failures
+vanished with its connection, at the moment there was nobody left to tell.
+
+## Upgrading
+
+`comq.parked.<queue>` queues from an earlier version keep whatever they already hold. comq stops
+declaring them and stops publishing to them, so they are drained and deleted once, by hand.
+
+Nothing is redeclared with different arguments, so no assertion answers `PRECONDITION_FAILED`
+and no broker has to be emptied. During a rollout the processes still on the old version go on
+parking per source and the new ones park in `comq.parked`; both are readable, and both say
+which queue a message came from.
+
+## What comq says about it
+
+That the queue is there, that a message in it names its source, and that comq removes neither.
+What to do with a queue on a broker — a `max-length`, a TTL, an alert on depth — is read off
+those facts by whoever can see the broker.

package/discussions/one-reply-queue.md

@@ -0,0 +1,44 @@
+# One reply queue
+
+An `IO` receives every reply on one queue, `comq.reply..<id>`, whatever it sent the request to.
+
+A reply is found by its `correlationId`. `ReplyEmitter.next` builds one from eight random bytes
+and a counter, and it is unique across processes — it has to be, because a producer's control
+queue sees the requests of every consumer and tells them apart by nothing else. Routing a reply
+reads that identifier and nothing else: the queue it arrived on was never consulted.
+
+## What this changes
+
+| | before | after |
+|---|---|---|
+| reply queues | one per distinct queue or exchange requested | one |
+| its name | `<target>..<id>` | `comq.reply..<id>` |
+| scales with | how widely the caller fans out | nothing |
+
+Both are exclusive, so both go with the connection. A sharded connection holds one per shard, as
+it held one per target per shard before.
+
+## Why the queue per target goes
+
+The count was the caller's to set and the broker's to pay: a connection that requests fifty
+queues held fifty queues and fifty consumers for as long as it lived, whether or not it ever
+requested them again. Nothing bounded it but how widely the application was decomposed.
+
+The name was the argument for it — a queue named after what is being called says, to somebody
+reading the broker, who is waiting on what. It says it of a queue that carries no messages
+between requests, and the same thing is on every message that does pass through: `correlationId`
+identifies the request, and the reply-side handler knows which one it belongs to.
+
+## What is given up
+
+Reading the broker no longer tells you which operations a connection calls. A reply queue names
+its connection instead, and what it is waiting for is in flight rather than on the broker.
+
+## Upgrading
+
+Reply queues are exclusive and are asserted on the first request, so a process on the old
+version and one on the new hold different queues and neither declares the other's. Nothing is
+redeclared, and a rollout needs no order.
+
+A parked request keeps the `replyTo` it was sent with, so one parked by an old process still
+names the queue that process was listening on — which, as before, is gone once that process is.

package/discussions/poison-message-handling.md

@@ -7,7 +7,8 @@
 > where it survives a retry.
 >
 > **All three parts are implemented.** Text below is written as a proposal because that is what
-> it was; it describes what the code now does.
+> it was; it describes what the code now does — except for the parking queue's name and
+> lifetime, which [one parking queue](./one-parking-queue.md) supersedes.
 
 When a consumer callback rejects, comq is supposed to retry the message a few times and then
 give up on it. What it actually does is kill the process, and take every other consumer in that

package/docs/headers.md

@@ -26,7 +26,7 @@ the message properties.
 | `x-comq-attempt` | a retried message | Which attempt this delivery is, counting from one. Absent on the first, so read it as `headers?.['x-comq-attempt'] ?? 1`. The last attempt is one more than the number of rungs in the [backoff ladder](../readme.md#retries). |
 | `x-comq-exchange` | a retried or parked message | The exchange it was originally published to. |
 | `x-comq-key` | a retried or parked message | The routing key it was originally published with. |
-| `x-comq-queue` | a parked message | The queue it was consumed from. |
+| `x-comq-queue` | a parked message | The queue it was consumed from. One `comq.parked` queue holds what every source parked, so this is what tells them apart. |
 | `x-comq-reason` | a parked message | The `message` of the exception that ended its attempts. |
 | `x-comq-cause` | a parked message | The `message` of that exception's `cause`, when it has one — a verdict is usually thrown with the failure that prompted it. |
 | `x-comq-at` | a parked message | When it was parked, as `Date.now()`. |

package/features/parking.feature

@@ -0,0 +1,32 @@
+Feature: The parking queue
+
+  What a consumer could not process is kept in one queue, `comq.parked`, whatever it was
+  consumed from. The message says where it came from, so the queue does not have to.
+
+  Background:
+    Given an active connection to the broker
+
+  Scenario: Messages parked from two queues are kept in one
+
+    A queue per source would repeat what every parked message already carries, and
+    would stay on the broker for as long as the broker does.
+
+    Given that events from the `parking_left` exchange are causing exceptions
+    And that events from the `parking_right` exchange are causing exceptions
+    When an event is emitted to the `parking_left` exchange
+    And an event is emitted to the `parking_right` exchange
+    Then a message parked from the `parking_left` exchange is in the parking queue
+    And a message parked from the `parking_right` exchange is in the parking queue
+
+  Scenario: A message parked from a groupless subscription outlives its connection
+
+    A groupless subscriber consumes a queue of its own that the broker removes with the
+    connection. What it could not process is not ephemeral: it is waiting for a person,
+    and there is nobody left to tell.
+
+    Given that groupless events from the `parking_ephemeral` exchange are causing exceptions
+    When an event is emitted to the `parking_ephemeral` exchange
+    And the message is parked
+    And the connection is closed
+    And an active connection to the broker
+    Then a message parked from the `parking_ephemeral` exchange is in the parking queue

package/features/rpc.call.feature

@@ -65,7 +65,29 @@ Feature: Calls under a key
   Scenario: A caller stops waiting for a holder that crashed
     Given a holder never answering `void` under the `a` key
     When the consumer calls `void` under the `a` key with a 1000ms timeout
-    And after 100ms
+    And the silent holder has taken the call
     And the silent holder crashes
     Then the consumer stops waiting
     And a call to `void` under the `a` key is refused within 10 seconds
+
+  Scenario: A caller stops waiting at its timeout
+    Given a holder on another connection answering `slow` under the `a` key in 1000ms
+    When the consumer calls `slow` under the `a` key with a 200ms timeout
+    Then the consumer stops waiting
+
+  Scenario: A call its holder has not taken in time is never processed
+    Given a holder not taking `later` under the `a` key
+    When the consumer calls `later` under the `a` key with a 200ms timeout
+    Then the consumer stops waiting
+    When after 300ms
+    And the idle holder starts taking
+    Then the idle holder takes nothing
+
+  Scenario: A call abandoned by its signal stays in its queue
+    Given a holder not taking `stray` under the `a` key
+    When the consumer calls `stray` under the `a` key with a signal
+    And after 100ms
+    And the signal aborts
+    Then the consumer stops waiting for the aborted call
+    When the idle holder starts taking
+    Then the idle holder takes the call

package/features/rpc.call.recovery.feature

@@ -39,13 +39,6 @@ Feature: Calls under a key across failures
     And the broker is up
     Then the call ends
 
-  Scenario: A caller stops waiting for a request at its timeout while the broker is down
-    Given an active connection to the broker
-    And a producer replying `echo` queue
-    When the broker has crashed
-    And the consumer sends a request to the `echo` queue with a 1000ms timeout
-    Then the consumer stops waiting within 5 seconds
-
   Scenario: A caller stops waiting for a call at its timeout while the broker is down
     Given an active connection to the broker
     And a holder on another connection answering `echo` under the `a` key
@@ -53,20 +46,6 @@ Feature: Calls under a key across failures
     And the consumer calls `echo` under the `a` key with a 1000ms timeout
     Then the consumer stops waiting within 5 seconds
 
-  Scenario: A request re-sent after the broker restarts expires at its caller's deadline
-
-    The request is lost with the broker and sent again once the connection is restored, carrying
-    the time its caller has left.
-
-    Given an active connection to the broker
-    When the consumer sends a request to the `resent` queue with a 30000ms timeout
-    And after 200ms
-    And the broker has crashed
-    And the broker is up
-    Then the consumer stops waiting within 40 seconds
-    When a producer counting requests to the `resent` queue
-    Then the producer receives nothing
-
   Scenario: A call reaches its holder while one of the brokers is down
     Given an active sharded connection
     And a holder on another connection answering `echo` under the `a` key

package/features/rpc.parked.feature

@@ -5,13 +5,13 @@ Feature: Parked requests
 
   Scenario: A parked request can still be answered
 
-    A caller that sets no timeout is certain of an eventual answer for as long as it is
-    alive, and parking is what keeps that true when no consumer can produce one: the
-    request is kept, along with who was asking. Somebody else can answer it, and the
-    caller — still waiting, still holding an exclusive reply queue — receives it.
+    A caller is certain of an eventual answer for as long as it is alive, and parking
+    is what keeps that true when no consumer can produce one: the request is kept, along
+    with who was asking. Somebody else can answer it, and the caller — still waiting,
+    still holding an exclusive reply queue — receives it.
 
-    A caller that sets a timeout trades that for an end to the wait: once it stops
-    waiting, a parked request is addressed to a caller that has gone.
+    This is why a request has no timeout and cannot be withdrawn: either would leave the
+    parked message addressed to a caller that is no longer listening.
 
     Given a producer failing every request to the `unanswerable` queue
     When a request is sent to the `unanswerable` queue

package/features/rpc.replies.feature

@@ -0,0 +1,26 @@
+Feature: Reply queues
+
+  A connection consumes its replies from one queue, whatever it sends requests to. The
+  reply is found by its correlation identifier, which is unique across processes, so the
+  queue does not have to name what was called.
+
+  Scenario: One reply queue however many queues are requested
+
+    Given an active connection to the broker
+    And a producer replying `replies_alpha` queue
+    And a producer replying `replies_beta` queue
+    When the consumer sends a request to the `replies_alpha` queue
+    Then the consumer receives the reply
+    When the consumer sends a request to the `replies_beta` queue
+    Then the consumer receives the reply
+    And the broker holds 1 reply queue
+
+  Scenario: One reply queue per shard
+
+    A shard is a broker of its own, and a request published to one is answered on it.
+
+    Given an active sharded connection
+    And a producer replying `replies_sharded` queue
+    When the consumer sends 10 requests to the `replies_sharded` queue
+    Then all replies have been received
+    And each broker holds 1 reply queue

package/features/steps/brokers.js

@@ -12,8 +12,13 @@ const IMAGE = 'rabbitmq:4.3-management'
 const USER = 'developer'
 const PASSWORD = 'secret'
 const AMQP_PORT = 5672
+const MANAGEMENT_PORT = 15672
 const BROKERS_AMOUNT = 2
 const HOST_PORTS = [5673, 5674]
+
+// what a scenario reads the topology from: a queue nothing holds open is
+// invisible over AMQP, and its absence is what some of them are about
+const MANAGEMENT_HOST_PORTS = [15673, 15674]
 const HEALTHCHECK_INTERVAL = global.COMQ_TESTING_HEALTHCHECK_INTERVAL ?? 1000
 
 /** @type {import('@testcontainers/rabbitmq').StartedRabbitMQContainer[]} */
@@ -33,7 +38,9 @@ async function startBrokers () {
         })
         .withAutoRemove(false)
         .withName(`comq-rmq-${n}`)
-        .withExposedPorts({ container: AMQP_PORT, host: hostPort })
+        .withExposedPorts(
+          { container: AMQP_PORT, host: hostPort },
+          { container: MANAGEMENT_PORT, host: MANAGEMENT_HOST_PORTS[n] })
         .withHealthCheck({
           test: ['CMD', 'rabbitmq-diagnostics', '-q', 'ping'],
           interval: 5000,
@@ -88,6 +95,22 @@ function getAddress (n = 0) {
   return `localhost:${HOST_PORTS[n]}`
 }
 
+/**
+ * The queues on a broker, by name.
+ *
+ * @param {number} [n]
+ * @returns {Promise<string[]>}
+ */
+async function queues (n = 0) {
+  const authorization = 'Basic ' + Buffer.from(`${USER}:${PASSWORD}`).toString('base64')
+  const url = `http://localhost:${MANAGEMENT_HOST_PORTS[n]}/api/queues/%2F?columns=name`
+  const response = await fetch(url, { headers: { authorization } })
+
+  if (!response.ok) throw new Error(`Cannot read the queues of broker ${n}: ${response.status}`)
+
+  return (await response.json()).map((queue) => queue.name)
+}
+
 /**
  * @param {number} [n]
  */
@@ -129,5 +152,6 @@ module.exports = {
   startBrokers,
   stopBrokers,
   getAddress,
+  queues,
   actions
 }

package/features/steps/call.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const assert = require('node:assert')
-const amqplib = require('amqplib')
+const amqplib = require('@toa.io/amqplib')
 const { Given, When, Then, After } = require('@cucumber/cucumber')
 
 const { connect, Unroutable } = require('../../')
@@ -84,11 +84,76 @@ Given('a holder never answering {token} under the {token} key',
     await channel.assertExchange(exchange, 'direct', { durable: true })
     await channel.assertQueue(queue, { exclusive: true })
     await channel.bindQueue(queue, exchange, key)
-    await channel.consume(queue, () => undefined)
+    await channel.consume(queue, () => (this.handed = true))
 
     this.silent = connection
   })
 
+Then('the silent holder has taken the call',
+  /**
+   * The publication is awaited nowhere, and what the crash has to find already queued is what
+   * the holder has been handed.
+   *
+   * @this {comq.features.Context}
+   */
+  async function () {
+    assert.equal(await until(() => this.handed === true, 10_000), true,
+      'The silent holder was handed nothing')
+  })
+
+Given('a holder not taking {token} under the {token} key',
+  /**
+   * Holds the key as comq does, and takes nothing until told to, so that a call waits in its
+   * queue. Each scenario holds a key of its own: the broker releases an exclusive queue once it
+   * has noticed the connection close, and a scenario that declared it again before then would be
+   * refused it.
+   *
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key) {
+    const connection = await amqplib.connect(url(0))
+    const channel = await connection.createChannel()
+    const queue = exchange + '.' + key
+
+    await channel.assertExchange(exchange, 'direct', { durable: true })
+    await channel.assertQueue(queue, { exclusive: true })
+    await channel.bindQueue(queue, exchange, key)
+
+    this.idle = { connection, channel, queue, taken: 0 }
+  })
+
+When('the idle holder starts taking',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    const idle = this.idle
+
+    await idle.channel.consume(idle.queue, () => idle.taken++, { noAck: true })
+  })
+
+When('the consumer calls {token} under the {token} key with a signal',
+  /**
+   * @param {string} exchange
+   * @param {string} key
+   * @this {comq.features.Context}
+   */
+  async function (exchange, key) {
+    this.controller = new AbortController()
+
+    call(this, this.io.call(exchange, key, { key }, { signal: this.controller.signal }))
+  })
+
+When('the signal aborts',
+  /**
+   * @this {comq.features.Context}
+   */
+  function () {
+    this.controller.abort()
+  })
+
 When('the silent holder crashes',
   /**
    * Its socket is destroyed without a word, as a process that dies leaves it.
@@ -149,16 +214,6 @@ When('the consumer calls {token} under the {token} key {number} times',
     this.replies = await Promise.all(calls)
   })
 
-When('the consumer sends a request to the {token} queue with a {number}ms timeout',
-  /**
-   * @param {string} queue
-   * @param {number} ms
-   * @this {comq.features.Context}
-   */
-  async function (queue, ms) {
-    call(this, this.io.request(queue, { queue }, { timeout: ms }))
-  })
-
 When('the holder is sealed',
   /**
    * @this {comq.features.Context}
@@ -192,19 +247,32 @@ When('the first holder disconnects',
     await this.holder.close()
   })
 
-When('a producer counting requests to the {token} queue',
+Then('the idle holder takes nothing',
   /**
-   * @param {string} queue
    * @this {comq.features.Context}
    */
-  async function (queue) {
-    this.produced = 0
+  async function () {
+    await timeout(500)
 
-    await this.io.reply(queue, () => {
-      this.produced++
+    assert.equal(this.idle.taken, 0, 'An expired call was taken')
+  })
 
-      return null
-    })
+Then('the idle holder takes the call',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await until(() => this.idle.taken > 0, 5000)
+
+    assert.equal(this.idle.taken, 1)
+  })
+
+Then('the consumer stops waiting for the aborted call',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await assert.rejects(this.reply, (error) => error.name === 'AbortError')
   })
 
 Then('the call is refused as unroutable',
@@ -373,16 +441,6 @@ Then('every call is answered',
     assert.deepEqual(this.replies, this.replies.map((_, n) => n))
   })
 
-Then('the producer receives nothing',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    await timeout(500)
-
-    assert.equal(this.produced, 0, 'An expired request was processed')
-  })
-
 After(
   /**
    * @this {comq.features.Context}
@@ -390,9 +448,11 @@ After(
   async function () {
     await Promise.all((this.holders ?? []).map((io) => io.close()))
     await this.silent?.close().catch(() => undefined)
+    await this.idle?.connection.close().catch(() => undefined)
 
     this.holders = []
     this.silent = undefined
+    this.idle = undefined
   })
 
 /**

package/features/steps/events.js

@@ -225,7 +225,7 @@ async function consumed (group) {
 /**
  * @param {string} exchange
  * @param {any} message
- * @param {import('amqplib').Options.Publish} [properties]
+ * @param {import('@toa.io/amqplib').Options.Publish} [properties]
  * @return {Promise<void>}
  * @this {comq.features.Context}
  */