@yarkivaev/scada 2.3.116 → 2.4.0

package/src/infrastructure/streams/modbusConnection.js

@@ -0,0 +1,173 @@
+import ModbusRTU from 'modbus-serial';
+import deadline from './deadline.js';
+
+/**
+ * Idle state for Modbus connection.
+ *
+ * @returns {object} State with no open attempt
+ */
+export function idle() {
+  return {
+    connected() {
+      return false;
+    },
+    retrying() {
+      return false;
+    },
+    opening() {
+      return false;
+    }
+  };
+}
+
+/**
+ * Retrying state for Modbus connection.
+ *
+ * @param {object} handle - Timer handle from setTimeout
+ * @returns {object} State with retrying() returning true
+ */
+function retrying(handle) {
+  return {
+    connected() {
+      return false;
+    },
+    retrying() {
+      return true;
+    },
+    opening() {
+      return false;
+    },
+    cancel() {
+      clearTimeout(handle);
+    }
+  };
+}
+
+/**
+ * In-flight TCP or RTU connect state.
+ *
+ * @returns {object} State with opening() returning true
+ */
+export function opening() {
+  return {
+    connected() {
+      return false;
+    },
+    retrying() {
+      return false;
+    },
+    opening() {
+      return true;
+    }
+  };
+}
+
+/**
+ * Connected state for Modbus connection.
+ *
+ * @param {object} client - ModbusRTU client
+ * @returns {object} State with connected() returning true
+ */
+function connected(client) {
+  return {
+    connected() {
+      return true;
+    },
+    retrying() {
+      return false;
+    },
+    opening() {
+      return false;
+    },
+    disconnect() {
+      client.close();
+    }
+  };
+}
+
+/**
+ * Destroys a Modbus client without throwing if already closed.
+ *
+ * @param {object} client - ModbusRTU client
+ */
+export function drop(client) {
+  if (client && typeof client.destroy === 'function') {
+    client.destroy(() => {
+      return undefined;
+    });
+  }
+}
+
+/**
+ * Builds a ModbusRTU client for one connect attempt.
+ *
+ * @returns {object} Fresh ModbusRTU client
+ */
+export function create() {
+  return new ModbusRTU();
+}
+
+/**
+ * Starts one connect attempt and ignores results after stop().
+ *
+ * @param {object} bag - Mutable lifecycle bag
+ */
+export function attempt(bag) {
+  const token = bag.epoch;
+  bag.state = opening();
+  drop(bag.client);
+  const client = bag.create();
+  bag.client = client;
+  const connecting = bag.connect(client);
+  void connecting.then(() => { if (token !== bag.epoch) { drop(client); } }).catch(() => { return undefined; });
+  bag.opened = deadline(connecting, 5000, 'Modbus connect', (error) => {
+    bag.fatal = error; bag.epoch += 1; drop(client);
+  }).then(() => {
+    if (token !== bag.epoch) {
+      drop(client);
+      return;
+    }
+    bag.delay = bag.interval;
+    bag.state = connected(client);
+    client.setTimeout(bag.interval * 1000);
+    client.once('close', () => {
+      if (token === bag.epoch && bag.client === client) { bag.lost(); }
+    });
+    void bag.source.start().catch((error) => { bag.fatal = error; drop(client); });
+  }).catch((err) => {
+    if (token !== bag.epoch) {
+      return;
+    }
+    drop(bag.client);
+    bag.log.error(`Connection to ${bag.target} failed, retrying in ${bag.delay}s: ${err.message}`);
+    const handle = setTimeout(() => {
+      attempt(bag);
+    }, bag.delay * 1000);
+    bag.state = retrying(handle);
+    bag.delay = Math.min(bag.delay * 2, bag.maxDelay);
+  });
+}
+
+/**
+ * Resets a live session and retries through attempt() backoff.
+ *
+ * @param {object} bag - Mutable lifecycle bag
+ */
+export function resume(bag) {
+  if (!bag.state.connected()) {
+    return;
+  }
+  const drained = bag.source.stop();
+  const { client } = bag;
+  bag.client = undefined;
+  bag.state = idle();
+  drop(client);
+  bag.log.error(`Connection to ${bag.target} lost, retrying in ${bag.delay}s`);
+  const token = bag.epoch;
+  const handle = setTimeout(() => {
+    void drained.then(() => { if (token === bag.epoch) { attempt(bag); } }).catch((error) => { bag.fatal = error; });
+  }, bag.delay * 1000);
+  bag.state = retrying(handle);
+  bag.delay = Math.min(bag.delay * 2, bag.maxDelay);
+}
+

