@yarkivaev/source-to-sink 1.3.9 → 1.3.11

package/README.md

@@ -5,13 +5,13 @@ A library for building data streaming pipelines with batching and circuit breake
 ## Installation
 
 ```bash
-npm install source-to-sink
+npm install @yarkivaev/source-to-sink
 ```
 
 ## Usage
 
 ```javascript
-import { batch, circuit, timedBatch, clock, clickhouseSink, mqttSource } from 'source-to-sink';
+import { batch, circuit, timedBatch, clock, clickhouseSink, mqttSource } from '@yarkivaev/source-to-sink';
 
 const clk = clock();
 const breaker = circuit(5, 60, clk);
@@ -35,10 +35,6 @@ source.start();
 | `mqttSource(url, topic, collector)` | MQTT subscription source |
 | `lokiSource(url, query, interval, collector, clock)` | Loki polling source |
 
-## License
-
-MIT
-
 ### STOMP delivery window
 
 `stompSource(url, destination, collector, { prefetch: 32 })` bounds broker deliveries
@@ -47,3 +43,158 @@ integer to tune throughput. A zero (unlimited) window is rejected because a
 backlog can otherwise exhaust the consumer's heap. With `manualAck: true`, the
 collector remains responsible for settling frames. If it flushes only by count,
 its batch must not exceed the prefetch window; a timed flush also avoids stalls.
+
+Manual collectors may call `settle.nack(false)` to dead-letter invalid messages. Configure a durable dead-letter queue and broker policy before enabling this; without a route RabbitMQ discards rejected messages. `settle.nack()` retains retry behaviour.
+
+
+## Transport sources and lifecycle
+
+The sources below receive a collector with `accept(record)`. Return a promise
+that resolves when processing is accepted; rejecting it reports a processing
+failure. Keep application decoding, routing, SQL queries and cursor updates in
+the collector. Await `stop()` before stopping downstream collectors or sinks,
+so in-flight acceptance can finish. A collector that never settles also prevents
+a draining stop from finishing.
+
+### Serial chunks
+
+```javascript
+import { serialSource } from '@yarkivaev/source-to-sink';
+
+const source = serialSource([
+  { path: '/dev/ttyUSB0', baudRate: 9600, dataBits: 8, parity: 'none', stopBits: 1 }
+], {
+  accept({ device, chunk }) {
+    return decodeAndStore(device.path, chunk);
+  }
+}, { retryMs: 1000, onError: (error, device) => console.error(device.path, error) });
+
+await source.start();
+```
+
+Each port has its own open/retry loop. `chunk` is the original buffer and `device`
+is the original configuration object; framing and decoding belong in the
+collector. Duplicate paths are rejected. Errors or a closed port trigger cleanup
+and retry without interrupting other devices. `start()` initiates opens;
+`stop()` waits for pending opens, closes ports, removes listeners and drains
+in-flight acceptance before restart.
+
+For testing or another port implementation, pass `openPort(device)`, returning a
+port or promise for a port. The port supports EventEmitter `data`, `error` and
+`close` events plus `close(callback)`. The default opens `serialport` lazily.
+Serial input is a push stream; the source does not impose a collector backlog
+limit or pause the device.
+
+### Periodic collection
+
+```javascript
+import { intervalSource } from '@yarkivaev/source-to-sink';
+
+const source = intervalSource(1000, {
+  async accept({ ts }) {
+    const records = await readChanges(ts);
+    await publish(records);
+    // Advance a cursor only after publication succeeds.
+  }
+}, { immediate: true, onError: console.error });
+
+await source.start();
+```
+
+`intervalMs` must be positive. Ticks carry a Unix timestamp in milliseconds.
+The default `immediate: false` waits one interval before the first tick. With
+`immediate: true`, `start()` waits for the first acceptance to settle. Subsequent
+ticks wait the interval after the previous acceptance settles, so slow work never
+overlaps another tick. Rejections call `onError` and scheduling continues.
+`stop()` cancels scheduling and drains the active tick; restart waits for that
+drain. Tests can inject `schedule(callback, milliseconds)` and `clear(handle)`.
+
+### AMQP consumption
+
+```javascript
+import { amqpSource } from '@yarkivaev/source-to-sink';
+
+const source = amqpSource('amqp://localhost', 'readings', {
+  async accept(delivery) {
+    await storeReading(JSON.parse(delivery.content.toString()));
+  }
+}, {
+  queueOptions: { durable: true },
+  exchanges: [{ name: 'telemetry', type: 'topic', options: { durable: true } }],
+  bindings: [{ exchange: 'telemetry', pattern: 'reading.#' }],
+  prefetch: 32,
+  onError: console.error
+});
+
+await source.start();
+```
+
+Deliveries contain `content`, `fields`, `properties`, `ack()` and
+`reject(requeue = true)`. By default the source acknowledges only after
+`collector.accept` resolves; rejection requeues the delivery and reports the
+error. Settlement is idempotent within a delivery. Set `ackMode: 'manual'` to
+let the collector choose `ack()` or `reject(false)` for dead-lettering; configure
+a broker dead-letter route if those messages must be retained. A collector that
+settles manually should still await its processing work so stop can drain it.
+
+The default queue is durable and the default prefetch is 32. Choose a finite,
+positive prefetch to bound outstanding broker deliveries. With count-based
+batching, the batch must fit within that window, or use a timed flush.
+Connection/channel failure or consumer cancellation causes reconnection with
+backoff from one to 30 seconds. `stop()` cancels the consumer, drains acceptance,
+and closes the channel and connection. `active()` means the lifecycle is running,
+including while reconnecting; it does not prove a broker connection is ready.
+
+`amqpSession(url, subscribeChannel, options)` exposes that same lifecycle for
+custom channel topology or consumption. The async `subscribeChannel(channel)`
+returns a consumer tag for cancellation. `options.drain(channel)` can await
+application work before channel closure. Both APIs accept `onError` (or `report`),
+`connect(url)`, `schedule(callback, milliseconds)` and `clear(handle)`; the latter
+three are useful for testing. The default connection uses a ten-second heartbeat.
+
+### AMQP publication
+
+```javascript
+import { amqpSink } from '@yarkivaev/source-to-sink';
+
+const sink = amqpSink('amqp://localhost', {
+  exchanges: [{ name: 'telemetry', type: 'topic', options: { durable: true } }],
+  maxPending: 1024,
+  onError: console.error
+});
+await sink.start();
+await sink.write([{
+  exchange: 'telemetry', routingKey: 'reading.temperature',
+  body: JSON.stringify({ value: 42 }), options: { persistent: true }
+}]);
+await sink.stop();
+```
+
+`write(records)` resolves after broker publisher confirms for every record. Each
+record requires an exchange, routing key and string or Buffer body; `options`
+passes publication options to amqplib. A confirm does not mean a consumer has
+processed the message or that an unroutable message reached a queue.
+
+`maxPending` (default 1024) bounds outstanding confirmations. Writes reject while
+the connection is unavailable, when the channel awaits its `drain` event, or when
+the batch would exceed that bound. There is no unbounded offline queue. A write
+can partially succeed before rejection; callers must account for that when
+choosing retries or advancing cursors.
+
+Connection loss or `confirmTimeoutMs` expiry rejects uncertain publications and
+reconnects for future writes. **The sink never automatically replays records**:
+the broker may already have accepted them. Use application idempotency when
+retrying uncertain results. `active()` reports whether a live channel exists.
+`start()` waits for connection and topology setup; a failed initial attempt
+rejects while background retries continue until stopped.
+
+Other options are `retryMs` (1000), `connectTimeoutMs` (5000),
+`confirmTimeoutMs` (10000), `onError(error)`, and injectable
+`connect(url, connectionOptions)`. Exchange declarations default to type `topic`
+and durable options when omitted. `stop()` closes the session and rejects pending
+confirms; it does not flush them. For graceful shutdown, first stop and drain
+sources, await outstanding `write()` promises, then stop the sink.
+
+## License
+
+MIT

package/index.js

@@ -43,3 +43,9 @@ export { default as modbusSource, modbusRtuSource } from './src/modbusSource.js'
 export { default as modbusRtuBusSource } from './src/modbusRtuBusSource.js';
 export { default as mqttSink } from './src/mqttSink.js';
 export { default as sqliteSink } from './src/sqliteSink.js';
+
+export { default as amqpSink } from './src/amqpSink.js';
+export { default as amqpSource } from './src/amqpSource.js';
+export { default as amqpSession } from './src/amqpSource/session.js';
+export { default as serialSource } from './src/serialSource.js';
+export { default as intervalSource } from './src/intervalSource.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/source-to-sink",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "description": "Generic library for building data streaming pipelines",
   "repository": {
     "type": "git",
@@ -9,12 +9,14 @@
   "type": "module",
   "main": "index.js",
   "dependencies": {
-    "mqtt": "^5.0.0",
     "@clickhouse/client": "^1.0.0",
-    "stompit": "^1.0.0",
-    "pg": "^8.0.0",
+    "amqplib": "^0.10.9",
+    "better-sqlite3": "^11.0.0",
     "modbus-serial": "^8.0.0",
-    "better-sqlite3": "^11.0.0"
+    "mqtt": "^5.0.0",
+    "pg": "^8.0.0",
+    "serialport": "^12.0.0",
+    "stompit": "^1.0.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",

package/src/amqpSink/publication.js

@@ -0,0 +1,31 @@
+/** Confirms one send, without replaying an outcome the broker may already have accepted. */
+export default function publication(live, record, timeoutMs) {
+    if (!record || typeof record.exchange !== 'string' || typeof record.routingKey !== 'string'
+        || !(typeof record.body === 'string' || Buffer.isBuffer(record.body))) {
+        return Promise.reject(new TypeError('AMQP record requires exchange, routingKey and string/Buffer body'));
+    }
+    return new Promise((resolve, reject) => {
+        const body = Buffer.isBuffer(record.body) ? record.body : Buffer.from(record.body);
+        let settled = false;
+        const timer = { handle: null };
+        function settle(error) {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer.handle);
+                live.pending.delete(settle);
+                if (error) { reject(error); } else { resolve(); }
+            }
+        }
+        timer.handle = setTimeout(() => {
+            const error = new Error('AMQP publish confirmation timed out');
+            settle(error);
+            live.fail(error);
+        }, timeoutMs);
+        live.pending.add(settle);
+        try {
+            if (!live.channel.publish(record.exchange, record.routingKey, body, record.options || {}, settle)) {
+                live.blocked = true;
+            }
+        } catch (error) { settle(error); }
+    });
+}

package/src/amqpSink/session.js

@@ -0,0 +1,82 @@
+import amqp from 'amqplib';
+
+export function report(state, error) {
+    try { state.options.onError?.(error); } catch {
+        // Diagnostics cannot break recovery.
+    }
+}
+export function closeLive(live) {
+    if (!live) { return Promise.resolve(); }
+    live.closing ??= Promise.resolve().then(async () => {
+        live.pending.forEach((settle) => { settle(new Error('AMQP connection closed before confirmation')); });
+        if (live.channel) { await live.channel.close().catch(() => { return undefined; }); }
+        if (live.connection) { await live.connection.close().catch(() => { return undefined; }); }
+    });
+    return live.closing;
+}
+function retry(state, epoch) {
+    if (state.wanted && state.epoch === epoch && !state.retry) {
+        state.retry = setTimeout(() => {
+            state.retry = null;
+            void state.reopen().catch((error) => { report(state, error); });
+        }, state.options.retryMs);
+    }
+}
+function drop(state, live, error) {
+    if (live.dead) { return; }
+    live.dead = true;
+    if (state.live === live) { state.live = null; }
+    if (error) { report(state, error); }
+    void closeLive(live).then(() => { retry(state, live.epoch); });
+}
+function bind(state, live, handle) {
+    handle.on('error', (error) => { drop(state, live, error); });
+    handle.on('close', () => { drop(state, live); });
+}
+async function configure(state, live) {
+    // This attempt owns live; stop closes it after opening settles and epoch is checked below.
+    // eslint-disable-next-line require-atomic-updates
+    live.channel = await live.connection.createConfirmChannel();
+    bind(state, live, live.channel);
+    live.channel.on('drain', () => { live.blocked = false; });
+    await Promise.all((state.options.exchanges || []).map((item) => {
+        return live.channel.assertExchange(item.name, item.type || 'topic', item.options || {durable: true});
+    }));
+}
+async function current(state, live) {
+    if (live.epoch !== state.epoch || !state.wanted) {
+        await closeLive(live);
+        return false;
+    }
+    return true;
+}
+function keep(state, live) {
+    if (live.epoch !== state.epoch || !state.wanted) { return closeLive(live); }
+    state.live = live;
+    return undefined;
+}
+async function connect(state, epoch) {
+    const live = { connection: null, channel: null, pending: new Set(), epoch, dead: false, blocked: false,
+        fail(error) { drop(state, live, error); } };
+    try {
+        live.connection = await (state.options.connect || amqp.connect)(state.url, { timeout: state.options.connectTimeoutMs });
+        bind(state, live, live.connection);
+        if (!await current(state, live)) { return; }
+        await configure(state, live);
+        if (live.dead) { throw new Error('AMQP session closed during initialization'); }
+        await keep(state, live);
+    } catch (error) {
+        await closeLive(live);
+        retry(state, epoch);
+        throw error;
+    }
+}
+export function begin(state) {
+    if (state.live) { return Promise.resolve(); }
+    if (state.opening) { return state.opening; }
+    if (!state.wanted) { return Promise.resolve(); }
+    clearTimeout(state.retry);
+    state.retry = null;
+    state.opening = connect(state, state.epoch).finally(() => { state.opening = null; });
+    return state.opening;
+}

package/src/amqpSink.js

@@ -0,0 +1,47 @@
+import { begin, closeLive } from './amqpSink/session.js';
+import publication from './amqpSink/publication.js';
+
+function settings(url, options) {
+    if (typeof url !== 'string' || !/^amqps?:\/\//u.test(url)) { throw new TypeError('AMQP URL is required'); }
+    const config = { retryMs: 1000, connectTimeoutMs: 5000, confirmTimeoutMs: 10000, maxPending: 1024, ...options };
+    ['retryMs', 'connectTimeoutMs', 'confirmTimeoutMs', 'maxPending'].forEach((name) => {
+        if (!Number.isFinite(config[name]) || config[name] <= 0) { throw new TypeError(`${name} must be positive`); }
+    });
+    if (!Number.isInteger(config.maxPending)) { throw new TypeError('maxPending must be an integer'); }
+    return config;
+}
+function stop(state) {
+    state.request += 1;
+    state.epoch += 1;
+    state.wanted = false;
+    clearTimeout(state.retry);
+    state.retry = null;
+    const { live } = state;
+    state.live = null;
+    state.stopped = Promise.all([closeLive(live), state.opening?.catch(() => { return undefined; })]);
+    return state.stopped;
+}
+/** AMQP record sink with confirms and independent connection recovery; never automatically replays sends. */
+export default function amqpSink(url, options = {}) {
+    const state = {url, options: settings(url, options), wanted: false, epoch: 0, request: 0,
+        live: null, opening: null, retry: null, stopped: Promise.resolve(), reopen() { return begin(state); }};
+    return {
+        active() { return Boolean(state.live); },
+        start() {
+            state.wanted = true;
+            state.request += 1;
+            const { request } = state;
+            return state.stopped.then(() => { if (request === state.request) { return begin(state); } return undefined; });
+        },
+        stop() { return stop(state); },
+        write(records) {
+            if (!Array.isArray(records)) { return Promise.reject(new TypeError('AMQP records must be an array')); }
+            if (!state.live) { return Promise.reject(new Error('AMQP sink is not connected')); }
+            const { live } = state;
+            if (live.blocked || live.pending.size + records.length > state.options.maxPending) {
+                return Promise.reject(new Error('AMQP sink backpressure: retry after confirmations or drain'));
+            }
+            return Promise.all(records.map((record) => { return publication(live, record, state.options.confirmTimeoutMs); }));
+        }
+    };
+}

package/src/amqpSource/session.js

@@ -0,0 +1,111 @@
+// Each session is mutated only by its generation; disposal waits for subscription.
+/* eslint-disable require-atomic-updates */
+async function connectBroker(url) {
+    const { default: amqp } = await import('amqplib');
+    return amqp.connect(url, { heartbeat: 10 });
+}
+function reportFailure(error) {
+    process.stderr.write(`amqp consume failed ${error.message}\n`);
+}
+async function closePart(action, report) {
+    try { await action(); } catch (error) { report(error); }
+}
+async function closeLive(live, ctx) {
+    if (live.tag) { await closePart(() => { return live.channel.cancel(live.tag); }, ctx.report); }
+    if (ctx.drain) { await closePart(() => { return ctx.drain(live.channel); }, ctx.report); }
+    if (live.channel) { await closePart(() => { return live.channel.close(); }, ctx.report); }
+    if (live.connection) { await closePart(() => { return live.connection.close(); }, ctx.report); }
+}
+function dispose(live, ctx) {
+    if (!live) { return Promise.resolve(); }
+    if (!live.closing) { live.closing = closeLive(live, ctx); }
+    return live.closing;
+}
+
+function current(ctx, generation) {
+    return ctx.state.running && ctx.state.generation === generation;
+}
+function retry(ctx, generation) {
+    if (!current(ctx, generation) || ctx.state.timer !== undefined) { return; }
+    const pause = ctx.state.delay;
+    ctx.state.delay = Math.min(pause * 2, 30000);
+    ctx.state.timer = ctx.schedule(() => {
+        ctx.state.timer = undefined;
+        ctx.state.opening = ctx.open(generation);
+        return ctx.state.opening;
+    }, pause);
+}
+function bind(ctx, generation, live, emitter) {
+    function lost(error) {
+        if (live.lost || !current(ctx, generation)) { return; }
+        live.lost = true;
+        if (error) { ctx.report(error); }
+        ctx.state.cleanup = live.ready.then(() => { return dispose(live, ctx); }).then(() => { retry(ctx, generation); });
+    }
+    emitter.on('error', lost);
+    emitter.on('close', lost);
+}
+async function subscribe(ctx, generation, live) {
+    if (!current(ctx, generation) || live.lost) { return; }
+    live.channel = await live.connection.createChannel();
+    bind(ctx, generation, live, live.channel);
+    if (!current(ctx, generation) || live.lost) { return; }
+    live.tag = await ctx.subscribe(live.channel);
+}
+async function open(ctx, generation) {
+    let complete;
+    const live = { closed: false, ready: new Promise((resolve) => { complete = resolve; }) };
+    try {
+        live.connection = await ctx.connect(ctx.url);
+        bind(ctx, generation, live, live.connection);
+        await subscribe(ctx, generation, live);
+        if (!current(ctx, generation) || live.lost) { await dispose(live, ctx); return; }
+        ctx.state.live = live;
+        ctx.state.delay = 1000;
+    } catch (error) {
+        ctx.report(error);
+        await dispose(live, ctx);
+        retry(ctx, generation);
+    } finally { complete(); }
+}
+async function begin(ctx) {
+    if (ctx.state.running) { await ctx.state.opening; return; }
+    ctx.state.running = true;
+    ctx.state.generation += 1;
+    const { generation } = ctx.state;
+    await ctx.state.stopping;
+    await ctx.state.cleanup;
+    if (current(ctx, generation)) {
+        ctx.state.opening = ctx.open(generation);
+        await ctx.state.opening;
+    }
+}
+async function end(ctx) {
+    ctx.state.running = false;
+    ctx.state.generation += 1;
+    if (ctx.state.timer !== undefined) { ctx.clear(ctx.state.timer); ctx.state.timer = undefined; }
+    await ctx.state.opening;
+    await ctx.state.cleanup;
+    await dispose(ctx.state.live, ctx);
+    ctx.state.live = undefined;
+}
+/** Shared AMQP session lifecycle; subscribe returns a consumer tag. */
+export default function amqpSession(url, subscribeChannel, options = {}) {
+    const ctx = {
+        url, subscribe: subscribeChannel, drain: options.drain,
+        connect: options.connect || connectBroker,
+        schedule: options.schedule || setTimeout,
+        clear: options.clear || clearTimeout,
+        report: options.onError || options.report || reportFailure,
+        state: { generation: 0, running: false, delay: 1000 },
+        open(generation) { return open(ctx, generation); }
+    };
+    return {
+        start() { return begin(ctx); },
+        stop() {
+            ctx.state.stopping = end(ctx);
+            return ctx.state.stopping;
+        },
+        active() { return ctx.state.running; }
+    };
+}

package/src/amqpSource.js

@@ -0,0 +1,70 @@
+import amqpSession from './amqpSource/session.js';
+
+function deliveryFor(channel, message) {
+    let settled = false;
+    return {
+        content: message.content, fields: message.fields, properties: message.properties,
+        ack() {
+            if (!settled) { channel.ack(message); settled = true; }
+        },
+        reject(requeue = true) {
+            if (!settled) { channel.nack(message, false, requeue); settled = true; }
+        }
+    };
+}
+function reportFailure(options, error) {
+    const report = options.onError || options.report;
+    try {
+        if (report) { report(error); }
+        else { process.stderr.write(`amqp delivery failed ${error.message}\n`); }
+    } catch {
+        // Error reporting must not reject a broker callback.
+    }
+}
+function rejectDelivery(delivery, options, error) {
+    try { delivery.reject(true); }
+    catch (settlementError) { reportFailure(options, settlementError); }
+    reportFailure(options, error);
+}
+function consume(channel, collector, options) {
+    return async (message) => {
+        if (!message) { channel.emit('close'); return; }
+        const delivery = deliveryFor(channel, message);
+        try {
+            await collector.accept(delivery);
+            if (options.ackMode !== 'manual') { delivery.ack(); }
+        } catch (error) {
+            rejectDelivery(delivery, options, error);
+        }
+    };
+}
+function trackedConsume(channel, collector, options, pending) {
+    const accept = consume(channel, collector, options);
+    return (message) => {
+        const delivery = accept(message);
+        pending.add(delivery);
+        return delivery.finally(() => { pending.delete(delivery); });
+    };
+}
+async function topology(channel, queue, options) {
+    await Promise.all((options.exchanges || []).map((exchange) => {
+        return channel.assertExchange(exchange.name, exchange.type, exchange.options);
+    }));
+    const declared = await channel.assertQueue(queue, options.queueOptions || { durable: true });
+    const name = declared?.queue || queue;
+    await Promise.all((options.bindings || []).map((binding) => {
+        return channel.bindQueue(name, binding.exchange, binding.pattern, binding.args);
+    }));
+    await channel.prefetch(options.prefetch || 32);
+    return name;
+}
+/** Delivers AMQP records, acknowledging only after collector acceptance. */
+export default function amqpSource(url, queue, collector, options = {}) {
+    if (!collector || typeof collector.accept !== 'function') { throw new Error('Collector must have an accept() method'); }
+    const pending = new Set();
+    return amqpSession(url, async (channel) => {
+        const name = await topology(channel, queue, options);
+        const result = await channel.consume(name, trackedConsume(channel, collector, options, pending), { noAck: false });
+        return result.consumerTag;
+    }, { ...options, drain() { return Promise.all([...pending]); } });
+}

package/src/intervalSource.js

@@ -0,0 +1,47 @@
+import positive from './positive.js';
+
+function report(onError, error) {
+    try { onError?.(error); } catch {
+        // Observability must not stop scheduling.
+    }
+}
+
+/** Serialized periodic ticks. stop() drains acceptance before restart can run. */
+export default function intervalSource(intervalMs, collector, options = {}) {
+    positive(intervalMs, 'intervalMs');
+    if (!collector || typeof collector.accept !== 'function') {
+        throw new TypeError('Collector must have an accept() method');
+    }
+    const { immediate = false, onError, schedule = setTimeout, clear = clearTimeout } = options;
+    const state = { active: false, revision: 0, timer: null, pending: Promise.resolve() };
+    function tick(revision) {
+        if (!state.active || revision !== state.revision) { return; }
+        state.timer = null;
+        state.pending = Promise.resolve().then(() => {
+            if (state.active && revision === state.revision) { return collector.accept({ ts: Date.now() }); }
+            return undefined;
+        }).catch((error) => { report(onError, error); }).then(() => {
+            if (state.active && revision === state.revision) {
+                state.timer = schedule(() => { tick(revision); }, intervalMs);
+            }
+        });
+    }
+    return {
+        async start() {
+            if (state.active) { return; }
+            state.revision += 1;
+            const { revision } = state;
+            await state.pending;
+            if (revision !== state.revision) { return; }
+            state.active = true;
+            if (immediate) { tick(revision); await state.pending; } else { state.timer = schedule(() => { tick(revision); }, intervalMs); }
+        },
+        stop() {
+            state.active = false;
+            state.revision += 1;
+            clear(state.timer);
+            state.timer = null;
+            return state.pending;
+        }
+    };
+}

package/src/positive.js

@@ -0,0 +1,5 @@
+export default function positive(value, name) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new TypeError(`${name} must be a positive number`);
+    }
+}

package/src/serialSource.js

@@ -0,0 +1,95 @@
+import positive from './positive.js';
+
+function report(options, error, device) {
+    try { options.onError?.(error, device); } catch {
+        // Observability must not prevent retries.
+    }
+}
+async function openPort(device) {
+    const { SerialPort } = await import('serialport');
+    const port = new SerialPort({ ...device, autoOpen: false });
+    await new Promise((resolve, reject) => { port.open((error) => { if (error) { reject(error); } else { resolve(); } }); });
+    return port;
+}
+function closePort(port) {
+    if (port.isOpen === false) { return Promise.resolve(); }
+    return new Promise((resolve) => { port.close(() => { resolve(); }); });
+}
+function pause(state, milliseconds) {
+    return new Promise((resolve) => { state.wake = resolve; state.timer = setTimeout(resolve, milliseconds); })
+        .finally(() => { clearTimeout(state.timer); state.wake = null; });
+}
+async function receive(state, port, device, collector, options) {
+    const pending = new Set();
+    const closed = new Promise((resolve) => { state.wake = resolve; });
+    function data(chunk) {
+        const accepted = Promise.resolve().then(() => {
+            if (state.active) { return collector.accept({ device, chunk }); }
+            return undefined;
+        }).catch((error) => { report(options, error, device); }).finally(() => { pending.delete(accepted); });
+        pending.add(accepted);
+    }
+    function failed(failure) { report(options, failure, device); state.wake?.(); }
+    function close() { state.wake?.(); }
+    port.on('data', data).on('error', failed).on('close', close);
+    if (!state.active) { state.wake(); }
+    await closed;
+    port.off('data', data);
+    try { await closePort(port); } finally {
+        port.off('error', failed).off('close', close);
+        await Promise.all(pending);
+    }
+}
+async function run(state, device, collector, options) {
+    while (state.active) {
+        try {
+            // Each port has an independent serialized open/close/retry loop.
+            // eslint-disable-next-line no-await-in-loop
+            const port = await options.openPort(device);
+            // eslint-disable-next-line no-await-in-loop
+            await receive(state, port, device, collector, options);
+        } catch (error) { if (state.active) { report(options, error, device); } }
+        if (state.active) {
+            // eslint-disable-next-line no-await-in-loop
+            await pause(state, options.retryMs);
+        }
+    }
+}
+function validate(devices, collector) {
+    if (!Array.isArray(devices)) { throw new TypeError('devices must be an array'); }
+    if (!collector || typeof collector.accept !== 'function') { throw new TypeError('Collector must have an accept() method'); }
+    const paths = new Set();
+    devices.forEach((device) => {
+        if (!device || typeof device.path !== 'string' || !device.path.trim() || paths.has(device.path)) {
+            throw new TypeError('invalid or duplicate serial path');
+        }
+        paths.add(device.path);
+    });
+}
+/** Independent serial devices; chunks and device metadata pass through unchanged. */
+export default function serialSource(devices, collector, options = {}) {
+    validate(devices, collector);
+    const settings = { retryMs: 1000, ...options, openPort: options.openPort ?? openPort };
+    positive(settings.retryMs, 'retryMs');
+    const states = devices.map(() => { return { active: false, task: null, wake: null, timer: null }; });
+    let revision = 0;
+    let stopping = Promise.resolve();
+    return {
+        async start() {
+            revision += 1;
+            const requested = revision;
+            await stopping;
+            if (requested === revision) {
+                states.forEach((state, index) => {
+                    if (!state.active) { state.active = true; state.task = run(state, devices[index], collector, settings); }
+                });
+            }
+        },
+        stop() {
+            revision += 1;
+            states.forEach((state) => { state.active = false; state.wake?.(); });
+            stopping = Promise.all(states.map((state) => { return state.task; }));
+            return stopping;
+        }
+    };
+}

package/src/stompSource.js

@@ -62,8 +62,8 @@ function settleOf(channel, message) {
     ack() {
       channel.ack(message);
     },
-    nack() {
-      channel.nack(message);
+    nack(requeue = true) {
+      channel.nack(message, { requeue: String(requeue) });
     }
   };
 }

package/test/integration_amqp.js

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import { GenericContainer, Wait } from 'testcontainers';
+import amqp from 'amqplib';
+import amqpSink from '../src/amqpSink.js';
+import amqpSource from '../src/amqpSource.js';
+
+function pause(ms) {
+    return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+async function until(probe, timeout = 20000) {
+    const deadline = Date.now() + timeout;
+    while (!await probe()) {
+        if (Date.now() >= deadline) { throw new Error('AMQP recovery condition timed out'); }
+        await pause(100);
+    }
+}
+
+describe('AMQP source and sink integration', function() {
+    let container;
+    let url;
+    let source;
+    let sink;
+    before(async function() {
+        this.timeout(120000);
+        container = await new GenericContainer('rabbitmq:3.13-management')
+            .withEnvironment({ RABBITMQ_DEFAULT_USER: 'streams', RABBITMQ_DEFAULT_PASS: 'streams' })
+            .withExposedPorts(5672)
+            .withWaitStrategy(Wait.forListeningPorts())
+            .withStartupTimeout(90000).start();
+        url = `amqp://streams:streams@${container.getHost()}:${container.getMappedPort(5672)}`;
+    });
+    after(async function() {
+        this.timeout(30000);
+        await source?.stop();
+        await sink?.stop();
+        await container?.stop();
+    });
+    it('awaits acceptance and restores exactly one consumer and confirmed publishing after broker restart', async function() {
+        this.timeout(60000);
+        const received = [];
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        const exchange = 'streams.integration';
+        const queue = 'streams.integration.queue';
+        const exchanges = [{ name: exchange, type: 'direct', options: { durable: true } }];
+        source = amqpSource(url, queue, { async accept(delivery) {
+            const body = delivery.content.toString();
+            received.push(body);
+            if (body === 'first') { await gate; }
+        } }, { exchanges, bindings: [{ exchange, pattern: 'record' }], prefetch: 1, onError: () => {} });
+        sink = amqpSink(url, { exchanges, retryMs: 100, onError: () => {} });
+        await source.start();
+        await sink.start();
+        await sink.write(['first', 'second'].map((body) => {
+            return { exchange, routingKey: 'record', body, options: { persistent: true } };
+        }));
+        await until(() => { return received.length === 1; });
+        await pause(200);
+        assert.deepEqual(received, ['first'], 'prefetch credit returned before acceptance');
+        release();
+        await until(() => { return received.length === 2; });
+        const down = await container.exec(['rabbitmqctl', 'stop_app']);
+        assert.equal(down.exitCode, 0, down.output);
+        await until(() => { return !sink.active(); });
+        const up = await container.exec(['rabbitmqctl', 'start_app']);
+        assert.equal(up.exitCode, 0, up.output);
+        await until(() => { return sink.active(); });
+        const probe = await amqp.connect(url);
+        try {
+            const channel = await probe.createChannel();
+            await until(async () => { return (await channel.checkQueue(queue)).consumerCount === 1; });
+            await sink.write([{ exchange, routingKey: 'record', body: 'recovered' }]);
+            await until(() => { return received.length >= 3; });
+            await pause(200);
+            assert.deepEqual(received, ['first', 'second', 'recovered']);
+            assert.equal((await channel.checkQueue(queue)).consumerCount, 1);
+        } finally { await probe.close(); }
+    });
+});

