@yarkivaev/scada 2.3.115 → 2.4.0

package/src/application/runtime/taskState.js

@@ -0,0 +1,73 @@
+import deadline from './deadline.js';
+import stateDocument from './stateDocument.js';
+
+async function save(ctx, changes) {
+    if (ctx.failed) { throw new Error('Task state requires reload'); }
+    ctx.options.signal?.throwIfAborted();
+    const next = { ...ctx.data, ...changes };
+    try {
+        const version = await ctx.store.commit({ ...next, expectedVersion: ctx.data.version, ownership: ctx.options.ownership });
+        ctx.options.signal?.throwIfAborted();
+        Object.assign(ctx, { data: { ...next, version } });
+    } catch (error) { Object.assign(ctx, { failed: true }); throw error; }
+}
+async function resume(ctx, sinks) {
+    if (ctx.failed) { throw new Error('Task state requires reload'); }
+    if (!ctx.data) { throw new Error('Task state must be opened'); }
+    if (!ctx.data.pending) { return; }
+    const { event, remaining, checkpoint } = ctx.data.pending;
+    for (const name of remaining) {
+        ctx.options.signal?.throwIfAborted();
+        if (!sinks[name]) { throw new Error('Missing required sink'); }
+        // Sequential fan-out persists every durable acknowledgement before continuing.
+        // eslint-disable-next-line no-await-in-loop
+        await deadline(() => { return sinks[name].write([event], { signal: ctx.options.signal }); }, ctx.options.writeTimeoutMs ?? 10000);
+        const pending = { event, checkpoint, remaining: ctx.data.pending.remaining.filter((item) => { return item !== name; }) };
+        // eslint-disable-next-line no-await-in-loop
+        await save(ctx, { pending });
+    }
+    await save(ctx, { checkpoint, pending: null });
+}
+function exclusive(ctx, action) {
+    if (ctx.busy) { return Promise.reject(new Error('Task state operation in progress')); }
+    ctx.busy = true;
+    return Promise.resolve().then(action).finally(() => { ctx.busy = false; });
+}
+async function open(ctx) {
+    const saved = await ctx.store.load(ctx.options.taskId);
+    if (saved && (saved.stateVersion !== ctx.options.stateVersion || saved.compatibilityKey !== ctx.options.compatibilityKey)) {
+        throw new Error('Recovered task state is incompatible');
+    }
+    ctx.options.signal?.throwIfAborted();
+    Object.assign(ctx, { data: saved ?? { taskId: ctx.options.taskId, version: 0, stateVersion: ctx.options.stateVersion,
+        compatibilityKey: ctx.options.compatibilityKey, checkpoint: null, pending: null } });
+    Object.assign(ctx, { failed: false });
+}
+async function deliver(ctx, event, sinks, checkpoint) {
+    if (ctx.failed) { throw new Error('Task state requires reload'); }
+    if (!ctx.data) { throw new Error('Task state must be opened'); }
+    if (ctx.data.pending) { throw new Error('Pending delivery must be resumed first'); }
+    if (typeof event.eventId !== 'string' || !event.eventId || Object.keys(sinks).length === 0) {
+        throw new TypeError('Stable eventId and required sinks are mandatory');
+    }
+    const pending = stateDocument({ event, remaining: Object.keys(sinks), checkpoint }, ctx.options.maxBytes ?? 1048576);
+    await save(ctx, { pending });
+    await resume(ctx, sinks);
+}
+/** Durable per-recipient outbox. CAS detects conflicts; it is not distributed fencing. */
+export default function taskState(store, options) {
+    const ctx = { store, options, data: null, busy: false, failed: false };
+    return {
+        open() { return exclusive(ctx, () => { return open(ctx); }); },
+        deliver(event, sinks, checkpoint) { return exclusive(ctx, () => { return deliver(ctx, event, sinks, checkpoint); }); },
+        resume(sinks) { return exclusive(ctx, () => { return resume(ctx, sinks); }); },
+        checkpoint(value) {
+            return exclusive(ctx, () => {
+                if (!ctx.data) { throw new Error('Task state must be opened'); }
+                if (ctx.data.pending) { throw new Error('Pending delivery must be resumed first'); }
+                return save(ctx, { checkpoint: stateDocument(value, options.maxBytes ?? 1048576) });
+            });
+        },
+        snapshot() { return structuredClone(ctx.data); }
+    };
+}

