@yarkivaev/scada 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# scada
+
+SCADA domain objects for industrial plant monitoring.
+
+## Install
+
+```
+npm install scada
+```
+
+## Usage
+
+```javascript
+import { plant, meltingShop, meltingMachine, meltings, alerts, initialized } from 'scada';
+
+const machine = meltingMachine('icht1', sensors, alertHistory);
+const shop = meltingShop('shop1', initialized({ icht1: machine }, Object.values), meltings());
+const factory = plant(initialized({ shop1: shop }, Object.values));
+```
+
+## Modules
+
+### Plant Hierarchy
+- `plant`
+- `meltingShop`
+- `meltingMachine`
+- `machineChronology`
+- `monitoredMeltingMachine`
+
+### Melting Operations
+- `activeMelting`
+- `completedMelting`
+- `meltings`
+- `meltingChronology`
+
+### Alerting
+- `alert`
+- `acknowledgedAlert`
+- `alerts`
+- `meltingRuleEngine`
+
+### Sensors
+- `scyllaSensor`
+- `clickhouseSensor`
+
+### Utilities
+- `interval`
+- `initialized`
+- `events`
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,45 @@
+/**
+ * SCADA domain objects for industrial plant monitoring.
+ * Provides immutable objects for modeling melting operations,
+ * alerting systems, events, and plant hierarchy.
+ *
+ * @example
+ *   import { plant, meltingShop, meltingMachine, meltings, alerts, initialized } from 'scada';
+ *   const shop = meltingShop('shop1', initialized({ m1: machine }, Object.values), meltings());
+ *   const p = plant(initialized({ shop1: shop }, Object.values));
+ */
+
+// Plant hierarchy
+export { default as plant } from './src/plant.js';
+export { default as meltingShop } from './src/meltingShop.js';
+export { default as meltingMachine } from './src/meltingMachine.js';
+export { default as machineChronology } from './src/machineChronology.js';
+export { default as monitoredMeltingMachine } from './src/monitoredMeltingMachine.js';
+
+// Melting operations
+export { default as activeMelting } from './src/activeMelting.js';
+export { default as completedMelting } from './src/completedMelting.js';
+export { default as meltings } from './src/meltings.js';
+export { default as meltingChronology } from './src/meltingChronology.js';
+
+// Events system
+export { default as event } from './src/event.js';
+export { default as events } from './src/events.js';
+export { default as rule } from './src/rule.js';
+export { default as rules } from './src/rules.js';
+
+// Rule engine (legacy)
+export { default as meltingRuleEngine } from './src/meltingRuleEngine.js';
+
+// Alerting
+export { alert, acknowledgedAlert } from './src/alert.js';
+export { default as alerts } from './src/alerts.js';
+
+// Utilities
+export { default as interval } from './src/interval.js';
+export { default as initialized } from './src/initialized.js';
+export { default as pubsub } from './src/pubsub.js';
+
+// Sensors
+export { default as scyllaSensor } from './src/scyllaSensor.js';
+export { default as clickhouseSensor } from './src/clickhouseSensor.js';

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@yarkivaev/scada",
+  "version": "1.1.0",
+  "description": "SCADA domain objects for plant monitoring",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha --exit",
+    "coverage": "c8 --all --src src npm test",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "devDependencies": {
+    "@clickhouse/client": "^1.0.0",
+    "@eslint/js": "^9.39.2",
+    "c8": "^10.1.3",
+    "cassandra-driver": "^4.7.2",
+    "eslint": "^9.39.2",
+    "globals": "^17.0.0",
+    "mocha": "^10.2.0",
+    "testcontainers": "^10.13.0"
+  },
+  "files": [
+    "index.js",
+    "src/"
+  ]
+}

package/src/activeMelting.js