package/test/testIntervalSource.js

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import intervalSource from '../src/intervalSource.js';
+const turn = () => { return new Promise((resolve) => { setImmediate(resolve); }); };
+describe('intervalSource', function () {
+  it('serializes acceptance across stop and restart and cancels stale callbacks', async function () {
+    const scheduled = [];
+    const cleared = [];
+    let release;
+    const events = [];
+    const source = intervalSource(10, { accept(event) { events.push(event); return new Promise((resolve) => { release = resolve; }); } }, {
+      schedule(callback) { scheduled.push(callback); return callback; }, clear(handle) { cleared.push(handle); }
+    });
+    await source.start();
+    const old = scheduled.shift();
+    old();
+    await turn();
+    assert.equal(events.length, 1);
+    assert.equal(typeof events[0].ts, 'number');
+    assert.equal(scheduled.length, 0);
+    const stopped = source.stop();
+    const restarted = source.start();
+    old();
+    await turn();
+    assert.equal(events.length, 1);
+    release();
+    await Promise.all([stopped, restarted]);
+    assert.equal(scheduled.length, 1);
+    const stale = scheduled.shift();
+    await source.stop();
+    stale();
+    await turn();
+    assert.equal(events.length, 1);
+    assert.ok(cleared.includes(stale));
+  });
+  it('awaits the immediate acceptance before start resolves', async function () {
+    let release;
+    let started = false;
+    const source = intervalSource(1000, { accept() { return new Promise((resolve) => { release = resolve; }); } }, { immediate: true });
+    const starting = source.start().then(() => { started = true; });
+    await turn();
+    try {
+      assert.equal(started, false);
+    } finally {
+      release();
+      await starting;
+      await source.stop();
+    }
+  });
+  it('reports rejected ticks and keeps scheduling', async function () {
+    const errors = [];
+    const scheduled = [];
+    const failure = new Error('sink unavailable');
+    const source = intervalSource(10, { accept() { return Promise.reject(failure); } }, {
+      immediate: true, onError(error) { errors.push(error); }, schedule(callback) { scheduled.push(callback); }, clear() {}
+    });
+    await source.start();
+    await turn();
+    assert.deepEqual(errors, [failure]);
+    assert.equal(scheduled.length, 1);
+    await source.stop();
+  });
+});

