@yarkivaev/scada 1.5.0 → 2.3.45

package/README.md

@@ -1,53 +1,216 @@
 # scada
 
-SCADA domain objects for industrial plant monitoring.
+Generic industrial monitoring domain, state persistence, and HTTP APIs (`@yarkivaev/scada`).
+
+This package is plant-agnostic: it defines `plant` → `shop` → `machine` hierarchy, timeline and alerts, sensor read ports, STOMP ingest pipelines, and PostgreSQL/ClickHouse adapters. Plant-specific routes, sensors, HMI strings, and tag taxonomies live in downstream plant packages.
+
+Repository: `https://github.com/yarkivaev/scada`
 
 ## Install
 
+```bash
+npm install @yarkivaev/scada
 ```
-npm install scada
+
+Node.js 22+, ES modules.
+
+## Quick start
+
+```javascript
+import { plantApi, metricsPlant, clickhouseConnection } from '@yarkivaev/scada';
+
+const p = await metricsPlant(
+  [{ device: 'device-1', machine: 'm1' }],
+  {
+    connection: () => clickhouseConnection(process.env.CLICKHOUSE_HOST),
+    buildSensors: (conn, entry) => ({ /* sensor factories */ }),
+    shopFactory: (entries, ctx) => { /* return shop */ }
+  }
+);
+
+const api = plantApi('/api/v1', p);
 ```
 