@@ -0,0 +1,54 @@
+import meltingChronology from './meltingChronology.js';
+import completedMelting from './completedMelting.js';
+
+/**
+ * In-progress melting session that can be stopped to produce a completed melting.
+ * Chronology is bound to machine and derives values from machine's weight history.
+ * Notifies callbacks when stopped or updated.
+ *
+ * @param {string} id - unique melting session identifier
+ * @param {object} machine - the melting machine running this session
+ * @param {Date} start - when the melting session started
+ * @param {function} onStop - callback invoked with completedMelting when stopped
+ * @param {function} onUpdate - callback invoked when melting is updated
+ * @returns {object} active melting with id, machine, chronology, stop, update methods
+ *
+ * @example
+ *   const active = activeMelting('m1', machine, new Date(), onStop, onUpdate);
+ *   machine.load(500);
+ *   machine.dispense(480);
+ *   const completed = active.stop();
+ */
+export default function activeMelting(id, machine, start, onStop, onUpdate) {
+    return {
+        id() {
+            return id;
+        },
+        machine() {
+            return machine;
+        },
+        chronology() {
+            return meltingChronology(machine, start, undefined);
+        },
+        stop() {
+            const end = new Date();
+            const chron = meltingChronology(machine, start, end);
+            const completed = completedMelting(id, machine, chron, onUpdate);
+            onStop(completed);
+            return completed;
+        },
+        update(data) {
+            const opts = data === undefined ? {} : data;
+            const newStart = opts.start === undefined ? start : new Date(opts.start);
+            if (opts.end !== undefined) {
+                const chron = meltingChronology(machine, newStart, new Date(opts.end));
+                const completed = completedMelting(id, machine, chron, onUpdate);
+                onStop(completed);
+                return completed;
+            }
+            const updated = activeMelting(id, machine, newStart, onStop, onUpdate);
+            onUpdate(updated);
+            return updated;
+        }
+    };
+}

package/src/alert.js

@@ -0,0 +1,59 @@
+/* eslint-disable max-params */
+/**
+ * Immutable alert record with acknowledgment capability.
+ * Represents a single actionable item for supervisors.
+ *
+ * @param {string} id - unique alert identifier
+ * @param {string} message - alert description
+ * @param {Date} timestamp - when the alert occurred
+ * @param {string} object - identifier of the object that raised the alert
+ * @param {object} source - optional source event that triggered this alert
+ * @param {function} acknowledge - callback to dismiss the alert
+ * @returns {object} alert with id, message, timestamp, object, event, acknowledge, acknowledged
+ *
+ * @example
+ *   const a = alert('alert-1', 'High voltage', new Date(), 'icht1', srcEvent, ackCallback);
+ *   a.id; // 'alert-1'
+ *   a.event; // srcEvent reference
+ *   a.acknowledged; // false
+ *   a.acknowledge(); // triggers callback
+ */
+export function alert(id, message, timestamp, object, source, acknowledge) {
+    return {
+        id,
+        message,
+        timestamp,
+        object,
+        event: source,
+        acknowledge,
+        acknowledged: false
+    };
+}
+
+/**
+ * Immutable acknowledged alert record.
+ * Represents an alert that has been acknowledged by the user.
+ *
+ * @param {string} id - unique alert identifier
+ * @param {string} message - alert description
+ * @param {Date} timestamp - when the alert occurred
+ * @param {string} object - identifier of the object that raised the alert
+ * @param {object} source - optional source event that triggered this alert
+ * @returns {object} acknowledged alert with id, message, timestamp, object, event, acknowledged
+ *
+ * @example
+ *   const a = acknowledgedAlert('alert-1', 'High voltage', new Date(), 'icht1', srcEvent);
+ *   a.id; // 'alert-1'
+ *   a.event; // srcEvent reference
+ *   a.acknowledged; // true
+ */
+export function acknowledgedAlert(id, message, timestamp, object, source) {
+    return {
+        id,
+        message,
+        timestamp,
+        object,
+        event: source,
+        acknowledged: true
+    };
+}

package/src/alerts.js

@@ -0,0 +1,52 @@
+import pubsub from './pubsub.js';
+
+/**
+ * History of alert occurrences with filtering support.
+ * Creates and stores alerts, replaces with acknowledged version on acknowledge.
+ * Generates unique IDs for each alert.
+ *
+ * @param {function} alert - factory function to create alerts
+ * @param {function} acknowledgedAlert - factory function to create acknowledged alerts
+ * @returns {object} alerts history with trigger, all, find, stream methods
+ *
+ * @example
+ *   const history = alerts(alert, acknowledgedAlert);
+ *   const a = history.trigger('High voltage', new Date(), 'icht1');
+ *   a.id; // 'alert-0'
+ *   a.acknowledge(); // replaces with acknowledged version
+ *   history.trigger('From event', new Date(), 'icht1', sourceEvent); // with event
+ *   history.stream((evt) => console.log(evt)); // subscribe to events
+ */
+export default function alerts(alert, acknowledgedAlert) {
+    const items = [];
+    const bus = pubsub();
+    let counter = 0;
+    return {
+        trigger(message, timestamp, object, source) {
+            const id = `alert-${counter}`;
+            counter += 1;
+            const index = items.length;
+            const created = alert(id, message, timestamp, object, source, () => {
+                const acknowledged = acknowledgedAlert(id, message, timestamp, object, source);
+                items[index] = acknowledged;
+                bus.emit({ type: 'acknowledged', alert: acknowledged });
+            });
+            items.push(created);
+            bus.emit({ type: 'created', alert: created });
+            return created;
+        },
+        all(...filters) {
+            return items.filter((a) => {
+                return filters.every((filter) => {
+                    return filter(a);
+                });
+            });
+        },
+        find(id) {
+            return items.find((a) => {
+                return a.id === id;
+            });
+        },
+        stream: bus.stream
+    };
+}