package/src/application/siteCollection.js

@@ -0,0 +1,14 @@
+function external(config) {
+    const mode = config.collectorMode ?? config.env?.COLLECTOR_MODE ?? process.env.COLLECTOR_MODE ?? 'embedded';
+    if (!['embedded', 'external'].includes(mode)) { throw new TypeError('Invalid collectorMode'); }
+    return mode === 'external';
+}
+/** Keep site HTTP/state services while moving autonomous ingestion to executors. */
+export function collectionEnvironment(config) {
+    const env = config.env ?? process.env;
+    return external(config) ? { ...env, SINK_PIPELINES: 'false' } : env;
+}
+export function startCollection(config, start) {
+    if (external(config)) { return undefined; }
+    return start();
+}

package/src/application/siteServer.js

@@ -1,4 +1,4 @@
-import { clickhouseSink } from '@yarkivaev/source-to-sink';
+import { clickhouseSink } from '../infrastructure/streams/index.js';
 import supervisorSink from './supervisorSink.js';
 import plantServer from './plantServer.js';
 import plantOperations from './plantOperations.js';
@@ -11,6 +11,7 @@ import startTelemetryIngest from './siteTelemetry.js';
 import timelineOperatorFromEnv from './timelineOperatorFromEnv.js';
 import { buildSiteOperatorCatalog } from './siteOperatorCatalog.js';
 import siteSyncBind from './sync/siteSyncBind.js';
