@yarkivaev/scada 2.3.116 → 2.4.1

package/src/application/supervisorSink.js

@@ -15,7 +15,7 @@ const appRoot = path.dirname(fileURLToPath(import.meta.url));
 
 /**
  * Reads deployment environment into a normalized config object.
- * `SINK_PIPELINES=false` leaves Postgres and the state HTTP API in this process
+ * `COLLECTOR_MODE=external` or `SINK_PIPELINES=false` leaves Postgres and the state HTTP API in this process
  * and leaves the STOMP consumers to another container.
  *
  * @param {NodeJS.ProcessEnv} env - process environment
@@ -41,7 +41,7 @@ export function readDeploymentConfig(env) {
         retentionDays: parseInt(env.RETENTION_DAYS || '30', 10),
         migrationsDir: path.join(root, 'db', 'migrations'),
         requestTimeoutMs: parseRequestTimeoutMs(env.REQUEST_TIMEOUT_MS),
-        pipelines: env.SINK_PIPELINES !== 'false',
+        pipelines: env.COLLECTOR_MODE !== 'external' && env.SINK_PIPELINES !== 'false',
         pipeline: {
             prefetch,
             deadLetter: env.SEGMENTS_DEAD_LETTER_ENABLED === 'true',
@@ -60,6 +60,12 @@ export function readDeploymentConfig(env) {
     };
 }
 
+function startPipelines(cfg, pool) {
+    const pipelines = [segmentPipeline(cfg.stomp, cfg.postgres, pool, cfg.pipeline),
+        decisionPipeline(cfg.stomp, pool, cfg.pipeline), alertPipeline(cfg.stomp, pool, cfg.pipeline)];
+    return Promise.all(pipelines.map((pipeline) => { return pipeline.start(); }));
+}
+
 /**
  * Wires STOMP pipelines, migrations, and state data access from env config.
  * HTTP binding uses edgeApi (metrics, checkpoint, retention).
@@ -70,9 +76,6 @@ export function readDeploymentConfig(env) {
 export default function supervisorSink(env = process.env) {
     const cfg = readDeploymentConfig(env);
     const pool = holdClient(new pg.Pool({ connectionString: cfg.postgres }));
-    const segments = segmentPipeline(cfg.stomp, cfg.postgres, pool, cfg.pipeline);
-    const decisions = decisionPipeline(cfg.stomp, pool, cfg.pipeline);
-    const alerts = alertPipeline(cfg.stomp, pool, cfg.pipeline);
     const metricsEnabled = cfg.sinkDbProfile === 'edge';
     const dataAccess = stateDataFromPool(pool, { metricsEnabled });
     return {
@@ -97,9 +100,7 @@ export default function supervisorSink(env = process.env) {
                 await adminPool.end();
             }
             if (cfg.pipelines) {
-                await segments.start();
-                decisions.start();
-                alerts.start();
+                await startPipelines(cfg, pool);
             }
             if (httpServer) {
                 httpServer.start();

package/src/application/sync/siteSyncBind.js

@@ -1,4 +1,4 @@
-import { clickhouseSink } from '@yarkivaev/source-to-sink';
+import { clickhouseSink } from '../../infrastructure/streams/index.js';
 import { jobRoutes, jobs } from '@yarkivaev/simple-server';
 import exportQuery from '../export/exportQuery.js';
 import scadaClient from '../../infrastructure/client/scadaClient.js';

package/src/application/sync/siteSyncTargets.js

@@ -1,4 +1,4 @@
-import { postgresSink } from '@yarkivaev/source-to-sink';
+import { postgresSink } from '../../infrastructure/streams/index.js';
 import {
     alertRow,
     listedItems,

package/src/bin/collector.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { createRegistry, runCollector } from '../application/runtime/index.js';
+
+try { await runCollector({ registry: createRegistry() }); } catch (error) {
+    process.stderr.write(`collector: ${error.name}\n`);
+    process.exitCode = 1;
+}

package/src/bin/modbus-to-mqtt.js

@@ -3,12 +3,7 @@
  *
  * Polls ADDRESS or MODBUS_DEVICES and publishes STREAM + MAPPING document paths.
  */