package/src/clickhouseSensor.js

@@ -0,0 +1,88 @@
+/**
+ * Sensor backed by ClickHouse metrics table with downsampling.
+ *
+ * Reads sensor measurements from scada.metrics table
+ * and provides real-time streaming via polling.
+ * Supports time-based downsampling using ClickHouse aggregation.
+ * Returns value of 0 for missing data to comply with no-null-return principle.
+ *
+ * @param {object} connection - ClickHouse connection with query method
+ * @param {string} topic - Metric topic in format '{machine}/{sensor}'
+ * @param {string} displayName - Human-readable sensor name
+ * @param {string} unit - Measurement unit (e.g., 'V', 'cos(φ)')
+ * @returns {object} sensor with name, current, measurements and stream methods
+ *
+ * @example
+ *   const sensor = clickhouseSensor(conn, 'icht1/voltage', 'Voltage', 'V');
+ *   sensor.name(); // 'Voltage'
+ *   await sensor.current(); // { timestamp, value, unit }
+ *   await sensor.measurements({ start, end }, 60000); // downsampled to 1-minute intervals
+ *   sensor.stream(since, 1000, callback); // live stream
+ */
+function formatDateTime(date) {
+    return date.toISOString().replace('Z', '').replace('T', ' ');
+}
+
+// eslint-disable-next-line max-lines-per-function
+export default function clickhouseSensor(connection, topic, displayName, unit) {
+    return {
+        name() {
+            return displayName;
+        },
+        async current() {
+            const rows = await connection.query(
+                `SELECT ts, value FROM scada.metrics
+                 WHERE topic = {topic:String}
+                 ORDER BY ts DESC LIMIT 1`,
+                { topic }
+            );
+            if (rows.length === 0) {
+                return { timestamp: new Date(), value: 0, unit };
+            }
+            return { timestamp: new Date(rows[0].ts), value: rows[0].value, unit };
+        },
+        async measurements(range, step) {
+            const seconds = Math.max(1, Math.floor(step / 1000));
+            const rows = await connection.query(
+                `SELECT
+                    toStartOfInterval(ts, INTERVAL ${seconds} SECOND) as ts,
+                    avg(value) as value
+                FROM scada.metrics
+                WHERE topic = {topic:String}
+                  AND ts >= toStartOfInterval({start:DateTime64(3)}, INTERVAL ${seconds} SECOND)
+                  AND ts <= {end:DateTime64(3)}
+                GROUP BY ts
+                ORDER BY ts`,
+                {
+                    topic,
+                    start: formatDateTime(range.start),
+                    end: formatDateTime(range.end)
+                }
+            );
+            return rows.map((row) => {
+                return { timestamp: new Date(row.ts), value: row.value, unit };
+            });
+        },
+        stream(since, step, callback) {
+            let lastTs = since;
+            const timer = setInterval(async () => {
+                const rows = await connection.query(
+                    `SELECT ts, value FROM scada.metrics
+                     WHERE topic = {topic:String} AND ts > {since:DateTime64(3)}
+                     ORDER BY ts LIMIT 100`,
+                    { topic, since: formatDateTime(lastTs) }
+                );
+                rows.forEach((row) => {
+                    const timestamp = new Date(row.ts);
+                    callback({ timestamp, value: row.value, unit });
+                    lastTs = timestamp;
+                });
+            }, step);
+            return {
+                cancel() {
+                    clearInterval(timer);
+                }
+            };
+        }
+    };
+}

package/src/completedMelting.js

@@ -0,0 +1,42 @@
+import meltingChronology from './meltingChronology.js';
+
+/**
+ * Immutable record of a finished melting session.
+ * Chronology is bound to machine and derives values from machine's weight history.
+ * Notifies callback when updated.
+ *
+ * @param {string} id - unique melting session identifier
+ * @param {object} machine - the machine that performed this melting
+ * @param {object} chron - chronology bound to machine with start/end times
+ * @param {function} onUpdate - callback invoked when melting is updated
+ * @returns {object} completed melting with id, machine, chronology, update methods
+ *
+ * @example
+ *   const completed = completedMelting('m1', machine, chron, onUpdate);
+ *   completed.id(); // 'm1'
+ *   completed.chronology().get().start; // start time
+ *   completed.chronology().get().end; // end time
+ */
+export default function completedMelting(id, machine, chron, onUpdate) {
+    return {
+        id() {
+            return id;
+        },
+        machine() {
+            return machine;
+        },
+        chronology() {
+            return chron;
+        },
+        update(data) {
+            const opts = data === undefined ? {} : data;
+            const original = chron.get();
+            const newStart = opts.start === undefined ? original.start : new Date(opts.start);
+            const newEnd = opts.end === undefined ? original.end : new Date(opts.end);
+            const updated = meltingChronology(machine, newStart, newEnd);
+            const result = completedMelting(id, machine, updated, onUpdate);
+            onUpdate(result);
+            return result;
+        }
+    };
+}

