@yarkivaev/scada 1.4.0 → 2.3.45

package/src/application/siteServer.js

@@ -0,0 +1,191 @@
+import { clickhouseSink } from '@yarkivaev/source-to-sink';
+import supervisorSink from './supervisorSink.js';
+import plantServer from './plantServer.js';
+import plantOperations from './plantOperations.js';
+import edgeApi from '../infrastructure/http/edge/edgeApi.js';
+import runRetention from '../infrastructure/ingest/db/runRetention.js';
+import mqttMetrics from '../infrastructure/ingest/mqtt/mqttMetrics.js';
+import amqpMetricsIngest from '../infrastructure/ingest/telemetry/amqpMetricsIngest.js';
+import operationSyncIngest from '../infrastructure/sync/operationSyncIngest.js';
+import { metricsSinkFromPool } from '../infrastructure/persistence/pg/metrics.js';
+import bindSilentStreams from './bindSilentStreams.js';
+import timelineOperatorFromEnv from './timelineOperatorFromEnv.js';
+import { buildSiteOperatorCatalog } from './siteOperatorCatalog.js';
+
+function stompFromEnv(env) {
+    return {
+        url: env.STOMP_URL,
+        login: env.STOMP_LOGIN || 'guest',
+        passcode: env.STOMP_PASSCODE || 'guest',
+        host: env.STOMP_HOST || '/',
+        operatorUser: env.HMI_OPERATOR_USER || 'hmi-kiosk'
+    };
+}
+
+function mqttConfigFromEnv(env) {
+    return {
+        size: parseInt(env.BATCH_SIZE || '50', 10),
+        interval: parseInt(env.FLUSH_INTERVAL || '5', 10),
+        threshold: parseInt(env.CIRCUIT_THRESHOLD || '5', 10),
+        timeout: parseInt(env.CIRCUIT_TIMEOUT || '60', 10),
+        clientId: env.CLIENT_ID,
+        sessionExpiryInterval: parseInt(env.SESSION_EXPIRY || '3600', 10)
+    };
+}
+
+function mqttSinkForProfile(sink, env) {
+    const profile = env.SINK_DB_PROFILE === 'central' ? 'central' : 'edge';
+    if (profile === 'edge') {
+        return metricsSinkFromPool(sink.pool);
+    }
+    const url = env.CLICKHOUSE_URL
+        || (env.CLICKHOUSE_HOST ? `http://${env.CLICKHOUSE_HOST}:8123` : undefined);
+    if (!url) {
+        throw new Error('CLICKHOUSE_URL or CLICKHOUSE_HOST is required for central MQTT metrics');
+    }
+    return clickhouseSink(url, 'scada.metrics');
+}
+
+function startMqtt(sink, env) {
+    if (!env.MQTT_URL || !env.MQTT_TOPICS) {
+        return undefined;
+    }
+    const metricsSink = mqttSinkForProfile(sink, env);
+    const pipeline = mqttMetrics(env.MQTT_URL, metricsSink, env.MQTT_TOPICS, mqttConfigFromEnv(env));
+    pipeline.start();
+    return pipeline;
+}
+
+function startOperationSync(sink, env) {
+    if (env.SINK_DB_PROFILE === 'edge' || !env.AMQP_URL) {
+        return undefined;
+    }
+    const ingest = operationSyncIngest(
+        env.AMQP_URL,
+        env.AMQP_OPERATIONS_QUEUE || 'scada.operations.ingest',
+        sink.dataAccess.operations,
+        { prefetch: parseInt(env.AMQP_PREFETCH || '32', 10) }
+    );
+    ingest.start();
+    return ingest;
+}
+
+function clickhouseMetricsUrl(env) {
+    return env.CLICKHOUSE_URL
+        || (env.CLICKHOUSE_HOST ? `http://${env.CLICKHOUSE_HOST}:8123` : undefined);
+}
+
+function startAmqpMetrics(env, sink, onSeen) {
+    if (!env.AMQP_URL) {
+        return undefined;
+    }
+    const batchConfig = mqttConfigFromEnv(env);
+    const ingest = amqpMetricsIngest(
+        env.AMQP_URL,
+        env.AMQP_QUEUE || 'scada.telemetry.ingest',
+        sink,
+        {
+            size: batchConfig.size,
+            interval: batchConfig.interval,
+            threshold: batchConfig.threshold,
+            timeout: batchConfig.timeout,
+            prefetch: parseInt(env.AMQP_PREFETCH || '32', 10),
+            onSeen
+        }
+    );
+    ingest.start();
+    return ingest;
+}
+
+function startTelemetryIngest(env, streams) {
+    if (env.SINK_DB_PROFILE === 'edge' || (!env.AMQP_URL && !streams)) {
+        return undefined;
+    }
+    const url = clickhouseMetricsUrl(env);
+    if (!url) {
+        throw new Error('CLICKHOUSE_URL or CLICKHOUSE_HOST is required for AMQP telemetry ingest');
+    }
+    const sink = clickhouseSink(url, 'scada.metrics');
+    const onSeen = bindSilentStreams(streams, sink);
+    const ingest = startAmqpMetrics(env, sink, onSeen);
+    if (streams) {
+        streams.start();
+    }
+    return { ingest, streams };
+}
+
+function plantFactoryWithOperations(plantFactory, ops, sink) {
+    return (ctx) => {
+        const built = plantFactory({ ...ctx, operations: ops }, sink);
+        return Promise.resolve(built).then((p) => {
+            if (p.operations) {
+                return p;
+            }
+            return {
+                ...p,
+                operations: ops,
+                init() {
+                    p.init();
+                }
+            };
+        });
+    };
+}
+
+function siteExtraRoutes(catalog, extraRoutes) {
+    return (path, plant, clock) => {
+        const userExtra = extraRoutes ? extraRoutes(path, plant, clock) : [];
+        return [...catalog.routes, ...userExtra];
+    };
+}
+
+/**
+ * Unified site process: supervisor-sink HTTP, plant API, and optional MQTT ingest.
+ *
+ * @param {object} config - port, basePath, translations, requirePool, plantFactory, extraRoutes, operatorCatalog, kindSources, streams, env
+ * @returns {Promise<object>} sink, plant, mqtt pipeline
+ *
+ * @example
+ *   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 sink = supervisorSink(env);
+    const ops = plantOperations(
+        sink.dataAccess.operations,
+        config.kindSources || config.operationSources
+    );
+    sink.dataAccess.operations = ops;
+    const http = edgeApi(sink.dataAccess, {
+        port: sink.apiPort,
+        token: sink.apiToken,
+        metricsEnabled: sink.metricsEnabled,
+        retentionEnabled: sink.retentionEnabled,
+        retentionDays: sink.retentionDays,
+        requestTimeoutMs: sink.requestTimeoutMs,
+        pool: sink.pool,
+        runRetention
+    });
+    await sink.run(http);
+    const mqtt = startMqtt(sink, env);
+    const telemetry = startTelemetryIngest(env, config.streams);
+    const operationSync = startOperationSync(sink, env);
+    const basePath = config.basePath || '/api/v1';
+    const catalog = buildSiteOperatorCatalog(config, basePath, sink, env);
+    if (catalog.sync) {
+        await catalog.sync.start();
+    }
+    const plant = await plantServer({
+        port: config.port || parseInt(env.PORT || '3000', 10),
+        basePath,
+        translations: config.translations,
+        requirePool: config.requirePool,
+        stomp: stompFromEnv(env),
+        plantFactory: plantFactoryWithOperations(config.plantFactory, ops, sink),
+        extraRoutes: siteExtraRoutes(catalog, config.extraRoutes),
+        timelineOperator: timelineOperatorFromEnv(catalog, env, config),
+        operationDecisions: catalog.decisions,
+        owners: config.owners
+    });
+    return { sink, plant, mqtt, telemetry, operationSync, operatorsSync: catalog.sync };
+}

package/src/application/supervisorSink.js

@@ -0,0 +1,97 @@
+import segmentPipeline, {
+    segmentsIngestDestination
+} from '../infrastructure/ingest/pipelines/segmentPipeline.js';
+import decisionPipeline from '../infrastructure/ingest/pipelines/decisionPipeline.js';
+import alertPipeline from '../infrastructure/ingest/pipelines/alertPipeline.js';
+import migrate, { migratePrivileged } from '../infrastructure/ingest/db/migrate.js';
+import stateDataFromPool from '../infrastructure/persistence/stateDataFromPool.js';
+import { parseRequestTimeoutMs } from '../infrastructure/ingest/parseRequestTimeoutMs.js';
+import pg from 'pg';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const appRoot = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Reads deployment environment into a normalized config object.
+ *
+ * @param {NodeJS.ProcessEnv} env - process environment
+ * @returns {object} deployment configuration
+ */
+export function readDeploymentConfig(env) {
+    const root = path.join(appRoot, '../..');
+    return {
+        stomp: env.STOMP_URL,
+        postgres: env.POSTGRES_URL,
+        postgresAdmin: env.POSTGRES_ADMIN_URL,
+        apiPort: parseInt(
+            env.STATE_HTTP_PORT || env.INTERNAL_API_PORT || '8081',
+            10
+        ),
+        apiToken: env.STATE_HTTP_TOKEN || env.INTERNAL_API_TOKEN,
+        sinkDbProfile: env.SINK_DB_PROFILE === 'central' ? 'central' : 'edge',
+        retentionEnabled: env.RETENTION_ENABLED === 'true',
+        retentionDays: parseInt(env.RETENTION_DAYS || '30', 10),
+        migrationsDir: path.join(root, 'db', 'migrations'),
+        requestTimeoutMs: parseRequestTimeoutMs(env.REQUEST_TIMEOUT_MS),
+        pipeline: {
+            size: parseInt(env.BATCH_SIZE || '50', 10),
+            interval: parseInt(env.FLUSH_INTERVAL || '2', 10),
+            threshold: parseInt(env.CIRCUIT_THRESHOLD || '5', 10),
+            timeout: parseInt(env.CIRCUIT_TIMEOUT || '60', 10),
+            poll: parseInt(env.POLL_INTERVAL || '5', 10),
+            segmentWindow: parseInt(env.SEGMENT_WINDOW_SECONDS || '15', 10),
+            segmentsDestination: env.SEGMENTS_STOMP_DESTINATION ||
+                segmentsIngestDestination,
+            login: env.STOMP_LOGIN || 'guest',
+            passcode: env.STOMP_PASSCODE || 'guest',
+            host: env.STOMP_HOST || '/'
+        }
+    };
+}
+
+/**
+ * Wires STOMP pipelines, migrations, and state data access from env config.
+ * HTTP binding uses edgeApi (metrics, checkpoint, retention).
+ *
+ * @param {NodeJS.ProcessEnv} [env] - process environment, defaults to process.env
+ * @returns {object} sink runtime with pool, dataAccess, and run(httpServer?)
+ */
+export default function supervisorSink(env = process.env) {
+    const cfg = readDeploymentConfig(env);
+    const pool = 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 {
+        apiPort: cfg.apiPort,
+        apiToken: cfg.apiToken,
+        sinkDbProfile: cfg.sinkDbProfile,
+        retentionEnabled: cfg.retentionEnabled,
+        retentionDays: cfg.retentionDays,
+        requestTimeoutMs: cfg.requestTimeoutMs,
+        metricsEnabled,
+        pool,
+        dataAccess,
+        async run(httpServer) {
+            if (!cfg.postgresAdmin) {
+                throw new Error('POSTGRES_ADMIN_URL is required for supervisor-sink database migrations');
+            }
+            const adminPool = new pg.Pool({ connectionString: cfg.postgresAdmin });
+            try {
+                await migrate(adminPool, cfg.migrationsDir, cfg.sinkDbProfile);
+                await migratePrivileged(adminPool, cfg.migrationsDir, cfg.sinkDbProfile);
+            } finally {
+                await adminPool.end();
+            }
+            segments.start();
+            decisions.start();
+            alerts.start();
+            if (httpServer) {
+                httpServer.start();
+            }
+        }
+    };
+}