package/src/infrastructure/streams/modbusRtuBusSource.js

@@ -0,0 +1,124 @@
+import ModbusRTU from 'modbus-serial';
+import positive from './positive.js';
+import deadline from './deadline.js';
+
+function validate(path, serial, slaves, poll) {
+    if (typeof path !== 'string' || !path) { throw new Error('Serial path must be a non-empty string'); }
+    if (!serial || !Number.isFinite(serial.baudRate) || serial.baudRate <= 0) { throw new Error('Serial baudRate must be a positive number'); }
+    if (!Array.isArray(slaves) || !slaves.length) { throw new Error('Slaves must be a non-empty array'); }
+    positive(poll.interval, 'interval');
+    slaves.forEach((slave) => {
+        if (!Number.isInteger(slave.slaveId) || slave.slaveId < 1 || slave.slaveId > 247 || typeof slave.collector?.accept !== 'function') {
+            throw new TypeError('Each RTU slave requires an ID from 1 to 247 and a collector');
+        }
+    });
+}
+function report(ctx, error) {
+    try { ctx.poll.log?.error(`RTU bus on ${ctx.path}: ${error.message}`); } catch {
+        // Diagnostics cannot stop recovery.
+    }
+}
+function close(ctx) {
+    ctx.closing ??= deadline(new Promise((resolve, reject) => {
+        ctx.client.close((error) => { if (error) { reject(error); } else { resolve(); } });
+    }), ctx.poll.stopTimeoutMs, 'RTU close');
+    return ctx.closing;
+}
+function pause(ctx) {
+    return new Promise((resolve) => { ctx.wake = resolve; ctx.timer = setTimeout(resolve, ctx.poll.interval * 1000); })
+        .finally(() => { clearTimeout(ctx.timer); ctx.wake = null; });
+}
+async function read(ctx, slave) {
+    ctx.client.setID(slave.slaveId);
+    const result = await deadline(ctx.client.readHoldingRegisters(ctx.poll.address, ctx.poll.count), ctx.poll.readTimeoutMs, 'RTU read');
+    if (ctx.active) {
+        await deadline(Promise.resolve().then(() => {
+            return slave.collector.accept(result.data, { signal: ctx.controller.signal });
+        }), ctx.poll.acceptTimeoutMs, 'RTU acceptance', (error) => { ctx.controller.abort(error); });
+    }
+}
+async function cycle(ctx) {
+    for (const slave of ctx.slaves) {
+        if (!ctx.active) { return; }
+        try {
+            // Shared setID requires every read and acceptance to finish before the next slave.
+            // eslint-disable-next-line no-await-in-loop
+            await read(ctx, slave);
+        } catch (error) {
+            if (error.code === 'OPERATION_TIMEOUT') { throw error; }
+            report(ctx, error);
+        }
+    }
+}
+async function session(ctx) {
+    ctx.opening = true;
+    const opening = ctx.client.connectRTUBuffered(ctx.path, ctx.serial);
+    void Promise.resolve(opening).then(() => {
+        ctx.opening = false;
+        if (!ctx.active) { return close(ctx); }
+        return undefined;
+    }, () => { ctx.opening = false; }).catch((error) => { report(ctx, error); });
+    await deadline(opening, ctx.poll.connectTimeoutMs, 'RTU connect');
+    while (ctx.active) {
+        // eslint-disable-next-line no-await-in-loop
+        await cycle(ctx);
+        // eslint-disable-next-line no-await-in-loop
+        if (ctx.active) { await pause(ctx); }
+    }
+}
+async function run(ctx) {
+    while (ctx.active) {
+        ctx.client = (ctx.poll.createClient || (() => { return new ModbusRTU(); }))();
+        ctx.client.setTimeout(ctx.poll.readTimeoutMs);
+        ctx.closing = null;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            await session(ctx);
+        } catch (error) {
+            report(ctx, error);
+            if (error.code === 'OPERATION_TIMEOUT') { Object.assign(ctx, { fatal: error, active: false }); }
+        } finally {
+            // Never treat closing a still-opening handle as proof its eventual port is closed.
+            // eslint-disable-next-line no-await-in-loop
+            if (!ctx.opening) { await close(ctx); }
+        }
+        // eslint-disable-next-line no-await-in-loop
+        if (ctx.active) { await pause(ctx); }
+    }
+}
+function launch(path, serial, slaves, poll) {
+    const ctx = { path, serial, slaves, poll, active: true, controller: new AbortController() };
+    ctx.task = run(ctx);
+    void ctx.task.catch((error) => { ctx.fatal = error; ctx.active = false; report(ctx, error); });
+    return ctx;
+}
+/** One serialized RTU bus. stop drains/closes; uncertain deadlines quarantine this instance. */
+export default function modbusRtuBusSource(path, serial, slaves, poll) {
+    validate(path, serial, slaves, poll);
+    const settings = { readTimeoutMs: 5000, connectTimeoutMs: 5000, acceptTimeoutMs: 10000, stopTimeoutMs: 5000, ...poll };
+    ['readTimeoutMs', 'connectTimeoutMs', 'acceptTimeoutMs', 'stopTimeoutMs'].forEach((key) => { positive(settings[key], key); });
+    let ctx;
+    let revision = 0;
+    return {
+        async start() {
+            if (ctx?.active) { return; }
+            revision += 1;
+            const requested = revision;
+            if (ctx) {
+                await ctx.task;
+                if (ctx.fatal) { throw ctx.fatal; }
+            }
+            if (requested === revision) { ctx = launch(path, serial, slaves, settings); }
+        },
+        stop() {
+            revision += 1;
+            if (!ctx) { return Promise.resolve(); }
+            ctx.active = false;
+            ctx.controller.abort(new Error('RTU source stopped'));
+            ctx.wake?.();
+            return deadline(ctx.task, settings.stopTimeoutMs, 'RTU stop', (error) => { ctx.fatal = error; if (!ctx.opening) { void close(ctx).catch(() => { return undefined; }); } }).then(() => {
+                if (ctx.fatal) { throw ctx.fatal; }
+            });
+        }
+    };
+}