package/src/event.js

@@ -0,0 +1,24 @@
+/**
+ * Immutable event record with properties and labels.
+ * Represents a single occurrence in the system log.
+ *
+ * @param {string} id - unique event identifier
+ * @param {Date} timestamp - when the event occurred
+ * @param {object} properties - event-specific data
+ * @param {string[]} labels - classification tags for the event
+ * @returns {object} event with id, timestamp, properties, labels methods
+ *
+ * @example
+ *   const e = event('ev-1', new Date(), {machine: 'icht1', voltage: 340}, ['sensor']);
+ *   e.id();         // 'ev-1'
+ *   e.labels();     // ['sensor']
+ *   e.properties(); // {machine: 'icht1', voltage: 340}
+ */
+export default function event(id, timestamp, properties, labels) {
+    return {
+        id: () => {return id},
+        timestamp: () => {return timestamp},
+        properties: () => {return properties},
+        labels: () => {return [...labels]}
+    };
+}

package/src/events.js

@@ -0,0 +1,51 @@
+import pubsub from './pubsub.js';
+
+/**
+ * Append-only event log for system occurrences.
+ * Events are immutable and never modified after creation.
+ * Optionally evaluates rules when events are created.
+ *
+ * @param {function} factory - factory function to create event records
+ * @param {object} rules - optional rules collection to evaluate on create
+ * @returns {object} log with create, all, find, stream methods
+ *
+ * @example
+ *   const log = events(event, rules([rule1, rule2]));
+ *   const e = log.create(new Date(), {machine: 'icht1'}, ['sensor']);
+ *   log.all();                              // returns all events
+ *   log.all((e) => e.labels().includes('sensor')); // filter events
+ *   log.find('ev-0');                       // find by id
+ *   log.stream((evt) => console.log(evt));  // subscribe to new events
+ */
+export default function events(factory, rules) {
+    const items = [];
+    const bus = pubsub();
+    let counter = 0;
+    return {
+        create(timestamp, properties, labels) {
+            const id = `ev-${counter}`;
+            counter += 1;
+            const tags = labels === undefined ? [] : labels;
+            const e = factory(id, timestamp, properties, tags);
+            items.push(e);
+            bus.emit({ type: 'created', event: e });
+            if (rules !== undefined) {
+                rules.evaluate({ event: e });
+            }
+            return e;
+        },
+        all(...filters) {
+            return items.filter((e) => {
+                return filters.every((filter) => {
+                    return filter(e);
+                });
+            });
+        },
+        find(id) {
+            return items.find((e) => {
+                return e.id() === id;
+            });
+        },
+        stream: bus.stream
+    };
+}

package/src/initialized.js

@@ -0,0 +1,30 @@
+/**
+ * Wrapper that provides batch initialization for a collection.
+ * init() initializes items once, get() returns the collection.
+ *
+ * @param {object} collection - object or array containing items with init method
+ * @param {function} toList - function that extracts array of items from collection
+ * @returns {object} wrapper with init() and get() methods
+ *
+ * @example
+ *   const machines = initialized({ icht1: machine }, Object.values);
+ *   machines.init();        // initializes all items once
+ *   machines.get().icht1;   // access by key
+ *   Object.values(machines.get()); // iterate
+ */
+export default function initialized(collection, toList) {
+    let done = false;
+    return {
+        init() {
+            if (!done) {
+                toList(collection).forEach((item) => {
+                    item.init();
+                });
+                done = true;
+            }
+        },
+        get() {
+            return collection;
+        }
+    };
+}

package/src/interval.js

@@ -0,0 +1,18 @@
+/**
+ * Periodic action executor wrapping setInterval.
+ *
+ * @param {number} period - interval in milliseconds
+ * @param {function} action - callback to execute periodically
+ * @returns {object} interval with start method
+ *
+ * @example
+ *   const i = interval(1000, function() { console.log('tick'); });
+ *   i.start();
+ */
+export default function interval(period, action) {
+    return {
+        start() {
+            setInterval(action, period);
+        }
+    };
+}

package/src/machineChronology.js