-## Usage
+For a full deployable process, use `siteServer` or the `supervisor-sink` binary (see below). Plant packages wrap these with site-specific routes and sensors.
+
+## Layout
+
+```
+scada/
+  src/
+    domain/           business objects and ingest policies (no I/O)
+    application/      composition roots (plantApi, supervisorSink, siteServer)
+    infrastructure/   adapters (http, persistence, messaging, ingest, client)
+    bin/              process entry points
+  test/               mirrors src/ (domain/, infrastructure/, helpers/)
+  db/migrations/      PostgreSQL schema (profile-specific prefixes)
+  index.js            public API facade
+```
+
+## Three layers
+
+| Layer | Role | Examples |
+|-------|------|----------|
+| **domain/** | Pure business logic, no imports from infrastructure | `plant`, `shop`, `machine`, `timeline`, `alerts`, `segment/dispatch` |
+| **application/** | Wires domain + infrastructure into runnable units | `plantApi`, `metricsPlant`, `supervisorSink`, `siteServer` |
+| **infrastructure/** | I/O adapters behind narrow ports | `persistence/pg`, `http/plant`, `http/edge`, `messaging/stomp`, `ingest` |
+
+Dependency rules:
+
+- `domain/` imports `domain/` only
+- `application/` composes `domain/` + `infrastructure/`
+- HTTP routes receive injected `plant` objects; storage backends are swappable behind the same port shape
+
+## Data flow
+
+**Central plant API** (read path):
+
+```
+ClickHouse ← mqttMetrics / amqpMetricsIngest
+PostgreSQL ← STOMP alerts (via plantServer)
+plantApi → REST + SSE → frontend / @yarkivaev/scada/client
+```
+
+**Supervisor-sink** (write path):
+
+```
+STOMP (`/queue/scada.segments.ingest`, `/exchange/scada.alerts`, `/exchange/scada.user_decisions`)
+  → ingest/codecs → domain/segment → ingest/sinks → PostgreSQL
+edgeApi (:8081) ← metrics batch, checkpoints, retention (edge profile)
+```
+
+**Edge site** (`siteServer`): runs supervisor-sink HTTP, plant API, and optional MQTT ingest in one process. Metrics land in PostgreSQL on edge; on central they go to ClickHouse.
+
+## Public exports
+
+Main entry (`import { … } from '@yarkivaev/scada'`):
+
+| Export | Purpose |
+|--------|---------|
+| `plant`, `shop`, `machine` | Domain hierarchy |
+| `timeline`, `alerts`, `alert`, `acknowledgedAlert` | Timeline and alerting |
+| `plantApi`, `plantServer`, `siteServer` | HTTP composition |
+| `exportQuery`, `exportStream`, `exportSink`, `exportJob` | Generic export ports over plantApi / `@yarkivaev/scada/client` |
+| `metricsPlant`, `shopWithTimeline`, `machineInPlant` | Plant wiring helpers |
+| `supervisorSink`, `readDeploymentConfig` | STOMP ingest + PG persistence |
+| `edgeApi`, `stateHttpClient`, `metricsSensor` | Edge HTTP read/write |
+| `clickhouseConnection`, `clickhouseSensor`, `pgMetricsSensor` | Metric storage |
+| `pgTimeline`, `pgAlerts`, `stateDataFromPool`, `stateDataFromMemory` | State ports |
+| `stompTimeline`, `stompAlerts`, `userDecisions` | STOMP messaging |
+| `machineOwners`, `ownerTimeline`, `httpTimeline`, `httpOperations` | Owner-routed timeline and operations write (local or edge HTTP) |
+| `mqttMetrics`, `modbusMqtt`, `activityTracking`, `amqpMetricsIngest` | Ingest pipelines |
+
+Subpath exports:
+
+- `@yarkivaev/scada/client` — browser/Node HTTP+SSE client (`scadaClient`, `machineClient`) plus re-exported export ports
+- `@yarkivaev/scada/stateDataFake` — in-memory state backends for tests
+- `@yarkivaev/scada/startTestEdgeApi` — ephemeral edge API for integration tests
+
+## Export ports
+
+Generic read/stream/write contract for outbound jobs. Read side uses existing `plantApi` / `@yarkivaev/scada/client` only (no direct DB). Destination adapters and plant maps live in plant packages, not here. Do not put export into `edgeApi`.
+
+```javascript
+import { exportQuery, exportStream, exportSink, exportJob } from '@yarkivaev/scada';
+import { scadaClient } from '@yarkivaev/scada/client';
+
+const client = scadaClient(baseUrl, fetch, EventSource);
+const query = exportQuery(client);
+const stream = exportStream(client);
+const sink = exportSink({
+  write(records) { return destination.write(records); },
+  send(artifact) { return destination.send(artifact); }
+});
+const job = exportJob({ query, transform: (rows) => rows, sink });
+await job.run({ kind: 'segments', machine: 'furnace-α', from, to });
+```
+
+Downstream plant packages should pin a released tag (e.g. `#v2.3.45`).
+
+Alert and HMI copy are inject-only: pass `translations` into `siteServer` / `plantServer` / `alertPipeline` config, and override `TAG_CATALOG_PATH` or `plantApi({ tagCatalog })` for site taxonomy. Defaults ship empty or English stubs.
+
+## Binaries
+
+| Binary | Role |
+|--------|------|
+| `supervisor-sink` | STOMP → PostgreSQL ingest + edge HTTP API (`STATE_HTTP_PORT`, default 8081) |
+
+Full plant API with site-specific routes: plant packages call `siteServer` from this package.
+
+## Sensor port
+
+All sensor implementations expose the same interface:
 
 ```javascript
-import { plant, meltingShop, meltingMachine, meltings, alerts, initialized } from 'scada';
+{ name(), current(), measurements(range, step), stream(since, step, callback, clock?) }
+```
+
+Implementations: `clickhouseSensor` (central; live `stream()` batches many topics into one ClickHouse query per tick), `pgMetricsSensor` / `metricsSensor` (edge HTTP or PG).
+
+## Database migrations
+
+SQL files in `db/migrations/` use profile prefixes:
+
+| Prefix | Applies to |
+|--------|------------|
+| `V*` | Both central and edge |
+| `E*` | Edge only (metrics tables, retention) |
+| `C*` | Central only (revoke delete on metrics) |
+
+Set `SINK_DB_PROFILE=central|edge`. Migrations run at supervisor-sink startup via `POSTGRES_ADMIN_URL`.
 
-const machine = meltingMachine('icht1', sensors, alertHistory);
-const shop = meltingShop('shop1', initialized({ icht1: machine }, Object.values), meltings());
-const factory = plant(initialized({ shop1: shop }, Object.values));
+## Environment (supervisor-sink / siteServer)
+
+| Variable | Purpose |
+|----------|---------|
+| `STOMP_URL` | RabbitMQ STOMP broker |
+| `POSTGRES_URL` | Application DB user (`supervisor_sink`) |
+| `POSTGRES_ADMIN_URL` | Admin user for migrations |
+| `SINK_DB_PROFILE` | `central` or `edge` |
+| `STATE_HTTP_PORT` / `STATE_HTTP_TOKEN` | Edge internal API |
+| `MQTT_URL`, `MQTT_TOPICS` | Optional metrics ingest |
+| `CLICKHOUSE_URL` | Central metrics sink |
+| `PORT` | Plant API port (siteServer, default 3000) |
+
+## Testing
+
+```bash
+npm test                        # all Mocha unit tests
+npm test -- --grep "pattern"    # filter by name
+npm run test:deep               # domain + ingest (integration needs Docker)
+npm run coverage
+npm run lint
+npm run lint:eo                 # Elegant Objects naming audit
 ```
 
-## Modules
+Tests mirror `src/` under `test/`. Use fakes instead of mocks; one assertion per test. Integration tests under `test/infrastructure/**/integration/` use testcontainers.
+
+For HTTP/state tests without PostgreSQL:
+
+```javascript
+import stateDataFake from '@yarkivaev/scada/stateDataFake';
+```
 
-### Plant Hierarchy
-- `plant`
-- `meltingShop`
-- `meltingMachine`
-- `machineChronology`
-- `monitoredMeltingMachine`
+## Design conventions
 
-### Melting Operations
-- `activeMelting`
-- `completedMelting`
-- `meltings`
-- `meltingChronology`
+- Factory functions returning frozen objects — no classes, no inheritance
+- ESLint limits: `max-lines: 200`, `max-lines-per-function: 50`, `no-console`, `no-inline-comments`
+- Docblocks on every module; method bodies without blank lines
+- See `CLAUDE.md` for layer rules and ingest sandwich diagram
 
-### Alerting
-- `alert`
-- `acknowledgedAlert`
-- `alerts`
-- `meltingRuleEngine`
+## Package boundary
 
-### Sensors
-- `scyllaSensor`
-- `clickhouseSensor`
+| This package (`@yarkivaev/scada`) | Downstream plant package |
+|------------------------|--------------------------|
+| Generic plant, timeline, alerts, ingest | Site domain, sensors, HMI strings, tag taxonomy |
+| Empty/injectable alert `translations` | Localized rule messages |
+| Opaque operation `kind` strings | Site-specific kinds (`sample`, `load`, …) |
+| `plantApi`, `siteServer`, `supervisorSink` | Site bins and routes |
+| Export ports `Query` / `Stream` / `Sink` / `Job` | Export jobs + destination adapters |
+| ClickHouse + PG adapters | Plant wiring (`metricsPlant`, shops, machines) |
 
-### Utilities
-- `interval`
-- `initialized`
-- `events`
+Depend on a pinned version (`"@yarkivaev/scada": "…#v2.3.45"`), not a local path, in downstream packages.
 
-## License
+## CI/CD
 
-MIT
+GitHub Actions via `yarkivaev/npm-workflows` (lint, test, version check). This repo publishes an npm package only; container images are built in downstream deploy repos.

package/db/migrations/C0001__central_drop_metrics.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS metrics;

package/db/migrations/C0002__central_revoke_delete.sql

@@ -0,0 +1,12 @@
+REVOKE ALL ON SCHEMA public FROM supervisor_sink;
+GRANT USAGE ON SCHEMA public TO supervisor_sink;
+
+GRANT SELECT, INSERT, UPDATE ON segments TO supervisor_sink;
+GRANT SELECT, INSERT, UPDATE ON alerts TO supervisor_sink;
+GRANT SELECT, INSERT ON user_decisions TO supervisor_sink;
+GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO supervisor_sink;
+
+REVOKE CREATE ON SCHEMA public FROM supervisor_sink;
+REVOKE DELETE ON segments FROM supervisor_sink;
+REVOKE DELETE ON alerts FROM supervisor_sink;
+REVOKE DELETE ON user_decisions FROM supervisor_sink;

package/db/migrations/C0003__central_operators.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS operators (
+    id SERIAL PRIMARY KEY,
+    card_uid TEXT NOT NULL UNIQUE,
+    first_name TEXT NOT NULL,
+    last_name TEXT NOT NULL,
+    display_name TEXT NOT NULL
+);

package/db/migrations/C0004__central_operations_grants.sql

@@ -0,0 +1,2 @@
+GRANT SELECT, INSERT, UPDATE ON operations TO supervisor_sink;
+GRANT SELECT, INSERT, UPDATE ON ingest_checkpoints TO supervisor_sink;

package/db/migrations/C0005__central_operators_grants.sql

@@ -0,0 +1 @@
+GRANT SELECT ON operators TO supervisor_sink;

package/db/migrations/C0006__central_operators_registration.sql

@@ -0,0 +1,16 @@
+-- Singleton flag: HMI may register operators only while enabled is true.
+-- CHECK keeps exactly one row (singleton = 1); default disabled until console turns registration on.
+CREATE TABLE IF NOT EXISTS operators_registration (
+    singleton SMALLINT PRIMARY KEY DEFAULT 1 CHECK (singleton = 1),
+    enabled BOOLEAN NOT NULL DEFAULT FALSE
+);
+
+-- Seed the singleton on first apply; keep an existing enabled value on re-apply.
+INSERT INTO operators_registration (singleton, enabled)
+VALUES (1, FALSE)
+ON CONFLICT (singleton) DO NOTHING;
+
+-- Plant API role: create operators and read/update the registration flag.
+GRANT INSERT ON operators TO supervisor_sink;
+GRANT USAGE, SELECT ON SEQUENCE operators_id_seq TO supervisor_sink;
+GRANT SELECT, UPDATE ON operators_registration TO supervisor_sink;

package/db/migrations/E0001__edge_metrics.sql

@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS metrics (
+    topic TEXT NOT NULL,
+    ts TIMESTAMPTZ NOT NULL,
+    value DOUBLE PRECISION NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_metrics_topic_ts
+    ON metrics (topic, ts);

package/db/migrations/E0002__edge_retention_delete.sql

@@ -0,0 +1,8 @@
+ALTER TABLE IF EXISTS metrics OWNER TO supervisor_sink;
+
+GRANT SELECT, INSERT, UPDATE, DELETE ON metrics TO supervisor_sink;
+GRANT DELETE ON segments TO supervisor_sink;
+GRANT DELETE ON alerts TO supervisor_sink;
+GRANT DELETE ON user_decisions TO supervisor_sink;
+
+ALTER TABLE IF EXISTS user_decisions OWNER TO supervisor_sink;

package/db/migrations/E0003__edge_operations_grants.sql

@@ -0,0 +1,2 @@
+GRANT SELECT, INSERT, UPDATE ON operations TO supervisor_sink;
+GRANT SELECT, INSERT, UPDATE ON ingest_checkpoints TO supervisor_sink;

package/db/migrations/V0001__baseline.sql

@@ -0,0 +1,25 @@
+CREATE TABLE IF NOT EXISTS segments (
+    machine TEXT,
+    name TEXT,
+    start_time TIMESTAMPTZ,
+    end_time TIMESTAMPTZ,
+    duration FLOAT,
+    options TEXT,
+    tags TEXT,
+    properties TEXT,
+    resolved BOOLEAN DEFAULT TRUE,
+    consumed BOOLEAN DEFAULT TRUE
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_segments_machine_start
+    ON segments (machine, start_time);
+
+CREATE TABLE IF NOT EXISTS alerts (
+    id SERIAL PRIMARY KEY,
+    name TEXT,
+    message TEXT,
+    machine TEXT,
+    severity TEXT,
+    timestamp TIMESTAMPTZ,
+    acknowledged BOOLEAN DEFAULT FALSE
+);

package/db/migrations/V0002__sink_extension_tables.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS user_decisions (
+    machine TEXT,
+    start_time TIMESTAMPTZ,
+    username TEXT,
+    payload TEXT
+);

package/db/migrations/V0003__operations.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS operations (
+    machine TEXT NOT NULL,
+    occurred_at TIMESTAMPTZ NOT NULL,
+    kind TEXT NOT NULL,
+    key TEXT NOT NULL,
+    payload JSONB NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_operations_key
+    ON operations (key);

package/db/migrations/V0004__ingest_checkpoints.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS ingest_checkpoints (
+    source TEXT NOT NULL,
+    machine TEXT NOT NULL,
+    cursor_at TIMESTAMPTZ NOT NULL,
+    PRIMARY KEY (source, machine)
+);

package/db/migrations/V0005__user_decisions_operator.sql

@@ -0,0 +1,2 @@
+ALTER TABLE user_decisions ADD COLUMN IF NOT EXISTS operator_id INTEGER;
+ALTER TABLE user_decisions ADD COLUMN IF NOT EXISTS decided_at TIMESTAMPTZ;

package/index.js

@@ -1,51 +1,80 @@
 /**
- * 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));
+ * scada v2 — generic industrial monitoring domain and HTTP API.
  */
 
-// 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';
+export { default as plant } from './src/domain/plant/plant.js';
+export { default as shop } from './src/domain/plant/shop.js';
+export { default as machine } from './src/domain/plant/machine.js';
+export { default as timeline } from './src/domain/timeline/timeline.js';
+export { alert, acknowledgedAlert } from './src/domain/alerting/alert.js';
+export { operation } from './src/domain/operation/operation.js';
+export { ingestCursorAt, ingestCursorEmpty } from './src/domain/ingest/ingestCursor.js';
+export { default as alerts } from './src/domain/alerting/alerts.js';
+export { default as initialized } from './src/domain/shared/initialized.js';
+export { default as pubsub } from './src/domain/shared/pubsub.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';
+export { default as plantApi } from './src/application/plantApi.js';
+export { default as tagCatalog } from './src/infrastructure/catalog/tagCatalog.js';
+export { default as machineInPlant } from './src/application/machineInPlant.js';
+export { default as shopWithTimeline } from './src/application/shopWithTimeline.js';
+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 siteOperatorCatalog,
+    buildSiteOperatorCatalog
+} from './src/application/siteOperatorCatalog.js';
+export { default as edgeOperatorCatalog } from './src/application/edgeOperatorCatalog.js';
+export { default as operator } from './src/domain/operator/operator.js';
+export { default as operatorsFromPg } from './src/infrastructure/persistence/pg/operators.js';
+export { default as userDecisionsFromPg } from './src/infrastructure/persistence/pg/userDecisions.js';
+export { default as operatorRoute } from './src/infrastructure/http/plant/routes/operatorRoute.js';
+export { default as decisionRoute } from './src/infrastructure/http/plant/routes/decisionRoute.js';
+export { default as operatorJson } from './src/infrastructure/http/plant/json/operatorJson.js';
+export { default as operators } from './src/infrastructure/operators/operators.js';
+export { default as centralOperators } from './src/infrastructure/operators/centralOperators.js';
+export { default as edgeOperators } from './src/infrastructure/operators/edgeOperators.js';
+export { default as operatorsSync } from './src/infrastructure/operators/operatorsSync.js';
+export { default as operatorExtras } from './src/infrastructure/operators/operatorExtras.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';
-
-// Timeline
-export { default as segments } from './src/segments.js';
-export { default as requests } from './src/requests.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';
-export { default as sqliteSensor } from './src/sqliteSensor.js';
-export { default as postgresSensor } from './src/postgresSensor.js';
+export { default as pgTimeline } from './src/infrastructure/persistence/pg/timeline.js';
+export { default as pgAlerts } from './src/infrastructure/persistence/pg/alerts.js';
+export { default as pgOperations } from './src/infrastructure/persistence/pg/operations.js';
+export { default as clickhouseConnection } from './src/infrastructure/persistence/clickhouse/connection.js';
+export { default as clickhouseSensor } from './src/infrastructure/persistence/clickhouse/sensor.js';
+export { default as postgresPool } from './src/infrastructure/persistence/postgresPool.js';
+export { metricsSinkFromPool as pgMetricsSink } from './src/infrastructure/persistence/pg/metrics.js';
+export { pgMetricsSensor } from './src/infrastructure/persistence/metricsSensor.js';
+export { default as stompTimeline } from './src/infrastructure/messaging/stomp/timeline.js';
+export { default as stompTimelineSegments } from './src/infrastructure/messaging/stomp/stompTimelineSegments.js';
+export { default as machineOwners } from './src/infrastructure/messaging/ownership/machineOwners.js';
+export { default as httpTimeline } from './src/infrastructure/messaging/ownership/httpTimeline.js';
+export { default as httpOperations } from './src/infrastructure/messaging/ownership/httpOperations.js';
+export { default as ownerTimeline } from './src/infrastructure/messaging/ownership/ownerTimeline.js';
+export { default as stateDataFromPool } from './src/infrastructure/persistence/stateDataFromPool.js';
+export { default as stateDataFromMemory } from './src/infrastructure/persistence/stateDataFromMemory.js';
+export { default as stateDataFake } from './src/infrastructure/persistence/stateDataFromMemory.js';
+export { default as supervisorSink, readDeploymentConfig } from './src/application/supervisorSink.js';
+export { default as runRetention } from './src/infrastructure/ingest/db/runRetention.js';
+export { createEdgeApi, default as edgeApi } from './src/infrastructure/http/edge/edgeApi.js';
+export { default as startTestEdgeApi } from './src/infrastructure/http/edge/startTestEdgeApi.js';
+export { default as stateHttpClient } from './src/infrastructure/http/edge/stateHttpClient.js';
+export { default as metricsSensor } from './src/infrastructure/http/edge/metricsSensor.js';
+export { default as userDecisions } from './src/infrastructure/messaging/stomp/userDecisions.js';
+export { default as stompAlerts } from './src/infrastructure/messaging/stomp/alerts/stompAlerts.js';
+export { default as stompAlertsInit } from './src/infrastructure/messaging/stomp/alerts/stompAlertsInit.js';
+export { default as mqttMetrics } from './src/infrastructure/ingest/mqtt/mqttMetrics.js';
+export { default as modbusMqtt } from './src/infrastructure/ingest/mqtt/modbusMqtt.js';
+export { default as mx210Tcp } from './src/infrastructure/ingest/modbus/mx210Tcp.js';
+export { default as silentStreams } from './src/infrastructure/ingest/modbus/silentStreams.js';
+export { default as activityTracking } from './src/infrastructure/ingest/activity/activityTracking.js';
+export { default as amqpMetricsIngest } from './src/infrastructure/ingest/telemetry/amqpMetricsIngest.js';
+export { default as amqpMqttRelay } from './src/infrastructure/ingest/telemetry/amqpMqttRelay.js';
+export { default as operationSyncIngest } from './src/infrastructure/sync/operationSyncIngest.js';
+export { default as ingestCheckpointMemory, ingestCheckpointPg } from './src/infrastructure/ingest/ingestCheckpoint.js';
+export { default as bindSilentStreams } from './src/application/bindSilentStreams.js';
+export { default as exportQuery } from './src/application/export/exportQuery.js';
+export { default as exportStream } from './src/application/export/exportStream.js';
+export { default as exportSink } from './src/application/export/exportSink.js';
+export { default as exportJob } from './src/application/export/exportJob.js';

package/package.json

@@ -1,33 +1,52 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "1.5.0",
-  "description": "SCADA domain objects for plant monitoring",
+  "version": "2.3.45",
+  "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",
     "url": "https://github.com/yarkivaev/scada"
   },
   "type": "module",
   "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./src/infrastructure/client/index.js",
+    "./stateDataFake": "./src/infrastructure/persistence/stateDataFromMemory.js",
+    "./startTestEdgeApi": "./src/infrastructure/http/edge/startTestEdgeApi.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "supervisor-sink": "./src/bin/supervisor-sink.js"
+  },
   "scripts": {
-    "test": "mocha --exit",
+    "test": "mocha --exit 'test/**/test*.js'",
+    "test:deep": "mocha --exit 'test/domain/**/test*.js' 'test/infrastructure/ingest/**/test*.js'",
     "coverage": "c8 --all --src src npm test",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint": "eslint . && node scripts/check-eo-names.mjs",
+    "lint:fix": "eslint . --fix",
+    "lint:eo": "node scripts/check-eo-names.mjs"
   },
-  "devDependencies": {
+  "dependencies": {
     "@clickhouse/client": "^1.0.0",
+    "@yarkivaev/simple-server": "^1.0.0",
+    "@yarkivaev/source-to-sink": "1.3.2",
+    "amqplib": "^0.10.9",
+    "pg": "^8.0.0",
+    "stompit": "^1.0.0"
+  },
+  "devDependencies": {
     "@eslint/js": "^9.39.2",
+    "better-sqlite3": "^11.0.0",
     "c8": "^10.1.3",
     "cassandra-driver": "^4.7.2",
     "eslint": "^9.39.2",
     "globals": "^17.0.0",
-    "mocha": "^10.2.0",
-    "better-sqlite3": "^11.0.0",
-    "pg": "^8.0.0",
+    "mocha": "^10.8.2",
     "testcontainers": "^10.13.0"
   },
   "files": [
     "index.js",
+    "db/",
     "src/"
   ]
 }

package/src/application/bindSilentStreams.js

@@ -0,0 +1,20 @@
+/**
+ * Binds silent Modbus streams to a metrics sink and returns an onSeen callback.
+ *
+ * @example
+ *   const onSeen = bindSilentStreams(streams, clickhouseSink);
+ *   amqpMetricsIngest(url, queue, sink, { onSeen });
+ *
+ * @param {object|undefined} streams - silentStreams gate or omitted
+ * @param {object} sink - metrics sink with write(records)
+ * @returns {Function|undefined} onSeen(name) or undefined
+ */
+export default function bindSilentStreams(streams, sink) {
+    if (!streams) {
+        return undefined;
+    }
+    streams.bind(sink);
+    return (name) => {
+        streams.seen(name);
+    };
+}

package/src/application/edgeOperatorCatalog.js

@@ -0,0 +1,45 @@
+import operators from '../infrastructure/operators/operators.js';
+import centralOperators from '../infrastructure/operators/centralOperators.js';
+import operatorsSync from '../infrastructure/operators/operatorsSync.js';
+import edgeOperators from '../infrastructure/operators/edgeOperators.js';
+import stateHttpClient from '../infrastructure/http/edge/stateHttpClient.js';
+import operatorRoute from '../infrastructure/http/plant/routes/operatorRoute.js';
+
+const DEFAULT_SYNC_INTERVAL_SEC = 30;
+
+function syncIntervalMs(env) {
+    const sec = parseInt(env.OPERATORS_SYNC_INTERVAL_SEC || String(DEFAULT_SYNC_INTERVAL_SEC), 10);
+    if (!Number.isFinite(sec) || sec <= 0) {
+        return DEFAULT_SYNC_INTERVAL_SEC * 1000;
+    }
+    return sec * 1000;
+}
+
+/**
+ * Edge operator catalog: in-memory cache, periodic central sync, plant routes.
+ * POST create proxies to central and refreshes cache; registration flag is read from cache.
+ * Without CENTRAL_PLANT_URL create fails fast; first boot yields an empty list until sync.
+ *
+ * @param {string} basePath - plant API base path
+ * @param {object} env - process environment
+ * @returns {object} routes array and optional sync job
+ *
+ * @example
+ *   edgeOperatorCatalog('/api/v1', process.env);
+ */
+export default function edgeOperatorCatalog(basePath, env) {
+    const cache = operators();
+    const centralUrl = env.CENTRAL_PLANT_URL;
+    if (!centralUrl) {
+        const provider = edgeOperators(cache, undefined);
+        return { routes: operatorRoute(basePath, provider), sync: undefined, provider };
+    }
+    const client = stateHttpClient({
+        baseUrl: centralUrl,
+        token: env.CENTRAL_PLANT_TOKEN
+    });
+    const source = centralOperators(client, basePath);
+    const provider = edgeOperators(cache, source);
+    const sync = operatorsSync(source, cache, { intervalMs: syncIntervalMs(env) });
+    return { routes: operatorRoute(basePath, provider), sync, provider };
+}