-process.on('unhandledRejection', (err) => {
-    process.stderr.write(`Unhandled rejection: ${String(err)}\n`);
-    process.exit(1);
-});
-
-import modbusPublish from '../infrastructure/ingest/mqtt/modbusPublish.js';
+import { createRegistry, runCollector } from '../application/runtime/index.js';
 
 /**
  * Parses a JSON array environment value.
@@ -41,7 +36,7 @@ function integer(text) {
 }
 
 const addresses = jsonList(process.env.ADDRESS);
-const pipeline = modbusPublish(process.env.MQTT_URL, {
+const config = {
     address: integer(process.env.MODBUS_ADDRESS),
     addresses,
     clientId: process.env.CLIENT_ID,
@@ -52,6 +47,13 @@ const pipeline = modbusPublish(process.env.MQTT_URL, {
     streams: jsonList(process.env.STREAM) || [],
     threshold: parseInt(process.env.CIRCUIT_THRESHOLD || '5', 10),
     timeout: parseInt(process.env.CIRCUIT_TIMEOUT || '60', 10)
-});
+};
 
-pipeline.start();
+try {
+    const env = { ...process.env, COLLECTOR_MANIFEST: JSON.stringify({ assignments: [{ taskId: 'modbus', generation: 0, specVersion: 1,
+        spec: { adapter: 'modbus', url: { $secret: 'MQTT_URL' }, config } }] }) };
+    await runCollector({ registry: createRegistry(), env, argv: [] });
+} catch (error) {
+    process.stderr.write(`collector: ${error.name}\n`);
+    process.exitCode = 1;
+}

package/src/infrastructure/ingest/activity/activityTracking.js

@@ -1,19 +1,14 @@
-import {
-    batch,
-    circuit,
-    clickhouseSink,
-    clock,
-    lokiSource,
-    timedBatch
-} from '@yarkivaev/source-to-sink';
+import { clock } from '@yarkivaev/source-to-sink';
+import { clickhouseSink, lokiSource } from '../../streams/index.js';
+import ingestBatch from '../ingestBatch.js';
 import activityCodec from './activityTransformer.js';
 
 /**
  * Pipeline for streaming Loki HTTP access logs to ClickHouse.
  *
- * Polls Loki for log entries matching the query and batches them
- * before inserting into ClickHouse `activity.http_access` table.
- * Uses circuit breaker for failure isolation.
+ * Polls Loki and durably inserts each accepted log into ClickHouse
+ * before advancing the serial source cursor.
+ * Bounds pending records and bytes and waits for durable writes.
  *
  * @example
  *   const pipeline = activityTracking(
@@ -31,10 +26,10 @@ import activityCodec from './activityTransformer.js';
  * @param {string} query - LogQL query string
  * @param {object} config - Pipeline configuration
  * @param {number} config.poll - Loki polling interval in seconds
- * @param {number} config.size - Batch size before flush
+ * @param {number} config.size - Legacy option; serial durable acceptance writes one record at a time
  * @param {number} config.interval - Seconds before time-based flush
- * @param {number} config.threshold - Circuit breaker failure threshold
- * @param {number} config.timeout - Circuit breaker timeout in seconds
+ * @param {number} config.threshold - Legacy option (retained for configuration compatibility)
+ * @param {number} config.timeout - Legacy option (use writeTimeoutMs for write deadlines)
  * @returns {object} Pipeline with start() and stop() methods
  */
 export default function activityTracking(loki, clickhouse, query, config) {
@@ -51,24 +46,23 @@ export default function activityTracking(loki, clickhouse, query, config) {
         throw new Error('Config must be an object');
     }
     const clk = clock();
-    const breaker = circuit(config.threshold, config.timeout, clk);
     const sink = clickhouseSink(clickhouse, 'activity.http_access');
-    const collector = timedBatch(batch(sink, config.size, breaker), config.interval);
+    const collector = ingestBatch(sink, { ...config, size: 1 });
     const transformer = activityCodec(collector);
-    const source = lokiSource(loki, query, config.poll, transformer, clk);
+    const source = lokiSource(loki, query, config.poll, transformer, clk, { ...config.lokiOptions, budget: config.budget });
     return {
         /**
          * Starts the pipeline.
          */
         start() {
-            source.start();
+            return source.start();
         },
         /**
          * Stops the pipeline.
          */
-        stop() {
-            source.stop();
-            collector.stop();
+        async stop() {
+            await source.stop();
+            try { await collector.stop(); } finally { await sink.stop?.(); }
         }
     };
 }

package/src/infrastructure/ingest/activity/activityTransformer.js

@@ -22,24 +22,25 @@ export default function activityCodec(collector) {
          * @param {object} entry - Log entry with ts and line
          */
         accept(entry) {
+            let log;
             try {
-                const log = JSON.parse(entry.line);
-                if (!log.StartUTC || !log.RequestMethod || !log.RequestPath) {
-                    return;
-                }
-                collector.accept({
-                    ts: new Date(log.StartUTC).getTime(),
-                    user: log['request_Remote-User'] || '',
-                    email: log['request_Remote-Email'] || '',
-                    method: log.RequestMethod || '',
-                    path: log.RequestPath || '',
-                    status: parseInt(log.DownstreamStatus, 10) || 0,
-                    duration: parseFloat(log.Duration) / 1e9 || 0,
-                    ip: log.ClientHost || ''
-                });
+                log = JSON.parse(entry.line);
             } catch {
-                // Skip malformed log entries
+                return undefined;
             }
+            if (!log || !log.StartUTC || !log.RequestMethod || !log.RequestPath) {
+                return undefined;
+            }
+            return collector.accept({
+                ts: new Date(log.StartUTC).getTime(),
+                user: log['request_Remote-User'] || '',
+                email: log['request_Remote-Email'] || '',
+                method: log.RequestMethod || '',
+                path: log.RequestPath || '',
+                status: parseInt(log.DownstreamStatus, 10) || 0,
+                duration: parseFloat(log.Duration) / 1e9 || 0,
+                ip: log.ClientHost || ''
+            });
         }
     };
 }