package/test/testSerialSource.js

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import serialSource from '../src/serialSource.js';
+const pause = (ms = 10) => { return new Promise((resolve) => { setTimeout(resolve, ms); }); };
+function port() { const result = new EventEmitter(); result.close = (callback) => { result.emit('close'); callback(); }; return result; }
+describe('serialSource', function () {
+  it('rejects duplicate paths', function () { assert.throws(() => { serialSource([{ path: '/a' }, { path: '/a' }], { accept() {} }); }, /duplicate/u); });
+  it('isolates unavailable devices, retries close, and removes old listeners across restart', async function () {
+    const devices = [{ path: '/a' }, { path: '/b' }];
+    const opened = [];
+    const events = [];
+    const errors = [];
+    let unavailable = true;
+    const source = serialSource(devices, { accept(event) { events.push(event); } }, { retryMs: 5,
+      onError(error) { errors.push(error); }, openPort(device) { if (device.path === '/a' && unavailable) { throw new Error('unavailable'); } const item = port(); opened.push({ device, port: item }); return item; }
+    });
+    await source.start();
+    await source.start();
+    await pause();
+    const healthy = opened.find(({ device }) => { return device.path === '/b'; }).port;
+    const chunk = Buffer.from('raw');
+    healthy.emit('data', chunk);
+    await pause();
+    assert.equal(events[0].device, devices[1]);
+    assert.equal(events[0].chunk, chunk);
+    assert.ok(errors.length > 0);
+    unavailable = false;
+    healthy.emit('close');
+    await pause(30);
+    assert.equal(healthy.listenerCount('data'), 0);
+    assert.equal(opened.filter(({ device }) => { return device.path === '/b'; }).length, 2);
+    await source.stop();
+    assert.ok(opened.every(({ port: item }) => { return item.listenerCount('data') === 0; }));
+    const count = events.length;
+    healthy.emit('data', chunk);
+    await source.start();
+    await pause();
+    assert.equal(events.length, count);
+    assert.equal(opened.filter(({ device }) => { return device.path === '/b'; }).length, 3);
+    await source.stop();
+  });
+  it('removes listeners even when a custom port throws while closing', async function () {
+    const item = port();
+    item.close = () => { throw new Error('close failed'); };
+    const source = serialSource([{ path: '/a' }], { accept() {} }, { openPort() { return item; } });
+    await source.start();
+    await pause();
+    await source.stop();
+    assert.equal(item.listenerCount('data'), 0);
+    assert.equal(item.listenerCount('error'), 0);
+    assert.equal(item.listenerCount('close'), 0);
+  });
+  it('closes a port that finishes opening after stop and cancels immediate start', async function () {
+    let finish;
+    const item = port();
+    const source = serialSource([{ path: '/a' }], { accept() { assert.fail('late delivery'); } }, { openPort() { return new Promise((resolve) => { finish = resolve; }); } });
+    await source.start();
+    await pause();
+    const stopping = source.stop();
+    finish(item);
+    await stopping;
+    assert.equal(item.listenerCount('data'), 0);
+    const starting = source.start();
+    await source.stop();
+    await starting;
+  });
+});

