@yarkivaev/scada 2.3.55 → 2.3.57

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.55",
+  "version": "2.3.57",
   "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@clickhouse/client": "^1.0.0",
     "@yarkivaev/simple-server": "1.0.1",
-    "@yarkivaev/source-to-sink": "1.3.2",
+    "@yarkivaev/source-to-sink": "1.3.3",
     "amqplib": "^0.10.9",
     "pg": "^8.0.0",
     "stompit": "^1.0.0"

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/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/shopWithTimeline.js

@@ -33,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) {
@@ -122,6 +123,7 @@ 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) {

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/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/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/modbus/silentStreams.js

@@ -18,37 +18,37 @@ function isSilent(lastSeen, name, clk, budgetMs) {
 }
 
 /**
- * Stops one active poll if present.
+ * Stops one started poll if present. The poll instance is kept for reuse.
  *
- * @param {Map<string, object>} active - Active polls by name
+ * @param {object} state - Gate mutable state
  * @param {string} name - Stream id
  */
-function stopOne(active, name) {
-    const poll = active.get(name);
-    if (!poll) {
+function stopOne(state, name) {
+    if (!state.live.has(name)) {
         return;
     }
-    poll.stop();
-    active.delete(name);
+    state.held.get(name).stop();
+    state.live.delete(name);
 }
 
 /**
- * Starts one poll when not already active.
+ * Starts one poll, opening the source only the first time.
  *
- * @param {Map<string, object>} active - Active polls by name
+ * @param {object} state - Gate mutable state
  * @param {object} source - Stream source
- * @param {object} collector - Metrics collector
- * @param {object} clk - Clock
- * @param {number} intervalSec - Poll interval seconds
  */
-function startOne(active, source, collector, clk, intervalSec) {
+function startOne(state, source) {
     const name = source.name();
-    if (active.has(name)) {
+    if (state.live.has(name)) {
         return;
     }
-    const poll = source.open(collector, clk, intervalSec);
-    active.set(name, poll);
+    let poll = state.held.get(name);
+    if (!poll) {
+        poll = source.open(state.collector, state.clk, state.intervalSec);
+        state.held.set(name, poll);
+    }
     poll.start();
+    state.live.add(name);
 }
 
 /**
@@ -63,9 +63,9 @@ function pulse(state) {
     for (const source of state.sources) {
         const name = source.name();
         if (isSilent(state.lastSeen, name, state.clk, state.budgetMs)) {
-            startOne(state.active, source, state.collector, state.clk, state.intervalSec);
+            startOne(state, source);
         } else {
-            stopOne(state.active, name);
+            stopOne(state, name);
         }
     }
 }
@@ -88,7 +88,8 @@ function gateState(config) {
         }),
         clear: config.clear || clearInterval,
         lastSeen: new Map(),
-        active: new Map(),
+        held: new Map(),
+        live: new Set(),
         collector: undefined,
         timer: undefined,
         running: false
@@ -143,9 +144,10 @@ export default function silentStreams(config) {
                 state.clear(state.timer);
                 state.timer = undefined;
             }
-            for (const name of [...state.active.keys()]) {
-                stopOne(state.active, name);
+            for (const name of [...state.live]) {
+                stopOne(state, name);
             }
+            state.held.clear();
         },
         pulse: runPulse
     };

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/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,37 +47,58 @@ 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) {
@@ -85,3 +121,13 @@ export default function segmentStateMemory(store) {
         }
     };
 }
+
+/**
+ * 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/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,24 +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) {
             const result = await pool.query(
-                'UPDATE segments SET tags = $1, properties = $2 WHERE machine = $3 AND start_time = $4',
+                `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) {
             const result = await pool.query(
-                'UPDATE segments SET tags = $1, properties = $2, resolved = TRUE, consumed = FALSE WHERE machine = $3 AND start_time = $4',
+                `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) => {