comq 0.22.0 → 0.24.0

package/features/steps/parked.js

@@ -1,11 +1,10 @@
 'use strict'
 
 const assert = require('node:assert')
-const amqplib = require('amqplib')
 const { Given, When, Then } = require('@cucumber/cucumber')
 
-const { getAddress, USER, PASSWORD } = require('./brokers')
 const { until, timeout } = require('../../test/helpers')
+const { reading, pick } = require('./parking')
 
 Given('a producer failing every request to the {token} queue',
   /**
@@ -52,18 +51,9 @@ When('the parked request from the {token} queue is answered by hand',
    * @this {comq.features.Context}
    */
   async function (queue) {
-    const connection = await amqplib.connect(`amqp://${USER}:${PASSWORD}@${getAddress(0)}`)
-    const channel = await connection.createChannel()
-
-    try {
-      let parked
-
-      await channel.consume('comq.parked.' + queue, (message) => {
-        parked = message
-        channel.ack(message)
-      })
-
-      await until(() => parked !== undefined)
+    await reading(async (channel) => {
+      const parked = await pick(channel,
+        (one) => one.properties.headers?.['x-comq-queue'] === queue)
 
       assert.notEqual(parked, undefined, `Nothing was parked from ${queue}`)
 
@@ -74,15 +64,14 @@ When('the parked request from the {token} queue is answered by hand',
 
       this.answer = { answered: true, was: JSON.parse(parked.content.toString()) }
 
+      channel.ack(parked)
+
       channel.sendToQueue(replyTo, Buffer.from(JSON.stringify(this.answer)),
         { correlationId, contentType })
 
       // let the frame reach the broker before the connection goes
       await timeout(100)
-    } finally {
-      await channel.close()
-      await connection.close()
-    }
+    })
   })
 
 Then('the caller receives the reply',

package/features/steps/parking.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const assert = require('node:assert')
+const amqplib = require('@toa.io/amqplib')
+const { Given, When, Then } = require('@cucumber/cucumber')
+
+const { getAddress, USER, PASSWORD } = require('./brokers')
+const { timeout } = require('../../test/helpers')
+
+Given('(that )groupless events from the {token} exchange are causing exceptions',
+  /**
+   * @param {string} exchange
+   * @this {comq.features.Context}
+   */
+  async function (exchange) {
+    await this.io.consume(exchange, (payload, properties) => {
+      this.attempts.push(properties.headers?.['x-comq-attempt'] ?? 1)
+
+      throw new Error('Expected exception')
+    })
+  })
+
+When('the connection is closed',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function () {
+    await this.disconnect()
+  })
+
+Then('a message parked from the {token} exchange is in the parking queue',
+  /**
+   * @param {string} exchange
+   * @this {comq.features.Context}
+   */
+  async function (exchange) {
+    await reading(async (channel) => {
+      const message = await pick(channel,
+        (one) => one.properties.headers?.['x-comq-exchange'] === exchange)
+
+      assert.notEqual(message, undefined,
+        `Nothing in '${PARKED}' came from the '${exchange}' exchange`)
+
+      const headers = message.properties.headers
+
+      // a groupless subscriber consumes a name the broker chose, so what is asserted
+      // here is that the message says which queue, not which name that is
+      assert.notEqual(headers['x-comq-queue'], undefined,
+        'The parked message does not name the queue it came from')
+
+      assert.notEqual(headers['x-comq-reason'], undefined, 'The parked message has no reason')
+
+      channel.nack(message, false, true)
+    })
+  })
+
+/**
+ * Runs `read` against a connection of its own, so that what it does to the parking
+ * queue is not what comq is doing to it.
+ *
+ * @param {(channel: import('@toa.io/amqplib').Channel) => Promise<void>} read
+ */
+async function reading (read) {
+  const connection = await amqplib.connect(`amqp://${USER}:${PASSWORD}@${getAddress(0)}`)
+  const channel = await connection.createChannel()
+
+  try {
+    await read(channel)
+  } finally {
+    await channel.close().catch(noop)
+    await connection.close().catch(noop)
+  }
+}
+
+/**
+ * The first message in the parking queue that `matches`, waited for. One queue holds what
+ * every scenario before this one left in it, so everything that does not match is given
+ * back; the match is left unacknowledged, for the caller to take or to return.
+ *
+ * @param {import('@toa.io/amqplib').Channel} channel
+ * @param {(message: import('@toa.io/amqplib').GetMessage) => boolean} matches
+ * @returns {Promise<import('@toa.io/amqplib').GetMessage | undefined>}
+ */
+async function pick (channel, matches) {
+  const deadline = Date.now() + DEADLINE
+
+  do {
+    const taken = []
+
+    let delivery
+
+    while ((delivery = await channel.get(PARKED, { noAck: false })) !== false) taken.push(delivery)
+
+    const match = taken.find(matches)
+
+    for (const one of taken) if (one !== match) channel.nack(one, false, true)
+
+    if (match !== undefined) return match
+
+    await timeout(50)
+  } while (Date.now() < deadline)
+}
+
+const PARKED = 'comq.parked'
+
+/** The ladder the suite runs on is half a second; this is room for it and the broker. */
+const DEADLINE = 5000
+
+function noop () {}
+
+exports.PARKED = PARKED
+exports.reading = reading
+exports.pick = pick

package/features/steps/poison.js

@@ -3,6 +3,7 @@
 const assert = require('node:assert')
 const { until } = require('../../test/helpers')
 const { Then } = require('@cucumber/cucumber')
+const { PARKED, reading, pick } = require('./parking')
 
 Then('the event is attempted {int} time(s)',
   /**
@@ -35,32 +36,29 @@ Then('the parked message is kept, and says it came from the {token} exchange',
    */
   async function (exchange) {
     const queue = exchange + '..exceptions' // the group the throwing consumer uses
-    const parked = 'comq.parked.' + queue
 
-    await this.io.process(parked, (payload, properties) => {
-      this.parked[queue] = { payload, properties }
-    })
-
-    await until(() => this.parked[queue] !== undefined)
+    await reading(async (channel) => {
+      const message = await pick(channel,
+        (one) => one.properties.headers?.['x-comq-queue'] === queue)
 
-    const message = this.parked[queue]
+      assert.notEqual(message, undefined, `Nothing in '${PARKED}' came from ${queue}`)
 
-    assert.notEqual(message, undefined, `Nothing was parked in ${parked}`)
+      const headers = message.properties.headers
 
-    const headers = message.properties.headers
+      assert.notEqual(headers['x-comq-reason'], undefined, 'The parked message has no reason')
 
-    assert.equal(headers['x-comq-queue'], queue, 'The parked message does not name its queue')
-    assert.notEqual(headers['x-comq-reason'], undefined, 'The parked message has no reason')
+      // the message came back through the default exchange on every retry, so this
+      // is only right if the origin was recorded on the first failure
+      assert.equal(headers['x-comq-exchange'], exchange,
+        `The parked message says it came from '${headers['x-comq-exchange']}'`)
 
-    // the message came back through the default exchange on every retry, so this
-    // is only right if the origin was recorded on the first failure
-    assert.equal(headers['x-comq-exchange'], exchange,
-      `The parked message says it came from '${headers['x-comq-exchange']}'`)
+      // absent on a message parked from its first delivery, exactly as a consumer reads it;
+      // derived rather than stated, so it cannot drift from the configured ladder
+      assert.equal(headers['x-comq-attempt'] ?? 1, this.attempts.length,
+        'The parked message did not have as many attempts as the consumer saw')
 
-    // absent on a message parked from its first delivery, exactly as a consumer reads it;
-    // derived rather than stated, so it cannot drift from the configured ladder
-    assert.equal(headers['x-comq-attempt'] ?? 1, this.attempts.length,
-      'The parked message did not have as many attempts as the consumer saw')
+      channel.ack(message)
+    })
   })
 
 Then('{token} has received {int} event(s)',

package/features/steps/replies.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const assert = require('node:assert')
+const { Then } = require('@cucumber/cucumber')
+
+const { queues, BROKERS_AMOUNT } = require('./brokers')
+
+Then('the broker holds {int} reply queue(s)',
+  /**
+   * @param {number} count
+   */
+  async function (count) {
+    await held(0, count)
+  })
+
+Then('each broker holds {int} reply queue(s)',
+  /**
+   * @param {number} count
+   */
+  async function (count) {
+    for (let n = 0; n < BROKERS_AMOUNT; n++) await held(n, count)
+  })
+
+/**
+ * @param {number} broker
+ * @param {number} count
+ */
+async function held (broker, count) {
+  const replies = (await queues(broker)).filter((name) => name.startsWith(PREFIX))
+
+  assert.equal(replies.length, count,
+    `Broker ${broker} holds ${replies.length} reply queue(s): ${replies.join(', ')}`)
+}
+
+const PREFIX = 'comq.reply'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -34,7 +34,6 @@
     "@semantic-release/npm": "^13.1.2",
     "@semantic-release/release-notes-generator": "^14.1.0",
     "@testcontainers/rabbitmq": "^12.1.0",
-    "@types/amqplib": "^0.10.8",
     "@types/jest": "^30.0.0",
     "conventional-changelog-conventionalcommits": "^8.0.0",
     "fast-glob": "^3.3.3",
@@ -49,13 +48,16 @@
     "testcontainers": "^12.0.4"
   },
   "dependencies": {
-    "amqplib": "^2.0.1",
+    "@toa.io/amqplib": "^0.1.0",
     "promex": "^0.1.1",
     "reretry": "^0.1.0"
   },
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "scripts": {
     "prepare": "husky",
-    "test": "standard && jest",
+    "test": "standard && NODE_OPTIONS=--experimental-vm-modules jest",
     "features": "cucumber-js --fail-fast -t 'not @manual'",
     "features:fast": "cucumber-js --fail-fast -t 'not @manual and not @heavy'",
     "benchmark": "node benchmarks/run.js",

package/readme.md

@@ -6,8 +6,8 @@ for distributed, eventually consistent systems running on Node.js.
 ## Features
 
 - [Dynamic topology](#topology)
-- [Request](#request)-[reply](#reply) (RPC), with a [timeout](#timeout)
-- [Addressed requests](#addressed-requests) to the one connection holding a Key
+- [Request](#request)-[reply](#reply) (RPC)
+- [Addressed requests](#addressed-requests) to the one connection holding a Key, with a [timeout](#timeout)
 - Events ([pub](#emission)/[sub](#consumption)), fanned out or [routed](#routing)
 - [Tasks](#tasks)
 - [Pipelines](#pipelines)
@@ -107,21 +107,15 @@ await io.reply('add_numbers', ({ a, b }) => (a + b))
 
 ## Request
 
-`async IO.request(queue: string, payload: any, options?: string | RequestOptions): any`
+`async IO.request(queue: string, payload: any, encoding?: string): any`
 
 Send encoded Request message with `replyTo` and `correlationId` properties set and
-return decoded Reply content. The promise stays pending until the Reply arrives, or until the
-[timeout](#timeout) passes.
+return decoded Reply content. The promise stays pending until the Reply arrives, however long
+that takes: a Request has no timeout and cannot be withdrawn. One no Producer can answer is
+[parked](#parked-messages), and can still be answered while its caller waits.
 
-On the initial call, queues for Requests and Replies are asserted.
-
-`options` is the encoding, or an object:
-
-| Option     | Type          | Default            |
-|------------|---------------|--------------------|
-| `encoding` | `string`      | `application/json` |
-| `timeout`  | `number`, ms  | none               |
-| `signal`   | `AbortSignal` | none               |
+On the initial call, the queue for Requests is asserted, and so is the one this `IO` receives
+every Reply on.
 
 ### Example
 
@@ -129,28 +123,6 @@ On the initial call, queues for Requests and Replies are asserted.
 const sum = await io.request('add_numbers', { a: 1, b: 2 })
 ```
 
-### Timeout
-
-A Request with a `timeout` rejects once it passes, with the `TimeoutError` of
-[`AbortSignal.timeout`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static).
-It is published with that much
-[expiration](https://www.rabbitmq.com/docs/ttl#per-message-ttl-in-publishers), so a Request no
-Producer has taken by then is dropped by the broker and never processed. A Request a Producer has
-already taken is processed to the end, and its Reply is discarded. A Request re-sent after a lost
-connection carries the time it has left.
-
-A `signal` rejects the Request with its reason once aborted, within the `timeout` where both are
-given. It ends the wait and leaves the Request where it is: in its queue until the `timeout`
-passes, or, without a `timeout`, until a Producer takes it. A Request abandoned by its `signal` may
-therefore still be processed.
-
-A Request that failed and waits for its [next attempt](#retries) loses its expiration on the way
-back to its queue, so it may be processed after its caller has stopped waiting.
-
-```javascript
-const sum = await io.request('add_numbers', { a: 1, b: 2 }, { timeout: 5000 })
-```
-
 ## Consumption
 
 `async IO.consume(exchange: string, group?: string, consumer): void`
@@ -230,7 +202,7 @@ await io.route('records', 'store.customers', { id: 2 }) // not delivered to the
 
 `async IO.back(exchange: string, key: string, producer): void`
 
-`async IO.call(exchange: string, key: string, payload: any, options?: string | RequestOptions): any`
+`async IO.call(exchange: string, key: string, payload: any, options?: string | CallOptions): any`
 
 A Request to the one connection holding a Key, where a [Request](#request) goes to whichever
 Producer takes it first.
@@ -244,8 +216,15 @@ is let go when its connection closes, however it closes — once the broker has
 connection that went without a word. `back` returns once a broker holds the Key. The rest of the
 connection works throughout, and a connection that is restored claims its Keys again the same way.
 
-`call` publishes the encoded Request to the exchange under the `key` and returns the decoded Reply,
-taking the same options as [`request`](#request).
+`call` publishes the encoded Request to the exchange under the `key` and returns the decoded Reply.
+
+`options` is the encoding, or an object:
+
+| Option     | Type          | Default            |
+|------------|---------------|--------------------|
+| `encoding` | `string`      | `application/json` |
+| `timeout`  | `number`, ms  | none               |
+| `signal`   | `AbortSignal` | none               |
 
 A call ends in one of three ways:
 
@@ -271,6 +250,24 @@ same Key can therefore hold it on different shards and both answer calls, and `t
 so. A call returned by one shard is published on the next, and refused once every shard has
 returned it.
 
+### Timeout
+
+A call with a `timeout` rejects once it passes, with the `TimeoutError` of
+[`AbortSignal.timeout`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static).
+It is published with that much
+[expiration](https://www.rabbitmq.com/docs/ttl#per-message-ttl-in-publishers), so a call its holder
+has not taken by then is dropped by the broker and never processed. A call the holder has already
+taken is processed to the end, and its Reply is discarded. A call re-sent after a lost connection
+carries the time it has left.
+
+A `signal` rejects the call with its reason once aborted, within the `timeout` where both are
+given. It ends the wait and leaves the call where it is: in its queue until the `timeout` passes,
+or, without a `timeout`, until its holder takes it. A call abandoned by its `signal` may therefore
+still be processed.
+
+A call that failed and waits for its [next attempt](#retries) loses its expiration on the way back
+to its queue, so it may be processed after its caller has stopped waiting.
+
 ### Example
 
 ```javascript
@@ -550,7 +547,9 @@ requests and are expecting replies.
 - An exchange is asserted as _fanout_ for [Emission](#emission)
   and [Consumption](#consumption), and as _direct_ for [Routing](#routing). One name is one or
   the other: asserting it as both is what the broker refuses.
-- Queues for Replies are _exclusive_ and _auto deleted_.
+- One queue takes every Reply an `IO` receives, `comq.reply..<id>`, _exclusive_ and gone with the
+  connection. A Reply is matched by its `correlationId`, which is unique across processes, so the
+  queue names neither what was called nor what is waiting.
 - A queue [`back`](#addressed-requests) holds is _exclusive_, bound under its Key to a _direct_
   exchange.
 
@@ -558,7 +557,8 @@ comq declares two kinds of queue of its own, for [failed messages](#retries):
 
 - `comq.retry.<delay>`, with a fanout exchange of the same name, one pair per distinct rung of
   the [backoff ladder](#retries), shared by every queue that uses it.
-- `comq.parked.<queue>`, one per consumed queue, declared to live as long as it does.
+- `comq.parked`, one queue for everything parked, whatever it was consumed from, always
+  _durable_.
 
 See [queue assertion options](https://amqp-node.github.io/amqplib/channel_api.html#channel_assertQueue).
 
@@ -638,8 +638,10 @@ verdict's own message.
 
 #### Parked messages
 
-A message that has run out of attempts is published to `comq.parked.<queue>` and acknowledged
-only once the broker confirms it. It is not deleted, and it does not depend on a broker-side
+A message that has run out of attempts is published to `comq.parked` and acknowledged
+only once the broker confirms it. There is one such queue, and it holds what every queue this
+connection consumes could not process — including a groupless subscription's, which the broker
+removes with the connection while what it could not process stays. It is not deleted, and it does not depend on a broker-side
 policy. The [`discard`](#diagnostics) diagnostic event is emitted when it happens, and
 [`retry`](#diagnostics) on every attempt before it.
 
@@ -648,14 +650,16 @@ name where it was originally published, `x-comq-queue` the queue it was consumed
 `x-comq-reason` the exception's message, and `x-comq-at` when it was parked. Its original
 properties are kept as they were.
 
-Parked queues grow until somebody drains them, which is deliberate — the alternative is deleting
-evidence. Alert on [`discard`](#diagnostics), and do not delete `comq.retry.*` or `comq.parked.*`
-queues on a running system.
+A message is found by the queue it names rather than by the queue it is in: `comq.parked` holds
+messages from every source, so reading one source's means matching on `x-comq-queue`.
+
+The queue grows until somebody drains it, which is deliberate — the alternative is deleting
+evidence. Nothing comq does removes it or what it holds. Alert on [`discard`](#diagnostics), and
+do not delete `comq.retry.*` or `comq.parked` on a running system.
 
-> **A parked Request is never answered.** A Consumer awaiting its Reply waits until its
-> [timeout](#timeout), or indefinitely without one, and with a limited prefetch that can deadlock
-> it. Parking keeps the Request rather than deleting
-> it — and it keeps `replyTo` and `correlationId`, so a Reply can still be produced from it by
+> **A parked Request is never answered.** A Consumer awaiting its Reply waits indefinitely — a
+> call until its [timeout](#timeout) — and with a limited prefetch that can deadlock it. Parking
+> keeps the Request rather than deleting it — and it keeps `replyTo` and `correlationId`, so a Reply can still be produced from it by
 > hand while the caller is alive — but comq itself sends no Reply and reports no error to the
 > caller.
 
@@ -734,28 +738,6 @@ Sending Requests, receiving Replies, and emitting Events will still be available
 Keys held by [`back`](#addressed-requests) are withdrawn first, so a call published from then on is
 refused.
 
-### Abandoning
-
-`async IO.abandon(): void`
-
-Stop waiting for Replies.
-
-A [close](#disconnection) waits for every `producer` and `consumer` call to return, and such a
-call may itself be waiting on a Request of its own. Where the answer to that Request is the very
-thing going away — the process it would come from is shutting down alongside this one — the close
-waits for as long as the answer takes.
-
-`IO.abandon()` ends that wait:
-
-- every outstanding Reply is rejected with `Abandoned`, so a caller inside a `producer` or
-  `consumer` is told at once rather than held;
-- a Request made from then on is refused with `Abandoned`, so a callback cannot start another
-  wait on the way out.
-
-The Requests those Replies belonged to were sent and may well be processed; what is given up is
-this side's interest in the answers. It may be called before a close or while one is already under
-way, which is how a close that has begun is told to stop waiting.
-
 ### Disconnection
 
 `async IO.close(): void`
@@ -764,9 +746,6 @@ way, which is how a close that has begun is told to stop waiting.
 2. Wait for any outstanding messages to be processed[^2] and acknowledged.
 3. Close the connection.
 
-Step 2 still runs where the Replies have been [abandoned](#abandoning): each message is processed
-to a verdict and acknowledged, and what was given up is the waiting rather than the drain.
-
 [^2]: Therefore, if the underlying connection is lost, `.close()` will only be completed once the
 connection is [recovered](#connection-tolerance).
 

package/source/.io/ReplyPipe.js

@@ -60,12 +60,25 @@ class ReplyPipe extends EventEmitter {
       ok: { correlationId, replyTo: feedback.queue, ...CONTROL, headers: FLOW }
     }
 
+    // The source is not read until the confirmation is published, and a blocked broker holds the
+    // publish for as long as it stays blocked. A source failing in the meantime — a reply stream
+    // being relayed times out — would raise an `error` nobody listens to. How it failed is not
+    // reported to the consumer anyway: `#pump` ends the stream once it finds the source destroyed.
+    stream.on('error', noop)
+
     channel.diagnose('return', this.#onReturn)
     feedback.on(correlationId, this.#control)
   }
 
   async pipe () {
-    await this.#transmit(control.ok, this.#properties.ok)
+    try {
+      await this.#transmit(control.ok, this.#properties.ok)
+    } catch (exception) {
+      // nobody is going to read the source now
+      this.#interrupt()
+
+      throw exception
+    }
 
     if (this.#closed) return
 
@@ -198,4 +211,6 @@ const CONTROL = { type: 'control', mandatory: true }
 
 const FLOW = { [FLOW_HEADER]: true }
 
+function noop () {}
+
 exports.ReplyPipe = ReplyPipe

package/source/channel.js

@@ -27,14 +27,6 @@ class Channel {
   /** @type {string[]} */
   #tags = []
 
-  /**
-   * How each queue was declared, so that the queue holding what it could not
-   * process is declared to live exactly as long as it does.
-   *
-   * @type {Map<string, comq.amqp.options.Queue>}
-   */
-  #queues = new Map()
-
   /**
    * The exchange and key each held queue is bound under, so that sealing withdraws them.
    *
@@ -88,8 +80,7 @@ class Channel {
     // the consumers of the previous channel went down with it, their tags mean nothing here
     this.#tags = []
 
-    // a fresh channel has declared nothing, and bound nothing
-    this.#queues.clear()
+    // a fresh channel has bound nothing
     this.#held.clear()
 
     await this.#channel.prefetch(this.#topology.prefetch)
@@ -384,8 +375,6 @@ class Channel {
 
     const { queue } = await this.#channel.assertQueue(name, options)
 
-    this.#queues.set(queue, options)
-
     return [queue]
   }
 
@@ -485,21 +474,23 @@ class Channel {
    * The queue a message is kept in once it has run out of attempts. It has no consumer
    * either: what is in it is waiting for a person.
    *
-   * It is declared to live exactly as long as the queue it serves, which for a groupless
-   * subscriber means an exclusive queue whose contents go when the connection does. That
-   * is deliberate: such a subscriber is ephemeral by construction, and a durable queue per
-   * generated name would leak one per restart, forever. An ephemeral subscriber's failures
-   * are ephemeral too.
+   * One queue serves every queue this channel consumes, as one retry queue serves every
+   * source that shares its delay. A parked message carries the queue it came from, so a
+   * queue per source would name what the message already says, and stay on the broker
+   * long after the queue it was named for has gone.
+   *
+   * It is durable whatever the channel is. A groupless subscriber's own queue goes with
+   * its connection, but what it could not process is waiting for a person, and there is
+   * nobody left to tell.
    *
-   * @param {string} queue the queue the message was consumed from
    * @returns {Promise<void>}
    */
-  async #assertParkedQueue (queue) {
+  async #assertParkedQueue () {
     if (!this.#topology.acknowledgments) return
 
-    const options = this.#queues.get(queue) ?? (this.#topology.durable ? DURABLE : EXCLUSIVE)
-
-    await this.#assertQueue(parkedQueueOf(queue), options)
+    // declared here rather than when a message is first parked, for the reason the retry
+    // queues are: the failure handler is the least likely moment for a declare to succeed
+    await this.#assertQueue(PARKED, DURABLE)
   }
 
   /** The waits between attempts, as a ladder even when it is one rung. */
@@ -556,8 +547,9 @@ class Channel {
   }
 
   /**
-   * The retry topology is asserted once per channel and a parked queue once per queue:
-   * `lazy` keys an initializer by the arguments it takes, and both again after a recovery.
+   * The retry and parking topology is asserted once per channel: `lazy` keys an
+   * initializer by the arguments it takes, and neither takes any. Both again after
+   * a recovery.
    */
   #consume = lazy(this, [this.#assertRetryQueue, this.#assertParkedQueue],
     /**
@@ -660,7 +652,7 @@ class Channel {
       [PARKED_AT_HEADER]: Date.now()
     })
 
-    await this.#publish(DEFAULT, parkedQueueOf(queue), message.content, properties)
+    await this.#publish(DEFAULT, PARKED, message.content, properties)
 
     this.#channel.ack(message)
 
@@ -775,9 +767,9 @@ const INTERRUPTION = /** @type {Error} */ Symbol('internal interruption')
 const RESOURCE_LOCKED = 405
 
 const RETRY_PREFIX = 'comq.retry.'
-const PARKED_PREFIX = 'comq.parked.'
 
-const parkedQueueOf = (queue) => PARKED_PREFIX + queue
+/** Where every message that has run out of attempts is kept, whatever it was consumed from. */
+const PARKED = 'comq.parked'
 
 // Everything comq writes onto a message, under its own prefix: AMQP defines no retry
 // counter, so this one is comq's invention rather than a convention, and an unprefixed

package/source/connection.js

@@ -1,12 +1,11 @@
 'use strict'
 
 const { setTimeout: delay } = require('node:timers/promises')
-const amqp = require('amqplib')
+const amqp = require('@toa.io/amqplib')
 const { Promex } = require('promex')
 const { retry } = require('reretry')
 
 const { failsafe } = require('./attributes')
-const { batch } = require('./batch')
 const presets = require('./topology')
 const channels = require('./channel')
 const emitter = require('./emitter')
@@ -148,8 +147,6 @@ class Connection {
     connection.on('close', (error) => this.#close(connection, error))
     this.#connection = connection
 
-    batch(connection.connection?.stream)
-
     this.#armWatchdog(connection)
     this.#diagnostics.emit('open')