package/src/application/timelineOperatorFromEnv.js

@@ -0,0 +1,19 @@
+/**
+ * Builds timelineOperator options from env and optional site config.
+ *
+ * @param {object} catalog - operator routes catalog with provider
+ * @param {object} env - process environment
+ * @param {object} config - siteServer config with optional anonymousUsers
+ * @returns {object} timelineOperator options
+ */
+export default function timelineOperatorFromEnv(catalog, env, config) {
+    const options = {
+        provider: catalog.provider,
+        requireOperator: env.REQUIRE_OPERATOR === 'true',
+        defaultUser: env.HMI_OPERATOR_USER || 'hmi-kiosk'
+    };
+    if (config && config.anonymousUsers) {
+        options.anonymousUsers = config.anonymousUsers;
+    }
+    return options;
+}

package/src/bin/supervisor-sink.js

@@ -0,0 +1,28 @@
+/**
+ * Supervisor-sink service entry point.
+ */
+process.on('unhandledRejection', (err) => {
+    process.stderr.write(`Unhandled rejection: ${String(err)}\n`);
+    process.exit(1);
+});
+
+import supervisorSink from '../application/supervisorSink.js';
+import runRetention from '../infrastructure/ingest/db/runRetention.js';
+import edgeApi from '../infrastructure/http/edge/edgeApi.js';
+
+const sink = supervisorSink(process.env);
+const http = edgeApi(sink.dataAccess, {
+    port: sink.apiPort,
+    token: sink.apiToken,
+    metricsEnabled: sink.metricsEnabled,
+    retentionEnabled: sink.retentionEnabled,
+    retentionDays: sink.retentionDays,
+    requestTimeoutMs: sink.requestTimeoutMs,
+    pool: sink.pool,
+    runRetention
+});
+
+sink.run(http).catch((error) => {
+    process.stderr.write(`${String(error)}\n`);
+    process.exit(1);
+});