+import { collectionEnvironment, startCollection } from './siteCollection.js';
 
 function stompFromEnv(env) {
     return {
@@ -118,7 +119,7 @@ function siteExtraRoutes(catalog, extraRoutes, syncRoutes) {
  *   await siteServer({ plantFactory: ({ alerts, userDecisions }, sink) => edgePlant(machines, { metrics: sink.dataAccess.metrics, alerts, userDecisions }), kindSources: { temp } });
  */
 export default async function siteServer(config) {
-    const env = config.env || process.env;
+    const env = collectionEnvironment(config);
     const sink = supervisorSink(env);
     const ops = bindSiteOperations(sink, config.kindSources || config.operationSources);
     const http = edgeApi(sink.dataAccess, {
@@ -132,15 +133,15 @@ export default async function siteServer(config) {
         runRetention
     });
     await sink.run(http);
-    const mqtt = startMqtt(sink, env);
-    const telemetry = startTelemetryIngest(
+    const mqtt = startCollection(config, () => { return startMqtt(sink, env); });
+    const telemetry = startCollection(config, () => { return startTelemetryIngest(
         env,
         config.streams,
         mqttConfigFromEnv(env),
         sink.pool,
         config.intervalDevices
-    );
-    const operationSync = startOperationSync(sink, env);
+    ); });
+    const operationSync = startCollection(config, () => { return startOperationSync(sink, env); });
     const basePath = config.basePath || '/api/v1';
     const catalog = buildSiteOperatorCatalog(config, basePath, sink, env);
     if (catalog.sync) {

package/src/application/siteTelemetry.js

@@ -1,4 +1,4 @@
-import { clickhouseSink } from '@yarkivaev/source-to-sink';
+import { clickhouseSink } from '../infrastructure/streams/index.js';
 import amqpMetricsIngest from '../infrastructure/ingest/telemetry/amqpMetricsIngest.js';
 import foldedMetricsSink from './foldedMetricsSink.js';
 import bindSilentStreams from './bindSilentStreams.js';

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/deploy/executeRelease.js

@@ -1,11 +1,27 @@
 import { execFileSync } from 'node:child_process';
 
+/** Retire only explicit Deployments with a single exact app label selector. */
+function validateRetirements(plan) {
+    if (plan.retirements !== undefined && !Array.isArray(plan.retirements)) {
+        throw new Error('retirements must be an array');
+    }
+    for (const retirement of plan.retirements || []) {
+        const name = retirement?.workload?.match(/^deployment\/(?<name>[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?)$/u)?.groups.name;
+        const label = retirement?.selector?.match(/^app=(?<label>[A-Za-z0-9](?:[A-Za-z0-9_.-]*[A-Za-z0-9])?)$/u)?.groups.label;
+        if (!name || name.length > 253 || name.split('.').some((part) => { return !part || part.length > 63; })
+            || !label || label.length > 63 || (plan.workloads || []).includes(retirement.workload)) {
+            throw new Error('retirement requires an exact old deployment and app label outside desired workloads');
+        }
+    }
+}
+
 /** Validates the target before helm or kubectl can fall back to a default. */
 function validate(plan, action) {
     if (!['render', 'check', 'diff', 'apply', 'adopt', 'check-adoption'].includes(action)) {
         throw new Error('action must be render, check, diff or apply (adopt/check-adoption for migration)');
     }
     const fields = action === 'render' ? ['chart', 'release', 'namespace'] : ['chart', 'release', 'namespace', 'context', 'fieldManager'];
+    validateRetirements(plan);
     fields.forEach((key) => {
         if (typeof plan[key] !== 'string' || !plan[key].trim()) { throw new Error(`release requires ${key}`); }
     });
@@ -13,9 +29,9 @@ function validate(plan, action) {
 
 /** Every Kubernetes command, including the post-rollout hook, shares this target. */
 function kubeAt(plan, execute) {
-    return (args, input) => {
+    return (args, input, capture = false) => {
         return execute('kubectl', ['--context', plan.context, '--namespace', plan.namespace, ...args],
-            { input, encoding: 'utf8', stdio: ['pipe', 'inherit', 'inherit'] });
+            { input, encoding: 'utf8', stdio: ['pipe', capture ? 'pipe' : 'inherit', 'inherit'] });
     };
 }
 
@@ -25,8 +41,31 @@ function applyWith(kube, manifests, flags, checkOnly) {
     if (!checkOnly) { kube(args, manifests); }
 }
 
+/** A missing Deployment can still have terminating pods from an interrupted attempt. */
+function retireWorkloads(plan, kube) {
+    for (const { workload, selector } of plan.retirements || []) {
+        if (kube(['get', workload, '--ignore-not-found', '-o', 'name'], undefined, true).trim()) {
+            kube(['delete', workload, '--cascade=foreground', '--wait=true', '--timeout=300s']);
+        }
+        if (kube(['get', 'pods', '-l', selector, '-o', 'name'], undefined, true).trim()) {
+            throw new Error(`retirement pods remain for ${workload} (${selector})`);
+        }
+    }
+}
+
+function preflightRetirements(plan, action, kube, manifests) {
+    if (['apply', 'adopt'].includes(action) && plan.retirements?.length) {
+        if (action === 'adopt') {
+            applyWith(kube, manifests, ['--field-manager=kubectl-client-side-apply'], true);
+        }
+        applyWith(kube, manifests, ['--server-side', `--field-manager=${plan.fieldManager}`], true);
+        retireWorkloads(plan, kube);
+    }
+}
+
 /** Adopt legacy fields, then enforce the complete manifest before waiting for rollouts. */
 function applyRelease(plan, action, kube, manifests) {
+    preflightRetirements(plan, action, kube, manifests);
     if (['adopt', 'check-adoption'].includes(action)) {
         applyWith(kube, manifests, ['--field-manager=kubectl-client-side-apply'], action === 'check-adoption');
         if (action === 'check-adoption') { return ''; }
@@ -44,7 +83,10 @@ function applyRelease(plan, action, kube, manifests) {
  * Renders a Helm release and executes the selected kubectl action synchronously.
  * Supply chart, release, namespace and values. Cluster actions additionally require
  * an explicit context and fieldManager. prerequisites and workloads are kubectl
- * resource/name references. afterReady(plan, kube) runs after a successful apply.
+ * resource/name references. Optional retirements are { workload: "deployment/name",
+ * selector: "app=label" }; callers bind these to the old declarative app. They are
+ * removed after preflight and before any writes, with no selected pods remaining.
+ * afterReady(plan, kube) runs after a successful apply.
  */
 export default function executeRelease(plan, action = 'render', execute = execFileSync) {
     validate(plan, action);

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,169 +1,2 @@
-import amqp from 'amqplib';
-
-function connectBroker(url) {
-    return amqp.connect(url, { heartbeat: 10 });
-}
-
-function scheduleLater(fn, pause) {
-    return setTimeout(fn, pause);
-}
-
-function clearLater(handle) {
-    clearTimeout(handle);
-}
-
-function reportFailure(error) {
-    process.stderr.write(`amqp consume failed ${error.message}\n`);
-}
-
-function nextDelay(delay) {
-    return Math.min(delay * 2, 30000);
-}
-
-function blankState() {
-    return {
-        generation: 0,
-        timer: undefined,
-        stopping: false,
-        delay: 1000,
-        session: undefined
-    };
-}
-
-function running(state) {
-    return Boolean(state.session) || (state.generation > 0 && !state.stopping);
-}
-
-function scheduleRetry(ctx, generation) {
-    if (ctx.state.stopping || generation !== ctx.state.generation) {
-        return;
-    }
-    const pause = ctx.state.delay;
-    ctx.state.delay = nextDelay(ctx.state.delay);
-    ctx.state.timer = ctx.schedule(() => {
-        ctx.state.timer = undefined;
-        return ctx.open(generation);
-    }, pause);
-}
-
-function bindClose(ctx, generation, live) {
-    let dropped = false;
-    function lose() {
-        if (dropped || ctx.state.stopping || generation !== ctx.state.generation) {
-            return;
-        }
-        dropped = true;
-        if (ctx.state.session === live) {
-            ctx.state.session = undefined;
-        }
-        scheduleRetry(ctx, generation);
-    }
-    live.connection.on('error', lose);
-    live.connection.on('close', lose);
-    live.channel.on('error', lose);
-    live.channel.on('close', lose);
-}
-
-async function accept(ctx, generation, connection) {
-    if (ctx.state.stopping || generation !== ctx.state.generation) {
-        await connection.close();
-        return null;
-    }
-    return connection.createChannel();
-}
-
-async function keep(ctx, generation, connection, channel, tag) {
-    if (ctx.state.stopping || generation !== ctx.state.generation) {
-        await channel.close();
-        await connection.close();
-        return false;
-    }
-    const live = { connection, channel, tag };
-    ctx.state.session = live;
-    ctx.state.delay = 1000;
-    bindClose(ctx, generation, live);
-    return true;
-}
-
-async function open(ctx, generation) {
-    if (ctx.state.stopping || generation !== ctx.state.generation) {
-        return;
-    }
-    try {
-        const connection = await ctx.connect(ctx.url);
-        const channel = await accept(ctx, generation, connection);
-        if (!channel) {
-            return;
-        }
-        const tag = await ctx.subscribe(channel);
-        await keep(ctx, generation, connection, channel, tag);
-    } catch (error) {
-        ctx.report(error);
-        scheduleRetry(ctx, generation);
-    }
-}
-
-function begin(ctx) {
-    if (running(ctx.state)) {
-        return Promise.resolve();
-    }
-    ctx.state.stopping = false;
-    ctx.state.generation += 1;
-    ctx.state.delay = 1000;
-    return open(ctx, ctx.state.generation);
-}
-
-async function end(ctx) {
-    ctx.state.stopping = true;
-    ctx.state.generation += 1;
-    if (ctx.state.timer) {
-        ctx.clear(ctx.state.timer);
-        ctx.state.timer = undefined;
-    }
-    const live = ctx.state.session;
-    ctx.state.session = undefined;
-    if (!live) {
-        return;
-    }
-    await live.channel.cancel(live.tag);
-    await live.channel.close();
-    await live.connection.close();
-}
-
-/**
- * Keeps one AMQP consumer subscribed across broker restarts.
- *
- * @param {string} url - RabbitMQ AMQP URL
- * @param {function} subscribe - async (channel) => consumerTag
- * @param {object} [options] - connect, schedule, clear, report overrides
- * @returns {object} session with start and stop
- *
- * @example
- *   const session = durableConsume('amqp://localhost', async (channel) => {
- *       const tag = await channel.consume('scada.telemetry.ingest', () => {});
- *       return tag.consumerTag;
- *   });
- *   await session.start();
- */
-export default function durableConsume(url, subscribe, options = {}) {
-    const ctx = {
-        url,
-        subscribe,
-        connect: options.connect || connectBroker,
-        schedule: options.schedule || scheduleLater,
-        clear: options.clear || clearLater,
-        report: options.report || reportFailure,
-        state: blankState(),
-        open(generation) {
-            return open(ctx, generation);
-        }
-    };
-    return {
-        start() {
-            return begin(ctx);
-        },
-        stop() {
-            return end(ctx);
-        }
-    };
-}
+// 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])
                 });
-            }
+            }));
         }
     };
 }