fix: prevent infinite recursion in validateSchema for non-object schema entries

migrateConfig stamps a version string into config schemas. validateSchema
then iterates the string's character indices, causing infinite recursion.
Skip the 'version' key and guard against any non-object schema entries.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

datasets/assetData/assetData.json

@@ -110,6 +110,7 @@
                 { 
                   "id": "hidrostal-pump-001",
                   "name": "hidrostal-H05K-S03R",
+
                   "units": ["l/s"]
                 },
                 { 

datasets/assetData/curves/index.js

@@ -26,7 +26,11 @@ class AssetLoader {
    */
   loadAsset(datasetType, assetId) {
     //const cacheKey = `${datasetType}/${assetId}`;
-    const cacheKey = `${assetId}`;
+    const normalizedAssetId = String(assetId || '').trim();
+    if (!normalizedAssetId) {
+      return null;
+    }
+    const cacheKey = normalizedAssetId.toLowerCase();
 
     
     // Check cache first
@@ -35,11 +39,11 @@ class AssetLoader {
     }
 
     try {
-      const filePath = path.join(this.baseDir, `${assetId}.json`);
+      const filePath = this._resolveAssetPath(normalizedAssetId);
 
       // Check if file exists
-      if (!fs.existsSync(filePath)) {
+      if (!filePath || !fs.existsSync(filePath)) {
-        console.warn(`Asset not found: ${filePath}`);
+        console.warn(`Asset not found for id '${normalizedAssetId}' in ${this.baseDir}`);
         return null;
       }
 
@@ -61,6 +65,21 @@ class AssetLoader {
     }
   }
 
+  _resolveAssetPath(assetId) {
+    const exactPath = path.join(this.baseDir, `${assetId}.json`);
+    if (fs.existsSync(exactPath)) {
+      return exactPath;
+    }
+
+    const target = `${assetId}.json`.toLowerCase();
+    const files = fs.readdirSync(this.baseDir);
+    const matched = files.find((file) => file.toLowerCase() === target);
+    if (!matched) {
+      return null;
+    }
+    return path.join(this.baseDir, matched);
+  }
+
   /**
    * Get all available assets in a dataset
    * @param {string} datasetType - The dataset folder name

datasets/assetData/index.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+
+class AssetCategoryManager {
+  constructor(relPath = '.') {
+    this.assetDir = path.resolve(__dirname, relPath);
+    this.cache = new Map();
+  }
+
+  getCategory(softwareType) {
+    if (!softwareType) {
+      throw new Error('softwareType is required');
+    }
+
+    if (this.cache.has(softwareType)) {
+      return this.cache.get(softwareType);
+    }
+
+    const filePath = path.resolve(this.assetDir, `${softwareType}.json`);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Asset data '${softwareType}' not found in ${this.assetDir}`);
+    }
+
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    this.cache.set(softwareType, parsed);
+    return parsed;
+  }
+
+  hasCategory(softwareType) {
+    const filePath = path.resolve(this.assetDir, `${softwareType}.json`);
+    return fs.existsSync(filePath);
+  }
+
+  listCategories({ withMeta = false } = {}) {
+    const files = fs.readdirSync(this.assetDir, { withFileTypes: true });
+
+    return files
+      .filter(
+        (entry) =>
+          entry.isFile() &&
+          entry.name.endsWith('.json') &&
+          entry.name !== 'index.json' &&
+          entry.name !== 'assetData.json'
+      )
+      .map((entry) => path.basename(entry.name, '.json'))
+      .map((name) => {
+        if (!withMeta) {
+          return name;
+        }
+
+        const data = this.getCategory(name);
+        return {
+          softwareType: data.softwareType || name,
+          label: data.label || name,
+          file: `${name}.json`
+        };
+      });
+  }
+
+  searchCategories(query) {
+    const term = (query || '').trim().toLowerCase();
+    if (!term) {
+      return [];
+    }
+
+    return this.listCategories({ withMeta: true }).filter(
+      ({ softwareType, label }) =>
+        softwareType.toLowerCase().includes(term) ||
+        label.toLowerCase().includes(term)
+    );
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+const assetCategoryManager = new AssetCategoryManager();
+
+module.exports = {
+  AssetCategoryManager,
+  assetCategoryManager,
+  getCategory: (softwareType) => assetCategoryManager.getCategory(softwareType),
+  listCategories: (options) => assetCategoryManager.listCategories(options),
+  searchCategories: (query) => assetCategoryManager.searchCategories(query),
+  hasCategory: (softwareType) => assetCategoryManager.hasCategory(softwareType),
+  clearCache: () => assetCategoryManager.clearCache()
+};

datasets/assetData/machine.json

@@ -0,0 +1,21 @@
+{
+  "id": "machine",
+  "label": "machine",
+  "softwareType": "machine",
+  "suppliers": [
+    {
+      "id": "hidrostal",
+      "name": "Hidrostal",
+      "types": [
+        {
+          "id": "pump-centrifugal",
+          "name": "Centrifugal",
+          "models": [
+            { "id": "hidrostal-H05K-S03R", "name": "hidrostal-H05K-S03R", "units": ["l/s","m3/h"] },
+            { "id": "hidrostal-C5-D03R-SHN1", "name": "hidrostal-C5-D03R-SHN1", "units": ["l/s"] }
+          ]
+        }
+      ]
+    }
+  ]
+}

datasets/assetData/measurement.json

@@ -0,0 +1,115 @@
+{
+  "id": "sensor",
+  "label": "Sensor",
+  "softwareType": "measurement",
+  "suppliers": [
+    {
+      "id": "vega",
+      "name": "Vega",
+      "types": [
+        {
+          "id": "temperature",
+          "name": "Temperature",
+          "models": [
+            { "id": "vega-temp-10", "name": "VegaTemp 10", "units": ["degC", "degF"], "product_model_id": 1001, "product_model_uuid": "vega-temp-10" },
+            { "id": "vega-temp-20", "name": "VegaTemp 20", "units": ["degC", "degF"], "product_model_id": 1002, "product_model_uuid": "vega-temp-20" }
+          ]
+        },
+        {
+          "id": "pressure",
+          "name": "Pressure",
+          "models": [
+            { "id": "vega-pressure-10", "name": "VegaPressure 10", "units": ["bar", "mbar", "psi"], "product_model_id": 1003, "product_model_uuid": "vega-pressure-10" },
+            { "id": "vega-pressure-20", "name": "VegaPressure 20", "units": ["bar", "mbar", "psi"], "product_model_id": 1004, "product_model_uuid": "vega-pressure-20" }
+          ]
+        },
+        {
+          "id": "flow",
+          "name": "Flow",
+          "models": [
+            { "id": "vega-flow-10", "name": "VegaFlow 10", "units": ["m3/h", "gpm", "l/min"], "product_model_id": 1005, "product_model_uuid": "vega-flow-10" },
+            { "id": "vega-flow-20", "name": "VegaFlow 20", "units": ["m3/h", "gpm", "l/min"], "product_model_id": 1006, "product_model_uuid": "vega-flow-20" }
+          ]
+        },
+        {
+          "id": "level",
+          "name": "Level",
+          "models": [
+            { "id": "vega-level-10", "name": "VegaLevel 10", "units": ["m", "ft", "mm"], "product_model_id": 1007, "product_model_uuid": "vega-level-10" },
+            { "id": "vega-level-20", "name": "VegaLevel 20", "units": ["m", "ft", "mm"], "product_model_id": 1008, "product_model_uuid": "vega-level-20" }
+          ]
+        },
+        {
+          "id": "oxygen",
+          "name": "Quantity (oxygen)",
+          "models": [
+            { "id": "vega-oxy-10", "name": "VegaOxySense 10", "units": ["g/m3", "mol/m3"], "product_model_id": 1009, "product_model_uuid": "vega-oxy-10" }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "Endress+Hauser",
+      "name": "Endress+Hauser",
+      "types": [
+        {
+          "id": "flow",
+          "name": "Flow",
+          "models": [
+            { "id": "Promag-W400", "name": "Promag W400", "units": ["m3/h", "l/s", "gpm"] },
+            { "id": "Promag-W300", "name": "Promag W300", "units": ["m3/h", "l/s", "gpm"] }
+          ]
+        },
+        {
+          "id": "pressure",
+          "name": "Pressure",
+          "models": [
+            { "id": "Cerabar-PMC51", "name": "Cerabar PMC51", "units": ["mbar", "bar", "psi"] },
+            { "id": "Cerabar-PMC71", "name": "Cerabar PMC71", "units": ["mbar", "bar", "psi"] }
+          ]
+        },
+        {
+          "id": "level",
+          "name": "Level",
+          "models": [
+            { "id": "Levelflex-FMP50", "name": "Levelflex FMP50", "units": ["m", "mm", "ft"] }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "Hach",
+      "name": "Hach",
+      "types": [
+        {
+          "id": "dissolved-oxygen",
+          "name": "Dissolved Oxygen",
+          "models": [
+            { "id": "LDO2", "name": "LDO2", "units": ["mg/L", "ppm"] }
+          ]
+        },
+        {
+          "id": "ammonium",
+          "name": "Ammonium",
+          "models": [
+            { "id": "Amtax-sc", "name": "Amtax sc", "units": ["mg/L"] }
+          ]
+        },
+        {
+          "id": "nitrate",
+          "name": "Nitrate",
+          "models": [
+            { "id": "Nitratax-sc", "name": "Nitratax sc", "units": ["mg/L"] }
+          ]
+        },
+        {
+          "id": "tss",
+          "name": "TSS (Suspended Solids)",
+          "models": [
+            { "id": "Solitax-sc", "name": "Solitax sc", "units": ["mg/L", "g/L"] }
+          ]
+        }
+      ]
+    }
+  ]
+}

datasets/assetData/modelData/ECDV.json

@@ -0,0 +1,16 @@
+{
+    "1.204": {
+        "125": {
+            "x": [0,10,20,30,40,50,60,70,80,90,100],
+            "y": [0,18,50,95,150,216,337,564,882,1398,1870]
+        },
+        "150": {
+            "x": [0,10,20,30,40,50,60,70,80,90,100],
+            "y": [0,25,73,138,217,314,490,818,1281,2029,2715]
+        },
+        "400": {
+            "x": [0,10,20,30,40,50,60,70,80,90,100],
+            "y": [0,155,443,839,1322,1911,2982,4980,7795,12349,16524]
+        }
+    }
+}

datasets/assetData/modelData/hidrostal-C5-D03R-SHN1.json

@@ -0,0 +1,838 @@
+{
+    "np":  {
+               "400":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     0.5953611390998625,
+                                     1.6935085477165994,
+                                     3.801139124304824,
+                                     7.367829525776738,
+                                     12.081735423116616
+                                 ]
+                       },
+               "500":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     0.5522732775894703,
+                                     1.8497068236812997,
+                                     3.801139124304824,
+                                     7.367829525776738,
+                                     12.081735423116616
+                                 ]
+                       },
+               "600":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     0.5522732775894703,
+                                     1.7497197821018213,
+                                     3.801139124304824,
+                                     7.367829525776738,
+                                     12.081735423116616
+                                 ]
+                       },
+               "700":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     0.5522732775894703,
+                                     1.788320579602724,
+                                     3.9982668237045984,
+                                     7.367829525776738,
+                                     12.081735423116616
+                                 ]
+                       },
+               "800":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     0.5522732775894703,
+                                     1.7824519364844427,
+                                     3.9885060367793064,
+                                     7.367829525776738,
+                                     12.081735423116616
+                                 ]
+                       },
+               "900":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     0.5522732775894703,
+                                     1.6934482683506376,
+                                     3.9879559558537054,
+                                     7.367829525776738,
+                                     12.081735423116616
+                                 ]
+                       },
+               "1000":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6954385513069579,
+                                      4.0743508382926795,
+                                      7.422392692482345,
+                                      12.081735423116616
+                                  ]
+                        },
+               "1100":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      4.160745720731654,
+                                      7.596626714476177,
+                                      12.081735423116616
+                                  ]
+                        },
+               "1200":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      4.302551231007837,
+                                      7.637247864947884,
+                                      12.081735423116616
+                                  ]
+                        },
+               "1300":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      4.37557913990704,
+                                      7.773442147000839,
+                                      12.081735423116616
+                                  ]
+                        },
+               "1400":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      4.334434337766139,
+                                      7.940911352646818,
+                                      12.081735423116616
+                                  ]
+                        },
+               "1500":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      4.2327206586037995,
+                                      8.005238800611183,
+                                      12.254836577088351
+                                  ]
+                        },
+               "1600":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      4.195405588464695,
+                                      7.991827302945298,
+                                      12.423663269044452
+                                  ]
+                        },
+               "1700":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      14.255458319309813,
+                                      8.096768422220196,
+                                      12.584668380908582
+                                  ]
+                        },
+               "1800":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      31.54620347513727,
+                                      12.637080520201405
+                                  ]
+                        },
+               "1900":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      8.148423429611098,
+                                      12.74916725120127
+                                  ]
+                        },
+               "2000":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      8.146439484120116,
+                                      12.905178964345618
+                                  ]
+                        },
+               "2100":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      8.149576025637684,
+                                      13.006940917309247
+                                  ]
+                        },
+               "2200":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      8.126246430368305,
+                                      13.107503837410825
+                                  ]
+                        },
+               "2300":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      8.104379361635342,
+                                      13.223235973280122
+                                  ]
+                        },
+               "2400":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      8.135190080423746,
+                                      13.36128347785936
+                                  ]
+                        },
+               "2500":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      7.981219508598527,
+                                      13.473697427231842
+                                  ]
+                        },
+               "2600":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      7.863899404441271,
+                                      13.50303289156837
+                                  ]
+                        },
+               "2700":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      7.658860522528131,
+                                      13.485230880073107
+                                  ]
+                        },
+               "2800":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      7.44407948309266,
+                                      13.446135725634615
+                                  ]
+                        },
+               "2900":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      0.5522732775894703,
+                                      1.6920721090317592,
+                                      3.8742719210788685,
+                                      7.44407948309266,
+                                      13.413693596332184
+                                  ]
+                        }
+           },
+    "nq":  {
+               "400":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     7.6803204433986965,
+                                     25.506609120436963,
+                                     35.4,
+                                     44.4,
+                                     52.5
+                                 ]
+                       },
+               "500":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     6.4,
+                                     22.622804921188227,
+                                     35.4,
+                                     44.4,
+                                     52.5
+                                 ]
+                       },
+               "600":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     6.4,
+                                     19.966301579194372,
+                                     35.4,
+                                     44.4,
+                                     52.5
+                                 ]
+                       },
+               "700":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     6.4,
+                                     17.430763940163832,
+                                     33.79508340848005,
+                                     44.4,
+                                     52.5
+                                 ]
+                       },
+               "800":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     6.4,
+                                     14.752921911234477,
+                                     31.71885034449889,
+                                     44.4,
+                                     52.5
+                                 ]
+                       },
+               "900":  {
+                           "x":  [
+                                     0,
+                                     25.510204081632654,
+                                     51.020408163265309,
+                                     76.530612244897952,
+                                     100
+                                 ],
+                           "y":  [
+                                     6.4,
+                                     11.854693031181021,
+                                     29.923046639543475,
+                                     44.4,
+                                     52.5
+                                 ]
+                       },
+               "1000":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.549433913822687,
+                                      26.734189128096668,
+                                      43.96760750800311,
+                                      52.5
+                                  ]
+                        },
+               "1100":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      26.26933164936586,
+                                      42.23523193272671,
+                                      52.5
+                                  ]
+                        },
+               "1200":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      24.443114637042832,
+                                      40.57167959798151,
+                                      52.5
+                                  ]
+                        },
+               "1300":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      22.41596168949836,
+                                      39.04561852479495,
+                                      52.5
+                                  ]
+                        },
+               "1400":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      20.276864821170303,
+                                      37.557663261443224,
+                                      52.252852231224054
+                                  ]
+                        },
+               "1500":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      18.252772588147742,
+                                      35.9974418607538,
+                                      50.68604059588987
+                                  ]
+                        },
+               "1600":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      16.31441663648616,
+                                      34.51170378091407,
+                                      49.20153034100798
+                                  ]
+                        },
+               "1700":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      14.255458319309813,
+                                      33.043410795291045,
+                                      47.820213744181245
+                                  ]
+                        },
+               "1800":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      31.54620347513727,
+                                      46.51705619739449
+                                  ]
+                        },
+               "1900":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      29.986013742375484,
+                                      45.29506741639918
+                                  ]
+                        },
+               "2000":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      28.432646044605782,
+                                      44.107822395271945
+                                  ]
+                        },
+               "2100":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      26.892634464336055,
+                                      42.758175515158776
+                                  ]
+                        },
+               "2200":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      25.270679127870263,
+                                      41.467063889795895
+                                  ]
+                        },
+               "2300":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      23.531132157718837,
+                                      40.293041104955826
+                                  ]
+                        },
+               "2400":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      21.815645106750623,
+                                      39.03109248860755
+                                  ]
+                        },
+               "2500":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      20.34997949463564,
+                                      37.71320701654063
+                                  ]
+                        },
+               "2600":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      18.81710568651804,
+                                      36.35563657017404
+                                  ]
+                        },
+               "2700":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      17.259072160217805,
+                                      35.02979557646653
+                                  ]
+                        },
+               "2800":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      16,
+                                      33.74372254979665
+                                  ]
+                        },
+               "2900":  {
+                            "x":  [
+                                      0,
+                                      25.510204081632654,
+                                      51.020408163265309,
+                                      76.530612244897952,
+                                      100
+                                  ],
+                            "y":  [
+                                      6.4,
+                                      9.500000000000002,
+                                      12.7,
+                                      16,
+                                      32.54934541379723
+                                  ]
+                        }
+           }
+}

datasets/assetData/modelData/index.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+
+class AssetLoader {
+  constructor() {
+    this.relPath = './'
+    this.baseDir = path.resolve(__dirname, this.relPath);
+    this.cache = new Map(); // Cache loaded JSON files for better performance
+  }
+
+  /**
+   * Load a specific curve by type
+   * @param {string} curveType - The curve identifier (e.g., 'hidrostal-H05K-S03R')
+   * @returns {Object|null} The curve data object or null if not found
+   */
+  loadModel(modelType) {
+    return this.loadAsset('models', modelType);
+  }
+
+  /**
+   * Load any asset from a specific dataset folder
+   * @param {string} datasetType - The dataset folder name (e.g., 'curves', 'assetData')
+   * @param {string} assetId - The specific asset identifier
+   * @returns {Object|null} The asset data object or null if not found
+   */
+  loadAsset(datasetType, assetId) {
+    //const cacheKey = `${datasetType}/${assetId}`;
+    const cacheKey = `${assetId}`;
+
+    
+    // Check cache first
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    try {
+      const filePath = path.join(this.baseDir, `${assetId}.json`);
+
+      // Check if file exists
+      if (!fs.existsSync(filePath)) {
+        console.warn(`Asset not found: ${filePath}`);
+        return null;
+      }
+
+      // Load and parse JSON
+      const rawData = fs.readFileSync(filePath, 'utf8');
+      const assetData = JSON.parse(rawData);
+      
+      // Cache the result
+      this.cache.set(cacheKey, assetData);
+      
+      return assetData;
+    } catch (error) {
+      console.error(`Error loading asset ${cacheKey}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get all available assets in a dataset
+   * @param {string} datasetType - The dataset folder name
+   * @returns {string[]} Array of available asset IDs
+   */
+  getAvailableAssets(datasetType) {
+    try {
+      const datasetPath = path.join(this.baseDir, datasetType);
+      
+      if (!fs.existsSync(datasetPath)) {
+        return [];
+      }
+
+      return fs.readdirSync(datasetPath)
+        .filter(file => file.endsWith('.json'))
+        .map(file => file.replace('.json', ''));
+    } catch (error) {
+      console.error(`Error reading dataset ${datasetType}:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Clear the cache (useful for development/testing)
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+// Create and export a singleton instance
+const assetLoader = new AssetLoader();
+
+module.exports = {
+  AssetLoader,
+  assetLoader,
+  // Convenience methods for backward compatibility
+  loadModel: (modelType) => assetLoader.loadModel(modelType),
+  loadAsset: (datasetType, assetId) => assetLoader.loadAsset(datasetType, assetId),
+  getAvailableAssets: (datasetType) => assetLoader.getAvailableAssets(datasetType)
+};
+
+/*
+// Example usage in your scripts
+const loader = new AssetLoader();
+
+// Load a specific curve
+const curve = loader.loadModel('hidrostal-H05K-S03R');
+if (curve) {
+  console.log('Model loaded:', curve);
+} else {
+  console.log('Model not found');
+}
+/*
+// Load any asset from any dataset
+const someAsset = loadAsset('assetData', 'some-asset-id');
+
+// Get list of available models
+const availableCurves = getAvailableAssets('curves');
+console.log('Available curves:', availableCurves);
+
+// Using the class directly for more control
+const { AssetLoader } = require('./index.js');
+const customLoader = new AssetLoader();
+const data = customLoader.loadCurve('hidrostal-H05K-S03R');
+*/

datasets/assetData/monsterSamples.json

@@ -0,0 +1,716 @@
+{
+  "samples": [
+    {
+      "code": "106100",
+      "description": "Baarle Nassau influent totaal"
+    },
+    {
+      "code": "106100C",
+      "description": "RWZI Baarle Nassau influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "106120",
+      "description": "Baarle Nassau inhoud beluchtingsruimte"
+    },
+    {
+      "code": "106150",
+      "description": "Baarle Nassau effluent"
+    },
+    {
+      "code": "106209",
+      "description": "Baarle Nassau slibafvoer voorindikker"
+    },
+    {
+      "code": "106400",
+      "description": "Baarle Nassau slibafvoer slibbufferput"
+    },
+    {
+      "code": "109100",
+      "description": "RWZI Chaam influent totaal"
+    },
+    {
+      "code": "109100C",
+      "description": "RWZI Chaam influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "109120",
+      "description": "RWZI Chaam inhoud beluchtingstank"
+    },
+    {
+      "code": "109150",
+      "description": "RWZI Chaam effluent"
+    },
+    {
+      "code": "109153",
+      "description": "RWZI Chaam afloop cascade"
+    },
+    {
+      "code": "109400",
+      "description": "Chaam slib afvoer slibbufferput"
+    },
+    {
+      "code": "112004",
+      "description": "RWZI Dongemond diverse onderzoeken"
+    },
+    {
+      "code": "112062",
+      "description": "RWZI Dongemond RUWE(geleverde) PE zeefbandpers"
+    },
+    {
+      "code": "112100",
+      "description": "RWZI Dongemond influent totaal"
+    },
+    {
+      "code": "112100C",
+      "description": "RWZI Dongemond influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "112110",
+      "description": "RWZI Dongemond afloop voorbezinktank"
+    },
+    {
+      "code": "112121",
+      "description": "RWZI Dongemond inhoud beluchtingstank 1"
+    },
+    {
+      "code": "112122",
+      "description": "RWZI Dongemond inhoud beluchtingstank 2"
+    },
+    {
+      "code": "112123",
+      "description": "RWZI Dongemond inhoud beluchtingstank 3"
+    },
+    {
+      "code": "112124",
+      "description": "RWZI Dongemond inhoud beluchtingstank 4"
+    },
+    {
+      "code": "112150",
+      "description": "RWZI Dongemond effluent"
+    },
+    {
+      "code": "112203",
+      "description": "RWZI Dongemond inhoud container zandvanger"
+    },
+    {
+      "code": "112206",
+      "description": "RWZI Dongemond ingedikt primair slib"
+    },
+    {
+      "code": "112211",
+      "description": "RWZI Dongemond ingedikt secundair slib"
+    },
+    {
+      "code": "112231",
+      "description": "RWZI Dongemond afvoer bandindikker"
+    },
+    {
+      "code": "112244",
+      "description": "RWZI Dongemond inhoud gistingstank"
+    },
+    {
+      "code": "112287",
+      "description": "RWZI Dongemond waterafvoer zeefbandpers totaal"
+    },
+    {
+      "code": "112425",
+      "description": "RWZI Dongemond afvoer slibkoek silo"
+    },
+    {
+      "code": "112569",
+      "description": "RWZI Dongemond Al2(SO4)3"
+    },
+    {
+      "code": "115100",
+      "description": "RWZI Kaatsheuvel influent totaal"
+    },
+    {
+      "code": "115100C",
+      "description": "RWZI Kaatsheuvel influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "115120",
+      "description": "RWZI Kaatsheuvel inhoud beluchtingsruimte"
+    },
+    {
+      "code": "115150",
+      "description": "RWZI Kaatsheuvel effluent"
+    },
+    {
+      "code": "115155",
+      "description": "RWZI Kaatsheuvel toevoer zandfilter"
+    },
+    {
+      "code": "115156",
+      "description": "RWZI Kaatsheuvel afvoer zandfilter"
+    },
+    {
+      "code": "115157",
+      "description": "RWZI Kaatsheuvel afvoer waswater zandfilter"
+    },
+    {
+      "code": "115166",
+      "description": "RWZI Kaatsheuvel Voor UV filter"
+    },
+    {
+      "code": "115167",
+      "description": "RWZI Kaatsheuvel Na UV filter"
+    },
+    {
+      "code": "115203",
+      "description": "RWZI Kaatsheuvel inhoud container zandvanger"
+    },
+    {
+      "code": "115209",
+      "description": "RWZI Kaatsheuvel slibafvoer voorindikker"
+    },
+    {
+      "code": "115400",
+      "description": "RWZI Kaatsheuvel slibafvoer slibbufferput"
+    },
+    {
+      "code": "116100",
+      "description": "RWZI Lage-Zwaluwe influent totaal"
+    },
+    {
+      "code": "116100C",
+      "description": "RWZI Lage-Zwaluwe influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "116120",
+      "description": "RWZI Lage-Zwaluwe inhoud beluchtingsruimte"
+    },
+    {
+      "code": "116150",
+      "description": "RWZI Lage-Zwaluwe effluent"
+    },
+    {
+      "code": "116400",
+      "description": "RWZI Lage-Zwaluwe slibafvoer slibbufferput"
+    },
+    {
+      "code": "121100",
+      "description": "RWZI Riel influent totaal"
+    },
+    {
+      "code": "121100C",
+      "description": "RWZI Riel influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "121120",
+      "description": "RWZI Riel inhoud beluchtingruimte"
+    },
+    {
+      "code": "121150",
+      "description": "RWZI Riel effluent"
+    },
+    {
+      "code": "121203",
+      "description": "RWZI Riel inhoud container zandvanger"
+    },
+    {
+      "code": "121400",
+      "description": "RWZI Riel slibafvoer slibbufferput"
+    },
+    {
+      "code": "124089",
+      "description": "RWZI Rijen aanvoer kolkenzuigermateriaal"
+    },
+    {
+      "code": "124100",
+      "description": "RWZI Rijen influent totaal"
+    },
+    {
+      "code": "124100C",
+      "description": "RWZI Rijen influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "124110",
+      "description": "RWZI Rijen afloop voorbezinktank"
+    },
+    {
+      "code": "124120",
+      "description": "RWZI Rijen inhoud beluchtingsruimte"
+    },
+    {
+      "code": "124150",
+      "description": "RWZI Rijen effluent"
+    },
+    {
+      "code": "124151",
+      "description": "RWZI Rijen effluent voor legionella"
+    },
+    {
+      "code": "124203",
+      "description": "RWZI Rijen inhoud container zandvanger"
+    },
+    {
+      "code": "124206",
+      "description": "RWZI Rijen ingedikt primair slib"
+    },
+    {
+      "code": "124211",
+      "description": "RWZI Rijen ingedikt secundair slib"
+    },
+    {
+      "code": "124350",
+      "description": "RWZI Rijen Toevoer bandindikker"
+    },
+    {
+      "code": "124351",
+      "description": "RWZI Rijen Afvoer bandindikker"
+    },
+    {
+      "code": "124352",
+      "description": "RWZI Rijen waterafvoer bandindikker"
+    },
+    {
+      "code": "124400",
+      "description": "RWZI Rijen slibafvoer"
+    },
+    {
+      "code": "124540",
+      "description": "RWZI Rijen RUWE(geleverde) PE bandindikker"
+    },
+    {
+      "code": "127100",
+      "description": "RWZI Waalwijk influent totaal"
+    },
+    {
+      "code": "127100C",
+      "description": "RWZI Waalwijk influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "127110",
+      "description": "RWZI Waalwijk afloop VBT"
+    },
+    {
+      "code": "127121",
+      "description": "RWZI Waalwijk inhoud beluchtingsruimte 1"
+    },
+    {
+      "code": "127122",
+      "description": "RWZI Waalwijk inhoud beluchtingsruimte 2"
+    },
+    {
+      "code": "127150",
+      "description": "RWZI Waalwijk effluent"
+    },
+    {
+      "code": "127203",
+      "description": "RWZI Waalwijk inhoud container zandvanger"
+    },
+    {
+      "code": "127206",
+      "description": "RWZI Waalwijk ingedikt primair slib"
+    },
+    {
+      "code": "127211",
+      "description": "RWZI Waalwijk ingedikt secundair slib"
+    },
+    {
+      "code": "127244",
+      "description": "RWZI Waalwijk inhoud gistingstank"
+    },
+    {
+      "code": "127450",
+      "description": "RWZI Waalwijk slibafvoer indiklagune"
+    },
+    {
+      "code": "131100",
+      "description": "RWZI Waspik industrie & dorp influent totaal"
+    },
+    {
+      "code": "131100C",
+      "description": "RWZI Waspik influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "131120",
+      "description": "RWZI Waspik inhoud beluchtingsruimte"
+    },
+    {
+      "code": "131150",
+      "description": "RWZI Waspik effluent"
+    },
+    {
+      "code": "131400",
+      "description": "RWZI Waspik slibafvoer slibbufferput"
+    },
+    {
+      "code": "131581",
+      "description": "Waspik Levering Aluminiumchloride 9%"
+    },
+    {
+      "code": "142062",
+      "description": "RWZI Nieuwveer RUWE(geleverde) PE zeefbandpers"
+    },
+    {
+      "code": "142078",
+      "description": "RWZI Nieuwveer Cloetta suikerwater"
+    },
+    {
+      "code": "142089",
+      "description": "RWZI Nieuwveer aanvoer kolkenzuigermateriaal"
+    },
+    {
+      "code": "142105",
+      "description": "RWZI Nieuwveer afloop influentvijzels"
+    },
+    {
+      "code": "142105C",
+      "description": "RWZI Nieuwveer afloop influentvijzels - Monstername influent COVID-19"
+    },
+    {
+      "code": "142110",
+      "description": "RWZI Nieuwveer afloop TBT"
+    },
+    {
+      "code": "142121",
+      "description": "RWZI Nieuwveer inhoud beluchtingsruimte 1"
+    },
+    {
+      "code": "142122",
+      "description": "RWZI Nieuwveer inhoud beluchtingsruimte 2"
+    },
+    {
+      "code": "142123",
+      "description": "RWZI Nieuwveer inhoud beluchtingsruimte 3"
+    },
+    {
+      "code": "142124",
+      "description": "RWZI Nieuwveer inhoud beluchtingsruimte 4"
+    },
+    {
+      "code": "142150",
+      "description": "RWZI Nieuwveer effluent"
+    },
+    {
+      "code": "142174",
+      "description": "RWZI Nieuwveer secundair spuislib"
+    },
+    {
+      "code": "142203",
+      "description": "RWZI Nieuwveer inhoud container zandvanger"
+    },
+    {
+      "code": "142301",
+      "description": "RWZI Nieuwveer slibafvoer Bandindikker 1"
+    },
+    {
+      "code": "142302",
+      "description": "RWZI Nieuwveer slibafvoer Bandindikker 2"
+    },
+    {
+      "code": "142303",
+      "description": "RWZI Nieuwveer slibafvoer Bandindikker 3"
+    },
+    {
+      "code": "142310",
+      "description": "RWZI Nieuwveer monitor slibafvoer ESOMT"
+    },
+    {
+      "code": "142311",
+      "description": "RWZI Nieuwveer afloop Gisting"
+    },
+    {
+      "code": "142325",
+      "description": "RWZI Nieuwveer Influent DEMON"
+    },
+    {
+      "code": "142326",
+      "description": "RWZI Nieuwveer Inhoud DEMON"
+    },
+    {
+      "code": "142327",
+      "description": "RWZI Nieuwveer Effluent DEMON"
+    },
+    {
+      "code": "142332",
+      "description": "RWZI Nieuwveer retourwater slibverwerking"
+    },
+    {
+      "code": "142425",
+      "description": "RWZI Nieuwveer afvoer slibkoek silo"
+    },
+    {
+      "code": "142571",
+      "description": "RWZI Nieuwveer ijzersulfaat levering totaal"
+    },
+    {
+      "code": "144007",
+      "description": "Bouvigne Toevoer helofytenfilter"
+    },
+    {
+      "code": "144008",
+      "description": "Bouvigne Afvoer helofytenfilter"
+    },
+    {
+      "code": "144061",
+      "description": "144061 (toevoer verticale helofytenfilters)"
+    },
+    {
+      "code": "144062",
+      "description": "144062 (afvoer verticale helofytenfilters)"
+    },
+    {
+      "code": "144063",
+      "description": "144063 (afvoer horizontale helofytenfilters)"
+    },
+    {
+      "code": "144064",
+      "description": "144064 (kwaliteit voorberging)"
+    },
+    {
+      "code": "160061",
+      "description": "RWZI Bath RUWE(geleverde) PE bandindikker"
+    },
+    {
+      "code": "160062",
+      "description": "RWZI Bath RUWE(geleverde) PE zeefbandpers"
+    },
+    {
+      "code": "160100",
+      "description": "Bath influent totaal"
+    },
+    {
+      "code": "160100C",
+      "description": "RWZI Bath influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "160110",
+      "description": "Bath Afloop Voorbezinktank West (1 en 3)"
+    },
+    {
+      "code": "160112",
+      "description": "Bath Afloop Voorbezinktank Oost (2 en 4)"
+    },
+    {
+      "code": "160121",
+      "description": "Bath inhoud beluchtingsruimte 1, sectie 4"
+    },
+    {
+      "code": "160122",
+      "description": "Bath inhoud beluchtingsruimte 2, sectie 4"
+    },
+    {
+      "code": "160123",
+      "description": "Bath inhoud beluchtingsruimte 3, sectie 4"
+    },
+    {
+      "code": "160124",
+      "description": "Bath inhoud beluchtingsruimte 4, sectie 4"
+    },
+    {
+      "code": "160125",
+      "description": "Bath inhoud beluchtingsruimte 5, sectie 4"
+    },
+    {
+      "code": "160126",
+      "description": "Bath inhoud beluchtingsruimte 6, sectie 4"
+    },
+    {
+      "code": "160127",
+      "description": "Bath inhoud beluchtingsruimte 7, sectie 4"
+    },
+    {
+      "code": "160128",
+      "description": "Bath inhoud beluchtingsruimte 8, sectie 4"
+    },
+    {
+      "code": "160129",
+      "description": "Bath inhoud beluchtingsruimte 9, sectie 4"
+    },
+    {
+      "code": "160130",
+      "description": "Bath inhoud beluchtingsruimte 10, sectie 4"
+    },
+    {
+      "code": "160150",
+      "description": "Bath effluent"
+    },
+    {
+      "code": "160206",
+      "description": "Bath ingedikt primair slib"
+    },
+    {
+      "code": "160245",
+      "description": "Bath inhoud gistingstank 1 ZB"
+    },
+    {
+      "code": "160246",
+      "description": "Bath inhoud gistingstank 2 ZB"
+    },
+    {
+      "code": "160415",
+      "description": "Bath 160415 Ingedikt Sec.slib BI 1-4 (Buffer)"
+    },
+    {
+      "code": "160425",
+      "description": "Bath afvoer slibkoek silo"
+    },
+    {
+      "code": "169100",
+      "description": "RWZI Dinteloord influent totaal"
+    },
+    {
+      "code": "169100C",
+      "description": "RWZI Dinteloord influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "169120",
+      "description": "RWZI Dinteloord inhoud beluchtingsruimte"
+    },
+    {
+      "code": "169150",
+      "description": "RWZI Dinteloord effluent"
+    },
+    {
+      "code": "169209",
+      "description": "RWZI Dinteloord slibafvoer voorindikker"
+    },
+    {
+      "code": "169400",
+      "description": "RWZI Dinteloord slibafvoer slibbufferput"
+    },
+    {
+      "code": "169700",
+      "description": "RWZI Dinteloord Peilbuis ref 01"
+    },
+    {
+      "code": "169705",
+      "description": "RWZI Dinteloord Peilbuis ref 02"
+    },
+    {
+      "code": "169710",
+      "description": "RWZI Dinteloord Peilbuis 03"
+    },
+    {
+      "code": "169715",
+      "description": "RWZI Dinteloord Peilbuis 04"
+    },
+    {
+      "code": "169720",
+      "description": "RWZI Dinteloord Peilbuis 05"
+    },
+    {
+      "code": "172100",
+      "description": "RWZI Halsteren influent"
+    },
+    {
+      "code": "172100C",
+      "description": "RWZI Halsteren influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "172120",
+      "description": "RWZI Halsteren inhoud beluchtingsruimte"
+    },
+    {
+      "code": "172150",
+      "description": "RWZI Halsteren effluent"
+    },
+    {
+      "code": "172209",
+      "description": "RWZI Halsteren slibafvoer voorindikker"
+    },
+    {
+      "code": "172400",
+      "description": "RWZI Halsteren slibafvoer slibbufferput"
+    },
+    {
+      "code": "181100",
+      "description": "RWZI Nieuw-Vossemeer influent totaal"
+    },
+    {
+      "code": "181100C",
+      "description": "RWZI Nieuw-Vossemeer influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "181120",
+      "description": "RWZI Nieuw-Vossemeer inhoud beluchtingsruimte"
+    },
+    {
+      "code": "181150",
+      "description": "RWZI Nieuw-Vossemeer Effluent steekmonster"
+    },
+    {
+      "code": "181156",
+      "description": "RWZI Nieuw-Vossemeer Effluent waterharmonica steekmonster"
+    },
+    {
+      "code": "181400",
+      "description": "Nieuw Vossemeer slibafvoer slibbufferput"
+    },
+    {
+      "code": "184100",
+      "description": "RWZI Ossendrecht influent totaal"
+    },
+    {
+      "code": "184100C",
+      "description": "RWZI Ossendrecht influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "184120",
+      "description": "RWZI Ossendrecht inhoud beluchtingsruimte"
+    },
+    {
+      "code": "184150",
+      "description": "RWZI Ossendrecht effluent"
+    },
+    {
+      "code": "184460",
+      "description": "RWZI Ossendrecht afvoer slibpersleiding naar AWP"
+    },
+    {
+      "code": "191100",
+      "description": "RWZI Putte influent totaal"
+    },
+    {
+      "code": "191100C",
+      "description": "RWZI Putte influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "191120",
+      "description": "RWZI Putte inhoud beluchtingsruimte"
+    },
+    {
+      "code": "191150",
+      "description": "RWZI Putte effluent"
+    },
+    {
+      "code": "191460",
+      "description": "RWZI Putte afvoer slibpersleiding naar AWP"
+    },
+    {
+      "code": "196100",
+      "description": "RWZI Willemstad influent totaal"
+    },
+    {
+      "code": "196100C",
+      "description": "RWZI Willemstad influent - Monstername influent COVID-19"
+    },
+    {
+      "code": "196120",
+      "description": "RWZI Willemstad inhoud beluchtingsruimte"
+    },
+    {
+      "code": "196150",
+      "description": "RWZI Willemstad effluent"
+    },
+    {
+      "code": "196400",
+      "description": "RWZI Willemstad slibafvoer slibbufferput"
+    },
+    {
+      "code": "303203",
+      "description": "Persstation Bergen op Zoom inh. container zandvang"
+    },
+    {
+      "code": "312203",
+      "description": "AWP persstation Roosendaal inh. container zandvang"
+    },
+    {
+      "code": "WSBD Toeslag Weekendbemonsteri",
+      "description": "WSBD Toeslag Weekendbemonsteringen"
+    }
+  ]
+}

datasets/assetData/valve.json

@@ -0,0 +1,27 @@
+{
+  "id": "valve",
+  "label": "valve",
+  "softwareType": "valve",
+  "suppliers": [
+    {
+      "id": "binder",
+      "name": "Binder Engineering",
+      "types": [
+        {
+          "id": "valve-gate",
+          "name": "Gate",
+          "models": [
+            { "id": "binder-valve-001", "name": "ECDV", "units": ["m3/h", "gpm", "l/min"] }
+          ]
+        },
+        {
+          "id": "valve-jet",
+          "name": "Jet",
+          "models": [
+            { "id": "binder-valve-002", "name": "JCV", "units": ["m3/h", "gpm", "l/min"] }
+          ]
+        }
+      ]
+    }
+  ]
+}

index.js

@@ -8,38 +8,39 @@
  */
 
 // Core helper modules
-const outputUtils = require('./src/helper/outputUtils.js');
+const helper = require('./src/helper/index.js');
-const logger = require('./src/helper/logger.js');
+const {
-const validation = require('./src/helper/validationUtils.js');
+    outputUtils,
-const configUtils = require('./src/helper/configUtils.js');
+    logger,
-const assertions = require('./src/helper/assertionUtils.js')
+    validation,
+    configUtils,
+    assertions,
+    childRegistrationUtils,
+    gravity,
+} = helper;
 const coolprop = require('./src/coolprop-node/src/index.js');
+const assetApiConfig = require('./src/configs/assetApiConfig.js');
 
 // Domain-specific modules
 const { MeasurementContainer } = require('./src/measurements/index.js');
 const configManager = require('./src/configs/index.js');
-const nrmse = require('./src/nrmse/errorMetrics.js');
+const { nrmse } = require('./src/nrmse/index.js');
-const state = require('./src/state/state.js');
+const { state } = require('./src/state/index.js');
 const convert = require('./src/convert/index.js');
 const MenuManager = require('./src/menu/index.js');
-const predict = require('./src/predict/predict_class.js');
+const { predict, interpolation } = require('./src/predict/index.js');
-const interpolation = require('./src/predict/interpolation.js');
+const { PIDController, CascadePIDController, createPidController, createCascadePidController } = require('./src/pid/index.js');
-const childRegistrationUtils = require('./src/helper/childRegistrationUtils.js');
+const { loadCurve } = require('./datasets/assetData/curves/index.js'); //deprecated replace with load model data
-const { loadCurve } = require('./datasets/assetData/curves/index.js');
+const { loadModel } = require('./datasets/assetData/modelData/index.js');
 const { POSITIONS, POSITION_VALUES, isValidPosition } = require('./src/constants/positions.js');
 const Fysics = require('./src/convert/fysics.js');
 
-// Gravity helper (used by rotatingMachine for efficiency calculations)
-const gravity = {
-    getStandardGravity: () => 9.80665,
-    fysics: new Fysics()
-};
-
 // Export everything
 module.exports = {
     predict,
     interpolation,
     configManager,
+    assetApiConfig,
     outputUtils,
     configUtils,
     logger,
@@ -51,10 +52,16 @@ module.exports = {
     coolprop,
     convert,
     MenuManager,
+    PIDController,
+    CascadePIDController,
+    createPidController,
+    createCascadePidController,
     childRegistrationUtils,
-    loadCurve,
+    loadCurve, //deprecated replace with loadModel
+    loadModel,
     gravity,
     POSITIONS,
     POSITION_VALUES,
-    isValidPosition
+    isValidPosition,
+    Fysics
 };

package.json

@@ -9,11 +9,17 @@
     "./menuUtils":   "./src/helper/menuUtils.js",
     "./mathUtils":   "./src/helper/mathUtils.js",
     "./assetUtils":  "./src/helper/assetUtils.js",
-    "./outputUtils": "./src/helper/outputUtils.js"
+    "./outputUtils": "./src/helper/outputUtils.js",
+    "./helper": "./src/helper/index.js",
+    "./state": "./src/state/index.js",
+    "./predict": "./src/predict/index.js",
+    "./pid": "./src/pid/index.js",
+    "./nrmse": "./src/nrmse/index.js",
+    "./outliers": "./src/outliers/index.js"
   },
 
   "scripts": {
-    "test": "node test.js"
+    "test": "node --test test/*.test.js src/nrmse/errorMetric.test.js"
   },
   "repository": {
     "type": "git",

src/configs/assetApiConfig.js

@@ -0,0 +1,16 @@
+const BASE_URL = 'http://localhost:8000';
+const AUTHORIZATION = '4a49332a-fc3e-11f0-bf0a-9457f8d645d9';
+const CSRF_TOKEN = 'dcWLY6luSVuQu4mIlKNCGlk3i9VzG9n3p2pxihcm';
+
+module.exports = {
+  baseUrl: BASE_URL,
+  registerPath: '/assets/store',
+  updatePath: (tag) => `/assets/${encodeURIComponent(tag)}/edit`,
+  updateMethod: 'POST',
+  headers: {
+    accept: 'application/json',
+    Authorization: AUTHORIZATION,
+    'Content-Type': 'application/json',
+    'X-CSRF-TOKEN': CSRF_TOKEN
+  }
+};

src/configs/diffuser.json

@@ -0,0 +1,111 @@
+{
+  "general": {
+    "name": {
+      "default": "Diffuser",
+      "rules": {
+        "type": "string",
+        "description": "A human-readable name for this diffuser zone."
+      }
+    },
+    "id": {
+      "default": null,
+      "rules": {
+        "type": "string",
+        "nullable": true,
+        "description": "Unique identifier for this diffuser node."
+      }
+    },
+    "unit": {
+      "default": "Nm3/h",
+      "rules": {
+        "type": "string",
+        "description": "Default airflow unit for this diffuser."
+      }
+    },
+    "logging": {
+      "logLevel": {
+        "default": "info",
+        "rules": {
+          "type": "enum",
+          "values": [
+            { "value": "debug", "description": "Verbose diagnostic messages." },
+            { "value": "info", "description": "General informational messages." },
+            { "value": "warn", "description": "Warning messages." },
+            { "value": "error", "description": "Error level messages only." }
+          ]
+        }
+      },
+      "enabled": {
+        "default": true,
+        "rules": {
+          "type": "boolean",
+          "description": "Enable or disable logging."
+        }
+      }
+    }
+  },
+  "functionality": {
+    "softwareType": {
+      "default": "diffuser",
+      "rules": {
+        "type": "string",
+        "description": "Software type identifier for parent-child registration."
+      }
+    },
+    "role": {
+      "default": "Aeration diffuser",
+      "rules": {
+        "type": "string",
+        "description": "Describes the functional role of this node."
+      }
+    },
+    "positionVsParent": {
+      "default": "atEquipment",
+      "rules": {
+        "type": "enum",
+        "values": [
+          { "value": "upstream", "description": "Upstream of parent equipment." },
+          { "value": "atEquipment", "description": "At equipment level." },
+          { "value": "downstream", "description": "Downstream of parent equipment." }
+        ]
+      }
+    }
+  },
+  "diffuser": {
+    "number": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "description": "Sequential diffuser zone number."
+      }
+    },
+    "elements": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "description": "Number of diffuser elements in the zone."
+      }
+    },
+    "density": {
+      "default": 2.4,
+      "rules": {
+        "type": "number",
+        "description": "Installed diffuser density per square meter."
+      }
+    },
+    "waterHeight": {
+      "default": 0,
+      "rules": {
+        "type": "number",
+        "description": "Water column height above the diffuser."
+      }
+    },
+    "alfaFactor": {
+      "default": 0.7,
+      "rules": {
+        "type": "number",
+        "description": "Alpha factor used for oxygen transfer correction."
+      }
+    }
+  }
+}

src/configs/index.js

@@ -1,22 +1,52 @@
 const fs = require('fs');
 const path = require('path');
 
+/**
+ * Current config version. All config JSONs should declare this version.
+ * Bump this when the config schema changes.
+ */
+const CURRENT_CONFIG_VERSION = '1.0.0';
+
 class ConfigManager {
     constructor(relPath = '.') {
         this.configDir = path.resolve(__dirname, relPath);
+
+        /**
+         * Migration functions keyed by "fromVersion->toVersion".
+         * Each function receives a config object and returns the migrated config.
+         *
+         * Example:
+         *   this.migrations['1.0.0->1.1.0'] = (config) => {
+         *       config.newSection = { enabled: false };
+         *       return config;
+         *   };
+         */
+        this.migrations = {};
     }
 
     /**
-     * Load a configuration file by name
+     * Load a configuration file by name.
+     * Automatically checks the config version and migrates if needed.
      * @param {string} configName - Name of the config file (without .json extension)
-     * @returns {Object} Parsed configuration object
+     * @returns {Object} Parsed configuration object (migrated to current version if necessary)
      */
     getConfig(configName) {
         try {
             const configPath = path.resolve(this.configDir, `${configName}.json`);
             const configData = fs.readFileSync(configPath, 'utf8');
-            return JSON.parse(configData);
+            let config = JSON.parse(configData);
+
+            // Auto-migrate if version is behind current
+            const configVersion = config.version || '0.0.0';
+            if (configVersion !== CURRENT_CONFIG_VERSION) {
+                config = this.migrateConfig(config, configVersion, CURRENT_CONFIG_VERSION);
+            }
+
+            return config;
         } catch (error) {
+            if (error.message && error.message.startsWith('Failed to load config')) {
+                throw error;
+            }
             throw new Error(`Failed to load config '${configName}': ${error.message}`);
         }
     }
@@ -80,6 +110,10 @@ class ConfigManager {
                 softwareType: nodeName.toLowerCase(),
                 positionVsParent: uiConfig.positionVsParent || 'atEquipment',
                 distance: uiConfig.hasDistance ? uiConfig.distance : undefined
+            },
+            output: {
+                process: uiConfig.processOutputFormat || 'process',
+                dbase: uiConfig.dbaseOutputFormat || 'influxdb'
             }
         };
 
@@ -102,6 +136,27 @@ class ConfigManager {
         return config;
     }
 
+    /**
+     * Migrate a config object from one version to another by applying
+     * registered migration functions in sequence.
+     * @param {object} config - The config object to migrate
+     * @param {string} fromVersion - Current version of the config
+     * @param {string} toVersion - Target version
+     * @returns {object} Migrated config with updated version field
+     */
+    migrateConfig(config, fromVersion, toVersion) {
+        const migrationKey = `${fromVersion}->${toVersion}`;
+        const migrationFn = this.migrations[migrationKey];
+
+        if (migrationFn) {
+            config = migrationFn(config);
+        }
+
+        // Stamp the current version so it won't re-migrate
+        config.version = toVersion;
+        return config;
+    }
+
     /**
      * Get the base config schema (shared across all nodes).
      * @returns {object} Base config schema

src/configs/measurement.json

@@ -117,6 +117,14 @@
                 "description": "Asset tag code which is a unique identifier for this asset. May be null if not assigned."
             }
         },
+        "tagNumber": {
+            "default": null,
+            "rules": {
+                "type": "string",
+                "nullable": true,
+                "description": "Asset tag number assigned by the asset registry. May be null if not assigned."
+            }
+        },
         "geoLocation": {
             "default": {
                 "x": 0,
@@ -166,6 +174,10 @@
                     {
                         "value": "sensor",
                         "description": "A device that detects or measures a physical property and responds to it (e.g. temperature sensor)."
+                    },
+                    {
+                        "value": "measurement",
+                        "description": "Measurement software category used by the asset menu for this node."
                     }
                 ]
             }
@@ -208,6 +220,52 @@
             }
         }
     },
+    "assetRegistration": {
+        "default": {
+            "profileId": 1,
+            "locationId": 1,
+            "processId": 1,
+            "status": "actief",
+            "childAssets": []
+        },
+        "rules": {
+            "type": "object",
+            "schema": {
+                "profileId": {
+                    "default": 1,
+                    "rules": {
+                        "type": "number"
+                    }
+                },
+                "locationId": {
+                    "default": 1,
+                    "rules": {
+                        "type": "number"
+                    }
+                },
+                "processId": {
+                    "default": 1,
+                    "rules": {
+                        "type": "number"
+                    }
+                },
+                "status": {
+                    "default": "actief",
+                    "rules": {
+                        "type": "string"
+                    }
+                },
+                "childAssets": {
+                    "default": [],
+                    "rules": {
+                        "type": "array",
+                        "itemType": "string",
+                        "minLength": 0
+                    }
+                }
+            }
+        }
+    },
     "scaling": {
         "enabled": {
             "default": false,

src/configs/monster.json

@@ -0,0 +1,256 @@
+{
+    "general": {
+        "name": {
+            "default": "Monster Configuration",
+            "rules": {
+                "type": "string",
+                "description": "A human-readable name or label for this configuration."
+            }
+        },
+        "id": {
+            "default": null,
+            "rules": {
+                "type": "string",
+                "nullable": true,
+                "description": "A unique identifier for this configuration. If not provided, defaults to null."
+            }
+        },
+        "unit": {
+            "default": "unitless",
+            "rules": {
+                "type": "string",
+                "description": "The unit for this configuration (e.g., 'meters', 'seconds', 'unitless')."
+            }
+        },
+        "logging": {
+            "logLevel": {
+                "default": "info",
+                "rules": {
+                    "type": "enum",
+                    "values": [
+                        {
+                            "value": "debug",
+                            "description": "Log messages are printed for debugging purposes."
+                        },
+                        {
+                            "value": "info",
+                            "description": "Informational messages are printed."
+                        },
+                        {
+                            "value": "warn",
+                            "description": "Warning messages are printed."
+                        },
+                        {
+                            "value": "error",
+                            "description": "Error messages are printed."
+                        }
+                    ]
+                }
+            },
+            "enabled": {
+                "default": true,
+                "rules": {
+                    "type": "boolean",
+                    "description": "Indicates whether logging is active. If true, log messages will be generated."
+                }
+            }
+        }
+    },
+    "functionality": {
+        "softwareType": {
+            "default": "monster",
+            "rules": {
+                "type": "string",
+                "description": "Specified software type for this configuration."
+            }
+        },
+        "role": {
+            "default": "samplingCabinet",
+            "rules": {
+                "type": "string",
+                "description": "Indicates the role this configuration plays (e.g., sensor, controller, etc.)."
+            }
+        }
+    },
+    "asset": {
+        "uuid": {
+            "default": null,
+            "rules": {
+                "type": "string",
+                "nullable": true,
+                "description": "Asset tag number which is a universally unique identifier for this asset. May be null if not assigned."
+            }
+        },
+        "geoLocation": {
+            "default": {
+                "x": 0,
+                "y": 0,
+                "z": 0
+            },
+            "rules": {
+                "type": "object",
+                "description": "An object representing the asset's physical coordinates or location.",
+                "schema": {
+                    "x": {
+                        "default": 0,
+                        "rules": {
+                            "type": "number",
+                            "description": "X coordinate of the asset's location."
+                        }
+                    },
+                    "y": {
+                        "default": 0,
+                        "rules": {
+                            "type": "number",
+                            "description": "Y coordinate of the asset's location."
+                        }
+                    },
+                    "z": {
+                        "default": 0,
+                        "rules": {
+                            "type": "number",
+                            "description": "Z coordinate of the asset's location."
+                        }
+                    }
+                }
+            }
+        },
+        "supplier": {
+            "default": "Unknown",
+            "rules": {
+                "type": "string",
+                "description": "The supplier or manufacturer of the asset."
+            }
+        },
+        "type": {
+            "default": "sensor",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "sensor",
+                        "description": "A device that detects or measures a physical property and responds to it (e.g. temperature sensor)."
+                    }
+                ]
+            }
+        },
+        "subType": {
+            "default": "pressure",
+            "rules": {
+                "type": "string",
+                "description": "A more specific classification within 'type'. For example, 'pressure' for a pressure sensor."
+            }
+        },
+        "model": {
+            "default": "Unknown",
+            "rules": {
+                "type": "string",
+                "description": "A user-defined or manufacturer-defined model identifier for the asset."
+            }
+        },
+        "emptyWeightBucket": {
+            "default": 3,
+            "rules": {
+                "type": "number",
+                "description": "The weight of the empty bucket in kilograms."
+            }
+        }
+    },
+    "constraints": {
+        "samplingtime": {
+            "default": 0,
+            "rules": {
+                "type": "number",
+                "description": "The time interval between sampling events (in seconds) if not using a flow meter."
+            }
+        },
+        "samplingperiod": {
+            "default": 24,
+            "rules": {
+                "type": "number",
+                "description": "The fixed period in hours in which a composite sample is collected."
+            }
+        },
+        "minVolume": {
+            "default": 5,
+            "rules": {
+                "type": "number",
+                "min": 5,
+                "description": "The minimum volume in liters."
+            }
+        },
+        "maxWeight": {
+            "default": 23,
+            "rules": {
+                "type": "number",
+                "max": 23,
+                "description": "The maximum weight in kilograms."
+            }
+        },
+        "subSampleVolume": {
+            "default": 50,
+            "rules": {
+                "type": "number",
+                "min": 50,
+                "max": 50,
+                "description": "The volume of each sub-sample in milliliters."
+            }
+        },
+        "storageTemperature": {
+            "default": {
+                "min": 1,
+                "max": 5
+            },
+            "rules": {
+                "type": "object",
+                "description": "Acceptable storage temperature range for samples in degrees Celsius.",
+                "schema": {
+                    "min": {
+                        "default": 1,
+                        "rules": {
+                            "type": "number",
+                            "min": 1,
+                            "description": "Minimum acceptable storage temperature in degrees Celsius."
+                        }
+                    },
+                    "max": {
+                        "default": 5,
+                        "rules": {
+                            "type": "number",
+                            "max": 5,
+                            "description": "Maximum acceptable storage temperature in degrees Celsius."
+                        }
+                    }
+                }
+            }
+        },
+        "flowmeter": {
+            "default": true,
+            "rules": {
+                "type": "boolean",
+                "description": "Indicates whether a flow meter is used for proportional sampling."
+            }
+        },
+        "closedSystem": {
+            "default": false,
+            "rules": {
+                "type": "boolean",
+                "description": "Indicates if the sampling system is closed (true) or open (false)."
+            }
+        },
+        "intakeSpeed": {
+            "default": 0.3,
+            "rules": {
+                "type": "number",
+                "description": "Minimum intake speed in meters per second."
+            }
+        },
+        "intakeDiameter": {
+            "default": 12,
+            "rules": {
+                "type": "number",
+                "description": "Minimum inner diameter of the intake tubing in millimeters."
+            }
+        }
+    }
+}

src/configs/pumpingStation.json

@@ -93,6 +93,14 @@
                 ]
             }
         },
+        "distance": {
+            "default": null,
+            "rules": {
+                "type": "number",
+                "nullable": true,
+                "description": "Optional distance to parent asset for registration metadata."
+            }
+        },
         "tickIntervalMs": {
             "default": 1000,
             "rules": {
@@ -299,6 +307,30 @@
                 "description": "Reference height to use to identify the height vs other basins with. This will say something more about the expected pressure loss in m head"
             }
         },
+        "minHeightBasedOn": {
+            "default": "outlet",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "inlet",
+                        "description": "Minimum height is based on inlet elevation."
+                    },
+                    {
+                        "value": "outlet",
+                        "description": "Minimum height is based on outlet elevation."
+                    }
+                ],
+                "description": "Basis for minimum height check: inlet or outlet."
+            }
+        },
+        "basinBottomRef": {
+            "default": 0,
+            "rules": {
+                "type": "number",
+                "description": "Absolute elevation reference of basin bottom."
+            }
+        },
         "staticHead": {
             "default": 12,
             "rules": {
@@ -348,13 +380,13 @@
         }
     },
     "control": {
-        "controlStrategy": {
+        "mode": {
-            "default": "levelBased",
+            "default": "levelbased",
             "rules": {
-                "type": "enum",
+                "type": "string",
                 "values": [
                     {
-                        "value": "levelBased",
+                        "value": "levelbased",
                         "description": "Lead and lag pumps are controlled by basin level thresholds."
                     },
                     {
@@ -362,9 +394,21 @@
                         "description": "Pumps target a discharge pressure setpoint."
                     },
                     {
-                        "value": "flowTracking",
+                        "value": "flowBased",
                         "description": "Pumps modulate to match measured inflow or downstream demand."
                     },
+                    {
+                        "value": "percentageBased",
+                        "description": "Pumps operate to maintain basin volume at a target percentage."
+                    },
+                    {
+                        "value":"powerBased",
+                        "description": "Pumps are controlled based on power consumption.For example, to limit peak power usage or operate within netcongestion limits."
+                    },
+                    {
+                        "value": "hybrid",
+                        "description": "Combines multiple control strategies for optimized operation."
+                    },
                     {
                         "value": "manual",
                         "description": "Pumps are operated manually or by an external controller."
@@ -373,78 +417,135 @@
                 "description": "Primary control philosophy for pump actuation."
             }
         },
-        "levelSetpoints": {
+        "allowedModes": {
-            "default": {
+            "default": [
-                "startLeadPump": 1.2,
+                "levelbased",
-                "stopLeadPump": 0.8,
+                "pressurebased",
-                "startLagPump": 1.8,
+                "flowbased",
-                "stopLagPump": 1.4,
+                "percentagebased",
-                "alarmHigh": 2.3,
+                "powerbased",
-                "alarmLow": 0.3
+                "manual"
-            },
+            ],
             "rules": {
-                "type": "object",
+                "type": "set",
-                "description": "Level thresholds that govern pump staging and alarms (m).",
+                "itemType": "string",
-                "schema": {
+                "description": "List of control modes that the station is permitted to operate in."
-                    "startLeadPump": {
-                        "default": 1.2,
-                        "rules": {
-                            "type": "number",
-                            "description": "Level that starts the lead pump."
             }
         },
-                    "stopLeadPump": {
+        "levelbased": {
-                        "default": 0.8,
+            "startLevel": {
-                        "rules": {
+                "default": 1,
-                            "type": "number",
-                            "description": "Level that stops the lead pump."
-                        }
-                    },
-                    "startLagPump": {
-                        "default": 1.8,
-                        "rules": {
-                            "type": "number",
-                            "description": "Level that starts the lag pump."
-                        }
-                    },
-                    "stopLagPump": {
-                        "default": 1.4,
-                        "rules": {
-                            "type": "number",
-                            "description": "Level that stops the lag pump."
-                        }
-                    },
-                    "alarmHigh": {
-                        "default": 2.3,
-                        "rules": {
-                            "type": "number",
-                            "description": "High level alarm threshold."
-                        }
-                    },
-                    "alarmLow": {
-                        "default": 0.3,
-                        "rules": {
-                            "type": "number",
-                            "description": "Low level alarm threshold."
-                        }
-                    }
-                }
-            }
-        },
-        "pressureSetpoint": {
-            "default": 250,
                 "rules": {
                     "type": "number",
                     "min": 0,
+                    "description": "start of pump / group when level reaches this in meters starting from bottom."
+                }
+            },
+            "stopLevel": {
+                "default": 1,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "description": "stop of pump / group when level reaches this in meters starting from bottom"
+                }
+            },
+            "minFlowLevel": {
+                "default": 1,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "description": "min level to scale the flow lineair"
+                }
+            },
+            "maxFlowLevel": {
+                "default": 4,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "description": "max level to scale the flow lineair"
+                }
+            }
+        },
+        "pressureBased": {
+            "pressureSetpoint": {
+                "default": 1000,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "max": 5000,
                     "description": "Target discharge pressure when operating in pressure control (kPa)."
                 }
+            }
         },
-        "alarmDebounceSeconds": {
+        "flowBased": {
-            "default": 10,
+            "flowSetpoint": {
+                "default": 0,
                 "rules": {
                     "type": "number",
                     "min": 0,
-                "description": "Time a condition must persist before raising an alarm (seconds)."
+                    "description": "Target outflow setpoint used by flow-based control (m3/h)."
+                }
+            },
+            "flowDeadband": {
+                "default": 0,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "description": "Allowed deadband around the outflow setpoint before corrective actions are taken (m3/h)."
+                }
+            },
+            "pid": {
+                "default": {},
+                "rules": {
+                    "type": "object",
+                    "schema": {
+                        "kp": {
+                            "default": 1.5,
+                            "rules": {
+                                "type": "number",
+                                "description": "Proportional gain for flow-based PID control."
+                            }
+                        },
+                        "ki": {
+                            "default": 0.05,
+                            "rules": {
+                                "type": "number",
+                                "description": "Integral gain for flow-based PID control."
+                            }
+                        },
+                        "kd": {
+                            "default": 0.01,
+                            "rules": {
+                                "type": "number",
+                                "description": "Derivative gain for flow-based PID control."
+                            }
+                        },
+                        "derivativeFilter": {
+                            "default": 0.2,
+                            "rules": {
+                                "type": "number",
+                                "min": 0,
+                                "max": 1,
+                                "description": "Derivative filter coefficient (0..1)."
+                            }
+                        },
+                        "rateUp": {
+                            "default": 30,
+                            "rules": {
+                                "type": "number",
+                                "min": 0,
+                                "description": "Maximum controller output increase rate (%/s)."
+                            }
+                        },
+                        "rateDown": {
+                            "default": 40,
+                            "rules": {
+                                "type": "number",
+                                "min": 0,
+                                "description": "Maximum controller output decrease rate (%/s)."
+                            }
+                        }
+                    }
                 }
             },
             "equalizationTargetPercent": {
@@ -456,11 +557,59 @@
                     "description": "Target fill percentage of the basin when operating in equalization mode."
                 }
             },
-        "autoRestartAfterPowerLoss": {
+            "flowBalanceTolerance": {
-            "default": true,
+                "default": 5,
                 "rules": {
-                "type": "boolean",
+                    "type": "number",
-                "description": "If true, pumps resume based on last known state after power restoration."
+                    "min": 0,
+                    "description": "Allowable error between inflow and outflow before adjustments are triggered (m3/h)."
+                }
+            }
+        },
+        "percentageBased": {
+            "targetVolumePercent": {
+                "default": 50,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "max": 100,
+                    "description": "Target basin volume percentage to maintain during percentage-based control."
+                }
+            },
+            "tolerancePercent": {
+                "default": 5,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "description": "Acceptable deviation from the target volume percentage before corrective action is taken."
+                }
+            }
+        },
+        "powerBased": {
+            "maxPowerKW": {
+                "default": 50,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "description": "Maximum allowable power consumption for the pumping station (kW)."
+                }
+            },
+            "powerControlMode": {
+                "default": "limit",
+                "rules": {
+                    "type": "enum",
+                    "values": [
+                        {
+                            "value": "limit",
+                            "description": "Limit pump operation to stay below the max power threshold."
+                        },
+                        {
+                            "value": "optimize",
+                            "description": "Optimize pump scheduling to minimize power usage while meeting flow demands."
+                        }
+                    ],
+                    "description": "Defines how power constraints are managed during operation."
+                }
             }
         },
         "manualOverrideTimeoutMinutes": {
@@ -470,13 +619,63 @@
                 "min": 0,
                 "description": "Duration after which a manual override expires automatically (minutes)."
             }
+        }
     },
-        "flowBalanceTolerance": {
+    "safety": {
-            "default": 5,
+        "enableDryRunProtection": {
+            "default": true,
+            "rules": {
+                "type": "boolean",
+                "description": "If true, pumps will be prevented from running if basin volume is too low."
+            }
+        },
+        "dryRunThresholdPercent": {
+            "default": 2,
             "rules": {
                 "type": "number",
                 "min": 0,
-                "description": "Allowable error between inflow and outflow before adjustments are triggered (m3/h)."
+                "max": 100,
+                "description": "Volume percentage below which dry run protection activates."
+            }
+        },
+        "dryRunDebounceSeconds": {
+            "default": 30,
+            "rules": {
+                "type": "number",
+                "min": 0,
+                "description": "Time the low-volume condition must persist before dry-run protection engages (seconds)."
+            }
+        },
+        "enableOverfillProtection": {
+            "default": true,
+            "rules": {
+                "type": "boolean",
+                "description": "If true, high level alarms and shutdowns will be enforced to prevent overfilling."
+            }
+        },
+        "overfillThresholdPercent": {
+            "default": 98,
+            "rules": {
+                "type": "number",
+                "min": 0,
+                "max": 100,
+                "description": "Volume percentage above which overfill protection activates."
+            }
+        },
+        "overfillDebounceSeconds": {
+            "default": 30,
+            "rules": {
+                "type": "number",
+                "min": 0,
+                "description": "Time the high-volume condition must persist before overfill protection engages (seconds)."
+            }
+        },
+        "timeleftToFullOrEmptyThresholdSeconds": {
+            "default": 0,
+            "rules": {
+                "type": "number",
+                "min": 0,
+                "description": "Time threshold (seconds) used to predict imminent full or empty conditions."
             }
         }
     },

src/configs/rotatingMachine.json

@@ -16,7 +16,7 @@
         }
       },
       "unit": {
-        "default": "m3/h",
+        "default": "l/s",
         "rules": {
           "type": "string",
           "description": "The default measurement unit for this configuration (e.g., 'meters', 'seconds', 'unitless')."
@@ -110,6 +110,14 @@
                 "description": "Asset tag code which is a unique identifier for this asset. May be null if not assigned."
             }
         },
+      "tagNumber": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "Optional asset tag number for legacy integrations."
+        }
+      },
       "geoLocation": {
         "default": {},
         "rules": {
@@ -175,6 +183,47 @@
                 "description": "The unit of measurement for this asset (e.g., 'meters', 'seconds', 'unitless')."
             }
         },
+      "curveUnits": {
+        "default": {
+          "pressure": "mbar",
+          "flow": "m3/h",
+          "power": "kW",
+          "control": "%"
+        },
+        "rules": {
+          "type": "object",
+          "schema": {
+            "pressure": {
+              "default": "mbar",
+              "rules": {
+                "type": "string",
+                "description": "Pressure unit used on the machine curve dimension axis."
+              }
+            },
+            "flow": {
+              "default": "m3/h",
+              "rules": {
+                "type": "string",
+                "description": "Flow unit used in the machine curve output (nq.y)."
+              }
+            },
+            "power": {
+              "default": "kW",
+              "rules": {
+                "type": "string",
+                "description": "Power unit used in the machine curve output (np.y)."
+              }
+            },
+            "control": {
+              "default": "%",
+              "rules": {
+                "type": "string",
+                "description": "Control axis unit used in the curve x-dimension."
+              }
+            }
+          }
+        }
+      },
       "accuracy": {
         "default": null,
         "rules": {
@@ -245,10 +294,6 @@
             {
               "value": "fysicalControl",
               "description": "Controlled via physical buttons or switches; ignores external automated commands."
-            },
-            {
-              "value": "maintenance",
-              "description": "No active control from auto, virtual, or fysical sources."
             }
           ],
           "description": "The operational mode of the machine."
@@ -260,7 +305,14 @@
           "type": "object",
           "schema":{
             "auto": {
-              "default": ["statusCheck", "execMovement", "execSequence", "emergencyStop"],
+              "default": [
+                "statuscheck",
+                "execmovement",
+                "execsequence",
+                "flowmovement",
+                "emergencystop",
+                "entermaintenance"
+              ],
               "rules": {
                 "type": "set",
                 "itemType": "string",
@@ -268,7 +320,14 @@
               }
             },
             "virtualControl": {
-              "default": ["statusCheck", "execMovement", "execSequence", "emergencyStop"],
+              "default": [
+                "statuscheck",
+                "execmovement",
+                "flowmovement",
+                "execsequence",
+                "emergencystop",
+                "exitmaintenance"
+              ],
               "rules": {
                 "type": "set",
                 "itemType": "string",
@@ -276,24 +335,21 @@
               }
             },
             "fysicalControl": {
-              "default": ["statusCheck", "emergencyStop"],
+              "default": [
+                "statuscheck",
+                "emergencystop",
+                "entermaintenance",
+                "exitmaintenance"
+              ],
               "rules": {
                 "type": "set",
                 "itemType": "string",
                 "description": "Actions allowed in fysicalControl mode."
               }
-            },
-            "maintenance": {
-              "default": ["statusCheck"],
-              "rules": {
-                "type": "set",
-                "itemType": "string",
-                "description": "Actions allowed in maintenance mode."
             }
             }
           },
           "description": "Information about valid command sources recognized by the machine."
-        }
         },
       "allowedSources":{
         "default": {},
@@ -386,6 +442,22 @@
               "itemType": "string",
               "description": "Sequence of states for booting up the machine."
             }
+          },
+          "entermaintenance":{
+            "default": ["stopping","coolingdown","idle","maintenance"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states if the machine is running to put it in maintenance state"
+            }
+          },
+          "exitmaintenance":{
+            "default": ["off","idle"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states if the machine is running to put it in maintenance state"
+            }
           }
         }
       },

src/coolprop-node/src/index.js

@@ -3,11 +3,61 @@ const customRefs = require('./refData.js');
 
 class CoolPropWrapper {
     constructor() {
+
         this.initialized = false;
         this.defaultRefrigerant = null;
         this.defaultTempUnit = 'K';    // K, C, F
         this.defaultPressureUnit = 'Pa' // Pa, kPa, bar, psi
         this.customRef = false;
+        this.PropsSI = this._propsSI.bind(this);
+
+
+        // 🔹 Wastewater correction options (defaults)
+        this._ww = {
+            enabled: true,
+            tss_g_per_L: 3.5,       // default MLSS / TSS
+            density_k: 2e-4,        // +0.02% per g/L
+            viscosity_k: 0.07,      // +7% per g/L (clamped)
+            viscosity_max_gpl: 4    // cap effect at 4 g/L
+        };
+
+        this._initPromise = null;
+        this._autoInit({ refrigerant: 'Water' });
+
+    }
+
+    _isWastewaterFluid(fluidRaw) {
+        if (!fluidRaw) return false;
+        const token = String(fluidRaw).trim().toLowerCase();
+        return token === 'wastewater' || token.startsWith('wastewater:');
+    }
+
+    _parseWastewaterFluid(fluidRaw) {
+        if (!this._isWastewaterFluid(fluidRaw)) return null;
+            const ww = { ...this._ww };
+            const [, tail] = String(fluidRaw).split(':');
+            if (tail) {
+                tail.split(',').forEach(pair => {
+                    const [key, value] = pair.split('=').map(s => s.trim().toLowerCase());
+                    if (key === 'tss' && !Number.isNaN(Number(value))) {
+                        ww.tss_g_per_L = Number(value);
+                    }
+                });
+            }
+        return ww;
+    }
+
+    _applyWastewaterCorrection(outputKey, baseValue, ww) {
+        if (!Number.isFinite(baseValue) || !ww || !ww.enabled) return baseValue;
+        switch (outputKey.toUpperCase()) {
+            case 'D': // density
+                return baseValue * (1 + ww.density_k * ww.tss_g_per_L);
+            case 'V': // viscosity
+                const effTss = Math.min(ww.tss_g_per_L, ww.viscosity_max_gpl);
+                return baseValue * (1 + ww.viscosity_k * effTss);
+            default:
+                return baseValue;
+        }
     }
 
     // Temperature conversion helpers
@@ -407,13 +457,31 @@ class CoolPropWrapper {
         }
     }
 
-    // Direct access to CoolProp functions
+    _autoInit(defaults) {
-    async getPropsSI() {
+        if (!this._initPromise) {
+            this._initPromise = this.init(defaults);
+        }
+        return this._initPromise;
+    }
+
+    _propsSI(outputKey, inKey1, inVal1, inKey2, inVal2, fluidRaw) {
         if (!this.initialized) {
-            await coolprop.init();
+            // Start init if no one else asked yet
+            this._autoInit({ refrigerant: this.defaultRefrigerant || 'Water' });
+            throw new Error('CoolProp is still warming up, retry PropsSI in a moment');
         }
-        return coolprop.PropsSI;
+        const ww = this._parseWastewaterFluid(fluidRaw);
+        const fluid = ww ? 'Water' : (this.customRefString || fluidRaw);
+        const baseValue = coolprop.PropsSI(outputKey, inKey1, inVal1, inKey2, inVal2, fluid);
+        return ww ? this._applyWastewaterCorrection(outputKey, baseValue, ww) : baseValue;
     }
+
+    //Access to coolprop
+    async getPropsSI() {
+        await this._ensureInit({ refrigerant: this.defaultRefrigerant || 'Water' });
+        return this.PropsSI;
+    }
+    
 }
 
 module.exports = new CoolPropWrapper();

src/helper/assetUtils.js

@@ -1,5 +1,244 @@
-function getAssetVariables() {
+const http = require('node:http');
+const https = require('node:https');
+const { URL } = require('node:url');
+const { assetCategoryManager } = require('../../datasets/assetData');
 
+function toNumber(value, fallback = 1) {
+  const result = Number(value);
+  return Number.isFinite(result) && result > 0 ? result : fallback;
 }
 
-module.exports = { getAssetVariables };
+function toArray(value = []) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item !== 'undefined' && item !== null);
+  }
+  if (typeof value === 'string' && value.trim()) {
+    return [value.trim()];
+  }
+  if (typeof value === 'number') {
+    return [value];
+  }
+  return [];
+}
+
+function findModelMetadata(selection = {}) {
+  if (!selection) {
+    return null;
+  }
+
+  const categoryKey = selection.softwareType || 'measurement';
+  if (!assetCategoryManager.hasCategory(categoryKey)) {
+    return null;
+  }
+
+  const suppliers = assetCategoryManager.getCategory(categoryKey).suppliers || [];
+  const supplierMatch = (entry, value) => {
+    if (!entry || !value) return false;
+    const key = value.toString().toLowerCase();
+    return (
+      (entry.id && entry.id.toLowerCase() === key) ||
+      (entry.name && entry.name.toLowerCase() === key)
+    );
+  };
+
+  const supplier = suppliers.find((item) => supplierMatch(item, selection.supplier));
+  const types = supplier?.types || [];
+  const type = types.find((item) => supplierMatch(item, selection.assetType));
+  const models = type?.models || [];
+  const model = models.find((item) => supplierMatch(item, selection.model));
+
+  return model || null;
+}
+
+function buildAssetPayload({ assetSelection = {}, registrationDefaults = {} }) {
+  const defaults = {
+    profileId: 1,
+    locationId: 1,
+    processId: 1,
+    status: 'actief',
+    childAssets: [],
+    ...registrationDefaults
+  };
+
+  const metadata = assetSelection.modelMetadata || findModelMetadata(assetSelection) || {};
+  const rawName = assetSelection.assetName || assetSelection.name || assetSelection.assetType || assetSelection.model;
+  const assetName = (rawName || 'Measurement asset').toString();
+  const assetDescription = (assetSelection.assetDescription || assetSelection.description || assetName).toString();
+
+  const modelId = metadata.product_model_id ?? metadata.id ?? assetSelection.modelId ?? assetSelection.model ?? null;
+
+  const payload = {
+    profile_id: toNumber(defaults.profileId, 1),
+    location_id: toNumber(defaults.locationId, 1),
+    process_id: toNumber(defaults.processId, 1),
+    asset_name: assetName,
+    asset_description: assetDescription,
+    asset_status: (assetSelection.assetStatus || defaults.status || 'actief').toString(),
+    product_model_id: modelId,
+    product_model_uuid: metadata.product_model_uuid || metadata.uuid || null,
+    child_assets: toArray(defaults.childAssets)
+  };
+
+  const validation = [];
+  const missing = [];
+  const tooLong = [];
+  const invalid = [];
+
+  if (!payload.asset_name) {
+    missing.push('asset_name');
+  } else if (payload.asset_name.length > 100) {
+    tooLong.push('asset_name');
+  }
+
+  if (!payload.asset_status) {
+    missing.push('asset_status');
+  } else if (payload.asset_status.length > 20) {
+    tooLong.push('asset_status');
+  }
+
+  if (!Number.isInteger(payload.location_id)) {
+    invalid.push('location_id');
+  }
+  if (!Number.isInteger(payload.process_id)) {
+    invalid.push('process_id');
+  }
+  if (!Number.isInteger(payload.profile_id)) {
+    invalid.push('profile_id');
+  }
+
+  if (!Number.isInteger(payload.product_model_id)) {
+    invalid.push('product_model_id');
+  }
+
+  if (!Array.isArray(payload.child_assets)) {
+    invalid.push('child_assets');
+  }
+
+  if (missing.length) {
+    validation.push(`missing: ${missing.join(', ')}`);
+  }
+  if (tooLong.length) {
+    validation.push(`too long: ${tooLong.join(', ')}`);
+  }
+  if (invalid.length) {
+    validation.push(`invalid type: ${invalid.join(', ')}`);
+  }
+
+  if (validation.length) {
+    console.warn('[assetUtils] payload validation', validation.join(' | '));
+  } else {
+    console.info('[assetUtils] payload validation ok');
+  }
+
+  const tagNumber = typeof assetSelection.tagNumber === 'string' && assetSelection.tagNumber.trim()
+    ? assetSelection.tagNumber.trim()
+    : null;
+
+  return {
+    payload,
+    tagNumber,
+    isUpdate: Boolean(tagNumber)
+  };
+}
+
+function normalizeHeaders(headers = {}, body = '') {
+  const normalized = { ...headers };
+  if (!Object.prototype.hasOwnProperty.call(normalized, 'Content-Length')) {
+    normalized['Content-Length'] = Buffer.byteLength(body);
+  }
+  return normalized;
+}
+
+function prepareUrl(baseUrl = '', path = '') {
+  const trimmedBase = (baseUrl || '').replace(/\/+$/g, '').replace(/\\/g, '/');
+  const trimmedPath = path.startsWith('/') ? path : `/${path}`;
+  if (!trimmedBase) {
+    return trimmedPath;
+  }
+  return `${trimmedBase}${trimmedPath}`;
+}
+
+function sendHttpRequest(url, method, headers = {}, body = '') {
+  const parsedUrl = new URL(url, 'http://localhost');
+  const agent = parsedUrl.protocol === 'https:' ? https : http;
+  const requestOptions = {
+    method,
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
+    path: `${parsedUrl.pathname}${parsedUrl.search}`,
+    headers: normalizeHeaders(headers, body)
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = agent.request(requestOptions, (res) => {
+      let raw = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { raw += chunk; });
+      res.on('end', () => resolve({ status: res.statusCode, body: raw }));
+    });
+
+    req.on('error', reject);
+    if (body) {
+      req.write(body);
+    }
+    req.end();
+  });
+}
+
+function parseApiResponse(raw, status) {
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      success: parsed.success === true,
+      data: parsed.data || null,
+      message: parsed.message || (status >= 400 ? `HTTP ${status}` : 'Result returned')
+    };
+  } catch (error) {
+    return {
+      success: false,
+      data: raw,
+      message: `Unable to decode asset API response: ${error.message}`
+    };
+  }
+}
+
+async function syncAsset({ assetSelection = {}, registrationDefaults = {}, apiConfig = {}, nodeContext = {} }) {
+  const { payload, tagNumber, isUpdate } = buildAssetPayload({ assetSelection, registrationDefaults });
+  if (!apiConfig || !apiConfig.baseUrl) {
+    const message = 'Asset API configuration is missing';
+    console.warn('[assetUtils] ' + message, { nodeContext });
+    return { success: false, data: null, message };
+  }
+
+  const path = isUpdate && tagNumber && typeof apiConfig.updatePath === 'function'
+    ? apiConfig.updatePath(tagNumber)
+    : apiConfig.registerPath;
+  const url = prepareUrl(apiConfig.baseUrl, path);
+  const method = isUpdate ? (apiConfig.updateMethod || 'PUT') : 'POST';
+  const headers = apiConfig.headers || {};
+
+  console.info('[assetUtils] Sending asset update', { nodeContext, method, url });
+
+  try {
+    const response = await sendHttpRequest(url, method, headers, JSON.stringify(payload));
+    const parsed = parseApiResponse(response.body, response.status);
+    return {
+      success: parsed.success,
+      data: parsed.data,
+      message: parsed.message
+    };
+  } catch (error) {
+    console.error('[assetUtils] Asset API request failed', error, { nodeContext });
+    return {
+      success: false,
+      data: null,
+      message: `Asset API request error: ${error.message}`
+    };
+  }
+}
+
+module.exports = {
+  syncAsset,
+  buildAssetPayload,
+  findModelMetadata
+};

src/helper/childRegistrationUtils.js

@@ -5,9 +5,19 @@ class ChildRegistrationUtils {
     this.registeredChildren = new Map();
   }
 
-  async registerChild(child, positionVsParent, _distance) {
+  async registerChild(child, positionVsParent, distance) {
+    if (!child || typeof child !== 'object') {
+      this.logger?.warn('registerChild skipped: invalid child payload');
+      return false;
+    }
+    if (!child.config?.functionality || !child.config?.general) {
+      this.logger?.warn('registerChild skipped: missing child config/functionality/general');
+      return false;
+    }
+
     const softwareType = (child.config.functionality.softwareType || '').toLowerCase();
-    const { name, id } = child.config.general;
+    const name = child.config.general.name || child.config.general.id || 'unknown';
+    const id = child.config.general.id || name;
 
     this.logger.debug(`Registering child: ${name} (${id}) as ${softwareType} at ${positionVsParent}`);
 
@@ -43,19 +53,21 @@ class ChildRegistrationUtils {
     }
 
     this.logger.info(`✅ Child ${name} registered successfully`);
+    return true;
   }
 
   _storeChild(child, softwareType) {
     // Maintain your existing structure
     if (!this.mainClass.child) this.mainClass.child = {};
-    if (!this.mainClass.child[softwareType]) this.mainClass.child[softwareType] = {};
+    const typeKey = softwareType || 'unknown';
+    if (!this.mainClass.child[typeKey]) this.mainClass.child[typeKey] = {};
     
     const { category = "sensor" } = child.config.asset || {};
-    if (!this.mainClass.child[softwareType][category]) {
+    if (!this.mainClass.child[typeKey][category]) {
-      this.mainClass.child[softwareType][category] = [];
+      this.mainClass.child[typeKey][category] = [];
     }
     
-    this.mainClass.child[softwareType][category].push(child);
+    this.mainClass.child[typeKey][category].push(child);
   }
 
   // NEW: Utility methods for parent to use

src/helper/configUtils.js

@@ -39,8 +39,8 @@ const Logger = require("./logger");
 
 class ConfigUtils {
     constructor(defaultConfig, IloggerEnabled , IloggerLevel) {
-        const loggerEnabled = IloggerEnabled || true;
+        const loggerEnabled = IloggerEnabled ?? true;
-        const loggerLevel = IloggerLevel || "warn";
+        const loggerLevel = IloggerLevel ?? "warn";
         this.logger = new Logger(loggerEnabled, loggerLevel, 'ConfigUtils');
         this.defaultConfig = defaultConfig;
         this.validationUtils = new ValidationUtils(loggerEnabled, loggerLevel);
@@ -73,17 +73,25 @@ class ConfigUtils {
         return updatedConfig;
     }
 
+    _isPlainObject(value) {
+        return Object.prototype.toString.call(value) === '[object Object]';
+    }
+
     // loop through objects and merge them obj1 will be updated with obj2 values
     mergeObjects(obj1, obj2) {
         for (let key in obj2) {
             if (Object.prototype.hasOwnProperty.call(obj2, key)) {
-                if (typeof obj2[key] === 'object') {
+                const nextValue = obj2[key];
-                    if (!obj1[key]) {
+
+                if (Array.isArray(nextValue)) {
+                    obj1[key] = [...nextValue];
+                } else if (this._isPlainObject(nextValue)) {
+                    if (!this._isPlainObject(obj1[key])) {
                         obj1[key] = {};
                     }
-                    this.mergeObjects(obj1[key], obj2[key]);
+                    this.mergeObjects(obj1[key], nextValue);
                 } else {
-                    obj1[key] = obj2[key];
+                    obj1[key] = nextValue;
                 }
             }
         }

src/helper/endpointUtils.js

@@ -18,13 +18,102 @@ class EndpointUtils {
    * @param {string} nodeName     the name of the node (used in the URL)
    * @param {object} customHelpers  additional helper functions to inject
    */
-  createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}) {
+  createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}, options = {}) {
-    RED.httpAdmin.get(`/${nodeName}/resources/menuUtils.js`, (req, res) => {
+    const basePath = `/${nodeName}/resources`;
-      console.log(`Serving menuUtils.js for ${nodeName} node`);
+
-      res.set('Content-Type', 'application/javascript');
+    RED.httpAdmin.get(`${basePath}/menuUtilsData.json`, (req, res) => {
-      const browserCode = this.generateMenuUtilsCode(nodeName, customHelpers);
+      res.json(this.generateMenuUtilsData(nodeName, customHelpers, options));
-      res.send(browserCode);
     });
+
+    RED.httpAdmin.get(`${basePath}/menuUtils.legacy.js`, (req, res) => {
+      res.set('Content-Type', 'application/javascript');
+      res.send(this.generateLegacyMenuUtilsCode(nodeName, customHelpers));
+    });
+
+    RED.httpAdmin.get(`${basePath}/menuUtils.js`, (req, res) => {
+      res.set('Content-Type', 'application/javascript');
+      res.send(this.generateMenuUtilsBootstrap(nodeName));
+    });
+  }
+
+  generateMenuUtilsData(nodeName, customHelpers = {}, options = {}) {
+    const defaultHelpers = {
+      validateRequired: `function(value) {
+        return value != null && value.toString().trim() !== '';
+      }`,
+      formatDisplayValue: `function(value, unit) {
+        return \`${'${'}value} ${'${'}unit || ''}\`.trim();
+      }`,
+      validateScaling: `function(min, max) {
+        return !isNaN(min) && !isNaN(max) && Number(min) < Number(max);
+      }`,
+      validateUnit: `function(unit) {
+        return typeof unit === 'string' && unit.trim() !== '';
+      }`,
+    };
+
+    return {
+      nodeName,
+      helpers: { ...defaultHelpers, ...customHelpers },
+      options: {
+        autoLoadLegacy: options.autoLoadLegacy !== false,
+      },
+    };
+  }
+
+  generateMenuUtilsBootstrap(nodeName) {
+    return `
+// Stable bootstrap for EVOLV menu utils (${nodeName})
+(function() {
+  const nodeName = ${JSON.stringify(nodeName)};
+  const basePath = '/' + nodeName + '/resources';
+
+  window.EVOLV = window.EVOLV || {};
+  window.EVOLV.nodes = window.EVOLV.nodes || {};
+  window.EVOLV.nodes[nodeName] = window.EVOLV.nodes[nodeName] || {};
+  window.EVOLV.nodes[nodeName].utils = window.EVOLV.nodes[nodeName].utils || {};
+
+  function parseHelper(fnBody) {
+    try {
+      return (new Function('return (' + fnBody + ')'))();
+    } catch (error) {
+      console.error('[menuUtils] helper parse failed:', error);
+      return function() { return null; };
+    }
+  }
+
+  function loadLegacyIfNeeded(autoLoadLegacy) {
+    if (!autoLoadLegacy || typeof window.MenuUtils === 'function') return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const script = document.createElement('script');
+      script.src = basePath + '/menuUtils.legacy.js';
+      script.onload = resolve;
+      script.onerror = reject;
+      document.head.appendChild(script);
+    });
+  }
+
+  fetch(basePath + '/menuUtilsData.json')
+    .then(function(res) { return res.json(); })
+    .then(function(payload) {
+      const helperFns = {};
+      Object.entries(payload.helpers || {}).forEach(function(entry) {
+        helperFns[entry[0]] = parseHelper(entry[1]);
+      });
+
+      window.EVOLV.nodes[nodeName].utils.helpers = helperFns;
+      return loadLegacyIfNeeded(payload.options && payload.options.autoLoadLegacy);
+    })
+    .then(function() {
+      if (typeof window.MenuUtils === 'function' && !window.EVOLV.nodes[nodeName].utils.menuUtils) {
+        window.EVOLV.nodes[nodeName].utils.menuUtils = new window.MenuUtils();
+      }
+    })
+    .catch(function(error) {
+      console.error('[menuUtils] bootstrap failed for ' + nodeName, error);
+    });
+})();
+`;
   }
 
   /**
@@ -33,7 +122,7 @@ class EndpointUtils {
    * @param {object} customHelpers  map of name: functionString pairs
    * @returns {string}  a JS snippet to run in the browser
    */
-  generateMenuUtilsCode(nodeName, customHelpers = {}) {
+  generateLegacyMenuUtilsCode(nodeName, customHelpers = {}) {
     // Default helper implementations to expose alongside MenuUtils
     const defaultHelpers = {
       validateRequired: `function(value) {
@@ -101,6 +190,11 @@ ${helpersCode}
 console.log('Loaded EVOLV.nodes.${nodeName}.utils.menuUtils');
 `;
   }
+
+  // Backward-compatible alias.
+  generateMenuUtilsCode(nodeName, customHelpers = {}) {
+    return this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
+  }
 }
 
 module.exports = EndpointUtils;

src/helper/formatters/csvFormatter.js

@@ -0,0 +1,44 @@
+/**
+ * CSV formatter
+ * Produces a single CSV line: timestamp,measurement,field1=val1,field2=val2,...
+ *
+ * Values are escaped if they contain commas or quotes.
+ *
+ * @param {string} measurement - The measurement name (e.g. node name)
+ * @param {object} metadata    - { fields, tags }
+ *   - fields: key/value pairs of changed data points
+ *   - tags:   flat key/value string pairs (included as columns)
+ * @returns {string} CSV-formatted line
+ */
+function format(measurement, metadata) {
+  const { fields, tags } = metadata;
+  const timestamp = new Date().toISOString();
+  const parts = [escapeCSV(timestamp), escapeCSV(measurement)];
+
+  // Append tags first, then fields
+  if (tags) {
+    for (const key of Object.keys(tags).sort()) {
+      parts.push(escapeCSV(`${key}=${tags[key]}`));
+    }
+  }
+
+  for (const key of Object.keys(fields).sort()) {
+    parts.push(escapeCSV(`${key}=${fields[key]}`));
+  }
+
+  return parts.join(',');
+}
+
+/**
+ * Escapes a value for safe inclusion in a CSV field.
+ * Wraps in double quotes if the value contains a comma, quote, or newline.
+ */
+function escapeCSV(value) {
+  const str = String(value);
+  if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+    return '"' + str.replace(/"/g, '""') + '"';
+  }
+  return str;
+}
+
+module.exports = { format };

src/helper/formatters/index.js

@@ -0,0 +1,60 @@
+/**
+ * Formatter Registry
+ * ------------------
+ * Maps format names to formatter modules.
+ * Each formatter exports: format(measurement, metadata) => string|object
+ *
+ * Usage:
+ *   const { getFormatter, registerFormatter } = require('./formatters');
+ *   const fmt = getFormatter('json');
+ *   const output = fmt.format('pump1', { fields: {...}, tags: {...} });
+ */
+
+const influxdbFormatter = require('./influxdbFormatter');
+const jsonFormatter = require('./jsonFormatter');
+const csvFormatter = require('./csvFormatter');
+const processFormatter = require('./processFormatter');
+
+// Built-in registry
+const registry = {
+  influxdb: influxdbFormatter,
+  json: jsonFormatter,
+  csv: csvFormatter,
+  process: processFormatter,
+};
+
+/**
+ * Retrieve a formatter by name.
+ * @param {string} name - Format name (e.g. 'influxdb', 'json', 'csv')
+ * @returns {object} Formatter with a .format() method
+ * @throws {Error} If the format name is not registered
+ */
+function getFormatter(name) {
+  const formatter = registry[name];
+  if (!formatter) {
+    throw new Error(`Unknown output format: "${name}". Registered formats: ${Object.keys(registry).join(', ')}`);
+  }
+  return formatter;
+}
+
+/**
+ * Register a custom formatter at runtime.
+ * @param {string} name      - Format name
+ * @param {object} formatter - Object with a .format(measurement, metadata) method
+ */
+function registerFormatter(name, formatter) {
+  if (typeof formatter.format !== 'function') {
+    throw new Error('Formatter must have a .format(measurement, metadata) method');
+  }
+  registry[name] = formatter;
+}
+
+/**
+ * List all registered format names.
+ * @returns {string[]}
+ */
+function getRegisteredFormats() {
+  return Object.keys(registry);
+}
+
+module.exports = { getFormatter, registerFormatter, getRegisteredFormats };

src/helper/formatters/influxdbFormatter.js

@@ -0,0 +1,22 @@
+/**
+ * InfluxDB formatter
+ * Produces the structured object expected by Node-RED InfluxDB nodes:
+ *   { measurement, fields, tags, timestamp }
+ *
+ * @param {string} measurement - The measurement name (e.g. node name)
+ * @param {object} metadata    - { fields, tags }
+ *   - fields: key/value pairs of changed data points
+ *   - tags:   flat key/value string pairs (InfluxDB tags)
+ * @returns {string|object} Formatted payload (object for InfluxDB)
+ */
+function format(measurement, metadata) {
+  const { fields, tags } = metadata;
+  return {
+    measurement: measurement,
+    fields: fields,
+    tags: tags || {},
+    timestamp: new Date(),
+  };
+}
+
+module.exports = { format };

src/helper/formatters/jsonFormatter.js

@@ -0,0 +1,22 @@
+/**
+ * JSON formatter
+ * Produces a JSON string suitable for MQTT, REST APIs, etc.
+ *
+ * @param {string} measurement - The measurement name (e.g. node name)
+ * @param {object} metadata    - { fields, tags }
+ *   - fields: key/value pairs of changed data points
+ *   - tags:   flat key/value string pairs
+ * @returns {string} JSON-encoded string
+ */
+function format(measurement, metadata) {
+  const { fields, tags } = metadata;
+  const payload = {
+    measurement: measurement,
+    fields: fields,
+    tags: tags || {},
+    timestamp: new Date().toISOString(),
+  };
+  return JSON.stringify(payload);
+}
+
+module.exports = { format };

src/helper/formatters/processFormatter.js

@@ -0,0 +1,9 @@
+/**
+ * Process formatter
+ * Keeps the existing process-port behaviour: emit only changed fields as an object.
+ */
+function format(_measurement, metadata) {
+  return metadata.fields;
+}
+
+module.exports = { format };

src/helper/gravity.js

@@ -0,0 +1,90 @@
+/**
+ * Gravity calculations based on WGS-84 ellipsoid model.
+ * Author: Rene de Ren (Waterschap Brabantse Delta)
+ * License: EUPL-1.2
+ */
+
+class Gravity {
+  constructor() {
+    // Standard (conventional) gravity at 45° latitude, sea level
+    this.g0 = 9.80665; // m/s²
+  }
+
+  /**
+   * Returns standard gravity (constant)
+   * @returns {number} gravity in m/s²
+   */
+  getStandardGravity() {
+    return this.g0;
+  }
+
+  /**
+   * Computes local gravity based on latitude and elevation.
+   * Formula: WGS-84 normal gravity (Somigliana)
+   * @param {number} latitudeDeg  Latitude in degrees (−90 → +90)
+   * @param {number} elevationM   Elevation above sea level [m]
+   * @returns {number} gravity in m/s²
+   */
+  getLocalGravity(latitudeDeg, elevationM = 0) {
+    const phi = (latitudeDeg * Math.PI) / 180;
+    const sinPhi = Math.sin(phi);
+    const sin2 = sinPhi * sinPhi;
+    const sin2_2phi = Math.sin(2 * phi) ** 2;
+
+    // WGS-84 normal gravity on the ellipsoid
+    const gSurface =
+      9.780327 * (1 + 0.0053024 * sin2 - 0.0000058 * sin2_2phi);
+
+    // Free-air correction for elevation (~ −3.086×10⁻⁶ m/s² per m)
+    const gLocal = gSurface - 3.086e-6 * elevationM;
+    return gLocal;
+  }
+
+  /**
+   * Calculates hydrostatic pressure difference (ΔP = ρ g h)
+   * @param {number} density     Fluid density [kg/m³]
+   * @param {number} heightM     Height difference [m]
+   * @param {number} latitudeDeg Latitude (for local g)
+   * @param {number} elevationM  Elevation (for local g)
+   * @returns {number} Pressure difference [Pa]
+   */
+  pressureHead(density, heightM, latitudeDeg = 45, elevationM = 0) {
+    const g = this.getLocalGravity(latitudeDeg, elevationM);
+    return density * g * heightM;
+  }
+
+  /**
+   * Calculates weight force (F = m g)
+   * @param {number} massKg      Mass [kg]
+   * @param {number} latitudeDeg Latitude (for local g)
+   * @param {number} elevationM  Elevation (for local g)
+   * @returns {number} Force [N]
+   */
+  weightForce(massKg, latitudeDeg = 45, elevationM = 0) {
+    const g = this.getLocalGravity(latitudeDeg, elevationM);
+    return massKg * g;
+  }
+}
+
+module.exports = new Gravity();
+
+
+/*
+const gravity = gravity;
+
+// Standard gravity
+console.log('g₀ =', gravity.getStandardGravity(), 'm/s²');
+
+// Local gravity (Breda ≈ 51.6° N, 3 m elevation)
+console.log('g @ Breda =', gravity.getLocalGravity(51.6, 3).toFixed(6), 'm/s²');
+
+// Head pressure for 5 m water column at Breda
+console.log(
+  'ΔP =',
+  gravity.pressureHead(1000, 5, 51.6, 3).toFixed(1),
+  'Pa'
+);
+
+// Weight of 1 kg mass at Breda
+console.log('Weight =', gravity.weightForce(1, 51.6, 3).toFixed(6), 'N');
+*/

src/helper/index.js

@@ -0,0 +1,25 @@
+const assertions = require('./assertionUtils.js');
+const assetUtils = require('./assetUtils.js');
+const childRegistrationUtils = require('./childRegistrationUtils.js');
+const configUtils = require('./configUtils.js');
+const endpointUtils = require('./endpointUtils.js');
+const gravity = require('./gravity.js');
+const logger = require('./logger.js');
+const menuUtils = require('./menuUtils.js');
+const nodeTemplates = require('./nodeTemplates.js');
+const outputUtils = require('./outputUtils.js');
+const validation = require('./validationUtils.js');
+
+module.exports = {
+  assertions,
+  assetUtils,
+  childRegistrationUtils,
+  configUtils,
+  endpointUtils,
+  gravity,
+  logger,
+  menuUtils,
+  nodeTemplates,
+  outputUtils,
+  validation,
+};

src/helper/logger.js

@@ -44,7 +44,7 @@ class Logger {
       if (this.levels.includes(level)) {
         this.logLevel = level;
       } else {
-        console.error(`[ERROR ${this.nameModule}]: Invalid log level: ${level}`);
+        console.error(`[ERROR] -> ${this.nameModule}: Invalid log level: ${level}`);
       }
     }
   

src/helper/menu/htmlGeneration.js

@@ -16,17 +16,26 @@ const htmlGeneration = {
     }
   },
 
-  createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}) {
+  createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}, options = {}) {
-      RED.httpAdmin.get(`/${nodeName}/resources/menuUtils.js`, function(req, res) {
+    const basePath = `/${nodeName}/resources`;
-        console.log(`Serving menuUtils.js for ${nodeName} node`);
-        res.set('Content-Type', 'application/javascript');
 
-        const browserCode = this.generateMenuUtilsCode(nodeName, customHelpers);
+    RED.httpAdmin.get(`${basePath}/menuUtilsData.json`, function(req, res) {
+      res.json(this.generateMenuUtilsData(nodeName, customHelpers, options));
+    }.bind(this));
+
+    RED.httpAdmin.get(`${basePath}/menuUtils.legacy.js`, function(req, res) {
+      res.set('Content-Type', 'application/javascript');
+      const browserCode = this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
       res.send(browserCode);
     }.bind(this));
+
+    RED.httpAdmin.get(`${basePath}/menuUtils.js`, function(req, res) {
+      res.set('Content-Type', 'application/javascript');
+      res.send(this.generateMenuUtilsBootstrap(nodeName));
+    }.bind(this));
   },
 
-  generateMenuUtilsCode(nodeName, customHelpers = {}) {
+  generateMenuUtilsData(nodeName, customHelpers = {}, options = {}) {
     const defaultHelpers = {
       validateRequired: `function(value) {
         return value && value.toString().trim() !== '';
@@ -36,7 +45,71 @@ const htmlGeneration = {
       }`
     };
 
-    const allHelpers = { ...defaultHelpers, ...customHelpers };
+    return {
+      nodeName,
+      helpers: { ...defaultHelpers, ...customHelpers },
+      options: {
+        autoLoadLegacy: options.autoLoadLegacy !== false,
+      },
+    };
+  },
+
+  generateMenuUtilsBootstrap(nodeName) {
+    return `
+    // Stable bootstrap for EVOLV menu utils (${nodeName})
+    (function() {
+      const nodeName = ${JSON.stringify(nodeName)};
+      const basePath = '/' + nodeName + '/resources';
+
+      window.EVOLV = window.EVOLV || {};
+      window.EVOLV.nodes = window.EVOLV.nodes || {};
+      window.EVOLV.nodes[nodeName] = window.EVOLV.nodes[nodeName] || {};
+      window.EVOLV.nodes[nodeName].utils = window.EVOLV.nodes[nodeName].utils || {};
+
+      function parseHelper(fnBody) {
+        try {
+          return (new Function('return (' + fnBody + ')'))();
+        } catch (error) {
+          console.error('[menuUtils] helper parse failed:', error);
+          return function() { return null; };
+        }
+      }
+
+      function loadLegacyIfNeeded(autoLoadLegacy) {
+        if (!autoLoadLegacy || typeof window.MenuUtils === 'function') return Promise.resolve();
+        return new Promise((resolve, reject) => {
+          const script = document.createElement('script');
+          script.src = basePath + '/menuUtils.legacy.js';
+          script.onload = resolve;
+          script.onerror = reject;
+          document.head.appendChild(script);
+        });
+      }
+
+      fetch(basePath + '/menuUtilsData.json')
+        .then(function(res) { return res.json(); })
+        .then(function(payload) {
+          const helperFns = {};
+          Object.entries(payload.helpers || {}).forEach(function(entry) {
+            helperFns[entry[0]] = parseHelper(entry[1]);
+          });
+          window.EVOLV.nodes[nodeName].utils.helpers = helperFns;
+          return loadLegacyIfNeeded(payload.options && payload.options.autoLoadLegacy);
+        })
+        .then(function() {
+          if (typeof window.MenuUtils === 'function' && !window.EVOLV.nodes[nodeName].utils.menuUtils) {
+            window.EVOLV.nodes[nodeName].utils.menuUtils = new window.MenuUtils();
+          }
+        })
+        .catch(function(error) {
+          console.error('[menuUtils] bootstrap failed for ' + nodeName, error);
+        });
+    })();
+    `;
+  },
+
+  generateLegacyMenuUtilsCode(nodeName, customHelpers = {}) {
+    const allHelpers = { ...this.generateMenuUtilsData(nodeName).helpers, ...customHelpers };
 
     const helpersCode = Object.entries(allHelpers)
       .map(([name, func]) => `        ${name}: ${func}`)
@@ -68,6 +141,11 @@ const htmlGeneration = {
       console.log('${nodeName} utilities loaded in namespace');
     `;
   },
+
+  // Backward-compatible alias
+  generateMenuUtilsCode(nodeName, customHelpers = {}) {
+    return this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
+  },
 };
 
 module.exports = htmlGeneration;

src/helper/outputUtils.js

@@ -1,12 +1,16 @@
+const { getFormatter } = require('./formatters');
+
 //this class will handle the output events for the node red node
 class OutputUtils {
   constructor() {
     this.output = {};
-    this.output['influxdb'] = {};
-    this.output['process'] = {};
   }
 
   checkForChanges(output, format) {
+    if (!output || typeof output !== 'object') {
+      return {};
+    }
+    this.output[format] = this.output[format] || {};
     const changedFields = {};
     for (const key in output) {
       if (Object.prototype.hasOwnProperty.call(output, key) && output[key] !== this.output[format][key]) {
@@ -27,56 +31,45 @@ class OutputUtils {
   }
 
   formatMsg(output, config, format) {
-  
-    //define emtpy message
       let msg = {};
 
       // Compare output with last output and only include changed values
       const changedFields = this.checkForChanges(output,format);
 
       if (Object.keys(changedFields).length > 0) {
-
-        switch (format) {
-          case 'influxdb': {
-            // Extract the relevant config properties.
-            const relevantConfig = this.extractRelevantConfig(config);
-            // Flatten the tags so that no nested objects are passed on.
-            const flatTags = this.flattenTags(relevantConfig);
-            msg = this.influxDBFormat(changedFields, config, flatTags);
-
-            break;
-          }
-
-          case 'process':
-
-            // Compare output with last output and only include changed values
-            msg = this.processFormat(changedFields,config);
-            //console.log(msg);
-            break;
-
-          default:
-            console.log('Unknown format in output utils');
-            break;
-        }
-        return msg;
-      }
-  }
-  
-
-  influxDBFormat(changedFields, config , flatTags) {
-    // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
         const measurement = config.general.name;
-    const payload = {
+        const flatTags = this.flattenTags(this.extractRelevantConfig(config));
-      measurement: measurement,
+        const formatterName = this.resolveFormatterName(config, format);
+        const formatter = getFormatter(formatterName);
+        const payload = formatter.format(measurement, {
           fields: changedFields,
           tags: flatTags,
-      timestamp: new Date(),
+          config,
-    };
+          channel: format,
-
+        });
-    const topic = measurement;
+        msg = this.wrapMessage(measurement, payload);
-    const msg = { topic: topic, payload: payload };
         return msg;
       }
+      return null;
+  }
+
+  resolveFormatterName(config, channel) {
+    const outputConfig = config.output || {};
+    if (channel === 'process') {
+      return outputConfig.process || 'process';
+    }
+    if (channel === 'influxdb') {
+      return outputConfig.dbase || 'influxdb';
+    }
+    return outputConfig[channel] || channel;
+  }
+
+  wrapMessage(measurement, payload) {
+    return {
+      topic: measurement,
+      payload,
+    };
+  }
 
   flattenTags(obj) {
     const result = {};
@@ -105,29 +98,19 @@ class OutputUtils {
     return {
       // general properties
       id: config.general?.id,
-      name: config.general?.name,
-      unit: config.general?.unit,
       // functionality properties
       softwareType: config.functionality?.softwareType,
       role: config.functionality?.role,
       // asset properties (exclude machineCurve)
       uuid: config.asset?.uuid,
+      tagcode: config.asset?.tagcode,
       geoLocation: config.asset?.geoLocation,
-      supplier: config.asset?.supplier,
+      category: config.asset?.category,
       type: config.asset?.type,
-      subType: config.asset?.subType,
       model: config.asset?.model,
+      unit: config.general?.unit,
     };
   }
-
-  processFormat(changedFields,config) {
-        // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
-        const measurement = config.general.name;
-        const payload = changedFields;
-        const topic = measurement;
-        const msg = { topic: topic, payload: payload };
-        return msg;
-  }
 }
 
 module.exports = OutputUtils;

src/helper/validationUtils.js

@@ -50,9 +50,22 @@ const VALIDATORS = {
 
 class ValidationUtils {
   constructor(IloggerEnabled, IloggerLevel) {
-        const loggerEnabled = IloggerEnabled || true;
+        const loggerEnabled = IloggerEnabled ?? true;
-        const loggerLevel = IloggerLevel || "warn";
+        const loggerLevel = IloggerLevel ?? "warn";
         this.logger = new Logger(loggerEnabled, loggerLevel, 'ValidationUtils');
+        this._onceLogCache = new Set();
+  }
+
+    _logOnce(level, onceKey, message) {
+        if (onceKey && this._onceLogCache.has(onceKey)) {
+            return;
+        }
+        if (onceKey) {
+            this._onceLogCache.add(onceKey);
+        }
+        if (typeof this.logger?.[level] === "function") {
+            this.logger[level](message);
+        }
     }
 
     constrain(value, min, max) {
@@ -82,11 +95,19 @@ class ValidationUtils {
         // Validate each key in the schema and loop over wildcards if they are not in schema
         for ( const key in schema ) {
 
-            if (key === "rules" || key === "description" || key === "schema") {
+            if (key === "rules" || key === "description" || key === "schema" || key === "version") {
                 continue;
               }
 
             const fieldSchema = schema[key];
+
+            // Skip non-object schema entries (e.g. primitive values injected by migration)
+            if (fieldSchema === null || typeof fieldSchema !== 'object') {
+                this.logger.debug(`${name}.${key} has a non-object schema entry (${typeof fieldSchema}). Skipping.`);
+                validatedConfig[key] = fieldSchema;
+                continue;
+            }
+
             const { rules = {} } = fieldSchema;
 
             // Default to the schema's default value if the key is missing
@@ -110,7 +131,7 @@ class ValidationUtils {
                     continue;
                     }
                 } else {
-                    this.logger.info(`There is no value provided for ${name}.${key}. Using default value.`);
+                    this.logger.debug(`No value provided for ${name}.${key}. Using default value.`);
                     configValue = fieldSchema.default;
                 }
                 //continue;
@@ -186,7 +207,7 @@ class ValidationUtils {
               continue;
             }
 
-            if("default" in v){
+            if(v && typeof v === "object" && "default" in v){
                 //put the default value in the object
                 newObj[k] = v.default;
                 continue;

src/helper/validators/typeValidators.js

@@ -56,35 +56,83 @@ function validateBoolean(configValue, name, key, logger) {
     return configValue;
 }
 
+function _isUnitLikeField(path) {
+    const normalized = String(path || "").toLowerCase();
+    if (!normalized) return false;
+    return /(^|\.)([a-z0-9]*unit|units)(\.|$)/.test(normalized)
+        || normalized.includes(".curveunits.");
+}
+
+function _resolveStringNormalizeMode(path) {
+    const normalized = String(path || "").toLowerCase();
+    if (!normalized) return "none";
+
+    if (_isUnitLikeField(normalized)) return "none";
+    if (normalized.endsWith(".name")) return "none";
+    if (normalized.endsWith(".model")) return "none";
+    if (normalized.endsWith(".supplier")) return "none";
+    if (normalized.endsWith(".role")) return "none";
+    if (normalized.endsWith(".description")) return "none";
+
+    if (normalized.endsWith(".softwaretype")) return "lowercase";
+    if (normalized.endsWith(".type")) return "lowercase";
+    if (normalized.endsWith(".category")) return "lowercase";
+
+    return "lowercase";
+}
+
 function validateString(configValue, rules, fieldSchema, name, key, logger) {
     let newConfigValue = configValue;
+
     if (typeof configValue !== "string") {
+        //check if the value is nullable
         if(rules.nullable){
             if(configValue === null){
                 return null;
             }
         }
+
         logger.warn(`${name}.${key} is not a string. Trying to convert to string.`);
-        newConfigValue = String(configValue);
+        newConfigValue = String(configValue); // Coerce to string if not already
     }
+
+    //check if the string is a valid string after conversion
     if (typeof newConfigValue !== "string") {
         logger.warn(`${name}.${key} is not a valid string. Using default value.`);
         return fieldSchema.default;
     }
-    if (newConfigValue !== newConfigValue.toLowerCase()) {
+
-        logger.warn(`${name}.${key} contains uppercase characters. Converting to lowercase: ${newConfigValue} -> ${newConfigValue.toLowerCase()}`);
+    const keyString = `${name}.${key}`;
+    const normalizeMode = rules.normalize || _resolveStringNormalizeMode(keyString);
+    const preserveCase = normalizeMode !== "lowercase";
+
+    // Check for uppercase characters and convert to lowercase if present
+    if (!preserveCase && newConfigValue !== newConfigValue.toLowerCase()) {
+        logger.info(
+            `${name}.${key} normalized to lowercase: ${newConfigValue} -> ${newConfigValue.toLowerCase()}`
+        );
         newConfigValue = newConfigValue.toLowerCase();
     }
+
     return newConfigValue;
 }
 
 function validateEnum(configValue, rules, fieldSchema, name, key, logger) {
     if (Array.isArray(rules.values)) {
+        //if value is null take default
         if(configValue === null){
             logger.warn(`${name}.${key} is null. Using default value.`);
             return fieldSchema.default;
         }
+
+        if (typeof configValue !== "string") {
+            logger.warn(`${name}.${key} is not a valid enum string. Using default value.`);
+            return fieldSchema.default;
+        }
+
         const validValues = rules.values.map(e => e.value.toLowerCase());
+
+        //remove caps
         configValue = configValue.toLowerCase();
         if (!validValues.includes(configValue)) {
             logger.warn(

src/measurements/Measurement.js

@@ -69,8 +69,10 @@ class Measurement {
   }
 
   getLaggedValue(lag){
-    if(this.values.length <= lag) return null;
+    if (lag < 0) throw new Error('lag must be >= 0');
-    return this.values[this.values.length - lag];
+    const index = this.values.length - 1 - lag;
+    if (index < 0) return null;
+    return this.values[index];
   }
 
   getLaggedSample(lag){
@@ -177,7 +179,7 @@ class Measurement {
     
     try {
       const convertedValues = this.values.map(value => 
-        convertModule.convert(value).from(this.unit).to(targetUnit)
+        convertModule(value).from(this.unit).to(targetUnit)
       );
       
       const newMeasurement = new Measurement(

src/measurements/MeasurementContainer.js

@@ -4,19 +4,21 @@ const convertModule = require('../convert/index');
 const { POSITIONS } = require('../constants/positions');
 
 class MeasurementContainer {
-  constructor(options = {},_logger) {
+  constructor(options = {},logger) {
+    this.logger = logger || null;
     this.emitter = new EventEmitter();
     this.measurements = {};
     this.windowSize = options.windowSize || 10; // Default window size
     
     // For chaining context
+    this._currentChildId = null;
     this._currentType = null;
     this._currentVariant = null;
     this._currentPosition = null;
     this._currentDistance = null;
     this._unit = null;
 
-    // Default units for each measurement type
+    // Default units for each measurement type (ingress/preferred)
     this.defaultUnits = {
       pressure: 'mbar',
       flow: 'm3/h',
@@ -27,9 +29,47 @@ class MeasurementContainer {
       ...options.defaultUnits // Allow override
     };
 
+    // Canonical storage unit map (single conversion anchor per measurement type)
+    this.canonicalUnits = {
+      pressure: 'Pa',
+      atmPressure: 'Pa',
+      flow: 'm3/s',
+      power: 'W',
+      hydraulicPower: 'W',
+      temperature: 'K',
+      volume: 'm3',
+      length: 'm',
+      mass: 'kg',
+      energy: 'J',
+      ...options.canonicalUnits,
+    };
+    
     // Auto-conversion settings
     this.autoConvert = options.autoConvert !== false; // Default to true
     this.preferredUnits = options.preferredUnits || {}; // Per-measurement overrides
+    this.storeCanonical = options.storeCanonical === true;
+    this.strictUnitValidation = options.strictUnitValidation === true;
+    this.throwOnInvalidUnit = options.throwOnInvalidUnit === true;
+    this.requireUnitForTypes = new Set(
+      (options.requireUnitForTypes || []).map((t) => String(t).trim().toLowerCase())
+    );
+
+    // Map EVOLV measurement types to convert-module measure families
+    this.measureMap = {
+      pressure: 'pressure',
+      atmpressure: 'pressure',
+      flow: 'volumeFlowRate',
+      power: 'power',
+      hydraulicpower: 'power',
+      reactivepower: 'reactivePower',
+      apparentpower: 'apparentPower',
+      temperature: 'temperature',
+      volume: 'volume',
+      length: 'length',
+      mass: 'mass',
+      energy: 'energy',
+      reactiveenergy: 'reactiveEnergy',
+    };
     
     // For chaining context
     this._currentType = null;
@@ -50,6 +90,11 @@ class MeasurementContainer {
       return this;
   }
 
+  child(childId) {
+    this._currentChildId = childId || 'default';
+    return this;
+  }
+
   setChildName(childName) {
       this.childName = childName;
       return this;
@@ -66,6 +111,11 @@ class MeasurementContainer {
     return this;
   }
 
+  setCanonicalUnit(measurementType, unit) {
+    this.canonicalUnits[measurementType] = unit;
+    return this;
+  }
+
   // Get the target unit for a measurement type
   _getTargetUnit(measurementType) {
     return this.preferredUnits[measurementType] || 
@@ -73,28 +123,113 @@ class MeasurementContainer {
            null;
   }
 
+  _getCanonicalUnit(measurementType) {
+    return this.canonicalUnits[measurementType] || null;
+  }
+
+  _normalizeType(measurementType) {
+    return String(measurementType || '').trim().toLowerCase();
+  }
+
+  _describeUnit(unit) {
+    if (typeof unit !== 'string' || unit.trim() === '') return null;
+    try {
+      return convertModule().describe(unit.trim());
+    } catch (error) {
+      return null;
+    }
+  }
+
+  isUnitCompatible(measurementType, unit) {
+    const desc = this._describeUnit(unit);
+    if (!desc) return false;
+    const normalizedType = this._normalizeType(measurementType);
+    const expectedMeasure = this.measureMap[normalizedType];
+    if (!expectedMeasure) return true;
+    return desc.measure === expectedMeasure;
+  }
+
+  _handleUnitViolation(message) {
+    if (this.throwOnInvalidUnit) {
+      throw new Error(message);
+    }
+    if (this.logger) {
+      this.logger.warn(message);
+    }
+  }
+
+  _resolveUnitPolicy(measurementType, sourceUnit = null) {
+    const normalizedType = this._normalizeType(measurementType);
+    const rawSourceUnit = typeof sourceUnit === 'string' && sourceUnit.trim()
+      ? sourceUnit.trim()
+      : null;
+    const fallbackIngressUnit = this._getTargetUnit(measurementType);
+    const canonicalUnit = this._getCanonicalUnit(measurementType);
+    const resolvedSourceUnit = rawSourceUnit || fallbackIngressUnit || canonicalUnit || null;
+
+    if (this.requireUnitForTypes.has(normalizedType) && !rawSourceUnit) {
+      this._handleUnitViolation(`Missing source unit for required measurement type '${measurementType}'.`);
+      return { valid: false };
+    }
+
+    if (resolvedSourceUnit && !this.isUnitCompatible(measurementType, resolvedSourceUnit)) {
+      this._handleUnitViolation(`Incompatible or unknown source unit '${resolvedSourceUnit}' for measurement type '${measurementType}'.`);
+      return { valid: false };
+    }
+
+    const resolvedStorageUnit = this.storeCanonical
+      ? (canonicalUnit || fallbackIngressUnit || resolvedSourceUnit)
+      : (fallbackIngressUnit || canonicalUnit || resolvedSourceUnit);
+
+    if (resolvedStorageUnit && !this.isUnitCompatible(measurementType, resolvedStorageUnit)) {
+      this._handleUnitViolation(`Incompatible storage unit '${resolvedStorageUnit}' for measurement type '${measurementType}'.`);
+      return { valid: false };
+    }
+
+    return {
+      valid: true,
+      sourceUnit: resolvedSourceUnit,
+      storageUnit: resolvedStorageUnit || null,
+      strictValidation: this.strictUnitValidation,
+    };
+  }
+
+  getUnit(type) {
+    if (!type) return null;
+    if (this.preferredUnits && this.preferredUnits[type]) return this.preferredUnits[type];
+    if (this.defaultUnits && this.defaultUnits[type]) return this.defaultUnits[type];
+    return null;
+  }
+
   // Chainable methods
   type(typeName) {
     this._currentType = typeName;
     this._currentVariant = null;
     this._currentPosition = null;
+    this._currentChildId = null;
     return this;
   }
 
   variant(variantName) {
     if (!this._currentType) {
-      throw new Error('Type must be specified before variant');
+      if (this.logger) {
+        this.logger.warn('variant() ignored: type must be specified before variant');
+      }
+      return this;
     }
     this._currentVariant = variantName;
     this._currentPosition = null;
+    this._currentChildId = null;
     return this;
   }
 
   position(positionValue) {
     if (!this._currentVariant) {
-      throw new Error('Variant must be specified before position');
+      if (this.logger) {
+        this.logger.warn('position() ignored: variant must be specified before position');
+      }
+      return this;
     }
-
 
     this._currentPosition = positionValue.toString().toLowerCase();
     
@@ -116,33 +251,39 @@ class MeasurementContainer {
   value(val, timestamp = Date.now(), sourceUnit = null) {
       if (!this._ensureChainIsValid()) return this;
 
+      const unitPolicy = this._resolveUnitPolicy(this._currentType, sourceUnit);
+      if (!unitPolicy.valid) return this;
+
       const measurement = this._getOrCreateMeasurement();
-      const targetUnit = this._getTargetUnit(this._currentType);
+      const targetUnit = unitPolicy.storageUnit;
 
       let convertedValue = val;
-      let finalUnit = sourceUnit || targetUnit;
+      let finalUnit = targetUnit || unitPolicy.sourceUnit;
 
       // Auto-convert if enabled and units are specified
-      if (this.autoConvert && sourceUnit && targetUnit && sourceUnit !== targetUnit) {
+      if (this.autoConvert && unitPolicy.sourceUnit && targetUnit && unitPolicy.sourceUnit !== targetUnit) {
         try {
-          convertedValue = convertModule(val).from(sourceUnit).to(targetUnit);
+          convertedValue = convertModule(val).from(unitPolicy.sourceUnit).to(targetUnit);
           finalUnit = targetUnit;
           
           if (this.logger) {
-            this.logger.debug(`Auto-converted ${val} ${sourceUnit} to ${convertedValue} ${targetUnit}`);
+            this.logger.debug(`Auto-converted ${val} ${unitPolicy.sourceUnit} to ${convertedValue} ${targetUnit}`);
           }
         } catch (error) {
-          if (this.logger) {
+          const message = `Auto-conversion failed from ${unitPolicy.sourceUnit} to ${targetUnit}: ${error.message}`;
-            this.logger.warn(`Auto-conversion failed from ${sourceUnit} to ${targetUnit}: ${error.message}`);
+          if (this.strictUnitValidation) {
+            this._handleUnitViolation(message);
+            return this;
           }
+          if (this.logger) this.logger.warn(message);
           convertedValue = val;
-          finalUnit = sourceUnit;
+          finalUnit = unitPolicy.sourceUnit;
         }
       }
 
       measurement.setValue(convertedValue, timestamp);
       
-      if (finalUnit && !measurement.unit) {
+      if (finalUnit) {
         measurement.setUnit(finalUnit);
       }
 
@@ -151,7 +292,7 @@ class MeasurementContainer {
         value: convertedValue,
         originalValue: val,
         unit: finalUnit,
-        sourceUnit: sourceUnit,
+        sourceUnit: unitPolicy.sourceUnit,
         timestamp,
         position: this._currentPosition,
         distance: this._currentDistance,
@@ -213,8 +354,6 @@ class MeasurementContainer {
     return requireValues ? measurement.values?.length > 0 : true;
   }
 
-
-
   unit(unitName) {
     if (!this._ensureChainIsValid()) return this;
     
@@ -227,35 +366,46 @@ class MeasurementContainer {
   // Terminal operations - get data out
     get() {
       if (!this._ensureChainIsValid()) return null;
-    return this._getOrCreateMeasurement();
+      const variantBucket = this.measurements[this._currentType]?.[this._currentVariant];
+      if (!variantBucket) return null;
+      const posBucket = variantBucket[this._currentPosition];
+      if (!posBucket) return null;
+
+      // Legacy single measurement
+      if (posBucket?.getCurrentValue) return posBucket;
+
+      // Child-aware: pick requested child, otherwise fall back to default, otherwise first available
+      if (posBucket && typeof posBucket === 'object') {
+        const requestedKey = this._currentChildId || this.childId;
+        const keys = Object.keys(posBucket);
+        if (!keys.length) return null;
+        const measurement =
+          (requestedKey && posBucket[requestedKey]) ||
+          posBucket.default ||
+          posBucket[keys[0]];
+        return measurement || null;
       }
 
+      return null;
+    }
+
+
+
   getCurrentValue(requestedUnit = null) {
     const measurement = this.get();
     if (!measurement) return null;
-    
     const value = measurement.getCurrentValue();
     if (value === null) return null;
-
+    if (!requestedUnit || !measurement.unit || requestedUnit === measurement.unit) {
-    // Return as-is if no unit conversion requested
-    if (!requestedUnit) {
       return value;
     }
-
-    // Convert if needed
-    if (measurement.unit && requestedUnit !== measurement.unit) {
     try {
       return convertModule(value).from(measurement.unit).to(requestedUnit);
     } catch (error) {
-        if (this.logger) {
+      if (this.logger) this.logger.error(`Unit conversion failed: ${error.message}`);
-          this.logger.error(`Unit conversion failed: ${error.message}`);
-        }
-        return value; // Return original value if conversion fails
-      }
-    }
-
       return value;
     }
+  }
 
   getAverage(requestedUnit = null) {
     const measurement = this.get();
@@ -309,7 +459,7 @@ class MeasurementContainer {
     // Convert if needed
     if (measurement.unit && requestedUnit !== measurement.unit) {
       try {
-        const convertedValue = convertModule(value).from(measurement.unit).to(requestedUnit);
+        const convertedValue = convertModule(sample.value).from(measurement.unit).to(requestedUnit);
         //replace old value in sample and return obj
         sample.value = convertedValue ;
         sample.unit = requestedUnit;
@@ -358,19 +508,76 @@ class MeasurementContainer {
     return sample;
   }
 
+  sum(type, variant, positions = [], targetUnit = null) {
+    const bucket = this.measurements?.[type]?.[variant];
+    if (!bucket) return 0;
+    return positions
+      .map((pos) => {
+        const posBucket = bucket[pos];
+        if (!posBucket) return 0;
+        return Object.values(posBucket)
+          .map((m) => {
+            if (!m?.getCurrentValue) return 0;
+            const val = m.getCurrentValue();
+            if (val == null) return 0;
+            const fromUnit = m.unit || targetUnit;
+            if (!targetUnit || !fromUnit || fromUnit === targetUnit) return val;
+            try { return convertModule(val).from(fromUnit).to(targetUnit); } catch { return val; }
+          })
+          .reduce((acc, v) => acc + (Number.isFinite(v) ? v : 0), 0);
+      })
+      .reduce((acc, v) => acc + v, 0);
+  }
+
+    getFlattenedOutput(options = {}) {
+      const requestedUnits = options.requestedUnits || (options.usePreferredUnits ? this.preferredUnits : null);
+      const out = {};
+      Object.entries(this.measurements).forEach(([type, variants]) => {
+        Object.entries(variants).forEach(([variant, positions]) => {
+          Object.entries(positions).forEach(([position, entry]) => {
+            // Legacy single series
+            if (entry?.getCurrentValue) {
+              out[`${type}.${variant}.${position}`] = this._resolveOutputValue(type, entry, requestedUnits);
+              return;
+            }
+            // Child-bucketed series
+            if (entry && typeof entry === 'object') {
+              Object.entries(entry).forEach(([childId, m]) => {
+                if (m?.getCurrentValue) {
+                  out[`${type}.${variant}.${position}.${childId}`] = this._resolveOutputValue(type, m, requestedUnits);
+                }
+              });
+            }
+          });
+        });
+      });
+      return out;
+  }
 
   // Difference calculations between positions
   difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: requestedUnit } = {}) {
     if (!this._currentType || !this._currentVariant) {
-    throw new Error("Type and variant must be specified for difference calculation");
+      if (this.logger) {
+        this.logger.warn('difference() ignored: type and variant must be specified');
+      }
+      return null;
     }
 
-  const get = pos =>
+    const get = pos => {
-    this.measurements?.[this._currentType]?.[this._currentVariant]?.[pos] || null;
+      const bucket = this.measurements?.[this._currentType]?.[this._currentVariant]?.[pos];
+      if (!bucket) return null;
+      // child-aware bucket: pick current childId/default or first available
+      if (bucket && typeof bucket === 'object' && !bucket.getCurrentValue) {
+        const childKey = this._currentChildId || this.childId || Object.keys(bucket)[0];
+        return bucket?.[childKey] || null;
+      }
+      // legacy single measurement
+      return bucket;
+    };
 
     const a = get(from);
     const b = get(to);
-  if (!a || !b || a.values.length === 0 || b.values.length === 0) {
+    if (!a || !b || !a.values || !b.values || a.values.length === 0 || b.values.length === 0) {
       return null;
     }
 
@@ -381,13 +588,7 @@ difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: request
     const aAvg = this._convertValueToUnit(a.getAverage(), a.unit, targetUnit);
     const bAvg = this._convertValueToUnit(b.getAverage(), b.unit, targetUnit);
 
-  return {
+    return { value: aVal - bVal, avgDiff: aAvg - bAvg, unit: targetUnit, from, to };
-    value: aVal - bVal,
-    avgDiff: aAvg - bAvg,
-    unit: targetUnit,
-    from,
-    to,
-  };
   }
 
   // Helper methods
@@ -411,18 +612,26 @@ difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: request
       this.measurements[this._currentType][this._currentVariant] = {};
     }
     
-    if (!this.measurements[this._currentType][this._currentVariant][this._currentPosition]) {
+    const positionKey = this._currentPosition;
-      this.measurements[this._currentType][this._currentVariant][this._currentPosition] = 
+    const childKey = this._currentChildId || this.childId || 'default';
-        new MeasurementBuilder()
+
+    if (!this.measurements[this._currentType][this._currentVariant][positionKey]) {
+      this.measurements[this._currentType][this._currentVariant][positionKey] = {};
+    }
+
+    const bucket = this.measurements[this._currentType][this._currentVariant][positionKey];
+
+    if (!bucket[childKey]) {
+      bucket[childKey] = new MeasurementBuilder()
         .setType(this._currentType)
         .setVariant(this._currentVariant)
-          .setPosition(this._currentPosition)
+        .setPosition(positionKey)
         .setWindowSize(this.windowSize)
         .setDistance(this._currentDistance)
         .build();
     }
 
-    return this.measurements[this._currentType][this._currentVariant][this._currentPosition];
+    return bucket[childKey];
   }
 
   // Additional utility methods
@@ -432,15 +641,33 @@ difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: request
 
   getVariants() {
     if (!this._currentType) {
-      throw new Error('Type must be specified before listing variants');
+      if (this.logger) {
+        this.logger.warn('getVariants() ignored: type must be specified first');
+      }
+      return [];
     }
     return this.measurements[this._currentType] ? 
       Object.keys(this.measurements[this._currentType]) : [];
   }
 
+  _resolveOutputValue(type, measurement, requestedUnits = null) {
+    const value = measurement.getCurrentValue();
+    if (!requestedUnits || value === null || typeof value === 'undefined') {
+      return value;
+    }
+    const targetUnit = requestedUnits[type];
+    if (!targetUnit) {
+      return value;
+    }
+    return this._convertValueToUnit(value, measurement.unit, targetUnit);
+  }
+
   getPositions() {
     if (!this._currentType || !this._currentVariant) {
-      throw new Error('Type and variant must be specified before listing positions');
+      if (this.logger) {
+        this.logger.warn('getPositions() ignored: type and variant must be specified first');
+      }
+      return [];
     }
     
     if (!this.measurements[this._currentType] || 
@@ -462,7 +689,7 @@ difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: request
 
   // Helper method for value conversion
   _convertValueToUnit(value, fromUnit, toUnit) {
-    if (!value || !fromUnit || !toUnit || fromUnit === toUnit) {
+    if ((value === null || typeof value === 'undefined') || !fromUnit || !toUnit || fromUnit === toUnit) {
       return value;
     }
 
@@ -481,19 +708,7 @@ difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: request
     const type = measurementType || this._currentType;
     if (!type) return [];
 
-    // Map measurement types to convert module measures
+    const convertMeasure = this.measureMap[this._normalizeType(type)];
-    const measureMap = {
-      pressure: 'pressure',
-      flow: 'volumeFlowRate',
-      power: 'power',
-      temperature: 'temperature',
-      volume: 'volume',
-      length: 'length',
-      mass: 'mass',
-      energy: 'energy'
-    };
-
-    const convertMeasure = measureMap[type];
     if (!convertMeasure) return [];
 
     try {
@@ -543,16 +758,19 @@ difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: request
   }
 
   _convertPositionNum2Str(positionValue) {
-    switch (positionValue) {
+    if (positionValue === 0) {
-    case 0:
       return POSITIONS.AT_EQUIPMENT;
-    case (positionValue < 0):
-      return POSITIONS.UPSTREAM;
-    case (positionValue > 0):
-      return POSITIONS.DOWNSTREAM;
-    default:
-      console.log(`Invalid position provided: ${positionValue}`);
     }
+    if (positionValue < 0) {
+      return POSITIONS.UPSTREAM;
+    }
+    if (positionValue > 0) {
+      return POSITIONS.DOWNSTREAM;
+    }
+    if (this.logger) {
+      this.logger.warn(`Invalid position provided: ${positionValue}`);
+    }
+    return null;
   }
 
 }

src/measurements/examples.js

@@ -180,18 +180,18 @@ const downstreamData = basicContainer
   .get();
 
   //check wether a serie exists
-const hasSeries = measurements // eslint-disable-line no-unused-vars
+const hasSeries = basicContainer // eslint-disable-line no-unused-vars
   .type("flow")
   .variant("measured")
   .exists();                // true if any position exists
 
-const hasUpstreamValues = measurements // eslint-disable-line no-unused-vars
+const hasUpstreamValues = basicContainer // eslint-disable-line no-unused-vars
   .type("flow")
   .variant("measured")
   .exists({ position: POSITIONS.UPSTREAM, requireValues: true });
 
 // Passing everything explicitly
-const hasPercent = measurements.exists({ // eslint-disable-line no-unused-vars
+const hasPercent = basicContainer.exists({ // eslint-disable-line no-unused-vars
   type: "volume",
   variant: "percent",
   position: POSITIONS.AT_EQUIPMENT,
@@ -277,14 +277,14 @@ console.log(`  History: [${allValues.values.join(', ')}]\n`);
 
 console.log('--- Lagged sample comparison ---');
 
-const latest = stats.getCurrentValue();               // existing helper
+const latestSample = stats.getLaggedSample(0);   // newest sample object
-const prevSample = stats.getLaggedValue(1);           // new helper
+const prevSample = stats.getLaggedSample(1);
-const prevPrevSample = stats.getLaggedValue(2);       // optional
+const prevPrevSample = stats.getLaggedSample(2);
 
 if (prevSample) {
-  const delta = latest - prevSample.value;
+  const delta = (latestSample?.value ?? 0) - (prevSample.value ?? 0);
   console.log(
-    `Current vs previous: ${latest} ${statsData.unit} (t=${stats.get().getLatestTimestamp()}) vs ` +
+    `Current vs previous: ${latestSample?.value} ${statsData.unit} (t=${latestSample?.timestamp}) vs ` +
     `${prevSample.value} ${prevSample.unit} (t=${prevSample.timestamp})`
   );
   console.log(`Δ = ${delta.toFixed(2)} ${statsData.unit}`);
@@ -348,6 +348,68 @@ basicContainer.getTypes().forEach(type => {
   }
 });
 
+// ---------------------------------------------------------------------------
+// --- Child Aggregation -----------------------------------------------------
+// ---------------------------------------------------------------------------
+
+// ====================================
+// AGGREGATION WITH CHILD SERIES (sum)
+// ====================================
+console.log();
+console.log('--- Example X: Aggregation with sum() and child series ---');
+
+// Container where flow is stored internally in m3/h
+const aggContainer = new MeasurementContainer({
+  windowSize: 10,
+  defaultUnits: {
+    flow: 'm3/h',
+  },
+});
+
+// Two pumps both feeding the same inlet position
+aggContainer
+  .child('pumpA')
+  .type('flow')
+  .variant('measured')
+  .position('inlet')
+  .value(10, Date.now(), 'm3/h'); // 10 m3/h
+
+aggContainer
+  .child('pumpB')
+  .type('flow')
+  .variant('measured')
+  .position('inlet')
+  .value(15, Date.now(), 'm3/h'); // 15 m3/h
+
+// Another position, e.g. outlet, also with two pumps
+aggContainer
+  .child('pumpA')
+  .type('flow')
+  .variant('measured')
+  .position('outlet')
+  .value(8, Date.now(), 'm3/h'); // 8 m3/h
+
+aggContainer
+  .child('pumpB')
+  .type('flow')
+  .variant('measured')
+  .position('outlet')
+  .value(11, Date.now(), 'm3/h'); // 11 m3/h
+
+
+// 1) Sum only inlet position (children pumpA + pumpB)
+const inletTotal = aggContainer.sum('flow', 'measured', ['inlet']);
+console.log(`Total inlet flow: ${inletTotal} m3/h (expected 25 m3/h)`);
+
+// 2) Sum inlet + outlet positions together
+const totalAll = aggContainer.sum('flow', 'measured', ['inlet', 'outlet']);
+console.log(`Total inlet+outlet flow: ${totalAll} m3/h (expected 44 m3/h)`);
+
+// 3) Same sum but explicitly ask for a target unit (e.g. l/s)
+//    This will use convertModule(...) internally.
+//    If conversion is not supported, it will fall back to the raw value.
+const totalAllLps = aggContainer.sum('flow', 'measured', ['inlet', 'outlet'], 'l/s');
+console.log(`Total inlet+outlet flow in l/s: ${totalAllLps} l/s (converted from m3/h)\n`);
 
 
 console.log('\n✅ All examples complete!\n');

src/menu/aquonSamples.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+
+class AquonSamplesMenu {
+  constructor(relPath = '../../datasets/assetData') {
+    this.baseDir = path.resolve(__dirname, relPath);
+    this.samplePath = path.resolve(this.baseDir, 'monsterSamples.json');
+    this.specPath = path.resolve(this.baseDir, 'specs/monster/index.json');
+    this.cache = new Map();
+  }
+
+  _loadJSON(filePath, cacheKey) {
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Aquon dataset not found: ${filePath}`);
+    }
+
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    this.cache.set(cacheKey, parsed);
+    return parsed;
+  }
+
+  getAllMenuData() {
+    const samples = this._loadJSON(this.samplePath, 'samples');
+    const specs = this._loadJSON(this.specPath, 'specs');
+
+    return {
+      samples: samples.samples || [],
+      specs: {
+        defaults: specs.defaults || {},
+        bySample: specs.bySample || {}
+      }
+    };
+  }
+}
+
+module.exports = AquonSamplesMenu;

src/menu/asset.js

@@ -1,61 +1,88 @@
-// asset.js
+const { assetCategoryManager } = require('../../datasets/assetData');
-const fs   = require('fs');
+const assetApiConfig = require('../configs/assetApiConfig.js');
-const path = require('path');
 
 class AssetMenu {
-  /** Define path where to find data of assets in constructor for now */
+  constructor({ manager = assetCategoryManager, softwareType = null } = {}) {
-  constructor(relPath = '../../datasets/assetData') {
+    this.manager = manager;
-    this.baseDir = path.resolve(__dirname, relPath);
+    this.softwareType = softwareType;
-    this.assetData = this._loadJSON('assetData');
+    this.categories = this.manager
+      .listCategories({ withMeta: true })
+      .reduce((map, meta) => {
+        map[meta.softwareType] = this.manager.getCategory(meta.softwareType);
+        return map;
+      }, {});
   }
 
-  _loadJSON(...segments) {
+  normalizeCategory(key) {
-    const filePath = path.resolve(this.baseDir, ...segments) + '.json';
+    const category = this.categories[key];
-    try {
+    if (!category) {
-      return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      return null;
-    } catch (err) {
+    }
-      throw new Error(`Failed to load ${filePath}: ${err.message}`);
+
+    return {
+      ...category,
+      label: category.label || category.softwareType || key,
+      suppliers: (category.suppliers || []).map((supplier) => ({
+        ...supplier,
+        id: supplier.id || supplier.name,
+        types: (supplier.types || []).map((type) => ({
+          ...type,
+          id: type.id || type.name,
+          models: (type.models || []).map((model) => ({
+            ...model,
+            id: model.id || model.name,
+            units: model.units || []
+          }))
+        }))
+      }))
+    };
+  }
+
+  resolveCategoryForNode(nodeName) {
+    const keys = Object.keys(this.categories);
+    if (keys.length === 0) {
+      return null;
+    }
+
+    if (this.softwareType && this.categories[this.softwareType]) {
+      return this.softwareType;
+    }
+
+    if (nodeName) {
+      const normalized = typeof nodeName === 'string' ? nodeName.toLowerCase() : nodeName;
+      if (normalized && this.categories[normalized]) {
+        return normalized;
       }
     }
 
-  /**
+    return keys[0];
-   * ADD THIS METHOD
+  }
-   * Compiles all menu data from the file system into a single nested object.
+
-   * This is run once on the server to pre-load everything.
+  getAllMenuData(nodeName) {
-   * @returns {object} A comprehensive object with all menu options.
+    const categoryKey = this.resolveCategoryForNode(nodeName);
-   */
+    const selectedCategories = {};
-  getAllMenuData() {
+
-    // load the raw JSON once
+    if (categoryKey && this.categories[categoryKey]) {
-    const data = this._loadJSON('assetData');
+      selectedCategories[categoryKey] = this.normalizeCategory(categoryKey);
-    const allData = {};
+    }
-
+
-    data.suppliers.forEach(sup => {
+    return {
-      allData[sup.name] = {};
+      categories: selectedCategories,
-      sup.categories.forEach(cat => {
+      defaultCategory: categoryKey,
-        allData[sup.name][cat.name] = {};
+      apiConfig: {
-        cat.types.forEach(type => {
+        url: `${assetApiConfig.baseUrl}/apis/products/PLC/integration/`,
-          // here: store the full array of model objects, not just names
+        headers: { ...assetApiConfig.headers }
-          allData[sup.name][cat.name][type.name] = type.models;
+      }
-        });
+    };
-      });
-    });
-
-    return allData;
   }
 
-  /**
-   * Convert the static initEditor function to a string that can be served to the client
-   * @param {string} nodeName - The name of the node type
-   * @returns {string} JavaScript code as a string
-   */
   getClientInitCode(nodeName) {
-  // step 1: get the two helper strings
     const htmlCode = this.getHtmlInjectionCode(nodeName);
     const dataCode = this.getDataInjectionCode(nodeName);
     const eventsCode = this.getEventInjectionCode(nodeName);
+    const syncCode = this.getSyncInjectionCode(nodeName);
     const saveCode = this.getSaveInjectionCode(nodeName);
 
-
     return `
       // --- AssetMenu for ${nodeName} ---
       window.EVOLV.nodes.${nodeName}.assetMenu =
@@ -64,105 +91,462 @@ getClientInitCode(nodeName) {
       ${htmlCode}
       ${dataCode}
       ${eventsCode}
+      ${syncCode}
       ${saveCode}
 
-      // wire it all up when the editor loads
       window.EVOLV.nodes.${nodeName}.assetMenu.initEditor = function(node) {
-      // ------------------  BELOW sequence is important! -------------------------------
+        console.log('Initializing asset properties for ${nodeName}');
-        console.log('Initializing asset properties for ${nodeName}…');
         this.injectHtml();
-        // load the data and wire up events
-        // this will populate the fields and set up the event listeners
         this.wireEvents(node);
-        // this will load the initial data into the fields
+        this.loadData(node).catch((error) =>
-        // this is important to ensure the fields are populated correctly
+          console.error('Asset menu load failed:', error)
-        this.loadData(node);
+        );
       };
     `;
-  
   }
 
   getDataInjectionCode(nodeName) {
     return `
-      // Asset Data loader for ${nodeName}
+      // Asset data loader for ${nodeName}
-      window.EVOLV.nodes.${nodeName}.assetMenu.loadData = function(node) {
+      window.EVOLV.nodes.${nodeName}.assetMenu.loadData = async function(node) {
-        const data = window.EVOLV.nodes.${nodeName}.menuData.asset;
+        const menuAsset = window.EVOLV.nodes.${nodeName}.menuData.asset || {};
+        const categories = menuAsset.categories || {};
+        const defaultCategory = menuAsset.defaultCategory || Object.keys(categories)[0] || null;
+        const apiConfig = menuAsset.apiConfig || {};
         const elems = {
           supplier: document.getElementById('node-input-supplier'),
-          category: document.getElementById('node-input-category'),
           type: document.getElementById('node-input-assetType'),
           model: document.getElementById('node-input-model'),
           unit: document.getElementById('node-input-unit')
         };
-        function populate(el, opts, sel) {
+
-          const old = el.value;
+        function resolveCategoryKey() {
-          el.innerHTML = '<option value="">Select…</option>';
+          if (node.softwareType && categories[node.softwareType]) {
-          (opts||[]).forEach(o=>{
+            return node.softwareType;
-            const opt = document.createElement('option');
-            opt.value = o; opt.textContent = o;
-            el.appendChild(opt);
-          });
-          el.value = sel||"";
-          if(el.value!==old) el.dispatchEvent(new Event('change'));
           }
-        // initial population
+          if (node.category && categories[node.category]) {
-        populate(elems.supplier, Object.keys(data), node.supplier);
+            return node.category;
+          }
+          return defaultCategory;
+        }
+
+        function normalizeModel(model = {}) {
+          return {
+            id: model.id ?? model.name,
+            name: model.name,
+            units: model.units || []
           };
-    `
+        }
+
+        function normalizeType(type = {}) {
+          return {
+            id: type.id || type.name,
+            name: type.name,
+            models: Array.isArray(type.models)
+              ? type.models.map(normalizeModel)
+              : []
+          };
+        }
+
+        function normalizeSupplier(supplier = {}) {
+          const types = (supplier.categories || []).reduce((acc, category) => {
+            const categoryTypes = Array.isArray(category.types)
+              ? category.types.map(normalizeType)
+              : [];
+            return acc.concat(categoryTypes);
+          }, []);
+          return {
+            id: supplier.id || supplier.name,
+            name: supplier.name,
+            types
+          };
+        }
+
+        function normalizeApiCategory(key, label, suppliers = []) {
+          const normalizedSuppliers = suppliers
+            .map(normalizeSupplier)
+            .filter((supplier) => supplier.types && supplier.types.length);
+          if (!normalizedSuppliers.length) {
+            return null;
+          }
+          return {
+            softwareType: key,
+            label: label || key,
+            suppliers: normalizedSuppliers
+          };
+        }
+
+        async function fetchCategoryFromApi(key) {
+          if (!apiConfig.url || !key) {
+            return null;
+          }
+          const response = await fetch(apiConfig.url, {
+            headers: apiConfig.headers || {}
+          });
+          if (!response.ok) {
+            throw new Error('Asset API request failed: ' + response.status);
+          }
+          const payload = await response.json();
+          if (!payload || payload.success === false || !Array.isArray(payload.data)) {
+            throw new Error(payload?.message || 'Unexpected asset API response');
+          }
+          return normalizeApiCategory(key, node.softwareType || key, payload.data);
+        }
+
+        function populate(selectEl, items = [], selectedValue, mapFn, placeholderText = 'Select...') {
+          const previous = selectEl.value;
+          const mapper = typeof mapFn === 'function'
+            ? mapFn
+            : (value) => ({ value, label: value });
+
+          selectEl.innerHTML = '';
+
+          const placeholder = document.createElement('option');
+          placeholder.value = '';
+          placeholder.textContent = placeholderText;
+          placeholder.disabled = true;
+          placeholder.selected = true;
+          selectEl.appendChild(placeholder);
+
+          items.forEach((item) => {
+            const option = mapper(item);
+            if (!option || typeof option.value === 'undefined') {
+              return;
+            }
+            const opt = document.createElement('option');
+            opt.value = option.value;
+            opt.textContent = option.label;
+            selectEl.appendChild(opt);
+          });
+
+          if (selectedValue) {
+            selectEl.value = selectedValue;
+            if (!selectEl.value) {
+              selectEl.value = '';
+            }
+          } else {
+            selectEl.value = '';
+          }
+          if (selectEl.value !== previous) {
+            selectEl.dispatchEvent(new Event('change'));
+          }
+        }
+
+        const categoryKey = resolveCategoryKey();
+        const resolvedCategoryKey = categoryKey || defaultCategory;
+        let activeCategory = resolvedCategoryKey ? categories[resolvedCategoryKey] : null;
+
+        if (resolvedCategoryKey) {
+          node.category = resolvedCategoryKey;
+        }
+
+        try {
+          const apiCategory = await fetchCategoryFromApi(resolvedCategoryKey);
+          if (apiCategory) {
+            categories[resolvedCategoryKey] = apiCategory;
+            activeCategory = apiCategory;
+          }
+        } catch (error) {
+          console.warn('[AssetMenu] API lookup failed for ${nodeName}, using local asset data', error);
+        }
+
+        const suppliers = activeCategory ? activeCategory.suppliers : [];
+        populate(
+          elems.supplier,
+          suppliers,
+          node.supplier,
+          (supplier) => ({ value: supplier.id || supplier.name, label: supplier.name }),
+          suppliers.length ? 'Select...' : 'No suppliers available'
+        );
+
+        const activeSupplier = suppliers.find(
+          (supplier) => String(supplier.id || supplier.name) === String(node.supplier)
+        );
+        const types = activeSupplier ? activeSupplier.types : [];
+        populate(
+          elems.type,
+          types,
+          node.assetType,
+          (type) => ({ value: type.id || type.name, label: type.name }),
+          activeSupplier ? 'Select...' : 'Awaiting Supplier Selection'
+        );
+
+        const activeType = types.find(
+          (type) => String(type.id || type.name) === String(node.assetType)
+        );
+        const models = activeType ? activeType.models : [];
+        populate(
+          elems.model,
+          models,
+          node.model,
+          (model) => ({ value: model.id || model.name, label: model.name }),
+          activeType ? 'Select...' : 'Awaiting Type Selection'
+        );
+
+        const activeModel = models.find(
+          (model) => String(model.id || model.name) === String(node.model)
+        );
+        if (activeModel) {
+          node.modelMetadata = activeModel;
+          node.modelName = activeModel.name;
+        }
+        populate(
+          elems.unit,
+          activeModel ? activeModel.units || [] : [],
+          node.unit,
+          (unit) => ({ value: unit, label: unit }),
+          activeModel ? 'Select...' : activeType ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
+        );
+        this.setAssetTagNumber(node, node.assetTagNumber || '');
+      };
+    `;
   }
 
   getEventInjectionCode(nodeName) {
     return `
-      // Asset Event wiring for ${nodeName}
+      // Asset event wiring for ${nodeName}
       window.EVOLV.nodes.${nodeName}.assetMenu.wireEvents = function(node) {
-        const data = window.EVOLV.nodes.${nodeName}.menuData.asset;
+        const menuAsset = window.EVOLV.nodes.${nodeName}.menuData.asset || {};
+        const categories = menuAsset.categories || {};
+        const defaultCategory = menuAsset.defaultCategory || Object.keys(categories)[0] || null;
         const elems = {
           supplier: document.getElementById('node-input-supplier'),
-          category: document.getElementById('node-input-category'),
           type: document.getElementById('node-input-assetType'),
           model: document.getElementById('node-input-model'),
           unit: document.getElementById('node-input-unit')
         };
-        function populate(el, opts, sel) {
+
-          const old = el.value;
+        function populate(selectEl, items = [], selectedValue, mapFn, placeholderText = 'Select...') {
-          el.innerHTML = '<option value="">Select…</option>';
+          const previous = selectEl.value;
-          (opts||[]).forEach(o=>{
+          const mapper = typeof mapFn === 'function'
-            const opt = document.createElement('option');
+            ? mapFn
-            opt.value = o; opt.textContent = o;
+            : (value) => ({ value, label: value });
-            el.appendChild(opt);
+
-          });
+          selectEl.innerHTML = '';
-          el.value = sel||"";
+
-          if(el.value!==old) el.dispatchEvent(new Event('change'));
+          const placeholder = document.createElement('option');
+          placeholder.value = '';
+          placeholder.textContent = placeholderText;
+          placeholder.disabled = true;
+          placeholder.selected = true;
+          selectEl.appendChild(placeholder);
+
+          items.forEach((item) => {
+            const option = mapper(item);
+            if (!option || typeof option.value === 'undefined') {
+              return;
             }
-        elems.supplier.addEventListener('change', ()=>{
+            const opt = document.createElement('option');
-          populate(elems.category,
+            opt.value = option.value;
-            elems.supplier.value? Object.keys(data[elems.supplier.value]||{}) : [],
+            opt.textContent = option.label;
-            node.category);
+            selectEl.appendChild(opt);
           });
-        elems.category.addEventListener('change', ()=>{
+
-          const s=elems.supplier.value, c=elems.category.value;
+          if (selectedValue) {
-          populate(elems.type,
+            selectEl.value = selectedValue;
-            (s&&c)? Object.keys(data[s][c]||{}) : [],
+            if (!selectEl.value) {
-            node.assetType);
+              selectEl.value = '';
-        });
+            }
-        elems.type.addEventListener('change', ()=>{
+          } else {
-          const s=elems.supplier.value, c=elems.category.value, t=elems.type.value;
+            selectEl.value = '';
-          const md = (s&&c&&t)? data[s][c][t]||[] : [];
+          }
-          populate(elems.model, md.map(m=>m.name), node.model);
+          if (selectEl.value !== previous) {
-        });
+            selectEl.dispatchEvent(new Event('change'));
-        elems.model.addEventListener('change', ()=>{
+          }
-          const s=elems.supplier.value, c=elems.category.value, t=elems.type.value, m=elems.model.value;
+        }
-          const md = (s&&c&&t)? data[s][c][t]||[] : [];
+
-          const entry = md.find(x=>x.name===m);
+        const resolveCategoryKey = () => {
-          populate(elems.unit, entry? entry.units : [], node.unit);
+          if (node.softwareType && categories[node.softwareType]) {
-        });
+            return node.softwareType;
-      };
+          }
-    `
+          if (node.category && categories[node.category]) {
+            return node.category;
+          }
+          return defaultCategory;
+        };
+
+        const getActiveCategory = () => {
+          const key = resolveCategoryKey();
+          return key ? categories[key] : null;
+        };
+
+        node.category = resolveCategoryKey();
+
+        elems.supplier.addEventListener('change', () => {
+          const category = getActiveCategory();
+          const supplier = category
+            ? category.suppliers.find(
+                (item) => String(item.id || item.name) === String(elems.supplier.value)
+              )
+            : null;
+          const types = supplier ? supplier.types : [];
+          populate(
+            elems.type,
+            types,
+            node.assetType,
+            (type) => ({ value: type.id || type.name, label: type.name }),
+            supplier ? 'Select...' : 'Awaiting Supplier Selection'
+          );
+          node.modelMetadata = null;
+          populate(elems.model, [], '', undefined, 'Awaiting Type Selection');
+          populate(elems.unit, [], '', undefined, 'Awaiting Type Selection');
+        });
+
+        elems.type.addEventListener('change', () => {
+          const category = getActiveCategory();
+          const supplier = category
+            ? category.suppliers.find(
+                (item) => String(item.id || item.name) === String(elems.supplier.value)
+              )
+            : null;
+          const type = supplier
+            ? supplier.types.find(
+                (item) => String(item.id || item.name) === String(elems.type.value)
+              )
+            : null;
+          const models = type ? type.models : [];
+          populate(
+            elems.model,
+            models,
+            node.model,
+            (model) => ({ value: model.id || model.name, label: model.name }),
+            type ? 'Select...' : 'Awaiting Type Selection'
+          );
+          node.modelMetadata = null;
+          populate(
+            elems.unit,
+            [],
+            '',
+            undefined,
+            type ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
+          );
+        });
+
+        elems.model.addEventListener('change', () => {
+          const category = getActiveCategory();
+          const supplier = category
+            ? category.suppliers.find(
+                (item) => String(item.id || item.name) === String(elems.supplier.value)
+              )
+            : null;
+          const type = supplier
+            ? supplier.types.find(
+                (item) => String(item.id || item.name) === String(elems.type.value)
+              )
+            : null;
+          const model = type
+            ? type.models.find(
+                (item) => String(item.id || item.name) === String(elems.model.value)
+              )
+            : null;
+          node.modelMetadata = model;
+          node.modelName = model ? model.name : '';
+          populate(
+            elems.unit,
+            model ? model.units || [] : [],
+            node.unit,
+            (unit) => ({ value: unit, label: unit }),
+            model ? 'Select...' : type ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
+          );
+        });
+      };
+    `;
+  }
+
+  getSyncInjectionCode(nodeName) {
+    return `
+      // Asset synchronization helpers for ${nodeName}
+      window.EVOLV.nodes.${nodeName}.assetMenu.setAssetTagNumber = function(node, tag) {
+        const normalized = tag ? tag.toString() : '';
+        const input = document.getElementById('node-input-assetTagNumber');
+        const hint = document.getElementById('node-input-assetTagNumber-hint');
+        console.info('[AssetMenu] tag number update', {
+          nodeId: node && node.id ? node.id : null,
+          tag: normalized
+        });
+        if (input) {
+          input.value = normalized;
+        }
+        if (hint) {
+          hint.textContent = normalized ? 'Assigned tag ' + normalized : 'Not registered yet';
+        }
+        if (node) {
+          node.assetTagNumber = normalized;
+        }
+      };
+
+      window.EVOLV.nodes.${nodeName}.assetMenu.buildSyncRequest = function(node) {
+        const tagInput = document.getElementById('node-input-assetTagNumber');
+        const candidateTag = tagInput && tagInput.value ? tagInput.value.trim() : '';
+        const fallbackTag = node && node.assetTagNumber ? node.assetTagNumber : '';
+        const registrationDefaults =
+          (window.EVOLV.nodes.${nodeName}.config && window.EVOLV.nodes.${nodeName}.config.assetRegistration && window.EVOLV.nodes.${nodeName}.config.assetRegistration.default) || {};
+        const displayName = node && node.name ? node.name : node && node.id ? node.id : '${nodeName}';
+        console.info('[AssetMenu] build sync payload', {
+          nodeId: node && node.id ? node.id : null,
+          candidateTag,
+          fallbackTag,
+          status: registrationDefaults.status || 'actief'
+        });
+        return {
+          asset: {
+            tagNumber: candidateTag || fallbackTag,
+            supplier: node && node.supplier ? node.supplier : '',
+            assetType: node && node.assetType ? node.assetType : '',
+            model: node && node.model ? node.model : '',
+            unit: node && node.unit ? node.unit : '',
+            assetName: displayName,
+            assetDescription: displayName,
+            assetStatus: registrationDefaults.status || 'actief',
+            modelMetadata: node && node.modelMetadata ? node.modelMetadata : null
+          },
+          nodeId: node && node.id ? node.id : null,
+          nodeName: node && node.type ? node.type : '${nodeName}'
+        };
+      };
+
+      window.EVOLV.nodes.${nodeName}.assetMenu.syncAsset = function(node) {
+        const payload = this.buildSyncRequest(node);
+        const redSettings = window.RED && window.RED.settings;
+        const adminRoot = redSettings ? redSettings.httpAdminRoot : '';
+        const trimmedRoot = adminRoot && adminRoot.endsWith('/') ? adminRoot.slice(0, -1) : adminRoot || '';
+        const prefix = trimmedRoot || '';
+        const endpoint = (prefix || '') + '/${nodeName}/asset-reg';
+        console.info('[AssetMenu] sync request', {
+          endpoint,
+          nodeId: node && node.id ? node.id : null,
+          tagNumber: payload && payload.asset ? payload.asset.tagNumber : null
+        });
+        fetch(endpoint, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(payload)
+        })
+          .then((res) =>
+            res.json().catch((err) => {
+              console.warn('[AssetMenu] asset sync response is not JSON', err);
+              return { success: false, message: err.message || 'Invalid API response' };
+            })
+          )
+          .then((result) => {
+            console.info('[AssetMenu] sync response', result);
+            if (result && result.success) {
+              const newTag = (result.data && result.data.asset_tag_number) || payload.asset.tagNumber || '';
+              this.setAssetTagNumber(node, newTag);
+              if (window.RED && typeof window.RED.notify === 'function') {
+                window.RED.notify('Asset synced: ' + (newTag || 'no tag'), 'info');
+              }
+            } else {
+              console.warn('[AssetMenu] asset sync failed', result && result.message);
+            }
+          })
+          .catch((error) => {
+            console.error('[AssetMenu] asset sync error', error);
+          });
+      };
+    `;
   }
 
-/**
-   * Generate HTML template for asset fields
-   */
   getHtmlTemplate() {
     return `
       <!-- Asset Properties -->
@@ -172,10 +556,6 @@ getEventInjectionCode(nodeName) {
         <label for="node-input-supplier"><i class="fa fa-industry"></i> Supplier</label>
         <select id="node-input-supplier" style="width:70%;"></select>
       </div>
-      <div class="form-row">
-        <label for="node-input-category"><i class="fa fa-sitemap"></i> Category</label>
-        <select id="node-input-category" style="width:70%;"></select>
-      </div>
       <div class="form-row">
         <label for="node-input-assetType"><i class="fa fa-puzzle-piece"></i> Type</label>
         <select id="node-input-assetType" style="width:70%;"></select>
@@ -188,15 +568,19 @@ getEventInjectionCode(nodeName) {
         <label for="node-input-unit"><i class="fa fa-balance-scale"></i> Unit</label>
         <select id="node-input-unit" style="width:70%;"></select>
       </div>
+      <div class="form-row">
+        <label for="node-input-assetTagNumber"><i class="fa fa-hashtag"></i> Asset Tag</label>
+        <input type="text" id="node-input-assetTagNumber" readonly style="width:70%;" />
+        <div class="form-tips" id="node-input-assetTagNumber-hint">Not registered yet</div>
+      </div>
       <hr />
     `;
   }
 
-  /**
-   * Get client-side HTML injection code
-   */
   getHtmlInjectionCode(nodeName) {
-    const htmlTemplate = this.getHtmlTemplate().replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    const htmlTemplate = this.getHtmlTemplate()
+      .replace(/`/g, '\\`')
+      .replace(/\$/g, '\\$');
 
     return `
       // Asset HTML injection for ${nodeName}
@@ -210,33 +594,60 @@ getEventInjectionCode(nodeName) {
     `;
   }
 
-  /** 
-   * Returns the JS that injects the saveEditor function 
-   */
   getSaveInjectionCode(nodeName) {
     return `
-      // Asset Save injection for ${nodeName}
+      // Asset save handler for ${nodeName}
       window.EVOLV.nodes.${nodeName}.assetMenu.saveEditor = function(node) {
-        console.log('Saving asset properties for ${nodeName}…');
+        console.log('Saving asset properties for ${nodeName}');
-        const fields = ['supplier','category','assetType','model','unit'];
+        const menuAsset = window.EVOLV.nodes.${nodeName}.menuData.asset || {};
-        const errors = [];
+        const categories = menuAsset.categories || {};
-        fields.forEach(f => {
+        const defaultCategory = menuAsset.defaultCategory || Object.keys(categories)[0] || null;
-          const el = document.getElementById(\`node-input-\${f}\`);
+        const resolveCategoryKey = () => {
-          node[f] = el ? el.value : '';
+          if (node.softwareType && categories[node.softwareType]) {
-        });
+            return node.softwareType;
-        if (node.assetType && !node.unit) errors.push('Unit must be set when type is specified.');
+          }
-        if (!node.unit)             errors.push('Unit is required.');
+          if (node.category && categories[node.category]) {
-        errors.forEach(e=>RED.notify(e,'error'));
+            return node.category;
+          }
+          return defaultCategory || '';
+        };
 
-        // --- DEBUG: show exactly what was saved ---
+        node.category = resolveCategoryKey();
-        const saved = fields.reduce((o,f) => { o[f] = node[f]; return o; }, {});
+
-        console.log('→ assetMenu.saveEditor result:', saved);
+        const fields = ['supplier', 'assetType', 'model', 'unit', 'assetTagNumber'];
+        const errors = [];
+
+        fields.forEach((field) => {
+          const el = document.getElementById(\`node-input-\${field}\`);
+          node[field] = el ? el.value : '';
+        });
+
+        if (node.assetType && !node.unit) {
+          errors.push('Unit must be set when a type is specified.');
+        }
+        if (!node.unit) {
+          errors.push('Unit is required.');
+        }
+
+        errors.forEach((msg) => RED.notify(msg, 'error'));
+
+        const saved = fields.reduce((acc, field) => {
+          acc[field] = node[field];
+          return acc;
+        }, {});
+        if (node.modelMetadata && typeof node.modelMetadata.id !== 'undefined') {
+          saved.modelId = node.modelMetadata.id;
+        }
+        console.log('[AssetMenu] save result:', saved);
+
+        if (errors.length === 0 && this.syncAsset) {
+          this.syncAsset(node);
+        }
 
         return errors.length === 0;
       };
     `;
   }
-
 }
 
 module.exports = AssetMenu;

src/menu/asset_DEPRECATED.js

@@ -0,0 +1,243 @@
+// asset.js
+const fs   = require('fs');
+const path = require('path');
+
+
+class AssetMenu {
+  /** Define path where to find data of assets in constructor for now */
+  constructor(relPath = '../../datasets/assetData') {
+    this.baseDir = path.resolve(__dirname, relPath);
+    this.assetData = this._loadJSON('assetData');
+  }
+
+  _loadJSON(...segments) {
+    const filePath = path.resolve(this.baseDir, ...segments) + '.json';
+    try {
+      return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (err) {
+      throw new Error(`Failed to load ${filePath}: ${err.message}`);
+    }
+  }
+  
+  /**
+   * ADD THIS METHOD
+   * Compiles all menu data from the file system into a single nested object.
+   * This is run once on the server to pre-load everything.
+   * @returns {object} A comprehensive object with all menu options.
+   */
+  getAllMenuData() {
+    // load the raw JSON once
+    const data = this._loadJSON('assetData');
+    const allData = {};
+
+    data.suppliers.forEach(sup => {
+      allData[sup.name] = {};
+      sup.categories.forEach(cat => {
+        allData[sup.name][cat.name] = {};
+        cat.types.forEach(type => {
+          // here: store the full array of model objects, not just names
+          allData[sup.name][cat.name][type.name] = type.models;
+        });
+      });
+    });
+
+    return allData;
+  }
+
+  /**
+   * Convert the static initEditor function to a string that can be served to the client
+   * @param {string} nodeName - The name of the node type
+   * @returns {string} JavaScript code as a string
+   */
+getClientInitCode(nodeName) {
+  // step 1: get the two helper strings
+  const htmlCode = this.getHtmlInjectionCode(nodeName);
+  const dataCode   = this.getDataInjectionCode(nodeName);
+  const eventsCode = this.getEventInjectionCode(nodeName);
+  const saveCode = this.getSaveInjectionCode(nodeName);
+
+
+   return `
+      // --- AssetMenu for ${nodeName} ---
+      window.EVOLV.nodes.${nodeName}.assetMenu =
+        window.EVOLV.nodes.${nodeName}.assetMenu || {};
+
+      ${htmlCode}
+      ${dataCode}
+      ${eventsCode}
+      ${saveCode}
+
+      // wire it all up when the editor loads
+      window.EVOLV.nodes.${nodeName}.assetMenu.initEditor = function(node) {
+      // ------------------  BELOW sequence is important! -------------------------------
+        console.log('Initializing asset properties for ${nodeName}…');
+        this.injectHtml();
+        // load the data and wire up events
+        // this will populate the fields and set up the event listeners
+        this.wireEvents(node);
+        // this will load the initial data into the fields
+        // this is important to ensure the fields are populated correctly
+        this.loadData(node);
+      };
+    `;
+  
+}
+
+getDataInjectionCode(nodeName) {
+    return `
+      // Asset Data loader for ${nodeName}
+      window.EVOLV.nodes.${nodeName}.assetMenu.loadData = function(node) {
+        const data = window.EVOLV.nodes.${nodeName}.menuData.asset;
+        const elems = {
+          supplier: document.getElementById('node-input-supplier'),
+          category: document.getElementById('node-input-category'),
+          type:     document.getElementById('node-input-assetType'),
+          model:    document.getElementById('node-input-model'),
+          unit:     document.getElementById('node-input-unit')
+        };
+        function populate(el, opts, sel) {
+          const old = el.value;
+          el.innerHTML = '<option value="">Select…</option>';
+          (opts||[]).forEach(o=>{
+            const opt = document.createElement('option');
+            opt.value = o; opt.textContent = o;
+            el.appendChild(opt);
+          });
+          el.value = sel||"";
+          if(el.value!==old) el.dispatchEvent(new Event('change'));
+        }
+        // initial population
+        populate(elems.supplier, Object.keys(data), node.supplier);
+      };
+    `
+  }
+
+getEventInjectionCode(nodeName) {
+    return `
+      // Asset Event wiring for ${nodeName}
+      window.EVOLV.nodes.${nodeName}.assetMenu.wireEvents = function(node) {
+        const data = window.EVOLV.nodes.${nodeName}.menuData.asset;
+        const elems = {
+          supplier: document.getElementById('node-input-supplier'),
+          category: document.getElementById('node-input-category'),
+          type:     document.getElementById('node-input-assetType'),
+          model:    document.getElementById('node-input-model'),
+          unit:     document.getElementById('node-input-unit')
+        };
+        function populate(el, opts, sel) {
+          const old = el.value;
+          el.innerHTML = '<option value="">Select…</option>';
+          (opts||[]).forEach(o=>{
+            const opt = document.createElement('option');
+            opt.value = o; opt.textContent = o;
+            el.appendChild(opt);
+          });
+          el.value = sel||"";
+          if(el.value!==old) el.dispatchEvent(new Event('change'));
+        }
+        elems.supplier.addEventListener('change', ()=>{
+          populate(elems.category,
+            elems.supplier.value? Object.keys(data[elems.supplier.value]||{}) : [],
+            node.category);
+        });
+        elems.category.addEventListener('change', ()=>{
+          const s=elems.supplier.value, c=elems.category.value;
+          populate(elems.type,
+            (s&&c)? Object.keys(data[s][c]||{}) : [],
+            node.assetType);
+        });
+        elems.type.addEventListener('change', ()=>{
+          const s=elems.supplier.value, c=elems.category.value, t=elems.type.value;
+          const md = (s&&c&&t)? data[s][c][t]||[] : [];
+          populate(elems.model, md.map(m=>m.name), node.model);
+        });
+        elems.model.addEventListener('change', ()=>{
+          const s=elems.supplier.value, c=elems.category.value, t=elems.type.value, m=elems.model.value;
+          const md = (s&&c&&t)? data[s][c][t]||[] : [];
+          const entry = md.find(x=>x.name===m);
+          populate(elems.unit, entry? entry.units : [], node.unit);
+        });
+      };
+    `
+  }
+
+/**
+   * Generate HTML template for asset fields
+   */
+  getHtmlTemplate() {
+    return `
+      <!-- Asset Properties -->
+      <hr />
+      <h3>Asset selection</h3>
+      <div class="form-row">
+        <label for="node-input-supplier"><i class="fa fa-industry"></i> Supplier</label>
+        <select id="node-input-supplier" style="width:70%;"></select>
+      </div>
+      <div class="form-row">
+        <label for="node-input-category"><i class="fa fa-sitemap"></i> Category</label>
+        <select id="node-input-category" style="width:70%;"></select>
+      </div>
+      <div class="form-row">
+        <label for="node-input-assetType"><i class="fa fa-puzzle-piece"></i> Type</label>
+        <select id="node-input-assetType" style="width:70%;"></select>
+      </div>
+      <div class="form-row">
+        <label for="node-input-model"><i class="fa fa-wrench"></i> Model</label>
+        <select id="node-input-model" style="width:70%;"></select>
+      </div>
+      <div class="form-row">
+        <label for="node-input-unit"><i class="fa fa-balance-scale"></i> Unit</label>
+        <select id="node-input-unit" style="width:70%;"></select>
+      </div>
+      <hr />
+    `;
+  }
+
+  /**
+   * Get client-side HTML injection code
+   */
+  getHtmlInjectionCode(nodeName) {
+    const htmlTemplate = this.getHtmlTemplate().replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    
+    return `
+      // Asset HTML injection for ${nodeName}
+      window.EVOLV.nodes.${nodeName}.assetMenu.injectHtml = function() {
+        const placeholder = document.getElementById('asset-fields-placeholder');
+        if (placeholder && !placeholder.hasChildNodes()) {
+          placeholder.innerHTML = \`${htmlTemplate}\`;
+          console.log('Asset HTML injected successfully');
+        }
+      };
+    `;
+  }
+
+  /** 
+   * Returns the JS that injects the saveEditor function 
+   */
+  getSaveInjectionCode(nodeName) {
+    return `
+      // Asset Save injection for ${nodeName}
+      window.EVOLV.nodes.${nodeName}.assetMenu.saveEditor = function(node) {
+        console.log('Saving asset properties for ${nodeName}…');
+        const fields = ['supplier','category','assetType','model','unit'];
+        const errors = [];
+        fields.forEach(f => {
+          const el = document.getElementById(\`node-input-\${f}\`);
+          node[f] = el ? el.value : '';
+        });
+        if (node.assetType && !node.unit) errors.push('Unit must be set when type is specified.');
+        if (!node.unit)             errors.push('Unit is required.');
+        errors.forEach(e=>RED.notify(e,'error'));
+        
+        // --- DEBUG: show exactly what was saved ---
+        const saved = fields.reduce((o,f) => { o[f] = node[f]; return o; }, {});
+        console.log('→ assetMenu.saveEditor result:', saved);
+
+        return errors.length===0;
+      };
+    `;
+  }
+
+}
+
+module.exports = AssetMenu;

src/menu/index.js

@@ -2,16 +2,22 @@ const AssetMenu = require('./asset.js');
 // TagcodeApp and DynamicAssetMenu available via ./tagcodeApp.js
 const LoggerMenu = require('./logger.js');
 const PhysicalPositionMenu = require('./physicalPosition.js');
+const AquonSamplesMenu = require('./aquonSamples.js');
+const ConfigManager = require('../configs');
 
 class MenuManager {
 
     constructor() {
         this.registeredMenus = new Map();
+        this.configManager = new ConfigManager('../configs');
         // Register factory functions
-        this.registerMenu('asset', () => new AssetMenu()); // static menu to be replaced by dynamic one but later
+        this.registerMenu('asset', (nodeName) => new AssetMenu({
+            softwareType: this._getSoftwareType(nodeName)
+        })); // static menu to be replaced by dynamic one but later
         //this.registerMenu('asset', (nodeName) => new DynamicAssetMenu(nodeName, new TagcodeApp()));
         this.registerMenu('logger', () => new LoggerMenu());
         this.registerMenu('position', () => new PhysicalPositionMenu());
+        this.registerMenu('aquon', () => new AquonSamplesMenu());
     }
 
     /**
@@ -23,6 +29,34 @@ class MenuManager {
         this.registeredMenus.set(menuType, menuFactory);
     }
 
+    _getSoftwareType(nodeName) {
+        if (!nodeName) {
+            return null;
+        }
+
+        try {
+            const config = this.configManager.getConfig(nodeName);
+            const softwareType = config?.functionality?.softwareType;
+
+            if (typeof softwareType === 'string' && softwareType.trim()) {
+                return softwareType;
+            }
+            if (
+                softwareType &&
+                typeof softwareType === 'object' &&
+                typeof softwareType.default === 'string' &&
+                softwareType.default.trim()
+            ) {
+                return softwareType.default;
+            }
+
+            return nodeName;
+        } catch (error) {
+            console.warn(`Unable to determine softwareType for ${nodeName}: ${error.message}`);
+            return nodeName;
+        }
+    }
+
     /**
      * Create a complete endpoint script with data and initialization functions
      * @param {string} nodeName - The name of the node type
@@ -54,7 +88,7 @@ class MenuManager {
                 try {
                     const handler = instantiatedMenus.get(menuType);
                     if (handler && typeof handler.getAllMenuData === 'function') {
-                        menuData[menuType] = handler.getAllMenuData();
+                        menuData[menuType] = handler.getAllMenuData(nodeName);
                     } else {
                         // Provide default empty data if method doesn't exist
                         menuData[menuType] = {};

src/menu/physicalPosition.js

@@ -6,9 +6,9 @@ class PhysicalPositionMenu {
     return {
       positionGroups: [
         { group: 'Positional', options: [
-            { value: 'upstream',     label: '← Upstream', icon: '←'},
+            { value: 'upstream',     label: '→ Upstream', icon: '→'}, //flow is then typically left to right
             { value: 'atEquipment',  label: '⊥ in place' , icon: '⊥' },
-            { value: 'downstream',   label: '→ Downstream' , icon: '→' }
+            { value: 'downstream',   label: '← Downstream' , icon: '←' }
           ]
         }
       ],

src/nrmse/errorMetrics.js

@@ -1,125 +1,126 @@
-//load local dependencies
 const EventEmitter = require('events');
-
-//load all config modules
 const defaultConfig = require('./nrmseConfig.json');
 const ConfigUtils = require('../helper/configUtils');
 
 class ErrorMetrics {
   constructor(config = {}, logger) {
-
+    this.emitter = new EventEmitter();
-    this.emitter = new EventEmitter();  // Own EventEmitter
     this.configUtils = new ConfigUtils(defaultConfig);
     this.config = this.configUtils.initConfig(config);
-  
-    // Init after config is set
     this.logger = logger;
 
-    // For long-term NRMSD accumulation
+    this.metricState = new Map();
+    this.legacyMetricId = 'default';
+
+    // Backward-compatible fields retained for existing callers/tests.
     this.cumNRMSD = 0;
     this.cumCount = 0;
   }
 
-  //INCLUDE timestamps in the next update OLIFANT
+  registerMetric(metricId, profile = {}) {
-  meanSquaredError(predicted, measured) {
+    const key = String(metricId || this.legacyMetricId);
-    if (predicted.length !== measured.length) {
+    const state = this._ensureMetricState(key);
-      this.logger.error("Comparing MSE Arrays must have the same length.");
+    state.profile = { ...state.profile, ...profile };
-      return 0;
+    return state.profile;
   }
 
+  resetMetric(metricId = this.legacyMetricId) {
+    this.metricState.delete(String(metricId));
+    if (metricId === this.legacyMetricId) {
+      this.cumNRMSD = 0;
+      this.cumCount = 0;
+    }
+  }
 
+  getMetricState(metricId = this.legacyMetricId) {
+    return this.metricState.get(String(metricId)) || null;
+  }
+
+  meanSquaredError(predicted, measured, options = {}) {
+    const { p, m } = this._validateSeries(predicted, measured, options);
     let sumSqError = 0;
-    for (let i = 0; i < predicted.length; i++) {
+    for (let i = 0; i < p.length; i += 1) {
-      const err = predicted[i] - measured[i];
+      const err = p[i] - m[i];
       sumSqError += err * err;
     }
-    return sumSqError / predicted.length;
+    return sumSqError / p.length;
   }
 
-  rootMeanSquaredError(predicted, measured) {
+  rootMeanSquaredError(predicted, measured, options = {}) {
-    return Math.sqrt(this.meanSquaredError(predicted, measured));
+    return Math.sqrt(this.meanSquaredError(predicted, measured, options));
   }
 
-  normalizedRootMeanSquaredError(predicted, measured, processMin, processMax) {
+  normalizedRootMeanSquaredError(predicted, measured, processMin, processMax, options = {}) {
-    const range = processMax - processMin;
+    const range = Number(processMax) - Number(processMin);
-    if (range <= 0) {
+    if (!Number.isFinite(range) || range <= 0) {
-      this.logger.error("Invalid process range: processMax must be greater than processMin.");
+      this._failOrLog(
+        `Invalid process range: processMax (${processMax}) must be greater than processMin (${processMin}).`,
+        options
+      );
+      return NaN;
     }
-    const rmse = this.rootMeanSquaredError(predicted, measured);
+    const rmse = this.rootMeanSquaredError(predicted, measured, options);
     return rmse / range;
   }
 
-  longTermNRMSD(input) {
+  normalizeUsingRealtime(predicted, measured, options = {}) {
-
+    const { p, m } = this._validateSeries(predicted, measured, options);
-    const storedNRMSD = this.cumNRMSD;
+    const realtimeMin = Math.min(Math.min(...p), Math.min(...m));
-    const storedCount = this.cumCount;
+    const realtimeMax = Math.max(Math.max(...p), Math.max(...m));
-    const newCount = storedCount + 1;
+    const range = realtimeMax - realtimeMin;
-    
+    if (!Number.isFinite(range) || range <= 0) {
-    // Update cumulative values
+      throw new Error('Invalid process range: processMax must be greater than processMin.');
-    this.cumCount = newCount;
+    }
-    
+    const rmse = this.rootMeanSquaredError(p, m, options);
-    // Calculate new running average
+    return rmse / range;
-    if (storedCount === 0) {
-      this.cumNRMSD = input; // First value
-    } else {
-      // Running average formula: newAvg = oldAvg + (newValue - oldAvg) / newCount
-      this.cumNRMSD = storedNRMSD + (input - storedNRMSD) / newCount;
   }
 
-    if(newCount >= 100) {
+  longTermNRMSD(input, metricId = this.legacyMetricId, options = {}) {
-      // Return the current NRMSD value, not just the contribution from this sample
+    const metricKey = String(metricId || this.legacyMetricId);
-      return this.cumNRMSD;
+    const state = this._ensureMetricState(metricKey);
-    }
+    const profile = this._resolveProfile(metricKey, options);
+    const value = Number(input);
+    if (!Number.isFinite(value)) {
+      this._failOrLog(`longTermNRMSD input must be finite. Received: ${input}`, options);
       return 0;
     }
 
-  normalizeUsingRealtime(predicted, measured) {
+    // Keep backward compatibility if callers manipulate cumCount/cumNRMSD directly.
-    const realtimeMin = Math.min(Math.min(...predicted), Math.min(...measured));
+    if (metricKey === this.legacyMetricId && (state.sampleCount !== this.cumCount || state.longTermEwma !== this.cumNRMSD)) {
-    const realtimeMax = Math.max(Math.max(...predicted), Math.max(...measured));
+      state.sampleCount = Number(this.cumCount) || 0;
-    const range = realtimeMax - realtimeMin;
+      state.longTermEwma = Number(this.cumNRMSD) || 0;
-    if (range <= 0) {
-      throw new Error("Invalid process range: processMax must be greater than processMin.");
     }
-    const rmse = this.rootMeanSquaredError(predicted, measured);
+
-    return rmse / range;
+    state.sampleCount += 1;
+    const alpha = profile.ewmaAlpha;
+    state.longTermEwma = state.sampleCount === 1 ? value : (alpha * value) + ((1 - alpha) * state.longTermEwma);
+
+    if (metricKey === this.legacyMetricId) {
+      this.cumCount = state.sampleCount;
+      this.cumNRMSD = state.longTermEwma;
+    }
+
+    if (state.sampleCount < profile.minSamplesForLongTerm) {
+      return 0;
+    }
+    return state.longTermEwma;
   }
 
   detectImmediateDrift(nrmse) {
-    let ImmDrift = {};
+    const thresholds = this.config.thresholds;
-    this.logger.debug(`checking immediate drift with thresholds : ${this.config.thresholds.NRMSE_HIGH} ${this.config.thresholds.NRMSE_MEDIUM} ${this.config.thresholds.NRMSE_LOW}`);
+    if (nrmse > thresholds.NRMSE_HIGH) return { level: 3, feedback: 'High immediate drift detected' };
-    switch (true) {
+    if (nrmse > thresholds.NRMSE_MEDIUM) return { level: 2, feedback: 'Medium immediate drift detected' };
-      case( nrmse > this.config.thresholds.NRMSE_HIGH ) :
+    if (nrmse > thresholds.NRMSE_LOW) return { level: 1, feedback: 'Low immediate drift detected' };
-        ImmDrift = {level : 3 , feedback : "High immediate drift detected"};
+    return { level: 0, feedback: 'No drift detected' };
-        break;
-      case( nrmse > this.config.thresholds.NRMSE_MEDIUM ) :
-        ImmDrift = {level : 2 , feedback : "Medium immediate drift detected"};
-        break;
-      case(nrmse > this.config.thresholds.NRMSE_LOW ):
-        ImmDrift = {level : 1 , feedback : "Low immediate drift detected"};
-        break;
-      default:
-        ImmDrift = {level : 0 , feedback : "No drift detected"};
-    }
-    return ImmDrift;
   }
 
   detectLongTermDrift(longTermNRMSD) {
-    let LongTermDrift = {};
+    const thresholds = this.config.thresholds;
-    this.logger.debug(`checking longterm drift with thresholds : ${this.config.thresholds.LONG_TERM_HIGH} ${this.config.thresholds.LONG_TERM_MEDIUM} ${this.config.thresholds.LONG_TERM_LOW}`);
+    const absValue = Math.abs(longTermNRMSD);
-    switch (true) {
+    if (absValue > thresholds.LONG_TERM_HIGH) return { level: 3, feedback: 'High long-term drift detected' };
-      case(Math.abs(longTermNRMSD) > this.config.thresholds.LONG_TERM_HIGH) :
+    if (absValue > thresholds.LONG_TERM_MEDIUM) return { level: 2, feedback: 'Medium long-term drift detected' };
-        LongTermDrift = {level : 3 , feedback : "High long-term drift detected"};
+    if (absValue > thresholds.LONG_TERM_LOW) return { level: 1, feedback: 'Low long-term drift detected' };
-        break;
+    return { level: 0, feedback: 'No drift detected' };
-      case (Math.abs(longTermNRMSD) > this.config.thresholds.LONG_TERM_MEDIUM) :
-        LongTermDrift = {level : 2 , feedback : "Medium long-term drift detected"};
-        break;
-      case ( Math.abs(longTermNRMSD) > this.config.thresholds.LONG_TERM_LOW ) :
-        LongTermDrift = {level : 1 , feedback : "Low long-term drift detected"};
-        break;
-      default:
-        LongTermDrift = {level : 0 , feedback : "No drift detected"}; 
-    }
-    return LongTermDrift;
   }
 
   detectDrift(nrmse, longTermNRMSD) {
@@ -128,27 +129,272 @@ class ErrorMetrics {
     return { ImmDrift, LongTermDrift };
   }
 
-  // asses the drift
+  assessDrift(predicted, measured, processMin, processMax, options = {}) {
-  assessDrift(predicted, measured, processMin, processMax) {
+    const metricKey = String(options.metricId || this.legacyMetricId);
-    // Compute NRMSE and check for immediate drift
+    const profile = this._resolveProfile(metricKey, options);
-    const nrmse = this.normalizedRootMeanSquaredError(predicted, measured, processMin, processMax);
+    const strict = this._resolveStrict(options, profile);
-    this.logger.debug(`NRMSE: ${nrmse}`);
+
-    // cmopute long-term NRMSD and add result to cumalitve NRMSD
+    const aligned = this._alignSeriesByTimestamp(predicted, measured, options, profile);
-    const longTermNRMSD = this.longTermNRMSD(nrmse);
+    if (!aligned.valid) {
-    // return the drift
+      if (strict) {
-    // Return the drift assessment object
+        throw new Error(aligned.reason);
+      }
+      return this._invalidAssessment(metricKey, aligned.reason);
+    }
+
+    const nrmse = this.normalizedRootMeanSquaredError(
+      aligned.predicted,
+      aligned.measured,
+      processMin,
+      processMax,
+      { ...options, strictValidation: strict }
+    );
+    if (!Number.isFinite(nrmse)) {
+      if (strict) {
+        throw new Error('NRMSE calculation returned a non-finite value.');
+      }
+      return this._invalidAssessment(metricKey, 'non_finite_nrmse');
+    }
+
+    const longTermNRMSD = this.longTermNRMSD(nrmse, metricKey, { ...options, strictValidation: strict });
     const driftAssessment = this.detectDrift(nrmse, longTermNRMSD);
-    return {
+    const state = this._ensureMetricState(metricKey);
+    state.lastResult = {
       nrmse,
       longTermNRMSD,
       immediateLevel: driftAssessment.ImmDrift.level,
       immediateFeedback: driftAssessment.ImmDrift.feedback,
       longTermLevel: driftAssessment.LongTermDrift.level,
-      longTermFeedback: driftAssessment.LongTermDrift.feedback
+      longTermFeedback: driftAssessment.LongTermDrift.feedback,
+      valid: true,
+      metricId: metricKey,
+      sampleCount: state.sampleCount,
+      longTermReady: state.sampleCount >= profile.minSamplesForLongTerm,
+      flags: [],
+    };
+    return state.lastResult;
+  }
+
+  assessPoint(metricId, predictedValue, measuredValue, options = {}) {
+    const metricKey = String(metricId || this.legacyMetricId);
+    const profile = this._resolveProfile(metricKey, options);
+    const state = this._ensureMetricState(metricKey);
+    const strict = this._resolveStrict(options, profile);
+
+    const p = Number(predictedValue);
+    const m = Number(measuredValue);
+    if (!Number.isFinite(p) || !Number.isFinite(m)) {
+      const reason = `assessPoint requires finite numbers. predicted=${predictedValue}, measured=${measuredValue}`;
+      if (strict) {
+        throw new Error(reason);
+      }
+      return this._invalidAssessment(metricKey, reason);
+    }
+
+    const predictedTimestamp = Number(options.predictedTimestamp ?? options.timestamp ?? Date.now());
+    const measuredTimestamp = Number(options.measuredTimestamp ?? options.timestamp ?? Date.now());
+    const delta = Math.abs(predictedTimestamp - measuredTimestamp);
+    if (delta > profile.alignmentToleranceMs) {
+      const reason = `Sample timestamp delta (${delta} ms) exceeds tolerance (${profile.alignmentToleranceMs} ms)`;
+      if (strict) {
+        throw new Error(reason);
+      }
+      return this._invalidAssessment(metricKey, reason);
+    }
+
+    state.predicted.push(p);
+    state.measured.push(m);
+    state.predictedTimestamps.push(predictedTimestamp);
+    state.measuredTimestamps.push(measuredTimestamp);
+
+    while (state.predicted.length > profile.windowSize) state.predicted.shift();
+    while (state.measured.length > profile.windowSize) state.measured.shift();
+    while (state.predictedTimestamps.length > profile.windowSize) state.predictedTimestamps.shift();
+    while (state.measuredTimestamps.length > profile.windowSize) state.measuredTimestamps.shift();
+
+    if (state.predicted.length < 2 || state.measured.length < 2) {
+      return this._invalidAssessment(metricKey, 'insufficient_samples');
+    }
+
+    let processMin = Number(options.processMin);
+    let processMax = Number(options.processMax);
+    if (!Number.isFinite(processMin) || !Number.isFinite(processMax) || processMax <= processMin) {
+      processMin = Math.min(...state.predicted, ...state.measured);
+      processMax = Math.max(...state.predicted, ...state.measured);
+      if (!Number.isFinite(processMin) || !Number.isFinite(processMax) || processMax <= processMin) {
+        processMin = 0;
+        processMax = 1;
+      }
+    }
+
+    return this.assessDrift(state.predicted, state.measured, processMin, processMax, {
+      ...options,
+      metricId: metricKey,
+      strictValidation: strict,
+      predictedTimestamps: state.predictedTimestamps,
+      measuredTimestamps: state.measuredTimestamps,
+    });
+  }
+
+  _ensureMetricState(metricId) {
+    const key = String(metricId || this.legacyMetricId);
+    if (!this.metricState.has(key)) {
+      this.metricState.set(key, {
+        predicted: [],
+        measured: [],
+        predictedTimestamps: [],
+        measuredTimestamps: [],
+        sampleCount: 0,
+        longTermEwma: 0,
+        profile: {},
+        lastResult: null,
+      });
+    }
+    return this.metricState.get(key);
+  }
+
+  _resolveProfile(metricId, options = {}) {
+    const state = this._ensureMetricState(metricId);
+    const base = this.config.processing || {};
+    return {
+      windowSize: Number(options.windowSize ?? state.profile.windowSize ?? base.windowSize ?? 50),
+      minSamplesForLongTerm: Number(options.minSamplesForLongTerm ?? state.profile.minSamplesForLongTerm ?? base.minSamplesForLongTerm ?? 100),
+      ewmaAlpha: Number(options.ewmaAlpha ?? state.profile.ewmaAlpha ?? base.ewmaAlpha ?? 0.1),
+      alignmentToleranceMs: Number(options.alignmentToleranceMs ?? state.profile.alignmentToleranceMs ?? base.alignmentToleranceMs ?? 2000),
+      strictValidation: Boolean(options.strictValidation ?? state.profile.strictValidation ?? base.strictValidation ?? true),
     };
   }
 
+  _resolveStrict(options = {}, profile = null) {
+    if (Object.prototype.hasOwnProperty.call(options, 'strictValidation')) {
+      return Boolean(options.strictValidation);
+    }
+    if (profile && Object.prototype.hasOwnProperty.call(profile, 'strictValidation')) {
+      return Boolean(profile.strictValidation);
+    }
+    return Boolean(this.config.processing?.strictValidation ?? true);
+  }
 
+  _validateSeries(predicted, measured, options = {}) {
+    if (!Array.isArray(predicted) || !Array.isArray(measured)) {
+      this._failOrLog('predicted and measured must be arrays.', options);
+      return { p: [], m: [] };
+    }
+    if (!predicted.length || !measured.length) {
+      this._failOrLog('predicted and measured arrays must not be empty.', options);
+      return { p: [], m: [] };
+    }
+    if (predicted.length !== measured.length) {
+      this._failOrLog('predicted and measured arrays must have the same length.', options);
+      return { p: [], m: [] };
+    }
+
+    const p = predicted.map(Number);
+    const m = measured.map(Number);
+    const hasBad = p.some((v) => !Number.isFinite(v)) || m.some((v) => !Number.isFinite(v));
+    if (hasBad) {
+      this._failOrLog('predicted and measured arrays must contain finite numeric values.', options);
+      return { p: [], m: [] };
+    }
+    return { p, m };
+  }
+
+  _alignSeriesByTimestamp(predicted, measured, options = {}, profile = null) {
+    const strict = this._resolveStrict(options, profile);
+    const tolerance = Number(options.alignmentToleranceMs ?? profile?.alignmentToleranceMs ?? 2000);
+    const predictedTimestamps = Array.isArray(options.predictedTimestamps) ? options.predictedTimestamps.map(Number) : null;
+    const measuredTimestamps = Array.isArray(options.measuredTimestamps) ? options.measuredTimestamps.map(Number) : null;
+
+    if (!predictedTimestamps || !measuredTimestamps) {
+      if (!Array.isArray(predicted) || !Array.isArray(measured)) {
+        return { valid: false, reason: 'predicted and measured must be arrays.' };
+      }
+      if (predicted.length !== measured.length) {
+        const reason = `Series length mismatch without timestamps: predicted=${predicted.length}, measured=${measured.length}`;
+        if (strict) return { valid: false, reason };
+        const n = Math.min(predicted.length, measured.length);
+        if (n < 2) return { valid: false, reason };
+        return {
+          valid: true,
+          predicted: predicted.slice(-n).map(Number),
+          measured: measured.slice(-n).map(Number),
+          flags: ['length_mismatch_realigned'],
+        };
+      }
+      try {
+        const { p, m } = this._validateSeries(predicted, measured, { ...options, strictValidation: true });
+        return { valid: true, predicted: p, measured: m, flags: [] };
+      } catch (error) {
+        return { valid: false, reason: error.message };
+      }
+    }
+
+    if (!Array.isArray(predicted) || !Array.isArray(measured)) {
+      return { valid: false, reason: 'predicted and measured must be arrays.' };
+    }
+    if (predicted.length !== predictedTimestamps.length || measured.length !== measuredTimestamps.length) {
+      return { valid: false, reason: 'timestamp arrays must match value-array lengths.' };
+    }
+
+    const predictedSamples = predicted
+      .map((v, i) => ({ value: Number(v), ts: predictedTimestamps[i] }))
+      .filter((s) => Number.isFinite(s.value) && Number.isFinite(s.ts))
+      .sort((a, b) => a.ts - b.ts);
+    const measuredSamples = measured
+      .map((v, i) => ({ value: Number(v), ts: measuredTimestamps[i] }))
+      .filter((s) => Number.isFinite(s.value) && Number.isFinite(s.ts))
+      .sort((a, b) => a.ts - b.ts);
+
+    const alignedPredicted = [];
+    const alignedMeasured = [];
+    let i = 0;
+    let j = 0;
+    while (i < predictedSamples.length && j < measuredSamples.length) {
+      const p = predictedSamples[i];
+      const m = measuredSamples[j];
+      const delta = p.ts - m.ts;
+      if (Math.abs(delta) <= tolerance) {
+        alignedPredicted.push(p.value);
+        alignedMeasured.push(m.value);
+        i += 1;
+        j += 1;
+      } else if (delta < 0) {
+        i += 1;
+      } else {
+        j += 1;
+      }
+    }
+
+    if (alignedPredicted.length < 2 || alignedMeasured.length < 2) {
+      return { valid: false, reason: 'insufficient aligned samples after timestamp matching.' };
+    }
+
+    return { valid: true, predicted: alignedPredicted, measured: alignedMeasured, flags: [] };
+  }
+
+  _invalidAssessment(metricId, reason) {
+    return {
+      nrmse: NaN,
+      longTermNRMSD: 0,
+      immediateLevel: 0,
+      immediateFeedback: 'Drift assessment unavailable',
+      longTermLevel: 0,
+      longTermFeedback: 'Drift assessment unavailable',
+      valid: false,
+      metricId: String(metricId || this.legacyMetricId),
+      sampleCount: this._ensureMetricState(metricId).sampleCount,
+      longTermReady: false,
+      flags: [reason],
+    };
+  }
+
+  _failOrLog(message, options = {}) {
+    const strict = this._resolveStrict(options);
+    if (strict) {
+      throw new Error(message);
+    }
+    this.logger?.warn?.(message);
+  }
 }
 
 module.exports = ErrorMetrics;

src/nrmse/index.js

@@ -0,0 +1,7 @@
+const nrmse = require('./errorMetrics.js');
+const nrmseConfig = require('./nrmseConfig.json');
+
+module.exports = {
+  nrmse,
+  nrmseConfig,
+};

src/nrmse/nrmseConfig.json

@@ -1,7 +1,7 @@
 {
   "general": {
     "name": {
-      "default": "ErrorMetrics",
+      "default": "errormetrics",
       "rules": {
         "type": "string",
         "description": "A human-readable name for the configuration."
@@ -58,7 +58,7 @@
   },
   "functionality": {
     "softwareType": {
-      "default": "errorMetrics",
+      "default": "errormetrics",
       "rules": {
         "type": "string",
         "description": "Logical name identifying the software type."
@@ -134,5 +134,47 @@
         "description": "High threshold for long-term normalized root mean squared deviation."
       }
     }
+  },
+  "processing": {
+    "windowSize": {
+      "default": 50,
+      "rules": {
+        "type": "integer",
+        "min": 2,
+        "description": "Rolling sample window size used for drift evaluation."
+      }
+    },
+    "minSamplesForLongTerm": {
+      "default": 100,
+      "rules": {
+        "type": "integer",
+        "min": 1,
+        "description": "Minimum sample count before long-term drift is considered mature."
+      }
+    },
+    "ewmaAlpha": {
+      "default": 0.1,
+      "rules": {
+        "type": "number",
+        "min": 0.001,
+        "max": 1,
+        "description": "EWMA smoothing factor for long-term drift trend."
+      }
+    },
+    "alignmentToleranceMs": {
+      "default": 2000,
+      "rules": {
+        "type": "integer",
+        "min": 0,
+        "description": "Maximum timestamp delta allowed between predicted and measured sample pairs."
+      }
+    },
+    "strictValidation": {
+      "default": true,
+      "rules": {
+        "type": "boolean",
+        "description": "When true, invalid inputs raise errors instead of producing silent outputs."
+      }
+    }
   }
 }

src/outliers/index.js

@@ -0,0 +1,5 @@
+const outlierDetection = require('./outlierDetection.js');
+
+module.exports = {
+  outlierDetection,
+};

src/outliers/outlierDetection.js

@@ -61,6 +61,8 @@ class DynamicClusterDeviation {
     }
 }
 
+module.exports = DynamicClusterDeviation;
+
 // Rolling window simulation with outlier detection
 /*
 const detector = new DynamicClusterDeviation();
@@ -87,5 +89,3 @@ dataStream.forEach((value, index) => {
 
 console.log("\nFinal detector cluster states:", JSON.stringify(detector.clusters, null, 2));
 */
-
-module.exports = DynamicClusterDeviation;

src/pid/PIDController.js

@@ -0,0 +1,663 @@
+'use strict';
+
+/**
+ * Production-focused discrete PID controller with modern control features:
+ * - auto/manual and bumpless transfer
+ * - freeze/unfreeze (hold output while optionally tracking process)
+ * - derivative filtering and derivative-on-measurement/error
+ * - anti-windup (clamp or back-calculation)
+ * - output and integral limits
+ * - output rate limiting
+ * - deadband
+ * - gain scheduling (array/function)
+ * - feedforward and dynamic tunings at runtime
+ */
+class PIDController {
+  constructor(options = {}) {
+    const {
+      kp = 1,
+      ki = 0,
+      kd = 0,
+      sampleTime = 1000,
+      derivativeFilter = 0.15,
+      outputMin = Number.NEGATIVE_INFINITY,
+      outputMax = Number.POSITIVE_INFINITY,
+      integralMin = null,
+      integralMax = null,
+      derivativeOnMeasurement = true,
+      setpointWeight = 1,
+      derivativeWeight = 0,
+      deadband = 0,
+      outputRateLimitUp = Number.POSITIVE_INFINITY,
+      outputRateLimitDown = Number.POSITIVE_INFINITY,
+      antiWindupMode = 'clamp',
+      backCalculationGain = 0,
+      gainSchedule = null,
+      autoMode = true,
+      trackOnManual = true,
+      frozen = false,
+      freezeTrackMeasurement = true,
+      freezeTrackError = false,
+    } = options;
+
+    this.kp = 0;
+    this.ki = 0;
+    this.kd = 0;
+
+    this.setTunings({ kp, ki, kd });
+    this.setSampleTime(sampleTime);
+    this.setOutputLimits(outputMin, outputMax);
+    this.setIntegralLimits(integralMin, integralMax);
+    this.setDerivativeFilter(derivativeFilter);
+    this.setSetpointWeights({ beta: setpointWeight, gamma: derivativeWeight });
+    this.setDeadband(deadband);
+    this.setOutputRateLimits(outputRateLimitUp, outputRateLimitDown);
+    this.setAntiWindup({ mode: antiWindupMode, backCalculationGain });
+    this.setGainSchedule(gainSchedule);
+
+    this.derivativeOnMeasurement = Boolean(derivativeOnMeasurement);
+    this.autoMode = Boolean(autoMode);
+    this.trackOnManual = Boolean(trackOnManual);
+
+    this.frozen = Boolean(frozen);
+    this.freezeTrackMeasurement = Boolean(freezeTrackMeasurement);
+    this.freezeTrackError = Boolean(freezeTrackError);
+
+    this.reset();
+  }
+
+  setTunings({ kp = this.kp, ki = this.ki, kd = this.kd } = {}) {
+    [kp, ki, kd].forEach((gain, index) => {
+      if (!Number.isFinite(gain)) {
+        const label = ['kp', 'ki', 'kd'][index];
+        throw new TypeError(`${label} must be a finite number`);
+      }
+    });
+
+    this.kp = kp;
+    this.ki = ki;
+    this.kd = kd;
+    return this;
+  }
+
+  setSampleTime(sampleTimeMs = this.sampleTime) {
+    if (!Number.isFinite(sampleTimeMs) || sampleTimeMs <= 0) {
+      throw new RangeError('sampleTime must be a positive number of milliseconds');
+    }
+
+    this.sampleTime = sampleTimeMs;
+    return this;
+  }
+
+  setOutputLimits(min = this.outputMin, max = this.outputMax) {
+    if (!Number.isFinite(min) && min !== Number.NEGATIVE_INFINITY) {
+      throw new TypeError('outputMin must be finite or -Infinity');
+    }
+    if (!Number.isFinite(max) && max !== Number.POSITIVE_INFINITY) {
+      throw new TypeError('outputMax must be finite or Infinity');
+    }
+    if (min >= max) {
+      throw new RangeError('outputMin must be smaller than outputMax');
+    }
+
+    this.outputMin = min;
+    this.outputMax = max;
+    this.lastOutput = this._clamp(this.lastOutput ?? 0, this.outputMin, this.outputMax);
+    return this;
+  }
+
+  setIntegralLimits(min = this.integralMin ?? null, max = this.integralMax ?? null) {
+    if (min !== null && !Number.isFinite(min)) {
+      throw new TypeError('integralMin must be null or a finite number');
+    }
+    if (max !== null && !Number.isFinite(max)) {
+      throw new TypeError('integralMax must be null or a finite number');
+    }
+    if (min !== null && max !== null && min > max) {
+      throw new RangeError('integralMin must be smaller than integralMax');
+    }
+
+    this.integralMin = min;
+    this.integralMax = max;
+    this.integral = this._applyIntegralLimits(this.integral ?? 0);
+    return this;
+  }
+
+  setDerivativeFilter(value = this.derivativeFilter ?? 0) {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+      throw new RangeError('derivativeFilter must be between 0 and 1');
+    }
+
+    this.derivativeFilter = value;
+    return this;
+  }
+
+  setSetpointWeights({ beta = this.setpointWeight ?? 1, gamma = this.derivativeWeight ?? 0 } = {}) {
+    if (!Number.isFinite(beta) || !Number.isFinite(gamma)) {
+      throw new TypeError('setpoint and derivative weights must be finite numbers');
+    }
+
+    this.setpointWeight = beta;
+    this.derivativeWeight = gamma;
+    return this;
+  }
+
+  setDeadband(value = this.deadband ?? 0) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new RangeError('deadband must be a non-negative finite number');
+    }
+
+    this.deadband = value;
+    return this;
+  }
+
+  setOutputRateLimits(up = this.outputRateLimitUp, down = this.outputRateLimitDown) {
+    if (!Number.isFinite(up) && up !== Number.POSITIVE_INFINITY) {
+      throw new TypeError('outputRateLimitUp must be finite or Infinity');
+    }
+    if (!Number.isFinite(down) && down !== Number.POSITIVE_INFINITY) {
+      throw new TypeError('outputRateLimitDown must be finite or Infinity');
+    }
+    if (up <= 0 || down <= 0) {
+      throw new RangeError('output rate limits must be positive values');
+    }
+
+    this.outputRateLimitUp = up;
+    this.outputRateLimitDown = down;
+    return this;
+  }
+
+  setAntiWindup({ mode = this.antiWindupMode ?? 'clamp', backCalculationGain = this.backCalculationGain ?? 0 } = {}) {
+    const normalized = String(mode || 'clamp').trim().toLowerCase();
+    if (normalized !== 'clamp' && normalized !== 'backcalc') {
+      throw new RangeError('anti windup mode must be "clamp" or "backcalc"');
+    }
+    if (!Number.isFinite(backCalculationGain) || backCalculationGain < 0) {
+      throw new RangeError('backCalculationGain must be a non-negative finite number');
+    }
+
+    this.antiWindupMode = normalized;
+    this.backCalculationGain = backCalculationGain;
+    return this;
+  }
+
+  /**
+   * Gain schedule options:
+   * - null: disabled
+   * - function(input, state) => { kp, ki, kd }
+   * - array: [{ min, max, kp, ki, kd }, ...]
+   */
+  setGainSchedule(schedule = null) {
+    if (schedule == null) {
+      this.gainSchedule = null;
+      return this;
+    }
+
+    if (typeof schedule === 'function') {
+      this.gainSchedule = schedule;
+      return this;
+    }
+
+    if (!Array.isArray(schedule)) {
+      throw new TypeError('gainSchedule must be null, a function, or an array');
+    }
+
+    schedule.forEach((entry, index) => {
+      if (!entry || typeof entry !== 'object') {
+        throw new TypeError(`gainSchedule[${index}] must be an object`);
+      }
+      const { min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY, kp, ki, kd } = entry;
+      if (!Number.isFinite(min) && min !== Number.NEGATIVE_INFINITY) {
+        throw new TypeError(`gainSchedule[${index}].min must be finite or -Infinity`);
+      }
+      if (!Number.isFinite(max) && max !== Number.POSITIVE_INFINITY) {
+        throw new TypeError(`gainSchedule[${index}].max must be finite or Infinity`);
+      }
+      if (min >= max) {
+        throw new RangeError(`gainSchedule[${index}] min must be smaller than max`);
+      }
+      [kp, ki, kd].forEach((value, gainIndex) => {
+        const label = ['kp', 'ki', 'kd'][gainIndex];
+        if (!Number.isFinite(value)) {
+          throw new TypeError(`gainSchedule[${index}].${label} must be finite`);
+        }
+      });
+    });
+
+    this.gainSchedule = schedule;
+    return this;
+  }
+
+  setMode(mode, options = {}) {
+    if (mode !== 'automatic' && mode !== 'manual') {
+      throw new Error('mode must be either "automatic" or "manual"');
+    }
+
+    const nextAuto = mode === 'automatic';
+    const previousAuto = this.autoMode;
+    this.autoMode = nextAuto;
+
+    if (options && Number.isFinite(options.manualOutput)) {
+      this.setManualOutput(options.manualOutput);
+    }
+
+    if (!previousAuto && nextAuto) {
+      this._initializeForAuto(options);
+    }
+
+    return this;
+  }
+
+  freeze(options = {}) {
+    this.frozen = true;
+    this.freezeTrackMeasurement = options.trackMeasurement !== false;
+    this.freezeTrackError = Boolean(options.trackError);
+
+    if (Number.isFinite(options.output)) {
+      this.setManualOutput(options.output);
+    }
+
+    return this;
+  }
+
+  unfreeze() {
+    this.frozen = false;
+    return this;
+  }
+
+  isFrozen() {
+    return this.frozen;
+  }
+
+  setManualOutput(value) {
+    this._assertNumeric('manual output', value);
+    this.lastOutput = this._clamp(value, this.outputMin, this.outputMax);
+    return this.lastOutput;
+  }
+
+  reset(state = {}) {
+    const {
+      integral = 0,
+      lastOutput = 0,
+      timestamp = null,
+      prevMeasurement = null,
+      prevError = null,
+      prevDerivativeInput = null,
+      derivativeState = 0,
+    } = state;
+
+    this.integral = this._applyIntegralLimits(Number.isFinite(integral) ? integral : 0);
+    this.prevError = Number.isFinite(prevError) ? prevError : null;
+    this.prevMeasurement = Number.isFinite(prevMeasurement) ? prevMeasurement : null;
+    this.prevDerivativeInput = Number.isFinite(prevDerivativeInput) ? prevDerivativeInput : null;
+    this.lastOutput = this._clamp(
+      Number.isFinite(lastOutput) ? lastOutput : 0,
+      this.outputMin ?? Number.NEGATIVE_INFINITY,
+      this.outputMax ?? Number.POSITIVE_INFINITY
+    );
+    this.lastTimestamp = Number.isFinite(timestamp) ? timestamp : null;
+    this.derivativeState = Number.isFinite(derivativeState) ? derivativeState : 0;
+
+    return this;
+  }
+
+  update(setpoint, measurement, timestamp = Date.now(), options = {}) {
+    if (timestamp && typeof timestamp === 'object' && options && Object.keys(options).length === 0) {
+      options = timestamp;
+      timestamp = Date.now();
+    }
+
+    this._assertNumeric('setpoint', setpoint);
+    this._assertNumeric('measurement', measurement);
+    this._assertNumeric('timestamp', timestamp);
+
+    const opts = options || {};
+
+    if (opts.tunings && typeof opts.tunings === 'object') {
+      this.setTunings(opts.tunings);
+    }
+
+    if (Number.isFinite(opts.gainInput)) {
+      this._applyGainSchedule(opts.gainInput, { setpoint, measurement, timestamp });
+    }
+
+    if (typeof opts.setMode === 'string') {
+      this.setMode(opts.setMode, opts);
+    }
+
+    if (opts.freeze === true) this.freeze(opts);
+    if (opts.unfreeze === true) this.unfreeze();
+
+    if (Number.isFinite(opts.manualOutput)) {
+      this.setManualOutput(opts.manualOutput);
+    }
+
+    const feedForward = Number.isFinite(opts.feedForward) ? opts.feedForward : 0;
+    const force = Boolean(opts.force);
+
+    const error = setpoint - measurement;
+
+    if (!this.autoMode) {
+      if (this.trackOnManual) {
+        this._trackProcessState(setpoint, measurement, error, timestamp);
+      }
+      return this.lastOutput;
+    }
+
+    if (this.frozen) {
+      if (this.freezeTrackMeasurement || this.freezeTrackError) {
+        this._trackProcessState(setpoint, measurement, error, timestamp, {
+          trackMeasurement: this.freezeTrackMeasurement,
+          trackError: this.freezeTrackError,
+        });
+      }
+      return this.lastOutput;
+    }
+
+    if (!force && this.lastTimestamp !== null && (timestamp - this.lastTimestamp) < this.sampleTime) {
+      return this.lastOutput;
+    }
+
+    const elapsedMs = this.lastTimestamp === null ? this.sampleTime : (timestamp - this.lastTimestamp);
+    const dtSeconds = Math.max(elapsedMs / 1000, Number.EPSILON);
+
+    const inDeadband = Math.abs(error) <= this.deadband;
+    if (inDeadband) {
+      this.prevError = error;
+      this.prevMeasurement = measurement;
+      this.prevDerivativeInput = this.derivativeOnMeasurement
+        ? measurement
+        : ((this.derivativeWeight * setpoint) - measurement);
+      this.lastTimestamp = timestamp;
+      return this.lastOutput;
+    }
+
+    const effectiveError = error;
+
+    const pInput = (this.setpointWeight * setpoint) - measurement;
+    const pTerm = this.kp * pInput;
+
+    const derivativeRaw = this._computeDerivative({ setpoint, measurement, error, dtSeconds });
+    this.derivativeState = this.derivativeFilter === 0
+      ? derivativeRaw
+      : this.derivativeState + (derivativeRaw - this.derivativeState) * (1 - this.derivativeFilter);
+
+    const dTerm = this.kd * this.derivativeState;
+
+    const nextIntegral = this._applyIntegralLimits(this.integral + (effectiveError * dtSeconds));
+    let unclampedOutput = pTerm + (this.ki * nextIntegral) + dTerm + feedForward;
+    let clampedOutput = this._clamp(unclampedOutput, this.outputMin, this.outputMax);
+
+    if (this.antiWindupMode === 'backcalc' && this.ki !== 0 && this.backCalculationGain > 0) {
+      const correctedIntegral = nextIntegral + ((clampedOutput - unclampedOutput) * this.backCalculationGain * dtSeconds);
+      this.integral = this._applyIntegralLimits(correctedIntegral);
+    } else {
+      const saturatingHigh = clampedOutput >= this.outputMax && effectiveError > 0;
+      const saturatingLow = clampedOutput <= this.outputMin && effectiveError < 0;
+      this.integral = (saturatingHigh || saturatingLow) ? this.integral : nextIntegral;
+    }
+
+    let output = pTerm + (this.ki * this.integral) + dTerm + feedForward;
+    output = this._clamp(output, this.outputMin, this.outputMax);
+
+    if (this.lastTimestamp !== null) {
+      output = this._applyRateLimit(output, this.lastOutput, dtSeconds);
+    }
+
+    if (Number.isFinite(opts.trackingOutput)) {
+      this._trackIntegralToOutput(opts.trackingOutput, { pTerm, dTerm, feedForward });
+      output = this._clamp(opts.trackingOutput, this.outputMin, this.outputMax);
+    }
+
+    this.lastOutput = output;
+    this.prevError = error;
+    this.prevMeasurement = measurement;
+    this.prevDerivativeInput = this.derivativeOnMeasurement
+      ? measurement
+      : ((this.derivativeWeight * setpoint) - measurement);
+    this.lastTimestamp = timestamp;
+
+    return this.lastOutput;
+  }
+
+  getState() {
+    return {
+      kp: this.kp,
+      ki: this.ki,
+      kd: this.kd,
+      sampleTime: this.sampleTime,
+      outputLimits: { min: this.outputMin, max: this.outputMax },
+      integralLimits: { min: this.integralMin, max: this.integralMax },
+      derivativeFilter: this.derivativeFilter,
+      derivativeOnMeasurement: this.derivativeOnMeasurement,
+      setpointWeight: this.setpointWeight,
+      derivativeWeight: this.derivativeWeight,
+      deadband: this.deadband,
+      outputRateLimits: { up: this.outputRateLimitUp, down: this.outputRateLimitDown },
+      antiWindupMode: this.antiWindupMode,
+      backCalculationGain: this.backCalculationGain,
+      autoMode: this.autoMode,
+      frozen: this.frozen,
+      integral: this.integral,
+      derivativeState: this.derivativeState,
+      lastOutput: this.lastOutput,
+      lastTimestamp: this.lastTimestamp,
+    };
+  }
+
+  getLastOutput() {
+    return this.lastOutput;
+  }
+
+  _initializeForAuto(options = {}) {
+    const setpoint = Number.isFinite(options.setpoint) ? options.setpoint : null;
+    const measurement = Number.isFinite(options.measurement) ? options.measurement : null;
+    const timestamp = Number.isFinite(options.timestamp) ? options.timestamp : Date.now();
+
+    if (measurement !== null) {
+      this.prevMeasurement = measurement;
+    }
+    if (setpoint !== null && measurement !== null) {
+      this.prevError = setpoint - measurement;
+      this.prevDerivativeInput = this.derivativeOnMeasurement
+        ? measurement
+        : ((this.derivativeWeight * setpoint) - measurement);
+    }
+
+    this.lastTimestamp = timestamp;
+
+    if (this.ki !== 0 && setpoint !== null && measurement !== null) {
+      const pTerm = this.kp * ((this.setpointWeight * setpoint) - measurement);
+      const dTerm = this.kd * this.derivativeState;
+      const trackedIntegral = (this.lastOutput - pTerm - dTerm) / this.ki;
+      this.integral = this._applyIntegralLimits(Number.isFinite(trackedIntegral) ? trackedIntegral : this.integral);
+    }
+  }
+
+  _trackProcessState(setpoint, measurement, error, timestamp, tracking = {}) {
+    const trackMeasurement = tracking.trackMeasurement !== false;
+    const trackError = Boolean(tracking.trackError);
+
+    if (trackMeasurement) {
+      this.prevMeasurement = measurement;
+      this.prevDerivativeInput = this.derivativeOnMeasurement
+        ? measurement
+        : ((this.derivativeWeight * setpoint) - measurement);
+    }
+
+    if (trackError) {
+      this.prevError = error;
+    }
+
+    this.lastTimestamp = timestamp;
+  }
+
+  _trackIntegralToOutput(trackingOutput, terms) {
+    if (this.ki === 0) return;
+    const { pTerm, dTerm, feedForward } = terms;
+    const targetIntegral = (trackingOutput - pTerm - dTerm - feedForward) / this.ki;
+    if (Number.isFinite(targetIntegral)) {
+      this.integral = this._applyIntegralLimits(targetIntegral);
+    }
+  }
+
+  _applyGainSchedule(input, state) {
+    if (!this.gainSchedule) return;
+
+    if (typeof this.gainSchedule === 'function') {
+      const tunings = this.gainSchedule(input, this.getState(), state);
+      if (tunings && typeof tunings === 'object') {
+        this.setTunings(tunings);
+      }
+      return;
+    }
+
+    const matched = this.gainSchedule.find((entry) => input >= entry.min && input < entry.max);
+    if (matched) {
+      this.setTunings({ kp: matched.kp, ki: matched.ki, kd: matched.kd });
+    }
+  }
+
+  _computeDerivative({ setpoint, measurement, error, dtSeconds }) {
+    if (!(dtSeconds > 0) || !Number.isFinite(dtSeconds)) {
+      return 0;
+    }
+
+    if (this.derivativeOnMeasurement) {
+      if (this.prevMeasurement === null) return 0;
+      return -(measurement - this.prevMeasurement) / dtSeconds;
+    }
+
+    const derivativeInput = (this.derivativeWeight * setpoint) - measurement;
+    if (this.prevDerivativeInput === null) return 0;
+    const derivativeFromInput = (derivativeInput - this.prevDerivativeInput) / dtSeconds;
+
+    if (Number.isFinite(derivativeFromInput)) {
+      return derivativeFromInput;
+    }
+
+    if (this.prevError === null) return 0;
+    return (error - this.prevError) / dtSeconds;
+  }
+
+  _applyRateLimit(nextOutput, previousOutput, dtSeconds) {
+    const maxRise = Number.isFinite(this.outputRateLimitUp)
+      ? this.outputRateLimitUp * dtSeconds
+      : Number.POSITIVE_INFINITY;
+    const maxFall = Number.isFinite(this.outputRateLimitDown)
+      ? this.outputRateLimitDown * dtSeconds
+      : Number.POSITIVE_INFINITY;
+
+    const lower = previousOutput - maxFall;
+    const upper = previousOutput + maxRise;
+    return this._clamp(nextOutput, lower, upper);
+  }
+
+  _applyIntegralLimits(value) {
+    if (!Number.isFinite(value)) {
+      return 0;
+    }
+
+    let result = value;
+    if (this.integralMin !== null && result < this.integralMin) {
+      result = this.integralMin;
+    }
+    if (this.integralMax !== null && result > this.integralMax) {
+      result = this.integralMax;
+    }
+    return result;
+  }
+
+  _assertNumeric(label, value) {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`${label} must be a finite number`);
+    }
+  }
+
+  _clamp(value, min, max) {
+    if (value < min) return min;
+    if (value > max) return max;
+    return value;
+  }
+}
+
+/**
+ * Cascade PID utility:
+ * - primary PID controls the outer variable
+ * - primary output becomes setpoint for secondary PID
+ */
+class CascadePIDController {
+  constructor(options = {}) {
+    const {
+      primary = {},
+      secondary = {},
+    } = options;
+
+    this.primary = primary instanceof PIDController ? primary : new PIDController(primary);
+    this.secondary = secondary instanceof PIDController ? secondary : new PIDController(secondary);
+  }
+
+  update({
+    setpoint,
+    primaryMeasurement,
+    secondaryMeasurement,
+    timestamp = Date.now(),
+    primaryOptions = {},
+    secondaryOptions = {},
+  } = {}) {
+    if (!Number.isFinite(setpoint)) {
+      throw new TypeError('setpoint must be a finite number');
+    }
+    if (!Number.isFinite(primaryMeasurement)) {
+      throw new TypeError('primaryMeasurement must be a finite number');
+    }
+    if (!Number.isFinite(secondaryMeasurement)) {
+      throw new TypeError('secondaryMeasurement must be a finite number');
+    }
+
+    const secondarySetpoint = this.primary.update(setpoint, primaryMeasurement, timestamp, primaryOptions);
+    const controlOutput = this.secondary.update(secondarySetpoint, secondaryMeasurement, timestamp, secondaryOptions);
+
+    return {
+      primaryOutput: secondarySetpoint,
+      secondaryOutput: controlOutput,
+      state: this.getState(),
+    };
+  }
+
+  setMode(mode, options = {}) {
+    this.primary.setMode(mode, options.primary || options);
+    this.secondary.setMode(mode, options.secondary || options);
+    return this;
+  }
+
+  freeze(options = {}) {
+    this.primary.freeze(options.primary || options);
+    this.secondary.freeze(options.secondary || options);
+    return this;
+  }
+
+  unfreeze() {
+    this.primary.unfreeze();
+    this.secondary.unfreeze();
+    return this;
+  }
+
+  reset(state = {}) {
+    this.primary.reset(state.primary || {});
+    this.secondary.reset(state.secondary || {});
+    return this;
+  }
+
+  getState() {
+    return {
+      primary: this.primary.getState(),
+      secondary: this.secondary.getState(),
+    };
+  }
+}
+
+module.exports = {
+  PIDController,
+  CascadePIDController,
+};

src/pid/examples.js

@@ -0,0 +1,87 @@
+const { PIDController } = require('./index');
+
+console.log('=== PID CONTROLLER EXAMPLES ===\n');
+console.log('This guide shows how to instantiate, tune, and operate the PID helper.\n');
+
+// ====================================
+// EXAMPLE 1: FLOW CONTROL LOOP
+// ====================================
+console.log('--- Example 1: Pump speed control ---');
+
+const pumpController = new PIDController({
+  kp: 1.1,
+  ki: 0.35,
+  kd: 0.08,
+  sampleTime: 250, // ms
+  outputMin: 0,
+  outputMax: 100,
+  derivativeFilter: 0.2
+});
+
+const pumpSetpoint = 75; // desired flow percentage
+let pumpFlow = 20;
+const pumpStart = Date.now();
+
+for (let i = 0; i < 10; i += 1) {
+  const timestamp = pumpStart + (i + 1) * pumpController.sampleTime;
+  const controlSignal = pumpController.update(pumpSetpoint, pumpFlow, timestamp);
+
+  // Simple first-order plant approximation
+  pumpFlow += (controlSignal - pumpFlow) * 0.12;
+  pumpFlow -= (pumpFlow - pumpSetpoint) * 0.05; // disturbance rejection
+
+  console.log(
+    `Cycle ${i + 1}: output=${controlSignal.toFixed(2)}% | flow=${pumpFlow.toFixed(2)}%`
+  );
+}
+
+console.log('Pump loop state:', pumpController.getState(), '\n');
+
+// ====================================
+// EXAMPLE 2: TANK LEVEL WITH MANUAL/AUTO
+// ====================================
+console.log('--- Example 2: Tank level handover ---');
+
+const tankController = new PIDController({
+  kp: 2.0,
+  ki: 0.5,
+  kd: 0.25,
+  sampleTime: 400,
+  derivativeFilter: 0.25,
+  outputMin: 0,
+  outputMax: 1
+}).setIntegralLimits(-0.3, 0.3);
+
+tankController.setMode('manual');
+tankController.setManualOutput(0.4);
+console.log(`Manual output locked at ${tankController.getLastOutput().toFixed(2)}\n`);
+
+tankController.setMode('automatic');
+
+let level = 0.2;
+const levelSetpoint = 0.8;
+const tankStart = Date.now();
+
+for (let step = 0; step < 8; step += 1) {
+  const timestamp = tankStart + (step + 1) * tankController.sampleTime;
+  const output = tankController.update(levelSetpoint, level, timestamp);
+
+  // Integrating process with slight disturbance
+  level += (output - 0.5) * 0.18;
+  level += 0.02; // inflow bump
+  level = Math.max(0, Math.min(1, level));
+
+  console.log(
+    `Cycle ${step + 1}: output=${output.toFixed(3)} | level=${level.toFixed(3)}`
+  );
+}
+
+console.log('\nBest practice tips:');
+console.log('  - Call update() on a fixed interval (sampleTime).');
+console.log('  - Clamp output and integral to avoid windup.');
+console.log('  - Use setMode("manual") during maintenance or bump-less transfer.');
+
+module.exports = {
+  pumpController,
+  tankController
+};

src/pid/index.js

@@ -0,0 +1,14 @@
+const { PIDController, CascadePIDController } = require('./PIDController');
+
+/**
+ * Convenience factories.
+ */
+const createPidController = (options) => new PIDController(options);
+const createCascadePidController = (options) => new CascadePIDController(options);
+
+module.exports = {
+  PIDController,
+  CascadePIDController,
+  createPidController,
+  createCascadePidController,
+};

src/predict/index.js

@@ -0,0 +1,9 @@
+const predict = require('./predict_class.js');
+const interpolation = require('./interpolation.js');
+const predictConfig = require('./predictConfig.json');
+
+module.exports = {
+  predict,
+  interpolation,
+  predictConfig,
+};

src/state/index.js

@@ -0,0 +1,11 @@
+const state = require('./state.js');
+const stateManager = require('./stateManager.js');
+const movementManager = require('./movementManager.js');
+const stateConfig = require('./stateConfig.json');
+
+module.exports = {
+  state,
+  stateManager,
+  movementManager,
+  stateConfig,
+};

src/state/movementManager.js

@@ -13,12 +13,12 @@ class movementManager {
 
     this.speed = speed;
     this.maxSpeed = maxSpeed;
-      console.log(`MovementManager: Initial speed=${this.speed}, maxSpeed=${maxSpeed}`);
     this.interval = interval;
     this.timeleft = 0; // timeleft of current movement
 
     this.logger = logger;
     this.movementMode = config.movement.mode;
+    this.logger?.debug?.(`MovementManager initialized: speed=${this.speed}, maxSpeed=${this.maxSpeed}`);
   }
 
   getCurrentPosition() {
@@ -83,11 +83,8 @@ class movementManager {
     const direction = targetPosition > this.currentPosition ? 1 : -1;
     const distance  = Math.abs(targetPosition - this.currentPosition);
 
-    // Speed is a fraction [0,1] of full-range per second
+    const velocity = this.getVelocity(); // units per second
-    this.speed = Math.min(Math.max(this.speed, 0), 1);
+    if (velocity <= 0) {
-    const fullRange = this.maxPosition - this.minPosition;
-    const velocity  = this.speed * fullRange;      // units per second
-    if (velocity === 0) {
       return reject(new Error("Movement aborted: zero speed"));
     }
 
@@ -156,11 +153,11 @@ class movementManager {
       const direction = targetPosition > this.currentPosition ? 1 : -1;
       const distance = Math.abs(targetPosition - this.currentPosition);
 
-      // Ensure speed is a percentage [0, 1]
+      const velocity = this.getVelocity();
-      this.speed = Math.min(Math.max(this.speed, 0), 1);
+      if (velocity <= 0) {
-
+        return reject(new Error("Movement aborted: zero speed"));
-      // Calculate duration based on percentage of distance per second
+      }
-      const duration = 1 / this.speed; // 1 second for 100% of the distance
+      const duration = distance / velocity;
 
       this.timeleft = duration; //set this so other classes can use it
       this.logger.debug(
@@ -218,13 +215,16 @@ class movementManager {
 
       const totalDistance = Math.abs(targetPosition - this.currentPosition);
       const startPosition = this.currentPosition;
-      this.speed = Math.min(Math.max(this.speed, 0), 1);
+      const velocity = this.getVelocity();
+      if (velocity <= 0) {
+        return reject(new Error("Movement aborted: zero speed"));
+      }
 
       const easeFunction = (t) =>
         t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
 
       let elapsedTime = 0;
-      const duration = totalDistance / this.speed;
+      const duration = totalDistance / velocity;
       this.timeleft = duration;
       const interval = this.interval;
 
@@ -274,6 +274,20 @@ class movementManager {
   constrain(value) {
     return Math.min(Math.max(value, this.minPosition), this.maxPosition);
   }
+
+  getNormalizedSpeed() {
+    const rawSpeed = Number.isFinite(this.speed) ? this.speed : 0;
+    const clampedSpeed = Math.max(0, rawSpeed);
+    const hasMax = Number.isFinite(this.maxSpeed) && this.maxSpeed > 0;
+    const effectiveSpeed = hasMax ? Math.min(clampedSpeed, this.maxSpeed) : clampedSpeed;
+    return effectiveSpeed / 100; // convert %/s -> fraction of range per second
+  }
+
+  getVelocity() {
+    const normalizedSpeed = this.getNormalizedSpeed();
+    const fullRange = this.maxPosition - this.minPosition;
+    return normalizedSpeed * fullRange;
+  }
 }
 
 module.exports = movementManager;

src/state/state.js

@@ -52,6 +52,10 @@ class state{
     return this.stateManager.getRunTimeHours();
   }
 
+  getMaintenanceTimeHours(){
+    return this.stateManager.getMaintenanceTimeHours();
+  }
+
  
   async moveTo(targetPosition) {
 

src/state/stateConfig.json

@@ -127,7 +127,7 @@
         }
       },
       "maxSpeed": {
-        "default": 10,
+        "default": 1000,
         "rules": {
           "type": "number",
           "description": "Maximum speed setting."
@@ -205,6 +205,10 @@
             {
               "value": "off",
               "description": "Machine is off."
+            },
+            {
+              "value": "maintenance",
+              "description": "Machine locked for inspection or repair; automatic control disabled."
             }
           ],
           "description": "Current state of the machine."
@@ -216,7 +220,7 @@
           "type": "object",
           "schema": {
             "idle": {
-              "default": ["starting", "off","emergencystop"],
+              "default": ["starting", "off","emergencystop","maintenance"],
               "rules":{
                 "type": "set",
                 "itemType": "string",
@@ -280,7 +284,7 @@
               }
             },
             "off": {
-              "default": ["idle","emergencystop"],
+              "default": ["idle","emergencystop","maintenance"],
               "rules":{
                 "type": "set",
                 "itemType": "string",
@@ -288,12 +292,20 @@
               }
           },
           "emergencystop": {
-            "default": ["idle","off"],
+            "default": ["idle","off","maintenance"],
             "rules":{
               "type": "set",
               "itemType": "string",
               "description": "Allowed transitions from emergency stop state."
             }
+          },
+          "maintenance":  { 
+            "default": ["maintenance","idle","off"],
+            "rules":{
+              "type": "set",
+              "itemType": "string",
+              "description": "Allowed transitions for maintenance mode"
+            }
           }
         },
         "description": "Allowed transitions between states."

src/state/stateManager.js

@@ -48,10 +48,14 @@ class stateManager {
     // Define valid transitions (can be extended dynamically if needed)
     this.validTransitions = config.state.allowedTransitions;
 
-    // NEW: Initialize runtime tracking
+    //runtime tracking
     this.runTimeHours = 0; // cumulative runtime in hours
     this.runTimeStart = null; // timestamp when active state began
 
+    //maintenance tracking
+    this.maintenanceTimeStart = null; //timestamp when active state began
+    this.maintenanceTimeHours = 0; //cumulative
+
     // Define active states (runtime counts only in these states)
     this.activeStates = config.state.activeStates;
   }
@@ -73,8 +77,9 @@ class stateManager {
         ); //go back early and reject promise
       }
 
-      // NEW: Handle runtime tracking based on active states
+      //Time tracking based on active states
       this.handleRuntimeTracking(newState);
+      this.handleMaintenancetimeTracking(newState);
 
       const transitionDuration = this.transitionTimes[this.currentState] || 0; // Default to 0 if no transition time
       this.logger.debug(
@@ -100,7 +105,7 @@ class stateManager {
   }
 
   handleRuntimeTracking(newState) {
-    // NEW: Handle runtime tracking based on active states
+    //Handle runtime tracking based on active states
     const wasActive = this.activeStates.has(this.currentState);
     const willBeActive = this.activeStates.has(newState);
     if (wasActive && !willBeActive && this.runTimeStart) {
@@ -120,6 +125,28 @@ class stateManager {
     }
   }
 
+  handleMaintenancetimeTracking(newState) {
+    //is this maintenance time ?
+    const wasActive = (this.currentState == "maintenance"? true:false);
+    const willBeActive = ( newState == "maintenance" ? true:false );
+
+    if (wasActive && this.maintenanceTimeStart) {
+      // stop runtime timer and accumulate elapsed time
+      const elapsed = (Date.now() - this.maintenanceTimeStart) / 3600000; // hours
+      this.maintenanceTimeHours += elapsed;
+      this.maintenanceTimeStart = null;
+      this.logger.debug(
+        `Maintenance timer stopped; elapsed=${elapsed.toFixed(
+          3
+        )}h, total=${this.maintenanceTimeHours.toFixed(3)}h.`
+      );
+    } else if (willBeActive && !this.runTimeStart) {
+      // starting new runtime
+      this.maintenanceTimeStart = Date.now();
+      this.logger.debug("Runtime timer started.");
+    }
+  }
+
   isValidTransition(newState) {
     this.logger.debug(
       `Check 1 Transition valid ? From ${
@@ -150,7 +177,6 @@ class stateManager {
     return this.descriptions[state] || "No description available.";
   }
 
-  // NEW: Getter to retrieve current cumulative runtime (active time) in hours.
   getRunTimeHours() {
     // If currently active add the ongoing duration.
     let currentElapsed = 0;
@@ -159,6 +185,15 @@ class stateManager {
     }
     return this.runTimeHours + currentElapsed;
   }
+
+  getMaintenanceTimeHours() {
+    // If currently active add the ongoing duration.
+    let currentElapsed = 0;
+    if (this.maintenanceTimeStart) {
+      currentElapsed = (Date.now() - this.maintenanceTimeStart) / 3600000;
+    }
+    return this.maintenanceTimeHours + currentElapsed;
+  }
 }
 
 module.exports = stateManager;

test/00-barrel-contract.test.js

@@ -0,0 +1,50 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const barrel = require('../index.js');
+
+test('barrel exports expected public members', () => {
+  const expected = [
+    'predict',
+    'interpolation',
+    'configManager',
+    'assetApiConfig',
+    'outputUtils',
+    'configUtils',
+    'logger',
+    'validation',
+    'assertions',
+    'MeasurementContainer',
+    'nrmse',
+    'state',
+    'coolprop',
+    'convert',
+    'MenuManager',
+    'PIDController',
+    'CascadePIDController',
+    'createPidController',
+    'createCascadePidController',
+    'childRegistrationUtils',
+    'loadCurve',
+    'loadModel',
+    'gravity',
+  ];
+
+  for (const key of expected) {
+    assert.ok(key in barrel, `missing export: ${key}`);
+  }
+});
+
+test('barrel types are callable where expected', () => {
+  assert.equal(typeof barrel.logger, 'function');
+  assert.equal(typeof barrel.validation, 'function');
+  assert.equal(typeof barrel.configUtils, 'function');
+  assert.equal(typeof barrel.outputUtils, 'function');
+  assert.equal(typeof barrel.MeasurementContainer, 'function');
+  assert.equal(typeof barrel.convert, 'function');
+  assert.equal(typeof barrel.PIDController, 'function');
+  assert.equal(typeof barrel.CascadePIDController, 'function');
+  assert.equal(typeof barrel.createPidController, 'function');
+  assert.equal(typeof barrel.createCascadePidController, 'function');
+  assert.equal(typeof barrel.gravity.getStandardGravity, 'function');
+});

test/assertions.test.js

@@ -0,0 +1,14 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const Assertions = require('../src/helper/assertionUtils.js');
+
+test('assertNoNaN does not throw for valid nested arrays', () => {
+  const assertions = new Assertions();
+  assert.doesNotThrow(() => assertions.assertNoNaN([1, [2, 3, [4]]]));
+});
+
+test('assertNoNaN throws when NaN exists in nested arrays', () => {
+  const assertions = new Assertions();
+  assert.throws(() => assertions.assertNoNaN([1, [2, NaN]]), /NaN detected/);
+});

test/child-registration-utils.test.js

@@ -0,0 +1,55 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const ChildRegistrationUtils = require('../src/helper/childRegistrationUtils.js');
+
+function makeMainClass() {
+  return {
+    logger: {
+      debug() {},
+      info() {},
+      warn() {},
+      error() {},
+    },
+    child: {},
+    registerChildCalls: [],
+    registerChild(child, softwareType) {
+      this.registerChildCalls.push({ child, softwareType });
+    },
+  };
+}
+
+test('registerChild wires parent, measurement context, and storage', async () => {
+  const mainClass = makeMainClass();
+  const utils = new ChildRegistrationUtils(mainClass);
+
+  const measurementContext = {
+    childId: null,
+    childName: null,
+    parentRef: null,
+    setChildId(v) { this.childId = v; },
+    setChildName(v) { this.childName = v; },
+    setParentRef(v) { this.parentRef = v; },
+  };
+
+  const child = {
+    config: {
+      functionality: { softwareType: 'measurement' },
+      general: { name: 'PT1', id: 'child-1' },
+      asset: { category: 'sensor' },
+    },
+    measurements: measurementContext,
+  };
+
+  await utils.registerChild(child, 'upstream');
+
+  assert.deepEqual(child.parent, [mainClass]);
+  assert.equal(child.positionVsParent, 'upstream');
+  assert.equal(measurementContext.childId, 'child-1');
+  assert.equal(measurementContext.childName, 'PT1');
+  assert.equal(measurementContext.parentRef, mainClass);
+
+  assert.equal(mainClass.child.measurement.sensor.length, 1);
+  assert.equal(utils.getChildById('child-1'), child);
+  assert.equal(mainClass.registerChildCalls.length, 1);
+});

test/config-manager.test.js

@@ -0,0 +1,33 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const ConfigManager = require('../src/configs/index.js');
+
+test('can read known config and report existence', () => {
+  const manager = new ConfigManager('.');
+  assert.equal(manager.hasConfig('measurement'), true);
+
+  const config = manager.getConfig('measurement');
+  assert.ok(config.functionality);
+  assert.ok(config.functionality.softwareType);
+});
+
+test('getAvailableConfigs includes known names', () => {
+  const manager = new ConfigManager('.');
+  const configs = manager.getAvailableConfigs();
+  assert.ok(configs.includes('measurement'));
+  assert.ok(configs.includes('rotatingMachine'));
+});
+
+test('createEndpoint creates executable JS payload shell', () => {
+  const manager = new ConfigManager('.');
+  const script = manager.createEndpoint('measurement');
+
+  assert.match(script, /window\.EVOLV\.nodes\.measurement/);
+  assert.match(script, /config loaded and endpoint created/);
+});
+
+test('getConfig throws on missing config', () => {
+  const manager = new ConfigManager('.');
+  assert.throws(() => manager.getConfig('definitely-not-real'), /Failed to load config/);
+});

test/config-utils.test.js

@@ -0,0 +1,51 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const ConfigUtils = require('../src/helper/configUtils.js');
+
+const defaultConfig = {
+  functionality: {
+    softwareType: {
+      default: 'measurement',
+      rules: { type: 'string' },
+    },
+  },
+  general: {
+    logging: {
+      enabled: { default: true, rules: { type: 'boolean' } },
+      logLevel: {
+        default: 'info',
+        rules: {
+          type: 'enum',
+          values: [{ value: 'debug' }, { value: 'info' }, { value: 'warn' }, { value: 'error' }],
+        },
+      },
+    },
+    name: { default: 'default-name', rules: { type: 'string' } },
+  },
+  scaling: {
+    absMin: { default: 0, rules: { type: 'number' } },
+    absMax: { default: 100, rules: { type: 'number' } },
+  },
+};
+
+test('initConfig applies defaults', () => {
+  const cfg = new ConfigUtils(defaultConfig, false, 'error');
+  const result = cfg.initConfig({});
+  assert.equal(result.general.name, 'default-name');
+  assert.equal(result.scaling.absMax, 100);
+});
+
+test('updateConfig merges nested overrides and revalidates', () => {
+  const cfg = new ConfigUtils(defaultConfig, false, 'error');
+  const base = cfg.initConfig({ general: { name: 'sensor-a' } });
+  const updated = cfg.updateConfig(base, { scaling: { absMax: 150 } });
+
+  assert.equal(updated.general.name, 'sensor-a');
+  assert.equal(updated.scaling.absMax, 150);
+});
+
+test('constructor respects explicit logger disabled flag', () => {
+  const cfg = new ConfigUtils(defaultConfig, false, 'error');
+  assert.equal(cfg.logger.logging, false);
+});

test/configManager.test.js

@@ -56,6 +56,7 @@ describe('ConfigManager', () => {
     it('should include known config names without .json extension', () => {
       const configs = cm.getAvailableConfigs();
       expect(configs).toContain('baseConfig');
+      expect(configs).toContain('diffuser');
       expect(configs).toContain('measurement');
     });
 
@@ -79,6 +80,7 @@ describe('ConfigManager', () => {
       const result = cm.buildConfig('measurement', uiConfig, 'node-id-1');
       expect(result).toHaveProperty('general');
       expect(result).toHaveProperty('functionality');
+      expect(result).toHaveProperty('output');
     });
 
     it('should populate general.name from uiConfig.name', () => {
@@ -168,6 +170,25 @@ describe('ConfigManager', () => {
       expect(result).toHaveProperty('general');
       expect(result).toHaveProperty('functionality');
     });
+
+    it('should default output formats to process and influxdb', () => {
+      const result = cm.buildConfig('measurement', {}, 'id-1');
+      expect(result.output).toEqual({
+        process: 'process',
+        dbase: 'influxdb',
+      });
+    });
+
+    it('should allow output format overrides from ui config', () => {
+      const result = cm.buildConfig('measurement', {
+        processOutputFormat: 'json',
+        dbaseOutputFormat: 'csv',
+      }, 'id-1');
+      expect(result.output).toEqual({
+        process: 'json',
+        dbase: 'csv',
+      });
+    });
   });
 
   // ── createEndpoint() ─────────────────────────────────────────────────

test/curve-loader.test.js

@@ -0,0 +1,13 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { loadCurve } = require('../index.js');
+
+test('loadCurve resolves curve ids case-insensitively', () => {
+  const canonical = loadCurve('hidrostal-H05K-S03R');
+  const lowercase = loadCurve('hidrostal-h05k-s03r');
+
+  assert.ok(canonical);
+  assert.ok(lowercase);
+  assert.strictEqual(canonical, lowercase);
+});

test/endpoint-utils.test.js

@@ -0,0 +1,26 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const EndpointUtils = require('../src/helper/endpointUtils.js');
+
+test('generateMenuUtilsData returns helpers and compatibility options', () => {
+  const endpointUtils = new EndpointUtils();
+  const data = endpointUtils.generateMenuUtilsData('measurement', {
+    customCheck: 'function(value) { return !!value; }',
+  });
+
+  assert.equal(data.nodeName, 'measurement');
+  assert.equal(typeof data.helpers.validateRequired, 'string');
+  assert.equal(typeof data.helpers.customCheck, 'string');
+  assert.equal(data.options.autoLoadLegacy, true);
+});
+
+test('generateMenuUtilsBootstrap points to data and legacy endpoints', () => {
+  const endpointUtils = new EndpointUtils();
+  const script = endpointUtils.generateMenuUtilsBootstrap('measurement');
+
+  assert.match(script, /menuUtilsData\.json/);
+  assert.match(script, /menuUtils\.legacy\.js/);
+  assert.match(script, /window\.EVOLV\.nodes/);
+});
+

test/gravity.test.js

@@ -0,0 +1,21 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const gravity = require('../src/helper/gravity.js');
+
+test('standard gravity constant is available', () => {
+  assert.ok(Math.abs(gravity.getStandardGravity() - 9.80665) < 1e-9);
+});
+
+test('local gravity decreases with elevation', () => {
+  const seaLevel = gravity.getLocalGravity(45, 0);
+  const high = gravity.getLocalGravity(45, 1000);
+  assert.ok(high < seaLevel);
+});
+
+test('pressureHead and weightForce use local gravity', () => {
+  const dp = gravity.pressureHead(1000, 5, 45, 0);
+  const force = gravity.weightForce(2, 45, 0);
+  assert.ok(dp > 0);
+  assert.ok(force > 0);
+});

test/helpers.js

@@ -0,0 +1,24 @@
+const path = require('node:path');
+
+function makeLogger() {
+  return {
+    debug() {},
+    info() {},
+    warn() {},
+    error() {},
+  };
+}
+
+function near(actual, expected, epsilon = 1e-6) {
+  return Math.abs(actual - expected) <= epsilon;
+}
+
+function fixturePath(...segments) {
+  return path.join(__dirname, ...segments);
+}
+
+module.exports = {
+  makeLogger,
+  near,
+  fixturePath,
+};

test/logger.test.js

@@ -0,0 +1,65 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const Logger = require('../src/helper/logger.js');
+
+function withPatchedConsole(fn) {
+  const original = {
+    debug: console.debug,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+  };
+
+  const calls = [];
+  console.debug = (...args) => calls.push(['debug', ...args]);
+  console.info = (...args) => calls.push(['info', ...args]);
+  console.warn = (...args) => calls.push(['warn', ...args]);
+  console.error = (...args) => calls.push(['error', ...args]);
+
+  try {
+    fn(calls);
+  } finally {
+    console.debug = original.debug;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+  }
+}
+
+test('respects log level threshold', () => {
+  withPatchedConsole((calls) => {
+    const logger = new Logger(true, 'warn', 'T');
+    logger.debug('a');
+    logger.info('b');
+    logger.warn('c');
+    logger.error('d');
+
+    const levels = calls.map((c) => c[0]);
+    assert.deepEqual(levels, ['warn', 'error']);
+  });
+});
+
+test('toggleLogging disables output', () => {
+  withPatchedConsole((calls) => {
+    const logger = new Logger(true, 'debug', 'T');
+    logger.toggleLogging();
+    logger.debug('x');
+    logger.error('y');
+    assert.equal(calls.length, 0);
+  });
+});
+
+test('setLogLevel updates to valid level', () => {
+  const logger = new Logger(true, 'debug', 'T');
+  logger.setLogLevel('error');
+  assert.equal(logger.logLevel, 'error');
+});
+
+test('setLogLevel with invalid value should not throw', () => {
+  withPatchedConsole(() => {
+    const logger = new Logger(true, 'debug', 'T');
+    assert.doesNotThrow(() => logger.setLogLevel('invalid-level'));
+    assert.equal(logger.logLevel, 'debug');
+  });
+});

test/measurement-builder.test.js

@@ -0,0 +1,29 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const MeasurementBuilder = require('../src/measurements/MeasurementBuilder.js');
+
+test('builder requires mandatory fields', () => {
+  assert.throws(() => new MeasurementBuilder().build(), /Measurement type is required/);
+  assert.throws(() => new MeasurementBuilder().setType('flow').build(), /Measurement variant is required/);
+  assert.throws(
+    () => new MeasurementBuilder().setType('flow').setVariant('measured').build(),
+    /Measurement position is required/
+  );
+});
+
+test('builder creates measurement with provided config', () => {
+  const measurement = new MeasurementBuilder()
+    .setType('flow')
+    .setVariant('measured')
+    .setPosition('upstream')
+    .setWindowSize(25)
+    .setDistance(3.2)
+    .build();
+
+  assert.equal(measurement.type, 'flow');
+  assert.equal(measurement.variant, 'measured');
+  assert.equal(measurement.position, 'upstream');
+  assert.equal(measurement.windowSize, 25);
+  assert.equal(measurement.distance, 3.2);
+});

test/measurement-container-core.test.js

@@ -0,0 +1,97 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const MeasurementContainer = require('../src/measurements/MeasurementContainer.js');
+
+function makeContainer() {
+  return new MeasurementContainer({
+    windowSize: 10,
+    defaultUnits: {
+      flow: 'm3/h',
+      pressure: 'mbar',
+    },
+  });
+}
+
+test('stores and retrieves measurements via chain API', () => {
+  const c = makeContainer();
+  c.type('flow').variant('measured').position('upstream').value(100, 1, 'm3/h');
+
+  assert.equal(c.type('flow').variant('measured').position('upstream').getCurrentValue(), 100);
+  assert.equal(c.type('flow').variant('measured').position('upstream').exists(), true);
+});
+
+test('distance(null) auto-derives from position mapping', () => {
+  const c = makeContainer();
+  c.type('pressure').variant('measured').position('upstream').distance(null).value(5, 1, 'mbar');
+
+  const m = c.type('pressure').variant('measured').position('upstream').get();
+  assert.equal(m.distance, Number.POSITIVE_INFINITY);
+});
+
+test('getLaggedSample with requested unit converts sample value', () => {
+  const c = makeContainer();
+  c.type('flow').variant('measured').position('upstream').value(3.6, 1, 'm3/h');
+  c.type('flow').variant('measured').position('upstream').value(7.2, 2, 'm3/h');
+
+  const previous = c.type('flow').variant('measured').position('upstream').getLaggedSample(1, 'm3/s');
+  assert.ok(previous);
+  assert.equal(previous.unit, 'm3/s');
+  assert.ok(Math.abs(previous.value - 0.001) < 1e-8);
+});
+
+test('difference computes current and average delta between positions', () => {
+  const c = makeContainer();
+  c.type('pressure').variant('measured').position('downstream').value(120, 1, 'mbar');
+  c.type('pressure').variant('measured').position('downstream').value(130, 2, 'mbar');
+  c.type('pressure').variant('measured').position('upstream').value(100, 1, 'mbar');
+  c.type('pressure').variant('measured').position('upstream').value(110, 2, 'mbar');
+
+  const diff = c.type('pressure').variant('measured').difference();
+  assert.equal(diff.value, 20);
+  assert.equal(diff.avgDiff, 20);
+  assert.equal(diff.unit, 'mbar');
+});
+
+test('_convertPositionNum2Str maps signs to labels', () => {
+  const c = makeContainer();
+  assert.equal(c._convertPositionNum2Str(0), 'atEquipment');
+  assert.equal(c._convertPositionNum2Str(1), 'downstream');
+  assert.equal(c._convertPositionNum2Str(-1), 'upstream');
+});
+
+test('storeCanonical stores anchor unit internally and can emit preferred output units', () => {
+  const c = new MeasurementContainer({
+    windowSize: 10,
+    autoConvert: true,
+    defaultUnits: { flow: 'm3/h' },
+    preferredUnits: { flow: 'm3/h' },
+    canonicalUnits: { flow: 'm3/s' },
+    storeCanonical: true,
+  });
+
+  c.type('flow').variant('measured').position('upstream').value(3.6, 1, 'm3/h');
+
+  const internal = c.type('flow').variant('measured').position('upstream').getCurrentValue();
+  assert.ok(Math.abs(internal - 0.001) < 1e-9);
+
+  const flat = c.getFlattenedOutput({ requestedUnits: { flow: 'm3/h' } });
+  assert.ok(Math.abs(flat['flow.measured.upstream.default'] - 3.6) < 1e-9);
+});
+
+test('strict unit validation rejects missing required unit and incompatible units', () => {
+  const c = new MeasurementContainer({
+    windowSize: 10,
+    strictUnitValidation: true,
+    throwOnInvalidUnit: true,
+    requireUnitForTypes: ['flow'],
+  });
+
+  assert.throws(() => {
+    c.type('flow').variant('measured').position('upstream').value(10, 1);
+  }, /Missing source unit/i);
+
+  assert.throws(() => {
+    c.type('flow').variant('measured').position('upstream').value(10, 1, 'mbar');
+  }, /Incompatible|unknown source unit/i);
+});

test/measurement.test.js

@@ -0,0 +1,49 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const Measurement = require('../src/measurements/Measurement.js');
+const { near } = require('./helpers.js');
+
+test('maintains rolling window and exposes stats', () => {
+  const m = new Measurement('flow', 'measured', 'upstream', 3);
+  m.setValue(10, 1).setValue(20, 2).setValue(30, 3).setValue(40, 4);
+
+  assert.deepEqual(m.getAllValues().values, [20, 30, 40]);
+  assert.deepEqual(m.getAllValues().timestamps, [2, 3, 4]);
+  assert.equal(m.getCurrentValue(), 40);
+  assert.equal(m.getAverage(), 30);
+  assert.equal(m.getMin(), 20);
+  assert.equal(m.getMax(), 40);
+});
+
+test('lag semantics: lag=1 is previous sample', () => {
+  const m = new Measurement('flow', 'measured', 'upstream', 5);
+  m.setValue(10, 100).setValue(20, 200).setValue(30, 300);
+
+  assert.equal(m.getLaggedSample(0).value, 30);
+  assert.equal(m.getLaggedSample(1).value, 20);
+  assert.equal(m.getLaggedValue(1), 20);
+});
+
+test('convertTo converts values to target unit', () => {
+  const m = new Measurement('flow', 'measured', 'upstream', 5);
+  m.setUnit('m3/h');
+  m.setValue(3.6, 1);
+
+  const converted = m.convertTo('m3/s');
+  assert.ok(near(converted.getCurrentValue(), 0.001, 1e-8));
+  assert.equal(converted.unit, 'm3/s');
+  assert.equal(converted.getLatestTimestamp(), 1);
+});
+
+test('createDifference aligns timestamps and subtracts downstream from upstream', () => {
+  const up = new Measurement('pressure', 'measured', 'upstream', 10).setUnit('mbar');
+  const down = new Measurement('pressure', 'measured', 'downstream', 10).setUnit('mbar');
+
+  up.setValue(120, 1).setValue(140, 2);
+  down.setValue(100, 2).setValue(95, 3);
+
+  const diff = Measurement.createDifference(up, down);
+  assert.deepEqual(diff.getAllValues().timestamps, [2]);
+  assert.deepEqual(diff.getAllValues().values, [40]);
+});

test/menu-manager.test.js

@@ -0,0 +1,20 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const MenuManager = require('../src/menu/index.js');
+
+test('createEndpoint returns script including initEditor and menuData', () => {
+  const manager = new MenuManager();
+  const script = manager.createEndpoint('measurement', ['asset', 'logger', 'position']);
+
+  assert.match(script, /window\.EVOLV\.nodes\.measurement\.initEditor/);
+  assert.match(script, /window\.EVOLV\.nodes\.measurement\.menuData/);
+});
+
+test('_getSoftwareType resolves to string identifier', () => {
+  const manager = new MenuManager();
+  const softwareType = manager._getSoftwareType('measurement');
+
+  assert.equal(typeof softwareType, 'string');
+  assert.equal(softwareType, 'measurement');
+});

test/nrmse.test.js

@@ -0,0 +1,56 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const ErrorMetrics = require('../src/nrmse/errorMetrics.js');
+const { makeLogger } = require('./helpers.js');
+
+test('MSE and RMSE calculations are correct', () => {
+  const m = new ErrorMetrics({}, makeLogger());
+  const predicted = [1, 2, 3];
+  const measured = [1, 3, 5];
+
+  assert.ok(Math.abs(m.meanSquaredError(predicted, measured) - 5 / 3) < 1e-9);
+  assert.ok(Math.abs(m.rootMeanSquaredError(predicted, measured) - Math.sqrt(5 / 3)) < 1e-9);
+});
+
+test('MSE throws for mismatched series lengths in strict mode', () => {
+  const m = new ErrorMetrics({}, makeLogger());
+  assert.throws(() => m.meanSquaredError([1, 2], [1]), /same length/);
+});
+
+test('normalizeUsingRealtime throws when range is zero', () => {
+  const m = new ErrorMetrics({}, makeLogger());
+  assert.throws(() => m.normalizeUsingRealtime([1, 1, 1], [1, 1, 1]), /Invalid process range/);
+});
+
+test('longTermNRMSD returns 0 before 100 samples and value after', () => {
+  const m = new ErrorMetrics({}, makeLogger());
+  for (let i = 0; i < 99; i++) {
+    assert.equal(m.longTermNRMSD(0.1), 0);
+  }
+  assert.notEqual(m.longTermNRMSD(0.2), 0);
+});
+
+test('assessDrift returns expected result envelope', () => {
+  const m = new ErrorMetrics({}, makeLogger());
+  const out = m.assessDrift([100, 101, 102], [99, 100, 103], 90, 110);
+
+  assert.equal(typeof out.nrmse, 'number');
+  assert.equal(typeof out.longTermNRMSD, 'number');
+  assert.ok('immediateLevel' in out);
+  assert.ok('longTermLevel' in out);
+});
+
+test('assessPoint keeps per-metric state and returns metric id', () => {
+  const m = new ErrorMetrics({}, makeLogger());
+  m.registerMetric('flow', { windowSize: 5, minSamplesForLongTerm: 3, strictValidation: true });
+
+  m.assessPoint('flow', 100, 99, { processMin: 0, processMax: 200, timestamp: Date.now() - 2000 });
+  m.assessPoint('flow', 101, 100, { processMin: 0, processMax: 200, timestamp: Date.now() - 1000 });
+  const out = m.assessPoint('flow', 102, 101, { processMin: 0, processMax: 200, timestamp: Date.now() });
+
+  assert.equal(out.metricId, 'flow');
+  assert.equal(out.valid, true);
+  assert.equal(typeof out.nrmse, 'number');
+  assert.equal(typeof out.sampleCount, 'number');
+});

test/output-utils.test.js

@@ -0,0 +1,42 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const OutputUtils = require('../src/helper/outputUtils.js');
+
+const config = {
+  functionality: { softwareType: 'measurement', role: 'sensor' },
+  general: { id: 'abc', unit: 'mbar' },
+  asset: {
+    uuid: 'u1',
+    tagcode: 't1',
+    geoLocation: { lat: 51.6, lon: 4.7 },
+    category: 'measurement',
+    type: 'pressure',
+    model: 'M1',
+  },
+};
+
+test('process format emits message with changed fields only', () => {
+  const out = new OutputUtils();
+
+  const first = out.formatMsg({ a: 1, b: 2 }, config, 'process');
+  assert.equal(first.topic, 'measurement_abc');
+  assert.deepEqual(first.payload, { a: 1, b: 2 });
+
+  const second = out.formatMsg({ a: 1, b: 2 }, config, 'process');
+  assert.equal(second, null);
+
+  const third = out.formatMsg({ a: 1, b: 3, c: { x: 1 } }, config, 'process');
+  assert.deepEqual(third.payload, { b: 3, c: JSON.stringify({ x: 1 }) });
+});
+
+test('influx format flattens tags and stringifies tag values', () => {
+  const out = new OutputUtils();
+  const msg = out.formatMsg({ value: 10 }, config, 'influxdb');
+
+  assert.equal(msg.topic, 'measurement_abc');
+  assert.equal(msg.payload.measurement, 'measurement_abc');
+  assert.equal(msg.payload.tags.geoLocation_lat, '51.6');
+  assert.equal(msg.payload.tags.geoLocation_lon, '4.7');
+  assert.ok(msg.payload.timestamp instanceof Date);
+});

test/outputUtils.test.js

@@ -0,0 +1,69 @@
+const OutputUtils = require('../src/helper/outputUtils');
+
+describe('OutputUtils', () => {
+  let outputUtils;
+  let config;
+
+  beforeEach(() => {
+    outputUtils = new OutputUtils();
+    config = {
+      general: {
+        name: 'Pump-1',
+        id: 'node-1',
+        unit: 'm3/h',
+      },
+      functionality: {
+        softwareType: 'pump',
+        role: 'test-role',
+      },
+      asset: {
+        supplier: 'EVOLV',
+        type: 'sensor',
+      },
+      output: {
+        process: 'process',
+        dbase: 'influxdb',
+      },
+    };
+  });
+
+  it('keeps legacy process output by default', () => {
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'process');
+    expect(msg).toEqual({
+      topic: 'Pump-1',
+      payload: { flow: 12.5 },
+    });
+  });
+
+  it('keeps legacy influxdb output by default', () => {
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'influxdb');
+    expect(msg.topic).toBe('Pump-1');
+    expect(msg.payload).toEqual(expect.objectContaining({
+      measurement: 'Pump-1',
+      fields: { flow: 12.5 },
+      tags: expect.objectContaining({
+        id: 'node-1',
+        name: 'Pump-1',
+        softwareType: 'pump',
+      }),
+    }));
+  });
+
+  it('supports config-driven json formatting on the process channel', () => {
+    config.output.process = 'json';
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'process');
+    expect(msg.topic).toBe('Pump-1');
+    expect(typeof msg.payload).toBe('string');
+    expect(msg.payload).toContain('"measurement":"Pump-1"');
+    expect(msg.payload).toContain('"flow":12.5');
+  });
+
+  it('supports config-driven csv formatting on the database channel', () => {
+    config.output.dbase = 'csv';
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'influxdb');
+    expect(msg.topic).toBe('Pump-1');
+    expect(typeof msg.payload).toBe('string');
+    expect(msg.payload).toContain('Pump-1');
+    expect(msg.payload).toContain('flow=12.5');
+  });
+});

test/pid-controller.test.js

@@ -0,0 +1,105 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { PIDController, CascadePIDController } = require('../src/pid/index.js');
+
+test('pid supports freeze/unfreeze with held output', () => {
+  const pid = new PIDController({
+    kp: 2,
+    ki: 0.5,
+    kd: 0.1,
+    sampleTime: 100,
+    outputMin: 0,
+    outputMax: 100,
+  });
+
+  const t0 = Date.now();
+  const first = pid.update(10, 2, t0 + 100);
+  pid.freeze({ output: first, trackMeasurement: true });
+  const frozen = pid.update(10, 4, t0 + 200);
+  assert.equal(frozen, first);
+
+  pid.unfreeze();
+  const resumed = pid.update(10, 4, t0 + 300);
+  assert.equal(Number.isFinite(resumed), true);
+});
+
+test('pid supports dynamic tunings and gain scheduling', () => {
+  const pid = new PIDController({
+    kp: 1,
+    ki: 0,
+    kd: 0,
+    sampleTime: 100,
+    outputMin: -100,
+    outputMax: 100,
+    gainSchedule: [
+      { min: Number.NEGATIVE_INFINITY, max: 5, kp: 1, ki: 0, kd: 0 },
+      { min: 5, max: Number.POSITIVE_INFINITY, kp: 3, ki: 0, kd: 0 },
+    ],
+  });
+
+  const t0 = Date.now();
+  const low = pid.update(10, 9, t0 + 100, { gainInput: 4 });
+  const high = pid.update(10, 9, t0 + 200, { gainInput: 6 });
+
+  assert.equal(high > low, true);
+
+  const tuned = pid.update(10, 9, t0 + 300, { tunings: { kp: 10, ki: 0, kd: 0 } });
+  assert.equal(tuned > high, true);
+});
+
+test('pid applies deadband and output rate limits', () => {
+  const pid = new PIDController({
+    kp: 10,
+    ki: 0,
+    kd: 0,
+    deadband: 0.5,
+    sampleTime: 100,
+    outputMin: 0,
+    outputMax: 100,
+    outputRateLimitUp: 5,   // units per second
+    outputRateLimitDown: 5, // units per second
+  });
+
+  const t0 = Date.now();
+  const out1 = pid.update(10, 10, t0 + 100); // inside deadband -> no action
+  const out2 = pid.update(20, 0, t0 + 200);  // strong error but limited by rate
+
+  assert.equal(out1, 0);
+  // 5 units/sec * 0.1 sec = max 0.5 rise per cycle
+  assert.equal(out2 <= 0.5 + 1e-9, true);
+});
+
+test('cascade pid computes primary and secondary outputs', () => {
+  const cascade = new CascadePIDController({
+    primary: {
+      kp: 2,
+      ki: 0,
+      kd: 0,
+      sampleTime: 100,
+      outputMin: 0,
+      outputMax: 100,
+    },
+    secondary: {
+      kp: 1,
+      ki: 0,
+      kd: 0,
+      sampleTime: 100,
+      outputMin: 0,
+      outputMax: 100,
+    },
+  });
+
+  const t0 = Date.now();
+  const result = cascade.update({
+    setpoint: 10,
+    primaryMeasurement: 5,
+    secondaryMeasurement: 2,
+    timestamp: t0 + 100,
+  });
+
+  assert.equal(typeof result.primaryOutput, 'number');
+  assert.equal(typeof result.secondaryOutput, 'number');
+  assert.equal(result.primaryOutput > 0, true);
+  assert.equal(result.secondaryOutput > 0, true);
+});

test/validation-utils.test.js

@@ -0,0 +1,141 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const ValidationUtils = require('../src/helper/validationUtils.js');
+
+const schema = {
+  functionality: {
+    softwareType: {
+      default: 'measurement',
+      rules: { type: 'string' },
+    },
+  },
+  enabled: {
+    default: true,
+    rules: { type: 'boolean' },
+  },
+  mode: {
+    default: 'auto',
+    rules: {
+      type: 'enum',
+      values: [{ value: 'auto' }, { value: 'manual' }],
+    },
+  },
+  name: {
+    default: 'sensor',
+    rules: { type: 'string' },
+  },
+  asset: {
+    default: {},
+    rules: {
+      type: 'object',
+      schema: {
+        unit: {
+          default: 'm3/h',
+          rules: { type: 'string' },
+        },
+        curveUnits: {
+          default: {},
+          rules: {
+            type: 'object',
+            schema: {
+              power: {
+                default: 'kW',
+                rules: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+test('validateSchema applies defaults and type coercion where supported', () => {
+  const validation = new ValidationUtils(false, 'error');
+  const result = validation.validateSchema({ enabled: 'true', name: 'SENSOR' }, schema, 'test');
+
+  assert.equal(result.enabled, true);
+  assert.equal(result.name, 'SENSOR');
+  assert.equal(result.mode, 'auto');
+  assert.equal(result.functionality.softwareType, 'measurement');
+});
+
+test('enum with non-string value falls back to default', () => {
+  const validation = new ValidationUtils(false, 'error');
+  const result = validation.validateSchema({ mode: 123 }, schema, 'test');
+  assert.equal(result.mode, 'auto');
+});
+
+test('curve validation falls back to default for invalid dimension structure', () => {
+  const validation = new ValidationUtils(false, 'error');
+  const defaultCurve = { 1: { x: [1, 2], y: [10, 20] } };
+  const invalid = { 1: { x: [2, 1], y: [20, 10] } };
+  const curve = validation.validateCurve(invalid, defaultCurve);
+  assert.deepEqual(curve, defaultCurve);
+});
+
+test('removeUnwantedKeys handles primitive values without throwing', () => {
+  const validation = new ValidationUtils(false, 'error');
+  const input = {
+    a: { default: 1, rules: { type: 'number' } },
+    b: 2,
+    c: 'x',
+  };
+  assert.doesNotThrow(() => validation.removeUnwantedKeys(input));
+});
+
+test('unit-like fields preserve case while regular strings are normalized', () => {
+  const validation = new ValidationUtils(false, 'error');
+  const result = validation.validateSchema(
+    {
+      name: 'RotatingMachine',
+      asset: {
+        unit: 'kW',
+        curveUnits: { power: 'kW' },
+      },
+    },
+    schema,
+    'machine'
+  );
+
+  assert.equal(result.name, 'RotatingMachine');
+  assert.equal(result.asset.unit, 'kW');
+  assert.equal(result.asset.curveUnits.power, 'kW');
+});
+
+test('array with minLength 0 accepts empty arrays without fallback warning path', () => {
+  const validation = new ValidationUtils(false, 'error');
+  const localSchema = {
+    functionality: {
+      softwareType: {
+        default: 'measurement',
+        rules: { type: 'string' },
+      },
+    },
+    assetRegistration: {
+      default: { childAssets: ['default'] },
+      rules: {
+        type: 'object',
+        schema: {
+          childAssets: {
+            default: ['default'],
+            rules: {
+              type: 'array',
+              itemType: 'string',
+              minLength: 0,
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const result = validation.validateSchema(
+    { assetRegistration: { childAssets: [] } },
+    localSchema,
+    'measurement'
+  );
+
+  assert.deepEqual(result.assetRegistration.childAssets, []);
+});