package/src/infrastructure/streams/modbusSource.js

@@ -0,0 +1,185 @@
+import pollingSource from './pollingSource.js';
+import deadline from './deadline.js';
+import abortable from './abortable.js';
+import { attempt, create, drop, idle, opening, resume } from './modbusConnection.js';
+
+function read(bag, address, count) {
+  return async function fetch(since, until, { signal } = {}) {
+    const { client } = bag;
+    try {
+      const result = await abortable(client.readHoldingRegisters(address, count), signal, () => { drop(client); });
+      return [result.data];
+    } catch (err) {
+      if (bag.client === client) { bag.lost(); }
+      throw err;
+    }
+  };
+}
+
+/**
+ * Shared Modbus polling lifecycle for TCP and RTU transports.
+ *
+ * @param {object} options - connect, target, address, count, interval, collector, clk, client, log
+ * @returns {object} Source with start() and stop() methods
+ */
+function modbusPollingSource(options) {
+  const { address, count, interval, collector, clk } = options;
+  const bag = {
+    ...options,
+    client: undefined,
+    state: idle(),
+    epoch: 0,
+    maxDelay: 300,
+    delay: interval
+  };
+  bag.lost = function lost() {
+    resume(bag);
+  };
+  bag.source = pollingSource(read(bag, address, count), interval, collector, clk);
+  return {
+    /**
+     * Connects to the Modbus device and starts polling.
+     */
+    start() {
+      if (bag.fatal) { return Promise.reject(bag.fatal); }
+      if (bag.state.connected() || bag.state.retrying() || bag.state.opening()) {
+        return Promise.resolve();
+      }
+      const token = bag.epoch;
+      bag.state = opening();
+      return Promise.resolve(bag.stopping).then(() => { if (token === bag.epoch) { attempt(bag); } });
+    },
+    /**
+     * Stops polling and disconnects from the Modbus device.
+     */
+    stop() {
+      bag.epoch += 1;
+      const drained = bag.source.stop();
+      if (bag.state.retrying()) {
+        bag.state.cancel();
+      }
+      const { client } = bag;
+      bag.client = undefined;
+      bag.state = idle();
+      drop(client);
+      bag.stopping = deadline(Promise.all([drained, bag.opened]), 5000, 'Modbus stop', (error) => { bag.fatal = error; }).then(() => {
+        if (bag.fatal) { throw bag.fatal; }
+      });
+      return bag.stopping;
+    }
+  };
+}
+
+/**
+ * Modbus TCP polling source for reading holding registers.
+ *
+ * Connects to a Modbus TCP device and polls holding registers
+ * at a specified interval. Forwards register arrays to the
+ * collector via pollingSource.
+ *
+ * @example
+ * const source = modbusSource('192.168.2.148', 502, 4000, 14, 5, collector, clock);
+ * source.start();
+ *
+ * @param {string} host - Modbus TCP host address
+ * @param {number} port - Modbus TCP port
+ * @param {number} address - Starting register address
+ * @param {number} count - Number of registers to read
+ * @param {number} interval - Polling interval in seconds
+ * @param {object} collector - Collector with accept() method
+ * @param {object} clk - Clock with millis() method
+ * @param {object} [log] - Logger with error() method for connection failures
+ * @returns {object} Source with start() and stop() methods
+ */
+// Preserve the established positional adapter API.
+// eslint-disable-next-line max-params
+export default function modbusSource(host, port, address, count, interval, collector, clk, log = console) {
+  if (typeof host !== 'string' || host.length === 0) {
+    throw new Error('Host must be a non-empty string');
+  }
+  if (typeof port !== 'number' || port <= 0) {
+    throw new Error(`Port must be a positive number, got: ${port}`);
+  }
+  if (typeof address !== 'number' || address < 0) {
+    throw new Error(`Address must be a non-negative number, got: ${address}`);
+  }
+  if (typeof count !== 'number' || count <= 0) {
+    throw new Error(`Count must be a positive number, got: ${count}`);
+  }
+  function connect(modbusClient) {
+    return modbusClient.connectTCP(host, { port });
+  }
+  return modbusPollingSource({
+    create,
+    connect,
+    target: `${host}:${port}`,
+    address,
+    count,
+    interval,
+    collector,
+    clk,
+    log
+  });
+}
+
+/**
+ * Modbus RTU polling source for reading holding registers over serial.
+ *
+ * Connects to a Modbus RTU device on a serial port and polls holding registers
+ * at a specified interval. Forwards register arrays to the collector via pollingSource.
+ *
+ * @example
+ * const source = modbusRtuSource('/dev/ttyUSB0', { baudRate: 9600, slaveId: 1 }, 4000, 44, 5, collector, clock);
+ * source.start();
+ *
+ * @param {string} path - Serial device path (e.g. /dev/ttyUSB0)
+ * @param {object} serial - baudRate, dataBits, stopBits, parity, slaveId
+ * @param {number} address - Starting register address
+ * @param {number} count - Number of registers to read
+ * @param {number} interval - Polling interval in seconds
+ * @param {object} collector - Collector with accept() method
+ * @param {object} clk - Clock with millis() method
+ * @param {object} [log] - Logger with error() method for connection failures
+ * @returns {object} Source with start() and stop() methods
+ */
+// Preserve the established positional adapter API.
+// eslint-disable-next-line max-params
+export function modbusRtuSource(path, serial, address, count, interval, collector, clk, log = console) {
+  if (typeof path !== 'string' || path.length === 0) {
+    throw new Error('Serial path must be a non-empty string');
+  }
+  if (!serial || typeof serial !== 'object') {
+    throw new Error('Serial config must be an object');
+  }
+  if (typeof serial.baudRate !== 'number' || serial.baudRate <= 0) {
+    throw new Error(`Baud rate must be a positive number, got: ${serial.baudRate}`);
+  }
+  if (typeof address !== 'number' || address < 0) {
+    throw new Error(`Address must be a non-negative number, got: ${address}`);
+  }
+  if (typeof count !== 'number' || count <= 0) {
+    throw new Error(`Count must be a positive number, got: ${count}`);
+  }
+  const slaveId = serial.slaveId || 1;
+  function connect(modbusClient) {
+    return modbusClient.connectRTUBuffered(path, {
+      baudRate: serial.baudRate,
+      dataBits: serial.dataBits || 8,
+      stopBits: serial.stopBits || 1,
+      parity: serial.parity || 'none'
+    }).then(() => {
+      modbusClient.setID(slaveId);
+    });
+  }
+  return modbusPollingSource({
+    create,
+    connect,
+    target: path,
+    address,
+    count,
+    interval,
+    collector,
+    clk,
+    log
+  });
+}