package/test/test_amqpSink.js

@@ -0,0 +1,125 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import amqpSink from '../src/amqpSink.js';
+
+function broker() {
+  const sent = [];
+  const confirmations = [];
+  const channel = Object.assign(new EventEmitter(), {
+    assertExchange(...args) { sent.push(['exchange', ...args]); return Promise.resolve(); },
+    publish(exchange, routingKey, body, options, confirmed) {
+      sent.push(['publish', exchange, routingKey, body.toString(), options]);
+      confirmations.push(confirmed);
+      return true;
+    },
+    close() { channel.emit('close'); return Promise.resolve(); }
+  });
+  const connection = Object.assign(new EventEmitter(), {
+    createConfirmChannel() { return Promise.resolve(channel); },
+    close() { connection.emit('close'); return Promise.resolve(); }
+  });
+  return { connection, channel, sent, confirmations };
+}
+const record = {exchange: 'events', routingKey: 'line.temperature', body: '{"value":42}',
+  options: {persistent: true, contentType: 'application/json'}};
+
+describe('amqpSink', function() {
+  it('declares explicit exchanges and waits for broker confirmation', async function() {
+    const fixture = broker();
+    const sink = amqpSink('amqp://localhost', {connect: () => { return Promise.resolve(fixture.connection); },
+      exchanges: [{name: 'events', type: 'topic', options: {durable: true}}]});
+    await sink.start();
+    let done = false;
+    const written = sink.write([record]).then(() => { done = true; });
+    await new Promise((resolve) => { setImmediate(resolve); });
+    assert.equal(done, false);
+    assert.deepEqual(fixture.sent, [['exchange', 'events', 'topic', {durable: true}],
+      ['publish', 'events', 'line.temperature', record.body, record.options]]);
+    fixture.confirmations[0](null);
+    await written;
+    assert.equal(done, true);
+    await sink.stop();
+  });
+  it('rejects failed confirms without replaying an uncertain publication', async function() {
+    const fixture = broker();
+    const sink = amqpSink('amqp://localhost', {connect: () => { return Promise.resolve(fixture.connection); }});
+    await sink.start();
+    const written = sink.write([record]);
+    fixture.confirmations[0](new Error('nack'));
+    await assert.rejects(written, /nack/u);
+    assert.equal(fixture.sent.length, 1);
+    await sink.stop();
+  });
+  it('rejects offline writes and does not open duplicate sessions on repeated start', async function() {
+    const fixture = broker();
+    let connects = 0;
+    const sink = amqpSink('amqp://localhost', {connect: () => { connects += 1; return Promise.resolve(fixture.connection); }});
+    await assert.rejects(sink.write([record]), /not connected/u);
+    await Promise.all([sink.start(), sink.start()]);
+    assert.equal(connects, 1);
+    assert.equal(sink.active(), true);
+    await sink.stop();
+    assert.equal(sink.active(), false);
+  });
+  it('closes a connection whose channel initialization failed', async function() {
+    const fixture = broker();
+    let closed = 0;
+    fixture.connection.createConfirmChannel = () => { return Promise.reject(new Error('channel failed')); };
+    fixture.connection.close = () => { closed += 1; return Promise.resolve(); };
+    const sink = amqpSink('amqp://localhost', {connect: () => { return Promise.resolve(fixture.connection); }, retryMs: 10000});
+    await assert.rejects(sink.start(), /channel failed/u);
+    await sink.stop();
+    assert.equal(closed, 1);
+  });
+  it('ignores a late connection after stop and supports a clean restart', async function() {
+    let resolveConnection;
+    const fixture = broker();
+    const sink = amqpSink('amqp://localhost', {connect: () => { return new Promise((resolve) => { resolveConnection = resolve; }); }});
+    const starting = sink.start();
+    await new Promise((resolve) => { setImmediate(resolve); });
+    const stopped = sink.stop();
+    resolveConnection(fixture.connection);
+    await Promise.all([starting, stopped]);
+    assert.equal(sink.active(), false);
+  });
+  it('refuses more sends while transport is backpressured and resumes on drain', async function() {
+    const fixture = broker();
+    fixture.channel.publish = (...args) => { fixture.confirmations.push(args.at(-1)); return false; };
+    const sink = amqpSink('amqp://localhost', {connect: () => { return Promise.resolve(fixture.connection); }});
+    await sink.start();
+    const first = sink.write([record]);
+    await assert.rejects(sink.write([record]), /backpressure/u);
+    fixture.confirmations[0](null);
+    await first;
+    fixture.channel.emit('drain');
+    const second = sink.write([record]);
+    fixture.confirmations[1](null);
+    await second;
+    await sink.stop();
+  });
+  it('retires a session after confirmation timeout without replaying its records', async function() {
+    const fixture = broker();
+    let closed = 0;
+    fixture.connection.close = () => { closed += 1; return Promise.resolve(); };
+    const sink = amqpSink('amqp://localhost', {connect: () => { return Promise.resolve(fixture.connection); },
+      confirmTimeoutMs: 15, retryMs: 10000});
+    await sink.start();
+    await assert.rejects(sink.write([record]), /timed out/u);
+    await new Promise((resolve) => { setImmediate(resolve); });
+    assert.equal(sink.active(), false);
+    assert.equal(closed, 1);
+    assert.equal(fixture.sent.length, 1);
+    await sink.stop();
+  });
+  it('bounds the number of outstanding confirmations', async function() {
+    const fixture = broker();
+    const sink = amqpSink('amqp://localhost', {connect: () => { return Promise.resolve(fixture.connection); }, maxPending: 1});
+    await sink.start();
+    const first = sink.write([record]);
+    await assert.rejects(sink.write([record]), /backpressure/u);
+    fixture.confirmations[0](null);
+    await first;
+    await sink.stop();
+  });
+
+});