@@ -0,0 +1,77 @@
+/**
+ * Immutable chronology that queries shared machine weight history.
+ * Supports point-in-time and range queries via query object.
+ * Optionally includes sensor readings in current snapshot.
+ *
+ * @param {number} initial - initial weight when machine was created
+ * @param {array} history - shared mutable array of { timestamp, weight } entries
+ * @param {object} sensors - optional sensor objects keyed by name with current() method
+ * @returns {object} chronology with get method
+ *
+ * @example
+ *   const history = [{ timestamp: new Date(), weight: 0 }];
+ *   const chron = machineChronology(0, history, { voltage: sensor });
+ *   chron.get({ type: 'current' }).weight; // current weight
+ *   chron.get({ type: 'current' }).voltage; // current voltage reading
+ *   chron.get({ type: 'point', at: someDate }).weight; // weight at someDate
+ *   chron.get({ type: 'range', from: start, to: end }); // { loaded, dispensed }
+ */
+// eslint-disable-next-line max-lines-per-function
+export default function machineChronology(initial, history, sensors) {
+    async function current() {
+        const result = { weight: history[history.length - 1].weight };
+        if (sensors) {
+            const keys = Object.keys(sensors);
+            const values = await Promise.all(keys.map((key) => {
+                return sensors[key].current();
+            }));
+            keys.forEach((key, i) => { result[key] = values[i]; });
+        }
+        return result;
+    }
+    function point(datetime) {
+        const time = new Date(datetime).getTime();
+        for (let i = history.length - 1; i >= 0; i -= 1) {
+            if (history[i].timestamp.getTime() <= time) {
+                return { weight: history[i].weight };
+            }
+        }
+        return { weight: initial };
+    }
+    function range(from, to) {
+        const start = new Date(from).getTime();
+        const end = new Date(to).getTime();
+        const entries = history.filter((entry) => {
+            const time = entry.timestamp.getTime();
+            return time >= start && time < end;
+        });
+        let loaded = 0;
+        let dispensed = 0;
+        const base = point(from).weight;
+        let previous = base;
+        for (const entry of entries) {
+            const delta = entry.weight - previous;
+            if (delta > 0) {
+                loaded += delta;
+            } else if (delta < 0) {
+                dispensed += Math.abs(delta);
+            }
+            previous = entry.weight;
+        }
+        return { loaded, dispensed };
+    }
+    return {
+        get(query) {
+            if (query.type === 'current') {
+                return current();
+            }
+            if (query.type === 'point') {
+                return point(query.at);
+            }
+            if (query.type === 'range') {
+                return range(query.from, query.to);
+            }
+            throw new Error(`Unknown query type: ${query.type}`);
+        }
+    };
+}

package/src/meltingChronology.js

@@ -0,0 +1,37 @@
+/**
+ * Melting chronology bound to a machine.
+ * Derives values from machine's weight history during the melting window.
+ *
+ * @param {object} machine - melting machine with chronology method
+ * @param {Date} start - melting start time
+ * @param {Date} end - melting end time (undefined for active meltings)
+ * @returns {object} chronology with get method
+ *
+ * @example
+ *   const chron = meltingChronology(machine, startTime, endTime);
+ *   chron.get(); // { start, end, initial, weight, loaded, dispensed }
+ *   chron.get(someTime); // state at specific time
+ */
+export default function meltingChronology(machine, start, end) {
+    return {
+        get(datetime) {
+            const machineChron = machine.chronology();
+            const defaultTime = end === undefined ? new Date() : end;
+            const queryTime = datetime === undefined ? defaultTime : datetime;
+            const initial = machineChron.get({ type: 'point', at: start }).weight;
+            const current = machineChron.get({ type: 'point', at: queryTime }).weight;
+            const range = machineChron.get({ type: 'range', from: start, to: queryTime });
+            const result = {
+                start,
+                initial,
+                weight: current,
+                loaded: range.loaded,
+                dispensed: range.dispensed
+            };
+            if (end !== undefined) {
+                result.end = end;
+            }
+            return result;
+        }
+    };
+}

package/src/meltingMachine.js