package/src/infrastructure/streams/mqttSink/session.js

@@ -0,0 +1,51 @@
+import deadline from '../deadline.js';
+
+export function terminate(live, error) {
+    if (live.dead) { return live.closing; }
+    live.dead = true;
+    live.ready = false;
+    live.pending.forEach((settle) => { settle(error || new Error('MQTT connection closed')); });
+    live.closing = deadline(new Promise((resolve) => {
+        live.client.end(true, {}, resolve);
+    }), live.options.stopTimeoutMs, 'MQTT disconnect');
+    // An event callback cannot surface a rejected shutdown. stop() still returns it.
+    void live.closing.catch(() => { return undefined; });
+    return live.closing;
+}
+export function connect(live) {
+    return deadline(new Promise((resolve, reject) => {
+        function fail(error) { reject(error); void terminate(live, error); }
+        live.client.on('error', fail);
+        live.client.on('close', () => { fail(new Error('MQTT connection closed')); });
+        live.client.on('offline', () => { fail(new Error('MQTT connection offline')); });
+        live.client.on('connect', () => {
+            if (!live.dead) { live.ready = true; resolve(); }
+        });
+        live.pending.add(reject);
+    }), live.options.connectTimeoutMs, 'MQTT connect', (error) => { void terminate(live, error); });
+}
+export function publish(live, record, signal) {
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const timer = { handle: null };
+        function abort() { void terminate(live, signal.reason || new Error('MQTT publish aborted')); }
+        function settle(error) {
+            if (done) { return; }
+            done = true;
+            clearTimeout(timer.handle);
+            signal?.removeEventListener('abort', abort);
+            live.pending.delete(settle);
+            live.count -= 1;
+            if (error) { reject(error); } else { resolve(); }
+        }
+        timer.handle = setTimeout(() => { void terminate(live, new Error('MQTT confirmation timed out; outcome uncertain')); }, live.options.confirmTimeoutMs);
+        live.pending.add(settle);
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted) { abort(); return; }
+        try { live.client.publish(record.topic, record.payload, { qos: live.options.qos }, (error) => {
+            settle(error);
+            if (error) { void terminate(live, error); }
+        }); }
+        catch (error) { void terminate(live, error); }
+    });
+}