package/src/infrastructure/ingest/durableConsume.js

@@ -1,2 +1,2 @@
-// Compatibility facade; transport lifecycle belongs to source-to-sink.
-export { amqpSession as default } from '@yarkivaev/source-to-sink';
+// Compatibility facade; transport lifecycle is owned by the scada stream adapters.
+export { amqpSession as default } from '../streams/index.js';

package/src/infrastructure/ingest/ingestBatch.js

@@ -0,0 +1,13 @@
+import { boundedBatch } from '@yarkivaev/source-to-sink';
+
+/** Shared production limits; acceptance resolves only after the sink write. */
+export default function ingestBatch(sink, config = {}) {
+    return boundedBatch(sink, {
+        ...(config.budget ? { budget: config.budget } : {}),
+        size: config.size ?? 100,
+        maxRecords: config.maxRecords ?? 1000,
+        maxBytes: config.maxBytes ?? 1048576,
+        maxWaitMs: config.maxWaitMs ?? (config.interval ?? 5) * 1000,
+        writeTimeoutMs: config.writeTimeoutMs ?? 10000
+    });
+}

package/src/infrastructure/ingest/modbus/mx210Tcp.js

@@ -1,4 +1,4 @@
-import { modbusSource } from '@yarkivaev/source-to-sink';
+import { modbusSource } from '../../streams/index.js';
 
 const layout = [
     { offset: 0, channel: 'AI1' },
@@ -34,13 +34,13 @@ export function mx210Metrics(device, collector) {
     return {
         accept(registers) {
             const ts = Date.now();
-            for (const entry of layout) {
-                collector.accept({
+            return Promise.all(layout.map((entry) => {
+                return collector.accept({
                     topic: `MX210/${device}/GET/${entry.channel}/VALUE`,
                     ts,
                     value: decode(registers[entry.offset], registers[entry.offset + 1])
                 });
-            }
+            }));
         }
     };
 }

package/src/infrastructure/ingest/modbus/silentStreams.js

@@ -1,5 +1,20 @@
 import { clock, intervalSource } from '@yarkivaev/source-to-sink';
 
+function track(state, pending) {
+    if (!pending || typeof pending.then !== 'function') { return; }
+    const task = pending.catch((error) => {
+        state.failure = error;
+        try { state.onError?.(error); } catch {
+            // Reporting must not turn an observed source failure into an unhandled rejection.
+        }
+    })
+        .finally(() => { state.pending.delete(task); });
+    state.pending.add(task);
+}
+async function drained(state) {
+    await Promise.all(state.pending);
+    if (state.failure) { throw state.failure; }
+}
 /**
  * Whether a stream is past the silence budget.
  *
@@ -27,8 +42,12 @@ function stopOne(state, name) {
     if (!state.live.has(name)) {
         return;
     }
-    state.held.get(name).stop();
-    state.live.delete(name);
+    if (state.closing.has(name)) { return; }
+    const pending = state.held.get(name).stop();
+    if (pending && typeof pending.then === 'function') {
+        state.closing.add(name);
+        track(state, pending.finally(() => { state.live.delete(name); state.closing.delete(name); }));
+    } else { state.live.delete(name); }
 }
 
 /**
@@ -47,7 +66,7 @@ function startOne(state, source) {
         poll = source.open(state.collector, state.clk, state.intervalSec);
         state.held.set(name, poll);
     }
-    poll.start();
+    track(state, poll.start());
     state.live.add(name);
 }
 
@@ -88,6 +107,10 @@ function gateState(config) {
         lastSeen: new Map(),
         held: new Map(),
         live: new Set(),
+        closing: new Set(),
+        pending: new Set(),
+        failure: null,
+        onError: config.onError,
         collector: undefined,
         running: false
     };
@@ -129,22 +152,24 @@ export default function silentStreams(config) {
         bind(sink) {
             state.collector = {
                 accept(record) {
-                    sink.write([record]);
+                    return sink.write([record]);
                 }
             };
         },
         start() {
-            if (state.running) { return; }
+            if (state.running) { return drained(state); }
             state.running = true;
             runPulse();
-            void ticker.start();
+            track(state, ticker.start());
+            return drained(state);
         },
-        stop() {
+        async stop() {
             state.running = false;
-            void ticker.stop();
+            track(state, ticker.stop());
             for (const name of [...state.live]) {
                 stopOne(state, name);
             }
+            await drained(state);
             state.held.clear();
         },
         pulse: runPulse

package/src/infrastructure/ingest/mqtt/metricsTransformer.js

@@ -30,25 +30,24 @@ export default function metricsCodec(collector, log = console) {
                 parsed = JSON.parse(raw.payload);
             } catch {
                 log.warn(`Cannot resolve payload on ${raw.topic}: not valid JSON`);
-                return;
+                return undefined;
             }
             if (typeof parsed === 'number') {
-                collector.accept({
+                return collector.accept({
                     topic: raw.topic,
                     ts: Date.now(),
                     value: parsed
                 });
-                return;
             }
             if (typeof parsed === 'object' && parsed !== null && typeof parsed.value === 'number') {
-                collector.accept({
+                return collector.accept({
                     topic: raw.topic,
                     ts: parsed.ts || Date.now(),
                     value: parsed.value
                 });
-                return;
             }
             log.warn(`Cannot resolve payload on ${raw.topic}: no numeric value found`);
+            return undefined;
         }
     };
 }

package/src/infrastructure/ingest/mqtt/modbusMqtt.js

@@ -1,12 +1,6 @@
-import {
-    batch,
-    circuit,
-    clock,
-    modbusRtuBusSource,
-    modbusRtuSource,
-    modbusSource,
-    mqttSink
-} from '@yarkivaev/source-to-sink';
+import { clock } from '@yarkivaev/source-to-sink';
+import { modbusRtuBusSource, modbusRtuSource, modbusSource, mqttSink } from '../../streams/index.js';
+import ingestBatch from '../ingestBatch.js';
 import { parseModbusDeviceSpec } from './modbusDeviceSpec.js';
 
 /**
@@ -181,24 +175,28 @@ function buildSources(devices, config, collector, clk) {
 export default function modbusMqtt(mqtt, devices, config) {
     assertModbusMqttArgs(mqtt, devices, config);
     const clk = clock();
-    const breaker = circuit(config.threshold, config.timeout, clk);
     const sink = mqttSink(mqtt, {
         clientId: config.clientId || 'scada-modbus',
         qos: 1
     });
-    const collector = batch(sink, 5, breaker);
+    const collector = ingestBatch(sink, { ...config, size: config.size ?? 5 });
     const sources = buildSources(devices, config, collector, clk);
     return {
-        start() {
-            sink.start();
-            for (const source of sources) {
-                source.start();
+        async start() {
+            await sink.start();
+            try {
+                await Promise.all(sources.map((source) => { return source.start(); }));
+            } catch (error) {
+                await Promise.allSettled(sources.map((source) => { return source.stop(); }));
+                await sink.stop();
+                throw error;
             }
         },
-        stop() {
-            for (const source of sources) {
-                source.stop();
-            }
+        async stop() {
+            try {
+                await Promise.all(sources.map((source) => { return source.stop(); }));
+                await collector.stop();
+            } finally { await sink.stop(); }
         }
     };
 }

package/src/infrastructure/ingest/mqtt/modbusPublish.js

@@ -260,6 +260,10 @@ export default function modbusPublish(mqtt, config) {
         return [row.name, plans[index]];
     }));
     return modbusMqtt(mqtt, specs, {
+        budget: config.budget,
+        maxRecords: config.maxRecords,
+        maxBytes: config.maxBytes,
+        writeTimeoutMs: config.writeTimeoutMs,
         address: frame.address,
         clientId: config.clientId || 'scada-modbus',
         count: frame.count,

package/src/infrastructure/ingest/mqtt/mqttMetrics.js

@@ -1,21 +1,16 @@
-import {
-    batch,
-    circuit,
-    clock,
-    mqttSource,
-    timedBatch
-} from '@yarkivaev/source-to-sink';
+import { mqttSource } from '../../streams/index.js';
+import ingestBatch from '../ingestBatch.js';
 import metricsCodec from './metricsTransformer.js';
 
 /**
  * Pipeline for streaming MQTT sensor data to a storage sink.
  *
- * Subscribes to MQTT topic and batches messages before writing
- * to the provided sink. Uses circuit breaker for failure isolation
- * and time-based flushing for low-volume periods.
+ * Subscribes to MQTT and writes each message before acknowledging it.
+ * MQTT.js serializes acknowledgement, so acceptance cannot wait for a larger batch.
+ * Bounds queued records and bytes and enforces a durable-write deadline.
  *
  * @example
- *   import { clickhouseSink } from '@yarkivaev/source-to-sink';
+ *   import { clickhouseSink } from '../../streams/index.js';
  *   const sink = clickhouseSink('http://localhost:8123', 'scada.metrics');
  *   const pipeline = mqttMetrics(
  *     'mqtt://localhost:1883',
@@ -31,10 +26,10 @@ import metricsCodec from './metricsTransformer.js';
  * @param {object} sink - Sink with write(records) method
  * @param {string} topic - MQTT topic pattern to subscribe
  * @param {object} config - Pipeline configuration
- * @param {number} config.size - Batch size before flush
+ * @param {number} config.size - Legacy option; serial durable acceptance writes one record at a time
  * @param {number} config.interval - Seconds before time-based flush
- * @param {number} config.threshold - Circuit breaker failure threshold
- * @param {number} config.timeout - Circuit breaker timeout in seconds
+ * @param {number} config.threshold - Legacy option (retained for configuration compatibility)
+ * @param {number} config.timeout - Legacy option (use writeTimeoutMs for write deadlines)
  * @param {string} [config.clientId] - MQTT client ID for persistent sessions
  * @param {number} [config.sessionExpiryInterval] - Session expiry in seconds (default 3600)
  * @returns {object} Pipeline with start() and stop() methods
@@ -52,11 +47,12 @@ export default function mqttMetrics(mqtt, sink, topic, config) {
     if (!config || typeof config !== 'object') {
         throw new Error('Config must be an object');
     }
-    const clk = clock();
-    const breaker = circuit(config.threshold, config.timeout, clk);
-    const collector = timedBatch(batch(sink, config.size, breaker), config.interval);
+    const collector = ingestBatch(sink, { ...config, size: 1 });
     const transformer = metricsCodec(collector);
     const source = mqttSource(mqtt, topic, transformer, {
+        budget: config.budget,
+        prefetch: config.prefetch,
+        maxPacketBytes: config.maxBytes,
         clientId: config.clientId,
         sessionExpiryInterval: config.sessionExpiryInterval
     });
@@ -65,14 +61,14 @@ export default function mqttMetrics(mqtt, sink, topic, config) {
          * Starts the pipeline.
          */
         start() {
-            source.start();
+            return source.start();
         },
         /**
          * Stops the pipeline.
          */
-        stop() {
-            source.stop();
-            collector.stop();
+        async stop() {
+            await source.stop();
+            await collector.stop();
         }
     };
 }

package/src/infrastructure/ingest/mqtt/registerPublish.js

@@ -70,15 +70,15 @@ export default function registerPublish(plans, origin, collector) {
          * @param {Array<number>} registers - uint16 window
          */
         accept(registers) {
-            rows.forEach((item) => {
-                collector.accept({
+            return Promise.all(rows.map((item) => {
+                return collector.accept({
                     payload: JSON.stringify({
                         ts: Date.now(),
                         value: decodePoint(item.point, origin, registers)
                     }),
                     topic: item.topic
                 });
-            });
+            }));
         }
     };
 }

package/src/infrastructure/ingest/pipelines/alertPipeline.js

@@ -1,4 +1,5 @@
-import { stompSource } from '@yarkivaev/source-to-sink';
+import stompOptions from './stompOptions.js';
+import { stompSource } from '../../streams/index.js';
 import alertCodec from '../codecs/alertCodec.js';
 import alertSink from '../sinks/alertSink.js';
 
@@ -29,20 +30,20 @@ export default function alertPipeline(stomp, pool, config) {
     const sink = alertSink(pool);
     const codec = alertCodec(sink, config.translations || {});
     const source = stompSource(stomp, '/exchange/scada.alerts', codec,
-        { login: config.login, passcode: config.passcode, host: config.host });
+        stompOptions(config));
     return {
         /**
          * Starts the pipeline.
          */
         start() {
-            source.start();
+            return source.start();
         },
         /**
          * Stops the pipeline.
          */
-        stop() {
-            source.stop();
-            sink.stop();
+        async stop() {
+            await source.stop();
+            await sink.stop();
         }
     };
 }

package/src/infrastructure/ingest/pipelines/decisionPipeline.js

@@ -1,4 +1,5 @@
-import { stompSource } from '@yarkivaev/source-to-sink';
+import stompOptions from './stompOptions.js';
+import { stompSource } from '../../streams/index.js';
 import userDecisionCodec from '../codecs/userDecisionCodec.js';
 import userDecisionSink from '../sinks/userDecisionSink.js';
 
@@ -26,20 +27,20 @@ export default function decisionPipeline(stomp, pool, config) {
     const sink = userDecisionSink(pool);
     const codec = userDecisionCodec(sink);
     const source = stompSource(stomp, '/exchange/scada.user_decisions', codec,
-        { login: config.login, passcode: config.passcode, host: config.host });
+        stompOptions(config));
     return {
         /**
          * Starts consuming user decisions from RabbitMQ.
          */
         start() {
-            source.start();
+            return source.start();
         },
         /**
          * Stops consuming and releases resources.
          */
-        stop() {
-            source.stop();
-            pool.end();
+        async stop() {
+            await source.stop();
+            await pool.end();
         }
     };
 }

package/src/infrastructure/ingest/pipelines/segmentPipeline.js

@@ -1,7 +1,5 @@
-import {
-    postgresSink,
-    stompSource
-} from '@yarkivaev/source-to-sink';
+import stompOptions from './stompOptions.js';
+import { postgresSink, stompSource } from '../../streams/index.js';
 import segmentDispatch from '../../../domain/segment/dispatch.js';
 import segmentCoalesce from '../../../domain/segment/segmentCoalesce.js';
 import silenceBudget from '../../../domain/segment/silenceBudget.js';
@@ -64,14 +62,7 @@ export default function segmentPipeline(stomp, postgres, pool, config) {
         interval: config.interval
     });
     const destination = config.segmentsDestination || segmentsIngestDestination;
-    const source = stompSource(stomp, destination, coalesce, {
-        login: config.login,
-        passcode: config.passcode,
-        host: config.host,
-        serial: false,
-        manualAck: true,
-        prefetch: config.prefetch
-    });
+    const source = stompSource(stomp, destination, coalesce, stompOptions(config, { serial: false, manualAck: true }));
     const silence = silentOpenWatch(closeSilentOpen(pool), budget, {
         intervalMs: (config.poll || 5) * 1000
     });
@@ -82,13 +73,13 @@ export default function segmentPipeline(stomp, postgres, pool, config) {
             void repair.catch((error) => {
                 processingErrorLog('abut_segments', error, { budgetSeconds: budget });
             });
-            source.start();
+            await source.start();
             await silence.start();
         },
-        stop() {
-            silence.stop();
-            source.stop();
-            pool.end();
+        async stop() {
+            await silence.stop();
+            await source.stop();
+            await pool.end();
         }
     };
 }