package/src/{alert.js → domain/alerting/alert.js}

@@ -12,7 +12,7 @@
  * @returns {object} alert with id, message, timestamp, object, event, acknowledge, acknowledged
  *
  * @example
- *   const a = alert('alert-1', 'High voltage', new Date(), 'icht1', srcEvent, ackCallback);
+ *   const a = alert('alert-1', 'High voltage', new Date(), 'm1', srcEvent, ackCallback);
  *   a.id; // 'alert-1'
  *   a.event; // srcEvent reference
  *   a.acknowledged; // false
@@ -42,7 +42,7 @@ export function alert(id, message, timestamp, object, source, acknowledge) {
  * @returns {object} acknowledged alert with id, message, timestamp, object, event, acknowledged
  *
  * @example
- *   const a = acknowledgedAlert('alert-1', 'High voltage', new Date(), 'icht1', srcEvent);
+ *   const a = acknowledgedAlert('alert-1', 'High voltage', new Date(), 'm1', srcEvent);
  *   a.id; // 'alert-1'
  *   a.event; // srcEvent reference
  *   a.acknowledged; // true

package/src/{alerts.js → domain/alerting/alerts.js}

@@ -1,4 +1,4 @@
-import pubsub from './pubsub.js';
+import pubsub from '../shared/pubsub.js';
 
 /**
  * History of alert occurrences with filtering support.
@@ -11,10 +11,10 @@ import pubsub from './pubsub.js';
  *
  * @example
  *   const history = alerts(alert, acknowledgedAlert);
- *   const a = history.trigger('High voltage', new Date(), 'icht1');
+ *   const a = history.trigger('High voltage', new Date(), 'm1');
  *   a.id; // 'alert-0'
  *   a.acknowledge(); // replaces with acknowledged version
- *   history.trigger('From event', new Date(), 'icht1', sourceEvent); // with event
+ *   history.trigger('From event', new Date(), 'm1', sourceEvent); // with event
  *   history.stream((evt) => console.log(evt)); // subscribe to events
  */
 export default function alerts(alert, acknowledgedAlert) {

package/src/domain/alerting/ingest.js

@@ -0,0 +1,18 @@
+/**
+ * Maps alert ingest status to persistence action.
+ *
+ * @param {object} record - alert record with status field
+ * @returns {string|undefined} action name insert or acknowledge
+ *
+ * @example
+ *   alertIngestAction({ status: 'pending' });
+ */
+export function alertIngestAction(record) {
+    if (record.status === 'pending') {
+        return 'insert';
+    }
+    if (record.status === 'completed') {
+        return 'acknowledge';
+    }
+    return undefined;
+}

package/src/domain/ingest/ingestCursor.js

@@ -0,0 +1,26 @@
+/**
+ * Absent ingest poll cursor for first-run backfill.
+ *
+ * @returns {{ kind: 'empty' }} discriminated union tag without cursor instant
+ *
+ * @example
+ *   const cursor = ingestCursorEmpty();
+ *   cursor.kind;
+ */
+export function ingestCursorEmpty() {
+    return { kind: 'empty' };
+}
+
+/**
+ * Positioned ingest poll cursor after a processed source batch.
+ *
+ * @param {Date} at - last processed source updatedAt instant
+ * @returns {{ kind: 'cursor', at: Date }} discriminated union tag with cursor instant
+ *
+ * @example
+ *   const cursor = ingestCursorAt(new Date('2024-06-01T10:00:00.000Z'));
+ *   cursor.at.toISOString();
+ */
+export function ingestCursorAt(at) {
+    return { kind: 'cursor', at };
+}

package/src/domain/operation/operation.js

@@ -0,0 +1,23 @@
+/**
+ * Immutable generic machine operation record.
+ *
+ * @param {string} machine - machine identifier
+ * @param {Date} occurredAt - when the operation occurred on the machine
+ * @param {string} kind - opaque operation category defined by the plant package
+ * @param {string} key - idempotent storage key
+ * @param {object} payload - structured operation body
+ * @returns {object} operation value with machine, occurredAt, kind, key, payload
+ *
+ * @example
+ *   const item = operation('m1', new Date(), 'sample', 'nb-1', { lot: 'A' });
+ *   item.key;
+ */
+export function operation(machine, occurredAt, kind, key, payload) {
+    return {
+        machine,
+        occurredAt,
+        kind,
+        key,
+        payload
+    };
+}

package/src/domain/operation/operations.js

@@ -0,0 +1,81 @@
+function stampRow(item, updatedAt) {
+    return {
+        machine: item.machine,
+        occurred_at: item.occurred_at,
+        kind: item.kind,
+        key: item.key,
+        payload: item.payload,
+        source_updated_at: updatedAt
+    };
+}
+
+function loadKind(persistence, sources, machineId, kind, range) {
+    const source = sources[kind];
+    if (source) {
+        return source.list(machineId, range);
+    }
+    return persistence.listForMachine(machineId, kind, range);
+}
+
+function resolveKinds(kinds, sources) {
+    if (kinds === undefined) {
+        return Object.keys(sources);
+    }
+    if (Array.isArray(kinds)) {
+        return kinds;
+    }
+    return [kinds];
+}
+
+/**
+ * Operations wired to persistence, pubsub, and optional non-PG kind sources.
+ *
+ * listForMachine merges requested kinds from injectable sources and Postgres,
+ * sorted by occurred_at. Omitted kinds default to injectable source keys.
+ *
+ * @param {object} persistence - store with upsert, get, remove, listForMachine
+ * @param {object} bus - pubsub instance with stream and emit methods
+ * @param {object} [kindSources] - map of kind to { list(machineId, range) }
+ * @returns {object} operations with listForMachine, upsert, get, remove, stream
+ *
+ * @example
+ *   const ops = operations(store, bus, { temp: temperaturePort });
+ *   await ops.listForMachine('m1', ['chem', 'temp'], { from: new Date() });
+ *   await ops.remove('m1', 'nb-1');
+ */
+export default function operations(persistence, bus, kindSources) {
+    const sources = kindSources || {};
+    return {
+        listForMachine(machineId, kinds, range) {
+            const requested = resolveKinds(kinds, sources);
+            if (requested.length === 0) {
+                return Promise.resolve([]);
+            }
+            return Promise.all(requested.map((kind) => {
+                return loadKind(persistence, sources, machineId, kind, range);
+            })).then((batches) => {
+                return batches.flat().sort((left, right) => {
+                    return new Date(left.occurred_at) - new Date(right.occurred_at);
+                });
+            });
+        },
+        upsert(item) {
+            const updatedAt = new Date();
+            const row = stampRow(item, updatedAt);
+            return persistence.upsert(row).then((result) => {
+                const type = result.created ? 'created' : 'updated';
+                bus.emit({ type, operation: row });
+            });
+        },
+        get(machineId, key) {
+            return persistence.get(machineId, key);
+        },
+        remove(machineId, key) {
+            return persistence.remove(machineId, key).then((operation) => {
+                bus.emit({ type: 'deleted', operation });
+                return operation;
+            });
+        },
+        stream: bus.stream
+    };
+}

package/src/domain/operator/operator.js

@@ -0,0 +1,23 @@
+/**
+ * Immutable operator identity for central audit and HMI card lookup.
+ *
+ * @param {number} id - database primary key
+ * @param {string} cardUid - RFID or badge identifier
+ * @param {string} firstName - given name
+ * @param {string} lastName - family name
+ * @param {string} displayName - full name shown in HMI
+ * @returns {object} operator with id, cardUid, firstName, lastName, displayName
+ *
+ * @example
+ *   const op = operator(1, 'dev-card-001', 'Ivan', 'Petrov', 'Ivan Petrov');
+ *   op.displayName;
+ */
+export default function operator(id, cardUid, firstName, lastName, displayName) {
+    return {
+        id,
+        cardUid,
+        firstName,
+        lastName,
+        displayName
+    };
+}

package/src/domain/plant/machine.js

@@ -0,0 +1,32 @@
+/**
+ * Generic monitored machine with sensors, timeline, and alerts.
+ *
+ * @param {string} name - unique machine identifier
+ * @param {object} deps - machine dependencies
+ * @param {object} deps.sensors - sensor instances keyed by name
+ * @param {object} deps.alerts - shop-level alerts collection
+ * @param {object} deps.timeline - timeline port with list, retag, pending, respond, stream
+ * @returns {object} machine with name, sensors, timeline, alerts methods
+ *
+ * @example
+ *   const m = machine('m1', { sensors: { voltage }, alerts: history, timeline: tl });
+ *   m.name();
+ */
+export default function machine(name, deps) {
+    const { sensors, alerts: alertHistory, timeline: tl } = deps;
+    return {
+        name() {
+            return name;
+        },
+        sensors,
+        timeline: tl,
+        alerts() {
+            return alertHistory.all((item) => {
+                return item.object === name;
+            });
+        },
+        init() {
+            return this;
+        }
+    };
+}

package/src/domain/plant/plant.js

@@ -0,0 +1,20 @@
+/**
+ * Top-level plant structure containing shops.
+ * Provides initialization for all contained shops.
+ *
+ * @param {object} shops - initialized list of shops
+ * @returns {object} plant with shops property and init method
+ *
+ * @example
+ *   const p = plant(initialized({ area: shop }, Object.values));
+ *   p.init();
+ */
+export default function plant(shops, options = {}) {
+    return {
+        shops,
+        operations: options.operations,
+        init() {
+            shops.init();
+        }
+    };
+}

package/src/domain/plant/shop.js

@@ -0,0 +1,24 @@
+/**
+ * Shop containing machines and shop-level alerts.
+ *
+ * @param {string} name - unique identifier for the shop
+ * @param {object} machines - initialized wrapper of machines
+ * @param {object} alertHistory - alerts collection for the shop
+ * @returns {object} shop with name, machines, alerts properties and init method
+ *
+ * @example
+ *   const area = shop('area1', initialized({ m1: machine }, Object.values), alerts());
+ *   area.init();
+ */
+export default function shop(name, machines, alertHistory) {
+    return {
+        name() {
+            return name;
+        },
+        machines,
+        alerts: alertHistory,
+        init() {
+            machines.init();
+        }
+    };
+}

package/src/domain/segment/dispatch.js

@@ -0,0 +1,31 @@
+/**
+ * Routes normalized segment records to the correct persistence sink.
+ *
+ * @param {object} segmentSink - batch insert/update sink
+ * @param {object} retag - retag sink
+ * @param {object} splitSink - split update sink
+ * @param {object} closer - orphan open segment closer
+ * @returns {object} collector with accept(record)
+ *
+ * @example
+ *   const route = segmentDispatch(segmentSink, retag, splitSink, closer);
+ *   await route.accept({ type: 'segment', machine: 'm1', start_time: '...', duration: 0 });
+ */
+export default function segmentDispatch(segmentSink, retag, splitSink, closer) {
+    return {
+        async accept(record) {
+            if (record.type === 'retag') {
+                await retag.accept(record);
+            } else if (record.type === 'split') {
+                await splitSink.write([record]);
+            } else if (record.type === 'segment') {
+                if (record.duration === 0) {
+                    await closer.close(record.machine, record.start_time);
+                }
+                await segmentSink.write([record]);
+            } else {
+                throw new Error(`Segment command type ${record.type} is not defined`);
+            }
+        }
+    };
+}