@@ -0,0 +1,53 @@
+import machineChronology from './machineChronology.js';
+
+/**
+ * Melting machine that tracks metal weight history and sensor measurements.
+ * Supports loading and dispensing metal during melting operations.
+ * Weight history is tracked for historical queries.
+ *
+ * @param {string} name - unique machine identifier
+ * @param {object} sensors - object containing sensor instances
+ * @param {object} alerts - centralized alerts collection
+ * @param {number} initial - initial weight (defaults to 0)
+ * @returns {object} machine with name, sensors, alerts, chronology, load, dispense
+ *
+ * @example
+ *   const machine = meltingMachine('icht1', { voltage: voltageSensor() }, alerts());
+ *   machine.load(500);
+ *   machine.chronology().get().weight; // 500
+ *   machine.chronology().get(pastDate).weight; // weight at pastDate
+ */
+export default function meltingMachine(name, sensors, alerts, initial) {
+    const start = initial === undefined ? 0 : initial;
+    const history = [{ timestamp: new Date(), weight: start }];
+    let current = start;
+    return {
+        name() {
+            return name;
+        },
+        sensors,
+        alerts() {
+            return alerts.all((item) => {
+                return item.object === name;
+            });
+        },
+        chronology() {
+            return machineChronology(start, history, sensors);
+        },
+        load(w) {
+            current += w;
+            history.push({ timestamp: new Date(), weight: current });
+        },
+        dispense(w) {
+            current -= w;
+            history.push({ timestamp: new Date(), weight: current });
+        },
+        reset(w) {
+            current = w;
+            history.push({ timestamp: new Date(), weight: current });
+        },
+        init() {
+            return this;
+        }
+    };
+}

package/src/meltingRuleEngine.js