package/src/infrastructure/streams/mqttSink.js

@@ -0,0 +1,54 @@
+import mqtt from 'mqtt';
+import positive from './positive.js';
+import { connect, publish, terminate } from './mqttSink/session.js';
+
+function settings(options) {
+    const config = { qos: 0, maxPending: 1024, maxPendingBytes: 1048576, connectTimeoutMs: 5000, confirmTimeoutMs: 10000, stopTimeoutMs: 5000, ...options };
+    ['maxPending', 'maxPendingBytes', 'connectTimeoutMs', 'confirmTimeoutMs', 'stopTimeoutMs'].forEach((key) => { positive(config[key], key); });
+    if (!Number.isSafeInteger(config.maxPending)) { throw new TypeError('maxPending must be a safe integer'); }
+    if (![0, 1, 2].includes(config.qos)) { throw new TypeError('qos must be 0, 1, or 2'); }
+    return config;
+}
+function write(live, records, signal) {
+    if (!live?.ready || live.dead) { throw new Error('Sink is not connected'); }
+    if (!Array.isArray(records) || records.some((record) => {
+        return !record || typeof record.topic !== 'string' || !record.topic || !(typeof record.payload === 'string' || Buffer.isBuffer(record.payload));
+    })) { return Promise.reject(new TypeError('MQTT records require a topic and string/Buffer payload')); }
+    if (signal?.aborted) { return Promise.reject(signal.reason || new Error('MQTT publish aborted')); }
+    const bytes = records.reduce((total, record) => { return total + Buffer.byteLength(record.payload) + Buffer.byteLength(record.topic); }, 0);
+    if (live.bytes + bytes > live.options.maxPendingBytes || live.count + records.length > live.options.maxPending) { return Promise.reject(new Error('MQTT pending capacity exceeded')); }
+    live.count += records.length;
+    live.bytes += bytes;
+    return Promise.all(records.map((record) => {
+        if (live.dead) { live.count -= 1; return Promise.reject(new Error('MQTT connection closed')); }
+        return publish(live, record, signal);
+    })).finally(() => { live.bytes -= bytes; });
+}
+/** start awaits CONNACK; write awaits publish completion (broker confirmation at QoS 1/2).
+ * QoS 0 only confirms local handoff. No automatic replay of uncertain writes.
+ */
+export default function mqttSink(url, options = {}) {
+    if (typeof url !== 'string' || !url) { throw new Error('URL must be a non-empty string'); }
+    const config = settings(options);
+    let live;
+    return {
+        start() {
+            if (live && !live.dead) { return live.opening; }
+            if (live?.dead) { return Promise.reject(new Error('MQTT session retired; create a new sink after stop')); }
+            const client = (options.connect || mqtt.connect)(url, {
+                ...options.connectionOptions, clientId: options.clientId, protocolVersion: 5,
+                reconnectPeriod: 0, queueQoSZero: false, connectTimeout: config.connectTimeoutMs
+            });
+            live = { client, options: config, pending: new Set(), count: 0, bytes: 0, ready: false, dead: false };
+            live.opening = connect(live);
+            return live.opening;
+        },
+        write(records, { signal } = {}) { return write(live, records, signal); },
+        stop() {
+            const stopped = live;
+            return (stopped ? terminate(stopped, new Error('MQTT sink stopped')) : Promise.resolve()).then(() => {
+                if (live === stopped) { live = undefined; }
+            });
+        }
+    };
+}