package/test/test_amqpSource.js

@@ -0,0 +1,153 @@
+/* eslint-disable require-await */
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import amqpSource from '../src/amqpSource.js';
+
+function broker() {
+    const events = [];
+    const channel = new EventEmitter();
+    const connection = new EventEmitter();
+    Object.assign(channel, {
+        assertQueue: async () => { events.push('queue'); },
+        prefetch: async () => {},
+        consume: async (queue, callback) => { channel.deliver = callback; return { consumerTag: 'tag' }; },
+        ack: () => { events.push('ack'); },
+        nack: (msg, all, requeue) => { events.push(['reject', requeue]); },
+        cancel: async () => { events.push('cancel'); },
+        close: async () => { events.push('channel.close'); }
+    });
+    connection.createChannel = async () => { return channel; };
+    connection.close = async () => { events.push('connection.close'); };
+    return { connection, channel, events };
+}
+const message = { content: Buffer.from('value'), fields: {}, properties: {} };
+describe('amqpSource', () => {
+    it('acknowledges only after asynchronous acceptance', async () => {
+        const fake = broker();
+        let release;
+        const source = amqpSource('amqp://test', 'queue', { accept: () => { return new Promise((resolve) => { release = resolve; }); } }, { connect: async () => { return fake.connection; } });
+        await source.start();
+        const pending = fake.channel.deliver(message);
+        assert.deepEqual(fake.events, ['queue']);
+        release();
+        await pending;
+        assert.deepEqual(fake.events, ['queue', 'ack']);
+        await source.stop();
+    });
+    it('requeues acceptance failures and does not double settle explicit rejects', async () => {
+        const fake = broker();
+        const errors = [];
+        const source = amqpSource('amqp://test', 'queue', { accept: async (delivery) => { delivery.reject(false); throw new Error('bad record'); } }, { connect: async () => { return fake.connection; }, onError: (error) => { errors.push(error.message); } });
+        await source.start();
+        await fake.channel.deliver(message);
+        assert.deepEqual(fake.events, ['queue', ['reject', false]]);
+        assert.deepEqual(errors, ['bad record']);
+        await source.stop();
+    });
+    it('closes a partially subscribed session before retrying', async () => {
+        const fake = broker();
+        fake.channel.assertQueue = async () => { throw new Error('queue failure'); };
+        const callbacks = [];
+        const source = amqpSource('amqp://test', 'queue', { accept: () => {} }, { connect: async () => { return fake.connection; }, onError: () => {}, schedule: (callback) => { callbacks.push(callback); return 1; }, clear: () => {} });
+        await source.start();
+        assert.deepEqual(fake.events, ['channel.close', 'connection.close']);
+        assert.equal(callbacks.length, 1);
+        await source.stop();
+    });
+    it('closes a lost session once before scheduling one replacement', async () => {
+        const fake = broker();
+        const callbacks = [];
+        const source = amqpSource('amqp://test', 'queue', { accept: () => {} }, { connect: async () => { return fake.connection; }, schedule: (callback) => { callbacks.push(callback); return 1; }, clear: () => {}, onError: () => {} });
+        await source.start();
+        fake.channel.emit('error', new Error('lost'));
+        fake.connection.emit('close');
+        await new Promise((resolve) => { setImmediate(resolve); });
+        assert.deepEqual(fake.events, ['queue', 'cancel', 'channel.close', 'connection.close']);
+        assert.equal(callbacks.length, 1);
+        await source.stop();
+    });
+    it('requeues failed asynchronous acceptance', async () => {
+        const fake = broker();
+        const source = amqpSource('amqp://test', 'queue', { accept: async () => { throw new Error('unavailable'); } }, { connect: async () => { return fake.connection; }, onError: () => {} });
+        await source.start();
+        await fake.channel.deliver(message);
+        assert.deepEqual(fake.events, ['queue', ['reject', true]]);
+        await source.stop();
+    });
+    it('restart waits for the old connection to finish closing', async () => {
+        const first = broker();
+        const second = broker();
+        let close;
+        first.connection.close = () => { return new Promise((resolve) => { close = resolve; }); };
+        let count = 0;
+        const source = amqpSource('amqp://test', 'queue', { accept: () => {} }, { connect: async () => { count += 1; return count === 1 ? first.connection : second.connection; } });
+        await source.start();
+        const stopped = source.stop();
+        const started = source.start();
+        await new Promise((resolve) => { setImmediate(resolve); });
+        assert.equal(count, 1);
+        close();
+        await stopped;
+        await started;
+        assert.equal(count, 2);
+        await source.stop();
+    });
+
+    it('reports settlement failure without rejecting the broker callback', async () => {
+        const fake = broker();
+        const errors = [];
+        fake.channel.ack = () => { throw new Error('channel closed'); };
+        fake.channel.nack = () => { throw new Error('channel closed'); };
+        const source = amqpSource('amqp://test', 'queue', { accept: () => {} }, {
+            connect: () => { return Promise.resolve(fake.connection); },
+            onError: (error) => { errors.push(error.message); }
+        });
+        await source.start();
+        await assert.doesNotReject(fake.channel.deliver(message));
+        assert.ok(errors.includes('channel closed'));
+        await source.stop();
+    });
+
+    it('cancels consumption then drains acceptance before closing or restarting', async () => {
+        const first = broker();
+        const second = broker();
+        let release;
+        let connects = 0;
+        const source = amqpSource('amqp://test', 'queue', {
+            accept: () => { return new Promise((resolve) => { release = resolve; }); }
+        }, { connect: () => { connects += 1; return Promise.resolve(connects === 1 ? first.connection : second.connection); } });
+        await source.start();
+        const delivery = first.channel.deliver(message);
+        let stopped = false;
+        const stopping = source.stop().then(() => { stopped = true; });
+        const restarting = source.start();
+        await new Promise((resolve) => { setImmediate(resolve); });
+        const observed = { stopped, connects, events: [...first.events] };
+        release();
+        await Promise.all([delivery, stopping, restarting]);
+        await source.stop();
+        assert.deepEqual(observed, { stopped: false, connects: 1, events: ['queue', 'cancel'] });
+        assert.deepEqual(first.events, ['queue', 'cancel', 'ack', 'channel.close', 'connection.close']);
+    });
+    it('drains acceptance on connection loss before scheduling recovery', async () => {
+        const fake = broker();
+        let release;
+        const retries = [];
+        const source = amqpSource('amqp://test', 'queue', {
+            accept: () => { return new Promise((resolve) => { release = resolve; }); }
+        }, { connect: () => { return Promise.resolve(fake.connection); },
+            schedule: (callback) => { retries.push(callback); return 1; }, clear: () => {} });
+        await source.start();
+        const delivery = fake.channel.deliver(message);
+        fake.connection.emit('close');
+        await new Promise((resolve) => { setImmediate(resolve); });
+        const observed = { retries: retries.length, events: [...fake.events] };
+        release();
+        await delivery;
+        await new Promise((resolve) => { setImmediate(resolve); });
+        await source.stop();
+        assert.deepEqual(observed, { retries: 0, events: ['queue', 'cancel'] });
+        assert.equal(retries.length, 1);
+    });
+
+});

package/test/test_stompSource.js

@@ -114,3 +114,33 @@ describe('STOMP delivery window', function() {
     });
   }
 });
+
+
+describe('STOMP dead lettering', function() {
+  it('sends requeue=false for a rejected poison message', async function() {
+    const original = stompit.Channel;
+    let receive;
+    let headers;
+    stompit.Channel = function Channel() {
+      return {
+        subscribe(value, callback) { receive = callback; },
+        nack(message, value) { headers = value; },
+        close() {}
+      };
+    };
+    try {
+      const source = stompSource('stomp://localhost:61613', '/queue/test', {
+        accept({ settle }) { settle.nack(false); }
+      }, { manualAck: true });
+      source.start();
+      receive(null, { readString(encoding, callback) { callback(null, '{}'); } });
+      await new Promise((resolve) => { setImmediate(resolve); });
+      source.stop();
+      assert.deepStrictEqual(headers, { requeue: 'false' });
+    } finally {
+      // Test restores its synchronous module stub after delivery completes.
+      // eslint-disable-next-line require-atomic-updates
+      stompit.Channel = original;
+    }
+  });
+});