@yarkivaev/scada 2.3.54 → 2.3.56

package/db/migrations/V0001__baseline.sql

@@ -8,11 +8,12 @@ CREATE TABLE IF NOT EXISTS segments (
     tags TEXT,
     properties TEXT,
     resolved BOOLEAN DEFAULT TRUE,
-    consumed BOOLEAN DEFAULT TRUE
+    consumed BOOLEAN DEFAULT TRUE,
+    kind TEXT NOT NULL DEFAULT 'phase'
 );
 
-CREATE UNIQUE INDEX IF NOT EXISTS idx_segments_machine_start
-    ON segments (machine, start_time);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_segments_machine_kind_start
+    ON segments (machine, kind, start_time);
 
 CREATE TABLE IF NOT EXISTS alerts (
     id SERIAL PRIMARY KEY,

package/db/migrations/V0007__segments_kind.sql

@@ -0,0 +1,6 @@
+ALTER TABLE segments ADD COLUMN IF NOT EXISTS kind TEXT NOT NULL DEFAULT 'phase';
+
+DROP INDEX IF EXISTS idx_segments_machine_start;
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_segments_machine_kind_start
+    ON segments (machine, kind, start_time);

package/index.js

@@ -21,6 +21,7 @@ export { default as plantOperations } from './src/application/plantOperations.js
 export { default as metricsPlant } from './src/application/metricsPlant.js';
 export { default as plantServer } from './src/application/plantServer.js';
 export { default as siteServer } from './src/application/siteServer.js';
+export { default as foldedMetricsSink } from './src/application/foldedMetricsSink.js';
 export {
     default as siteOperatorCatalog,
     buildSiteOperatorCatalog

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "2.3.54",
+  "version": "2.3.56",
   "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",

package/src/application/foldedMetricsSink.js

@@ -0,0 +1,22 @@
+import intervalFold from '../domain/segment/intervalFold.js';
+import intervalFoldPg from '../infrastructure/persistence/pg/intervalFoldPg.js';
+import foldingSink from '../infrastructure/ingest/telemetry/foldingSink.js';
+import opcuaLocate from '../infrastructure/ingest/telemetry/opcuaLocate.js';
+
+/**
+ * Wraps a metrics sink so OPC UA points also fold into PG intervals.
+ *
+ * @param {object} inner - sink with write(records)
+ * @param {object} pool - pg Pool
+ * @param {object} devices - device id to machine id
+ * @returns {object} sink
+ *
+ * @example
+ *   const sink = foldedMetricsSink(pgMetrics, pool, { 'tlc-cm8': 'cm8' });
+ */
+export default function foldedMetricsSink(inner, pool, devices) {
+    if (!devices || Object.keys(devices).length === 0) {
+        return inner;
+    }
+    return foldingSink(inner, intervalFold(intervalFoldPg(pool)), opcuaLocate(devices));
+}

package/src/application/metricsPlant.js

@@ -29,6 +29,7 @@ export default async function metricsPlant(machines, options) {
         pool,
         alerts: options.alerts,
         userDecisions: options.userDecisions,
+        segments: options.segments,
         shopName: options.shopName
     });
     return plant(initialized({ [shop.name()]: shop }, Object.values));

package/src/application/plantApi.js

@@ -1,5 +1,6 @@
 import machineRoute from '../infrastructure/http/plant/routes/machineRoute.js';
 import measurementRoute from '../infrastructure/http/plant/routes/measurementRoute.js';
+import stateRoute from '../infrastructure/http/plant/routes/stateRoute.js';
 import measurementStream from '../infrastructure/http/plant/streams/measurementStream.js';
 import alertRoute from '../infrastructure/http/plant/routes/alertRoute.js';
 import alertStream from '../infrastructure/http/plant/streams/alertStream.js';
@@ -38,6 +39,7 @@ export default function plantApi(basePath, plant, config) {
     const routeList = [
         ...catalogRoute(basePath, opts.tagCatalog),
         ...machineRoute(basePath, plant),
+        ...stateRoute(basePath, plant),
         ...measurementStream(basePath, plant, time),
         ...measurementRoute(basePath, plant, time),
         ...alertStream(basePath, plant, time),

package/src/application/plantServer.js

@@ -6,6 +6,7 @@ import postgresPool from '../infrastructure/persistence/postgresPool.js';
 import stompAlerts from '../infrastructure/messaging/stomp/alerts/stompAlerts.js';
 import stompTimelineSegments from '../infrastructure/messaging/stomp/stompTimelineSegments.js';
 import userDecisions from '../infrastructure/messaging/stomp/userDecisions.js';
+import segmentRetags from '../infrastructure/messaging/stomp/segmentRetags.js';
 import { parseRequestTimeoutMs, virtualClock } from '@yarkivaev/simple-server';
 
 function stompCollectorFactory(stompUrl, destination, credentials) {
@@ -63,7 +64,13 @@ async function initStomp(stomp, translations, requirePool) {
         passcode: stomp.passcode,
         host: stomp.host
     });
-    return { alerts, userDecisions: decisions };
+    const segments = segmentRetags({
+        stompUrl: stomp.url,
+        login: stomp.login,
+        passcode: stomp.passcode,
+        host: stomp.host
+    });
+    return { alerts, userDecisions: decisions, segments };
 }
 
 /**
@@ -79,8 +86,8 @@ async function initStomp(stomp, translations, requirePool) {
  *   await plantServer({ port: 3000, basePath: '/api/v1', plantFactory, extraRoutes });
  */
 export default async function plantServer(config) {
-    const { alerts, userDecisions: decisions } = await initStomp(config.stomp, config.translations, config.requirePool);
-    const p = await config.plantFactory({ alerts, userDecisions: decisions });
+    const { alerts, userDecisions: decisions, segments: retags } = await initStomp(config.stomp, config.translations, config.requirePool);
+    const p = await config.plantFactory({ alerts, userDecisions: decisions, segments: retags });
     const segments = wireTimelineSegments(config.stomp, p);
     const clock = virtualClock(() => {
         return new Date();

package/src/application/shopWithTimeline.js

@@ -1,9 +1,11 @@
 import pubsub from '../domain/shared/pubsub.js';
 import timeline from '../domain/timeline/timeline.js';
 import pgTimeline from '../infrastructure/persistence/pg/timeline.js';
+import segmentStatePg from '../infrastructure/persistence/pg/segments.js';
 import memoryTimelineStore, { memoryTimelineRead } from '../infrastructure/persistence/memory/timeline.js';
 import ownerTimeline from '../infrastructure/messaging/ownership/ownerTimeline.js';
 import stompTimeline from '../infrastructure/messaging/stomp/timeline.js';
+import retagBody from '../infrastructure/messaging/stomp/retagBody.js';
 
 function parseStart(requestId) {
     const raw = decodeURIComponent(String(requestId));
@@ -31,6 +33,7 @@ function memoryTimelinePort(store, bus) {
         list: port.list,
         rowAt: port.rowAt,
         pending: port.pending,
+        latest: port.latest,
         stream: port.stream,
         bus,
         retag(start, tags, properties, audit) {
@@ -69,6 +72,34 @@ function writePort(name, decisions, owners) {
     }, owners)(name);
 }
 
+function ownsLocal(owners, name) {
+    if (!owners) {
+        return true;
+    }
+    return owners.resolve(name).kind !== 'edge';
+}
+
+async function persistTags(pool, patch) {
+    const state = segmentStatePg(pool);
+    const tagsJson = JSON.stringify(patch.tags);
+    const propsJson = JSON.stringify(patch.properties || {});
+    const count = patch.resolved
+        ? await state.resolveRequest(patch.machine, patch.start, tagsJson, propsJson)
+        : await state.retag(patch.machine, patch.start, tagsJson, propsJson);
+    if (!count) {
+        throw new RangeError(`Segment ${patch.machine} at ${patch.start.toISOString()} was not updated`);
+    }
+    return state.rowAt(patch.machine, patch.start);
+}
+
+async function confirm(pool, patch, segments) {
+    const row = await persistTags(pool, patch);
+    if (segments) {
+        await segments.publish(retagBody(patch.machine, row, patch.tags, patch.properties || {}));
+    }
+    return row;
+}
+
 /**
  * Builds a machine timeline from PostgreSQL persistence and STOMP user decisions.
  *
@@ -82,7 +113,7 @@ function writePort(name, decisions, owners) {
  *   const tl = shopWithTimeline('machine1', { pool, userDecisions, owners });
  */
 export default function shopWithTimeline(name, options) {
-    const { pool, userDecisions: decisions, owners } = options;
+    const { pool, userDecisions: decisions, owners, segments } = options;
     if (pool && decisions) {
         const bus = pubsub();
         const read = pgTimeline(pool, name);
@@ -92,14 +123,33 @@ export default function shopWithTimeline(name, options) {
             list: port.list,
             rowAt: port.rowAt,
             pending: port.pending,
+            latest: port.latest,
             stream: port.stream,
             bus,
             async retag(start, tags, properties, audit) {
+                if (ownsLocal(owners, name)) {
+                    await confirm(pool, {
+                        machine: name,
+                        start,
+                        tags,
+                        properties,
+                        resolved: false
+                    }, segments);
+                }
                 await write.retag(start, tags, properties, audit);
                 bus.emit({ type: 'resolved', segment: resolvedStub(start, tags, properties), audit });
             },
             async respond(requestId, body, audit) {
                 const start = parseStart(requestId);
+                if (ownsLocal(owners, name)) {
+                    await confirm(pool, {
+                        machine: name,
+                        start,
+                        tags: body.tags,
+                        properties: body.properties || {},
+                        resolved: true
+                    }, segments);
+                }
                 await write.respond(start, body.tags, body.properties || {}, audit);
                 bus.emit({ type: 'resolved', request: { id: requestId, start }, audit });
                 return { id: requestId, ...body };

package/src/application/siteServer.js

@@ -5,10 +5,9 @@ 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 startTelemetryIngest from './siteTelemetry.js';
 import timelineOperatorFromEnv from './timelineOperatorFromEnv.js';
 import { buildSiteOperatorCatalog } from './siteOperatorCatalog.js';
 
@@ -70,50 +69,6 @@ function startOperationSync(sink, env) {
     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);
@@ -168,7 +123,13 @@ export default async function siteServer(config) {
     });
     await sink.run(http);
     const mqtt = startMqtt(sink, env);
-    const telemetry = startTelemetryIngest(env, config.streams);
+    const telemetry = startTelemetryIngest(
+        env,
+        config.streams,
+        mqttConfigFromEnv(env),
+        sink.pool,
+        config.intervalDevices
+    );
     const operationSync = startOperationSync(sink, env);
     const basePath = config.basePath || '/api/v1';
     const catalog = buildSiteOperatorCatalog(config, basePath, sink, env);

package/src/application/siteTelemetry.js

@@ -0,0 +1,72 @@
+import { clickhouseSink } from '@yarkivaev/source-to-sink';
+import amqpMetricsIngest from '../infrastructure/ingest/telemetry/amqpMetricsIngest.js';
+import foldedMetricsSink from './foldedMetricsSink.js';
+import bindSilentStreams from './bindSilentStreams.js';
+
+/**
+ * Resolves the ClickHouse HTTP URL from site env.
+ *
+ * @param {object} env - process env
+ * @returns {string|undefined} URL
+ */
+function clickhouseMetricsUrl(env) {
+    return env.CLICKHOUSE_URL
+        || (env.CLICKHOUSE_HOST ? `http://${env.CLICKHOUSE_HOST}:8123` : undefined);
+}
+
+/**
+ * Starts AMQP telemetry ingest into a metrics sink.
+ *
+ * @param {object} env - process env
+ * @param {object} sink - metrics sink
+ * @param {function} onSeen - silent-stream callback
+ * @param {object} batchConfig - size interval threshold timeout
+ * @returns {object|undefined} ingest handle
+ */
+function startAmqpMetrics(env, sink, onSeen, batchConfig) {
+    if (!env.AMQP_URL) {
+        return undefined;
+    }
+    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;
+}
+
+/**
+ * Starts central AMQP telemetry ingest and optional silent streams.
+ *
+ * @param {object} env - process env
+ * @param {object} [streams] - silent Modbus streams
+ * @param {object} batchConfig - MQTT/AMQP batch options
+ * @param {object} pool - pg Pool
+ * @param {object} [devices] - OPC UA device to machine map
+ * @returns {object|undefined} ingest handles
+ */
+export default function startTelemetryIngest(env, streams, batchConfig, pool, devices) {
+    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 = foldedMetricsSink(clickhouseSink(url, 'scada.metrics'), pool, devices);
+    const onSeen = bindSilentStreams(streams, sink);
+    const ingest = startAmqpMetrics(env, sink, onSeen, batchConfig);
+    if (streams) {
+        streams.start();
+    }
+    return { ingest, streams };
+}

package/src/domain/segment/dispatch.js

@@ -20,7 +20,7 @@ export default function segmentDispatch(segmentSink, retag, splitSink, closer) {
                 await splitSink.write([record]);
             } else if (record.type === 'segment') {
                 if (record.duration === 0) {
-                    await closer.close(record.machine, record.start_time);
+                    await closer.close(record.machine, record.start_time, record.kind || 'phase');
                 }
                 await segmentSink.write([record]);
             } else {

package/src/domain/segment/intervalFold.js

@@ -0,0 +1,28 @@
+/**
+ * Folds successive equal samples into open state intervals.
+ *
+ * @param {object} port - open, begin, extend, finish
+ * @returns {object} collector with accept(sample)
+ *
+ * @example
+ *   const fold = intervalFold(port);
+ *   await fold.accept({ machine: 'cm8', kind: 'ladle_moving', value: 1, ts: Date.now() });
+ */
+export default function intervalFold(port) {
+    return {
+        async accept(sample) {
+            const name = String(sample.value);
+            const open = await port.open(sample.machine, sample.kind);
+            if (!open) {
+                await port.begin({ machine: sample.machine, kind: sample.kind, name, ts: sample.ts });
+                return;
+            }
+            if (open.name === name) {
+                await port.extend(open, sample.ts);
+                return;
+            }
+            await port.finish(open, sample.ts);
+            await port.begin({ machine: sample.machine, kind: sample.kind, name, ts: sample.ts });
+        }
+    };
+}

package/src/domain/segment/normalize.js

@@ -20,6 +20,7 @@ export default function segmentNormalize(parsed) {
         type: parsed.type,
         machine: parsed.machine,
         name: parsed.name,
+        kind: typeof parsed.kind === 'string' && parsed.kind.length > 0 ? parsed.kind : 'phase',
         start_time: new Date(parsed.start).toISOString(),
         end_time: new Date(parsed.end).toISOString(),
         duration: parsed.duration,

package/src/domain/timeline/cycleLookback.js

@@ -0,0 +1,37 @@
+function tagList(row) {
+    const raw = row.tags;
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        return JSON.parse(raw);
+    }
+    return [];
+}
+
+/**
+ * Walks newest-first timeline rows until a reset tag and returns them oldest-first.
+ *
+ * Reset ids are opaque; callers pass cycle start/stop tags.
+ *
+ * @param {Array<object>} rows - newest-first rows with tags
+ * @param {Array<string>} resetTags - tag ids that close the lookback
+ * @returns {Array<object>} chronological slice including the reset row
+ *
+ * @example
+ *   cycleLookback(newestFirst, ['cycle-start', 'cycle-stop'])
+ */
+export default function cycleLookback(rows, resetTags) {
+    const reset = new Set(resetTags);
+    const collected = [];
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i];
+        collected.push(row);
+        if (tagList(row).some((id) => {
+            return reset.has(id);
+        })) {
+            break;
+        }
+    }
+    return collected.reverse();
+}

package/src/domain/timeline/timeline.js

@@ -20,6 +20,12 @@ export default function timeline(read, bus) {
         pending() {
             return read.pending();
         },
+        latest(kinds) {
+            if (typeof read.latest !== 'function') {
+                return [];
+            }
+            return read.latest(kinds);
+        },
         stream: bus.stream
     };
 }

package/src/infrastructure/client/machineClient.js

@@ -30,6 +30,9 @@ function rangeQuery(options) {
     if (options && options.to) {
         params.set('to', options.to);
     }
+    if (options && Array.isArray(options.kinds) && options.kinds.length > 0) {
+        params.set('kinds', options.kinds.join(','));
+    }
     const qs = params.toString();
     return qs ? `?${qs}` : '';
 }
@@ -78,6 +81,9 @@ export default function machineClient(baseUrl, machineId, fetcher, eventSource,
         info() {
             return request('');
         },
+        state() {
+            return request('/state');
+        },
         measurements(options) {
             const params = new URLSearchParams();
             if (options && options.keys) {

package/src/infrastructure/http/edge/routes/checkpoint/checkpointRoutes.js

@@ -37,6 +37,38 @@ function segmentRoute(token, checkpointState) {
     });
 }
 
+function cyclePriorQuery(query) {
+    if (!query.machineId) {
+        return { error: 'machineId is required' };
+    }
+    const before = parseFrom(query.before);
+    if (before === null) {
+        return { error: 'before must be a number' };
+    }
+    const reset = toTopicList(query.reset);
+    if (reset.length === 0) {
+        return { error: 'reset is required' };
+    }
+    return { machineId: query.machineId, before, reset };
+}
+
+function cyclePriorRoute(token, checkpointState) {
+    return route('GET', '/v1/checkpoint/cycle-prior', async (req, res, params, query) => {
+        void params;
+        if (!hasAccess(req, token)) {
+            sendForbidden(res);
+            return;
+        }
+        const parsed = cyclePriorQuery(query);
+        if (parsed.error) {
+            errorResponse('BAD_REQUEST', parsed.error, 400).send(res);
+            return;
+        }
+        const items = await checkpointState.cyclePrior(parsed.machineId, parsed.before, parsed.reset);
+        jsonResponse({ items }).send(res);
+    });
+}
+
 export default function checkpointRoutes(token, checkpointState) {
     return [
         route('GET', '/v1/checkpoint/replay-cursor', async (req, res, params, query) => {
@@ -53,6 +85,7 @@ export default function checkpointRoutes(token, checkpointState) {
             jsonResponse({ machineId: query.machineId, cursor }).send(res);
         }),
         segmentRoute(token, checkpointState),
+        cyclePriorRoute(token, checkpointState),
         route('GET', '/v1/checkpoint/pending-segments', async (req, res) => {
             if (!hasAccess(req, token)) {
                 sendForbidden(res);

package/src/infrastructure/http/plant/json/segmentJson.js

@@ -14,6 +14,9 @@ export default function segmentJson(row) {
         end: row.duration === 0 ? new Date().toISOString() : row.end_time.toISOString(),
         duration: row.duration
     };
+    if (row.kind) {
+        mapped.kind = row.kind;
+    }
     if (row.options) {
         mapped.options = row.options;
     }

package/src/infrastructure/http/plant/routes/stateRoute.js

@@ -0,0 +1,87 @@
+import machineInPlant from '../../../../application/machineInPlant.js';
+import { jsonResponse, route } from '@yarkivaev/simple-server';
+
+/**
+ * Maps a sensor current() row to a state item.
+ *
+ * @param {object} sensor - sensor with current()
+ * @param {string} key - sensor key
+ * @returns {Promise<object>} state item
+ */
+async function readingOf(sensor, key) {
+    const row = await sensor.current();
+    if (!row.found) {
+        return { key, found: false };
+    }
+    return {
+        key,
+        found: true,
+        value: row.value,
+        timestamp: row.timestamp.toISOString(),
+        unit: row.unit
+    };
+}
+
+/**
+ * Overlays latest interval rows onto sensor snapshot items.
+ *
+ * @param {Array<object>} items - state items
+ * @param {Array<object>} rows - latest timeline rows
+ * @returns {Array<object>} items
+ */
+function overlay(items, rows) {
+    const byKey = new Map(items.map((item) => {
+        return [item.key, item];
+    }));
+    rows.forEach((row) => {
+        const item = byKey.get(row.kind);
+        if (!item) {
+            return;
+        }
+        item.found = true;
+        item.value = Number(row.name);
+        item.timestamp = row.end_time.toISOString();
+    });
+    return items;
+}
+
+/**
+ * Builds the latest machine snapshot from sensors and intervals.
+ *
+ * @param {object} machine - plant machine
+ * @returns {Promise<Array<object>>} state items
+ */
+async function snapshot(machine) {
+    const keys = Object.keys(machine.sensors || {});
+    const items = await Promise.all(keys.map((key) => {
+        return readingOf(machine.sensors[key], key);
+    }));
+    if (!machine.timeline || typeof machine.timeline.latest !== 'function') {
+        return items;
+    }
+    const rows = await machine.timeline.latest(keys);
+    return overlay(items, rows);
+}
+
+/**
+ * Latest machine state route.
+ *
+ * @param {string} basePath - API prefix
+ * @param {object} plant - plant domain
+ * @returns {array} routes
+ *
+ * @example
+ *   stateRoute('/api/v1', plant);
+ */
+export default function stateRoute(basePath, plant) {
+    return [
+        route('GET', `${basePath}/machines/:machineId/state`, async (req, res, params) => {
+            const result = machineInPlant(plant, params.machineId);
+            if (!result) {
+                jsonResponse({ items: [] }).send(res);
+                return;
+            }
+            jsonResponse({ items: await snapshot(result.machine) }).send(res);
+        })
+    ];
+}

package/src/infrastructure/http/plant/routes/timelineRoute.js

@@ -67,6 +67,11 @@ export default function timelineRoute(basePath, plant, operatorOptions, decorate
             if (query.to) {
                 options.to = query.to;
             }
+            if (query.kinds) {
+                options.kinds = query.kinds.split(',').filter((kind) => {
+                    return kind.length > 0;
+                });
+            }
             const rows = await decorate(params.machineId, await result.machine.timeline.list(options));
             jsonResponse({ items: rows.map(segmentJson) }).send(res);
         }),

package/src/infrastructure/http/plant/streams/measurementStream.js

@@ -13,8 +13,6 @@ import { route, sseResponse, timeExpression } from '@yarkivaev/simple-server';
  * @example
  *   const routes = measurementStream('/api/v1', plant, clock);
  */
-const RETAIN_MS = 10000;
-
 export default function measurementStream(basePath, plant, clock) {
     function beginning() {
         return new Date(clock().getTime() - 30 * 24 * 60 * 60 * 1000);
@@ -47,7 +45,7 @@ export default function measurementStream(basePath, plant, clock) {
             if (machine.sensors[key]) {
                 // eslint-disable-next-line no-await-in-loop
                 const reading = await machine.sensors[key].current();
-                if (reading.found && clock().getTime() - reading.timestamp.getTime() < RETAIN_MS) {
+                if (reading.found) {
                     sse.emit('measurement', {
                         key,
                         timestamp: reading.timestamp.toISOString(),

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

@@ -10,9 +10,9 @@ import closeOrphanOpen from '../sinks/closeOrphanOpen.js';
 import closeSilentOpen from '../sinks/closeSilentOpen.js';
 import retagSink from '../sinks/retagSink.js';
 
-export const segmentColumns = ['machine', 'name', 'start_time', 'end_time', 'duration',
+export const segmentColumns = ['machine', 'kind', 'name', 'start_time', 'end_time', 'duration',
                                'options', 'tags', 'properties', 'resolved'];
-export const segmentConflict = ['machine', 'start_time'];
+export const segmentConflict = ['machine', 'kind', 'start_time'];
 export const segmentUpdateColumns = ['name', 'end_time', 'duration', 'options', 'resolved'];
 export const splitUpdateColumns = ['name', 'end_time', 'duration', 'tags', 'options', 'resolved'];
 export const segmentsIngestDestination = '/queue/scada.segments.ingest';

package/src/infrastructure/ingest/sinks/closeOrphanOpen.js

@@ -4,27 +4,28 @@ import processingErrorLog from '../processingErrorLog.js';
  * Closes stale open segment rows for one machine before a new open segment lands.
  *
  * @param {object} pool - pg Pool with query() method
- * @returns {object} closer with close(machine, startTime)
+ * @returns {object} closer with close(machine, startTime, kind)
  *
  * @example
  *   const closer = closeOrphanOpen(pool);
- *   await closer.close('m1', '2024-01-01T00:00:00.000Z');
+ *   await closer.close('m1', '2024-01-01T00:00:00.000Z', 'phase');
  */
 export default function closeOrphanOpen(pool) {
     if (!pool || typeof pool.query !== 'function') {
         throw new Error('Pool must have a query() method');
     }
     return {
-        async close(machine, startTime) {
+        async close(machine, startTime, kind) {
+            const track = kind || 'phase';
             try {
                 await pool.query(
                     `UPDATE segments
                      SET end_time = start_time + interval '1 second', duration = 1
-                     WHERE machine = $1 AND duration = 0 AND start_time <> $2`,
-                    [machine, startTime]
+                     WHERE machine = $1 AND kind = $3 AND duration = 0 AND start_time <> $2`,
+                    [machine, startTime, track]
                 );
             } catch (error) {
-                processingErrorLog('close_orphan_open', error, { machine, startTime });
+                processingErrorLog('close_orphan_open', error, { machine, startTime, kind: track });
                 throw error;
             }
         }

package/src/infrastructure/ingest/telemetry/foldingSink.js

@@ -0,0 +1,26 @@
+/**
+ * Writes metrics then folds matching records into state intervals.
+ *
+ * @param {object} inner - sink with write(records)
+ * @param {object} fold - intervalFold collector
+ * @param {function} locate - record to sample or null
+ * @returns {object} sink with write
+ *
+ * @example
+ *   const sink = foldingSink(clickhouse, fold, locate);
+ *   await sink.write([{ topic, ts, value }]);
+ */
+export default function foldingSink(inner, fold, locate) {
+    return {
+        async write(records) {
+            await inner.write(records);
+            for (const record of records) {
+                const sample = locate(record);
+                if (sample) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await fold.accept(sample);
+                }
+            }
+        }
+    };
+}

package/src/infrastructure/ingest/telemetry/opcuaLocate.js

@@ -0,0 +1,24 @@
+/**
+ * Maps an OPC UA metrics record to an interval sample.
+ *
+ * @param {object} devices - device id to machine id
+ * @returns {function(object): object|null} locator
+ *
+ * @example
+ *   const locate = opcuaLocate({ 'tlc-cm8': 'cm8' });
+ *   locate({ topic: 'OPCUA/tlc-cm8/GET/ladle_moving/VALUE', value: 1, ts: 1 });
+ */
+export default function opcuaLocate(devices) {
+    const map = devices || {};
+    return (record) => {
+        const parts = String(record.topic || '').split('/');
+        if (parts[0] !== 'OPCUA' || parts[2] !== 'GET' || parts[4] !== 'VALUE') {
+            return null;
+        }
+        const machine = map[parts[1]];
+        if (!machine) {
+            return null;
+        }
+        return { machine, kind: parts[3], value: record.value, ts: record.ts };
+    };
+}

package/src/infrastructure/messaging/stomp/retagBody.js

@@ -0,0 +1,39 @@
+function asList(raw) {
+    if (Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string' && raw.length > 0) {
+        return JSON.parse(raw);
+    }
+    return [];
+}
+
+/**
+ * Builds a segments-exchange retag payload matching supervisor SegmentMessage.retag.
+ *
+ * @param {string} machine - machine id
+ * @param {object} row - persisted segment with start_time, end_time, duration, name, options
+ * @param {string[]} tags - operator tags
+ * @param {object} properties - operator properties
+ * @returns {object} STOMP JSON body
+ *
+ * @example
+ *   retagBody('icht1', row, ['to_ladle'], {})
+ */
+export default function retagBody(machine, row, tags, properties) {
+    const options = asList(row.options);
+    const props = properties && Object.keys(properties).length > 0 ? properties : null;
+    return {
+        type: 'retag',
+        status: 'completed',
+        machine,
+        name: row.name,
+        start: new Date(row.start_time).getTime(),
+        end: new Date(row.end_time).getTime(),
+        duration: row.duration,
+        tags,
+        options: options.length > 0 ? options : null,
+        properties: props,
+        resolved: true
+    };
+}

package/src/infrastructure/messaging/stomp/segmentRetags.js

@@ -0,0 +1,35 @@
+import { stompSend } from '@yarkivaev/source-to-sink';
+
+const DEFAULT_DESTINATION = '/exchange/scada.segments';
+
+/**
+ * Publishes operator retag envelopes to the segments exchange.
+ *
+ * @param {object} config - publisher configuration
+ * @param {string} config.stompUrl - STOMP broker URL
+ * @param {string} [config.destination] - STOMP destination
+ * @param {string} [config.login] - STOMP login
+ * @param {string} [config.passcode] - STOMP passcode
+ * @param {string} [config.host] - STOMP vhost header
+ * @returns {object} publisher with publish(body)
+ *
+ * @example
+ *   const retags = segmentRetags({ stompUrl });
+ *   await retags.publish(retagBody('icht1', row, ['to_ladle'], {}));
+ */
+export default function segmentRetags(config) {
+    if (!config.stompUrl) {
+        throw new Error('stompUrl is required for segment retag publisher');
+    }
+    const destination = config.destination || DEFAULT_DESTINATION;
+    const stompOptions = {
+        login: config.login,
+        passcode: config.passcode,
+        host: config.host
+    };
+    return {
+        async publish(body) {
+            await stompSend(config.stompUrl, destination, body, stompOptions);
+        }
+    };
+}

package/src/infrastructure/persistence/memory/checkpoints.js

@@ -1,3 +1,5 @@
+import cycleLookback from '../../../domain/timeline/cycleLookback.js';
+
 function parseJsonField(raw) {
     if (!raw) {
         return null;
@@ -93,6 +95,17 @@ export default function checkpointStateMemory(store) {
         },
         segment(machineId, startEpoch) {
             return segmentAt(store, machineId, startEpoch);
+        },
+        cyclePrior(machineId, beforeEpoch, resetTags) {
+            const beforeMs = Number(beforeEpoch) * 1000;
+            const rows = store.segments.filter((row) => {
+                return row.machine === machineId && new Date(row.start_time).getTime() < beforeMs;
+            }).sort((a, b) => {
+                return new Date(b.start_time) - new Date(a.start_time);
+            });
+            return cycleLookback(rows, resetTags).map((row) => {
+                return segmentItem(row);
+            });
         }
     };
 }

package/src/infrastructure/persistence/memory/segments.js

@@ -2,9 +2,20 @@ function sameInstant(a, b) {
     return new Date(a).getTime() === new Date(b).getTime();
 }
 
+function trackOf(row) {
+    return row.kind || 'phase';
+}
+
+function wantedKinds(range) {
+    if (range && Array.isArray(range.kinds) && range.kinds.length > 0) {
+        return range.kinds;
+    }
+    return ['phase'];
+}
+
 function findRow(store, machineId, start) {
     return store.segments.find((row) => {
-        return row.machine === machineId && sameInstant(row.start_time, start);
+        return row.machine === machineId && trackOf(row) === 'phase' && sameInstant(row.start_time, start);
     });
 }
 
@@ -16,10 +27,14 @@ function parseListFilters(range) {
 
 function filterList(store, machineId, range) {
     const { from, to } = parseListFilters(range);
+    const kinds = wantedKinds(range);
     return store.segments.filter((row) => {
         if (row.machine !== machineId) {
             return false;
         }
+        if (!kinds.includes(trackOf(row))) {
+            return false;
+        }
         if (from && new Date(row.end_time).getTime() < new Date(from).getTime() && row.duration !== 0) {
             return false;
         }
@@ -32,52 +47,87 @@ function filterList(store, machineId, range) {
     });
 }
 
-/**
- * In-memory segment state port for tests and local runs.
- *
- * @param {object} store - shared mutable store with segments array
- * @returns {object} segments port matching segmentStatePg shape
- */
-export default function segmentStateMemory(store) {
+function latestRows(store, machineId, kinds) {
+    const latest = new Map();
+    store.segments.filter((row) => {
+        return row.machine === machineId && kinds.includes(trackOf(row));
+    }).forEach((row) => {
+        const prev = latest.get(trackOf(row));
+        if (!prev || new Date(row.start_time) > new Date(prev.start_time)) {
+            latest.set(trackOf(row), row);
+        }
+    });
+    return Array.from(latest.values());
+}
+
+function pendingRows(store, machineId) {
+    return store.segments.filter((row) => {
+        return row.machine === machineId && row.resolved === false && trackOf(row) === 'phase';
+    }).sort((a, b) => {
+        return new Date(a.start_time) - new Date(b.start_time);
+    }).map((row) => {
+        return {
+            id: row.start_time,
+            name: row.name,
+            start_time: row.start_time,
+            end_time: row.end_time,
+            duration: row.duration,
+            options: row.options
+        };
+    });
+}
+
+function reads(store) {
     return {
         listForMachine(machineId, range) {
             return filterList(store, machineId, range);
         },
+        latestForKinds(machineId, kinds) {
+            if (!Array.isArray(kinds) || kinds.length === 0) {
+                return [];
+            }
+            return latestRows(store, machineId, kinds);
+        },
         rowAt(machineId, start) {
-            const row = findRow(store, machineId, start);
-            return row ?? null;
+            return findRow(store, machineId, start) ?? null;
         },
         pendingRequestsForMachine(machineId) {
-            return store.segments.filter((row) => {
-                return row.machine === machineId && row.resolved === false;
-            }).sort((a, b) => {
-                return new Date(a.start_time) - new Date(b.start_time);
-            }).map((row) => {
-                return {
-                    id: row.start_time,
-                    name: row.name,
-                    start_time: row.start_time,
-                    end_time: row.end_time,
-                    duration: row.duration,
-                    options: row.options
-                };
-            });
-        },
+            return pendingRows(store, machineId);
+        }
+    };
+}
+
+function writes(store) {
+    return {
         retag(machineId, start, tagsJson, propertiesJson) {
             const row = findRow(store, machineId, start);
-            if (row) {
-                row.tags = tagsJson;
-                row.properties = propertiesJson;
+            if (!row) {
+                return 0;
             }
+            row.tags = tagsJson;
+            row.properties = propertiesJson;
+            return 1;
         },
         resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
             const row = findRow(store, machineId, startKey);
-            if (row) {
-                row.tags = tagsJson;
-                row.properties = propertiesJson;
-                row.resolved = true;
-                row.consumed = false;
+            if (!row) {
+                return 0;
             }
+            row.tags = tagsJson;
+            row.properties = propertiesJson;
+            row.resolved = true;
+            row.consumed = false;
+            return 1;
         }
     };
 }
+
+/**
+ * In-memory segment state port for tests and local runs.
+ *
+ * @param {object} store - shared mutable store with segments array
+ * @returns {object} segments port matching segmentStatePg shape
+ */
+export default function segmentStateMemory(store) {
+    return { ...reads(store), ...writes(store) };
+}

package/src/infrastructure/persistence/memory/timeline.js

@@ -20,7 +20,11 @@ export default function memoryTimelineStore() {
                 if (!range) {
                     return items.slice();
                 }
+                const kinds = Array.isArray(range.kinds) && range.kinds.length > 0 ? range.kinds : ['phase'];
                 return items.filter((item) => {
+                    if (!kinds.includes(item.kind || 'phase')) {
+                        return false;
+                    }
                     if (range.from && item.end_time < new Date(range.from)) {
                         return false;
                     }
@@ -39,6 +43,23 @@ export default function memoryTimelineStore() {
                 return pending.filter((item) => {
                     return !item.resolved;
                 });
+            },
+            latest(kinds) {
+                if (!Array.isArray(kinds) || kinds.length === 0) {
+                    return [];
+                }
+                const found = new Map();
+                items.forEach((item) => {
+                    const track = item.kind || 'phase';
+                    if (!kinds.includes(track)) {
+                        return;
+                    }
+                    const prev = found.get(track);
+                    if (!prev || item.start_time > prev.start_time) {
+                        found.set(track, item);
+                    }
+                });
+                return Array.from(found.values());
             }
         }
     };

package/src/infrastructure/persistence/pg/checkpoints.js

@@ -1,4 +1,5 @@
 import segmentStatePg from './segments.js';
+import cycleLookback from '../../../domain/timeline/cycleLookback.js';
 
 function parseJsonField(raw) {
     if (!raw) {
@@ -110,6 +111,19 @@ export default function checkpointStatePg(pool, metricsEnabled = true) {
         },
         segment(machineId, startEpoch) {
             return segmentAt(pool, machineId, startEpoch);
+        },
+        cyclePrior(machineId, beforeEpoch, resetTags) {
+            return pool.query(
+                `SELECT name, start_time, end_time, duration, tags, options, properties
+                 FROM segments
+                 WHERE machine = $1 AND start_time < $2
+                 ORDER BY start_time DESC`,
+                [machineId, new Date(beforeEpoch * 1000)]
+            ).then((result) => {
+                return cycleLookback(result.rows, resetTags).map((row) => {
+                    return segmentItem(row, machineId);
+                });
+            });
         }
     };
 }

package/src/infrastructure/persistence/pg/intervalFoldPg.js

@@ -0,0 +1,49 @@
+/**
+ * Postgres port for intervalFold.
+ *
+ * @param {object} pool - pg Pool
+ * @returns {object} open begin extend finish
+ *
+ * @example
+ *   const port = intervalFoldPg(pool);
+ *   const open = await port.open('cm8', 'ladle_moving');
+ */
+export default function intervalFoldPg(pool) {
+    return {
+        async open(machine, kind) {
+            const result = await pool.query(
+                `SELECT machine, kind, name, start_time, end_time
+                 FROM segments
+                 WHERE machine = $1 AND kind = $2 AND duration = 0
+                 ORDER BY start_time DESC LIMIT 1`,
+                [machine, kind]
+            );
+            return result.rows[0] || null;
+        },
+        async begin(sample) {
+            const start = new Date(sample.ts).toISOString();
+            await pool.query(
+                `INSERT INTO segments (machine, kind, name, start_time, end_time, duration, resolved, consumed)
+                 VALUES ($1, $2, $3, $4, $4, 0, TRUE, TRUE)`,
+                [sample.machine, sample.kind, sample.name, start]
+            );
+        },
+        async extend(row, ts) {
+            await pool.query(
+                `UPDATE segments SET end_time = $1
+                 WHERE machine = $2 AND kind = $3 AND start_time = $4 AND duration = 0`,
+                [new Date(ts).toISOString(), row.machine, row.kind, row.start_time]
+            );
+        },
+        async finish(row, ts) {
+            const end = new Date(ts);
+            const start = new Date(row.start_time);
+            const duration = Math.max(1, Math.round((end.getTime() - start.getTime()) / 1000));
+            await pool.query(
+                `UPDATE segments SET end_time = $1, duration = $2
+                 WHERE machine = $3 AND kind = $4 AND start_time = $5 AND duration = 0`,
+                [end.toISOString(), duration, row.machine, row.kind, row.start_time]
+            );
+        }
+    };
+}

package/src/infrastructure/persistence/pg/segments.js

@@ -1,25 +1,51 @@
-export default function segmentStatePg(pool) {
+function wantedKinds(range) {
+    if (range && Array.isArray(range.kinds) && range.kinds.length > 0) {
+        return range.kinds;
+    }
+    return ['phase'];
+}
+
+function listSql(machineId, range) {
+    let sql = `SELECT s.kind, s.name, s.start_time, s.end_time, s.duration, s.options, s.tags, s.properties
+                FROM segments s WHERE s.machine = $1`;
+    const prm = [machineId];
+    prm.push(wantedKinds(range));
+    sql += ` AND s.kind = ANY($2)`;
+    if (range.from) {
+        prm.push(range.from);
+        sql += ` AND (s.end_time >= $${prm.length} OR s.duration = 0)`;
+    }
+    if (range.to) {
+        prm.push(range.to);
+        sql += ` AND s.start_time <= $${prm.length}`;
+    }
+    sql += ' ORDER BY s.start_time';
+    return { sql, prm };
+}
+
+function reads(pool) {
     return {
         async listForMachine(machineId, range) {
-            let sql = `SELECT s.name, s.start_time, s.end_time, s.duration, s.options, s.tags, s.properties
-                FROM segments s WHERE s.machine = $1`;
-            const prm = [machineId];
-            if (range.from) {
-                prm.push(range.from);
-                sql += ` AND (s.end_time >= $${prm.length} OR s.duration = 0)`;
-            }
-            if (range.to) {
-                prm.push(range.to);
-                sql += ` AND s.start_time <= $${prm.length}`;
+            const query = listSql(machineId, range || {});
+            const result = await pool.query(query.sql, query.prm);
+            return result.rows;
+        },
+        async latestForKinds(machineId, kinds) {
+            if (!Array.isArray(kinds) || kinds.length === 0) {
+                return [];
             }
-            sql += ' ORDER BY s.start_time';
-            const result = await pool.query(sql, prm);
+            const result = await pool.query(
+                `SELECT DISTINCT ON (kind) kind, name, start_time, end_time, duration, options, tags, properties
+                 FROM segments WHERE machine = $1 AND kind = ANY($2)
+                 ORDER BY kind, start_time DESC`,
+                [machineId, kinds]
+            );
             return result.rows;
         },
         async rowAt(machineId, start) {
             const result = await pool.query(
-                `SELECT name, start_time, end_time, duration, options, tags, properties
-                 FROM segments WHERE machine = $1 AND start_time = $2`,
+                `SELECT kind, name, start_time, end_time, duration, options, tags, properties
+                 FROM segments WHERE machine = $1 AND start_time = $2 AND kind = 'phase'`,
                 [machineId, start]
             );
             return result.rows[0] ?? null;
@@ -27,22 +53,36 @@ export default function segmentStatePg(pool) {
         async pendingRequestsForMachine(machineId) {
             const result = await pool.query(
                 `SELECT start_time AS id, name, start_time, end_time, duration, options
-                 FROM segments WHERE machine = $1 AND resolved = FALSE ORDER BY start_time`,
+                 FROM segments WHERE machine = $1 AND resolved = FALSE AND kind = 'phase'
+                 ORDER BY start_time`,
                 [machineId]
             );
             return result.rows;
-        },
+        }
+    };
+}
+
+function writes(pool) {
+    return {
         async retag(machineId, start, tagsJson, propertiesJson) {
-            await pool.query(
-                'UPDATE segments SET tags = $1, properties = $2 WHERE machine = $3 AND start_time = $4',
+            const result = await pool.query(
+                `UPDATE segments SET tags = $1, properties = $2
+                 WHERE machine = $3 AND start_time = $4 AND kind = 'phase'`,
                 [tagsJson, propertiesJson, machineId, start]
             );
+            return result.rowCount;
         },
         async resolveRequest(machineId, startKey, tagsJson, propertiesJson) {
-            await pool.query(
-                'UPDATE segments SET tags = $1, properties = $2, resolved = TRUE, consumed = FALSE WHERE machine = $3 AND start_time = $4',
+            const result = await pool.query(
+                `UPDATE segments SET tags = $1, properties = $2, resolved = TRUE, consumed = FALSE
+                 WHERE machine = $3 AND start_time = $4 AND kind = 'phase'`,
                 [tagsJson, propertiesJson, machineId, startKey]
             );
+            return result.rowCount;
         }
     };
 }
+
+export default function segmentStatePg(pool) {
+    return { ...reads(pool), ...writes(pool) };
+}

package/src/infrastructure/persistence/pg/timeline.js

@@ -4,6 +4,7 @@ function mapRow(item) {
     const tags = item.tags === undefined || item.tags === null ? null : item.tags;
     const properties = item.properties === undefined || item.properties === null ? null : item.properties;
     return {
+        kind: item.kind || 'phase',
         name: item.name,
         start_time: new Date(item.start_time),
         end_time: new Date(item.end_time),
@@ -36,6 +37,10 @@ export default function pgTimeline(pool, machineId) {
             const row = await segments.rowAt(machineId, start);
             return row ? mapRow(row) : null;
         },
+        async latest(kinds) {
+            const rows = await segments.latestForKinds(machineId, kinds || []);
+            return rows.map(mapRow);
+        },
         async pending() {
             const rows = await segments.pendingRequestsForMachine(machineId);
             return rows.map((item) => {