package/src/infrastructure/streams/mqttSource.js

@@ -0,0 +1,66 @@
+import mqtt from 'mqtt';
+import positive from './positive.js';
+import deadline from './deadline.js';
+import budgetAccept from './budgetAccept.js';
+
+function report(options, error) {
+    try { options.onError?.(error); } catch {
+        // Diagnostics cannot break transport callbacks.
+    }
+}
+function bind(live, collector, options) {
+    live.client.on('error', (error) => { report(options, error); });
+    // MQTT.js serializes handleMessage and sends PUBACK/PUBCOMP only on successful completion.
+    live.client.handleMessage = (packet, callback) => {
+        const accepted = Promise.resolve().then(() => {
+            if (!live.active) { throw new Error('MQTT source stopped'); }
+            return budgetAccept(collector, { topic: packet.topic, payload: packet.payload.toString() }, packet.payload.length, options, { signal: live.controller.signal });
+        });
+        live.pending.add(accepted);
+        void accepted.finally(() => { live.pending.delete(accepted); }).catch(() => { return undefined; });
+        deadline(accepted, options.acceptTimeoutMs, 'MQTT acceptance', (error) => {
+            live.active = false; live.controller.abort(error); live.client.end(true);
+        }).then(() => {
+            callback(live.active ? undefined : new Error('MQTT source stopped'));
+        }, (error) => { callback(error); report(options, error); });
+    };
+}
+function open(url, list, collector, options) {
+    const client = (options.connect || mqtt.connect)(url, {
+        ...options.connectionOptions, clientId: options.clientId, clean: !options.clientId, protocolVersion: 5,
+        properties: { sessionExpiryInterval: options.clientId ? options.sessionExpiryInterval ?? 3600 : 0,
+            receiveMaximum: options.prefetch ?? 32, maximumPacketSize: options.maxPacketBytes ?? 1048576 }
+    });
+    const live = { client, active: true, pending: new Set(), controller: new AbortController() };
+    bind(live, collector, options);
+    client.on('connect', () => {
+        if (live.active) { client.subscribe(list, { qos: options.qos ?? (options.clientId ? 1 : 0) }); }
+    });
+    return live;
+}
+/** ACK follows asynchronous acceptance, not merely receipt. Acceptance is not necessarily durable. */
+export default function mqttSource(url, topics, collector, options = {}) {
+    if (typeof url !== 'string' || !url) { throw new Error('URL must be a non-empty string'); }
+    if (typeof topics !== 'string' || !topics.trim()) { throw new Error('Topic must be a non-empty string'); }
+    if (typeof collector?.accept !== 'function') { throw new Error('Collector must have an accept() method'); }
+    const config = { acceptTimeoutMs: 10000, stopTimeoutMs: 5000, ...options };
+    positive(config.acceptTimeoutMs, 'acceptTimeoutMs');
+    positive(config.stopTimeoutMs, 'stopTimeoutMs');
+    const list = topics.split(',').map((topic) => { return topic.trim(); }).filter(Boolean);
+    let live;
+    return {
+        start() {
+            if (!live) { live = open(url, list, collector, config); }
+        },
+        stop() {
+            if (!live) { return Promise.resolve(); }
+            const stopped = live;
+            stopped.active = false;
+            stopped.controller.abort(new Error('MQTT source stopped'));
+            const closing = new Promise((resolve) => { stopped.client.end(true, {}, resolve); });
+            return deadline(Promise.all([closing, ...stopped.pending]), config.stopTimeoutMs, 'MQTT stop').then(() => {
+                if (live === stopped) { live = undefined; }
+            });
+        }
+    };
+}

package/src/infrastructure/streams/pollingSource.js

@@ -0,0 +1 @@
+export { pollingSource as default } from '@yarkivaev/source-to-sink';

package/src/infrastructure/streams/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`);
+    }
+}