@@ -0,0 +1,37 @@
+/**
+ * Expert system that evaluates measurements and issues alerts.
+ * Checks voltage and power factor thresholds.
+ *
+ * @param {function} issue - callback to issue alerts with message and timestamp
+ * @returns {object} rule engine with evaluate method
+ *
+ * @example
+ *   const engine = meltingRuleEngine(function(msg, ts) { console.log(msg); });
+ *   engine.evaluate({ voltage: { value: 340 }, cosphi: { value: 0.9 } });
+ */
+export default function meltingRuleEngine(issue) {
+    return {
+        evaluate(snapshot) {
+            const timestamp = new Date();
+            const {voltage} = snapshot;
+            const {cosphi} = snapshot;
+            if (voltage && voltage.value < 350) {
+                issue(`Critical low voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
+            } else if (voltage && voltage.value < 360) {
+                issue(`Low voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
+            } else if (voltage && voltage.value > 410) {
+                issue(`Critical high voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
+            } else if (voltage && voltage.value > 400) {
+                issue(`High voltage: ${  voltage.value.toFixed(1)  }V`, timestamp);
+            }
+            if (cosphi && cosphi.value < 0.7) {
+                issue(`Critical low power factor: ${  cosphi.value.toFixed(2)}`, timestamp);
+            } else if (cosphi && cosphi.value < 0.8) {
+                issue(`Low power factor: ${  cosphi.value.toFixed(2)}`, timestamp);
+            }
+            if (voltage && cosphi && voltage.value < 370 && cosphi.value < 0.8) {
+                issue('Power quality issue detected', timestamp);
+            }
+        }
+    };
+}

package/src/meltingShop.js

@@ -0,0 +1,32 @@
+/**
+ * Melting shop containing melting machines and their meltings.
+ * Provides initialization for all contained machines.
+ *
+ * @param {string} name - unique identifier for the shop
+ * @param {object} meltingMachines - initialized wrapper of melting machines
+ * @param {object} meltings - collection managing melting sessions
+ * @param {object} alerts - alerts collection for the shop
+ * @param {object} events - events collection shared from plant
+ * @returns {object} shop with name, machines, meltings, alerts, events properties and init method
+ *
+ * @example
+ *   const shop = meltingShop('shop1', initialized({ m1: machine }, Object.values), meltings(), alerts(), events());
+ *   shop.name(); // 'shop1'
+ *   shop.machines.init().m1; // access machine by key
+ *   shop.events.create(new Date(), {}, ['label']);
+ *   shop.init();
+ */
+export default function meltingShop(name, meltingMachines, meltings, alerts, events) {
+    return {
+        name() {
+            return name;
+        },
+        machines: meltingMachines,
+        meltings,
+        alerts,
+        events,
+        init() {
+            meltingMachines.init();
+        },
+    };
+}

package/src/meltings.js

@@ -0,0 +1,97 @@
+/* eslint-disable max-lines-per-function, max-statements */
+import pubsub from './pubsub.js';
+import meltingChronology from './meltingChronology.js';
+import activeMelting from './activeMelting.js';
+import completedMelting from './completedMelting.js';
+
+/**
+ * Collection of melting sessions associated with machines.
+ * Uses add() for creating both active and completed meltings.
+ * Uses query() for filtering and streaming meltings.
+ *
+ * @returns {object} collection with add, query methods
+ *
+ * @example
+ *   const list = meltings();
+ *   const active = list.add(machine, {}); // creates active melting
+ *   const completed = list.add(machine, { start, end }); // creates completed melting
+ *   list.query(); // returns all completed meltings
+ *   list.query({ machine }); // returns meltings for machine
+ *   list.query({ id: 'm1' }); // returns melting by id
+ *   list.query({ stream: callback }); // subscribe to events
+ */
+export default function meltings() {
+    const items = [];
+    const bus = pubsub();
+    let counter = 0;
+    function onUpdate(id, updated) {
+        const item = items.find((i) => {
+            return i.melting.id() === id;
+        });
+        if (item) {
+            item.melting = updated;
+            bus.emit({ type: 'updated', melting: updated });
+        }
+    }
+    return {
+        add(machine, data) {
+            const opts = data === undefined ? {} : data;
+            if (opts.end === undefined) {
+                const existing = items.find((i) => {
+                    const chron = i.melting.chronology().get();
+                    return i.machine === machine && chron.end === undefined;
+                });
+                if (existing) {
+                    return existing.melting;
+                }
+            }
+            counter += 1;
+            const id = `m${counter}`;
+            if (opts.end !== undefined) {
+                const chron = meltingChronology(machine, new Date(opts.start), new Date(opts.end));
+                const completed = completedMelting(id, machine, chron, (updated) => {
+                    onUpdate(id, updated);
+                });
+                items.push({ machine, melting: completed });
+                bus.emit({ type: 'completed', melting: completed });
+                return completed;
+            }
+            const start = opts.start === undefined ? new Date() : new Date(opts.start);
+            const item = { machine, melting: undefined };
+            items.push(item);
+            const active = activeMelting(id, machine, start, (completed) => {
+                item.melting = completed;
+                bus.emit({ type: 'completed', melting: completed });
+            }, (updated) => {
+                onUpdate(id, updated);
+            });
+            item.melting = active;
+            bus.emit({ type: 'started', melting: active });
+            return active;
+        },
+        query(options) {
+            const opts = options === undefined ? {} : options;
+            if (opts.stream !== undefined) {
+                return bus.stream(opts.stream);
+            }
+            if (opts.id !== undefined) {
+                const item = items.find((i) => {
+                    return i.melting.id() === opts.id;
+                });
+                return item === undefined ? undefined : item.melting;
+            }
+            if (opts.machine !== undefined) {
+                return items.filter((i) => {
+                    return i.machine === opts.machine;
+                }).map((i) => {
+                    return i.melting;
+                });
+            }
+            return items.filter((i) => {
+                return i.melting.chronology().get().end !== undefined;
+            }).map((i) => {
+                return i.melting;
+            });
+        }
+    };
+}

package/src/monitoredMeltingMachine.js

@@ -0,0 +1,33 @@
+/**
+ * Melting machine wrapper that monitors measurements and generates alerts.
+ * Periodically evaluates sensor readings using a rule engine via chronology.
+ *
+ * @param {object} machine - the melting machine to monitor
+ * @param {object} ruleEngine - engine that evaluates measurements and triggers alerts
+ * @param {function} interval - factory to create periodic intervals
+ * @returns {object} monitored machine with name, sensors, alerts, chronology, init methods
+ *
+ * @example
+ *   const monitored = monitoredMeltingMachine(machine, ruleEngine(), interval);
+ *   monitored.init(); // starts periodic monitoring
+ */
+export default function monitoredMeltingMachine(machine, ruleEngine, interval) {
+    return {
+        name() {
+            return machine.name();
+        },
+        sensors: machine.sensors,
+        alerts() {
+            return machine.alerts();
+        },
+        chronology() {
+            return machine.chronology();
+        },
+        init() {
+            interval(1000, async () => {
+                const snapshot = await machine.chronology().get({ type: 'current' });
+                ruleEngine.evaluate(snapshot);
+            }).start();
+        }
+    };
+}

package/src/plant.js

@@ -0,0 +1,23 @@
+/**
+ * Top-level plant structure containing melting shops.
+ * Provides initialization for all contained shops.
+ *
+ * @param {object} shops - initialized list of melting shops
+ * @param {object} events - events collection shared by all shops
+ * @returns {object} plant with shops, events properties and init method
+ *
+ * @example
+ *   const p = plant(initializedList(shop1, shop2), events(event, rules));
+ *   p.shops.list(); // [shop1, shop2]
+ *   p.events.create(new Date(), {}, ['label']);
+ *   p.init();
+ */
+export default function plant(shops, events) {
+    return {
+        shops,
+        events,
+        init() {
+            shops.init();
+        },
+    };
+}

package/src/pubsub.js

@@ -0,0 +1,32 @@
+/**
+ * Simple publish-subscribe mechanism for event distribution.
+ * Provides emit() to publish and stream() to subscribe.
+ * Abstraction point for future message broker integration.
+ *
+ * @returns {object} bus with emit() and stream() methods
+ *
+ * @example
+ *   const bus = pubsub();
+ *   const sub = bus.stream((e) => console.log(e));
+ *   bus.emit({ type: 'created', data: {...} });
+ *   sub.cancel();
+ */
+export default function pubsub() {
+    const subscribers = [];
+    return {
+        emit(event) {
+            subscribers.forEach((cb) => {
+                cb(event);
+            });
+        },
+        stream(callback) {
+            subscribers.push(callback);
+            return {
+                cancel() {
+                    const index = subscribers.indexOf(callback);
+                    subscribers.splice(index, 1);
+                }
+            };
+        }
+    };
+}

package/src/rule.js

@@ -0,0 +1,33 @@
+/**
+ * Unified trigger-action mapping for event processing.
+ * Evaluates context and executes action when trigger matches.
+ *
+ * @param {function} trigger - predicate that receives context and returns boolean
+ * @param {function} action - callback executed when trigger returns true
+ * @returns {object} rule with evaluate method
+ *
+ * @example
+ *   // Sensor rule - executes on voltage threshold
+ *   const r1 = rule(
+ *       (ctx) => ctx.sensor && ctx.sensor.voltage < 350,
+ *       (ctx) => alerts.trigger('Low voltage')
+ *   );
+ *
+ *   // Event rule - handles labeled events
+ *   const r2 = rule(
+ *       (ctx) => ctx.event && ctx.event.labels().includes('melting-start'),
+ *       (ctx) => meltings.add(ctx.event.properties().machine)
+ *   );
+ *
+ *   r1.evaluate({sensor: {voltage: 340}}); // triggers action
+ *   r2.evaluate({event: e}); // triggers action if labels match
+ */
+export default function rule(trigger, action) {
+    return {
+        evaluate(context) {
+            if (trigger(context)) {
+                action(context);
+            }
+        }
+    };
+}

package/src/rules.js

@@ -0,0 +1,23 @@
+/**
+ * Collection of rules with unified evaluation.
+ * Evaluates all rules against provided context.
+ *
+ * @param {object[]} list - array of rule objects with evaluate method
+ * @returns {object} rules collection with evaluate and all methods
+ *
+ * @example
+ *   const rs = rules([rule1, rule2, rule3]);
+ *   rs.evaluate({sensor: {voltage: 340}}); // evaluates all rules
+ *   rs.evaluate({event: e}); // evaluates all rules against event
+ *   rs.all(); // returns array of all rules
+ */
+export default function rules(list) {
+    return {
+        evaluate(context) {
+            list.forEach((item) => {
+                item.evaluate(context);
+            });
+        },
+        all: () => {return [...list]}
+    };
+}

package/src/scyllaSensor.js

@@ -0,0 +1,53 @@
+/**
+ * Sensor backed by ScyllaDB metrics table.
+ *
+ * Reads sensor measurements from scada.metrics table
+ * and provides real-time streaming via polling.
+ *
+ * @param {object} connection - ScyllaDB connection with query method
+ * @param {string} topic - Metric topic in format '{machine}/{sensor}'
+ * @param {string} displayName - Human-readable sensor name
+ * @param {string} unit - Measurement unit (e.g., 'V', 'cos(φ)')
+ * @returns {object} sensor with name, measurements and stream methods
+ *
+ * @example
+ *   const sensor = scyllaSensor(conn, 'icht1/voltage', 'Voltage', 'V');
+ *   sensor.name(); // 'Voltage'
+ *   await sensor.measurements({ start, end }); // array of readings
+ *   sensor.stream(since, 1000, callback); // live stream
+ */
+export default function scyllaSensor(connection, topic, displayName, unit) {
+    return {
+        name() {
+            return displayName;
+        },
+        async measurements(range, step) {
+            void step;
+            const rows = await connection.query(
+                'SELECT ts, value FROM scada.metrics WHERE topic = ? AND ts >= ? AND ts <= ?',
+                [topic, range.start, range.end]
+            );
+            return rows.map((row) => {
+                return { timestamp: row.ts, value: row.value, unit };
+            });
+        },
+        stream(since, step, callback) {
+            let lastTs = since;
+            const timer = setInterval(async () => {
+                const rows = await connection.query(
+                    'SELECT ts, value FROM scada.metrics WHERE topic = ? AND ts > ? LIMIT 100',
+                    [topic, lastTs]
+                );
+                rows.forEach((row) => {
+                    callback({ timestamp: row.ts, value: row.value, unit });
+                    lastTs = row.ts;
+                });
+            }, step);
+            return {
+                cancel() {
+                    clearInterval(timer);
+                }
+            };
+        }
+    };
+}