updates

Reviewed-on: https://gitea.centraal.wbd-rd.nl/RnD/generalFunctions/pulls/12

datasets/assetData/assetData.json

@@ -66,6 +66,33 @@
                   "units": ["g/m³", "mol/m³"]
                 }
               ]
+            },
+            {
+              "name": "Quantity (Ammonium)",
+              "models": [
+                { 
+                  "name": "VegaAmmoniaSense 10", 
+                  "units": ["g/m³", "mol/m³"]
+                }
+              ]
+            },
+            {
+              "name": "Quantity (NOx)",
+              "models": [
+                { 
+                  "name": "VegaNOxSense 10", 
+                  "units": ["g/m³", "mol/m³"]
+                }
+              ]
+            },
+            {
+              "name": "Quantity (TSS)",
+              "models": [
+                { 
+                  "name": "VegaSolidsProbe", 
+                  "units": ["g/m³"]
+                }
+              ]
             }
           ]
         }

datasets/assetData/curves/index.js

@@ -25,7 +25,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
@@ -34,11 +38,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;
       }
 
@@ -56,6 +60,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/measurement.json

@@ -11,39 +11,102 @@
           "id": "temperature",
           "name": "Temperature",
           "models": [
-            { "id": "vega-temp-10", "name": "VegaTemp 10", "units": ["degC", "degF"] },
+            { "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"] }
+            { "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"] },
+            { "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"] }
+            { "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"] },
+            { "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"] }
+            { "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"] },
+            { "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"] }
+            { "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"] }
+            { "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/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/get_all_assets.php

@@ -0,0 +1 @@
+Database connection failed: SQLSTATE[28000] [1045] Access denied for user 'pimmoe1q_rdlab'@'localhost' (using password: YES)

datasets/tagcodeapp_product_models.json

@@ -1,229 +0,0 @@
-{
-    "success": true,
-    "message": "Product modellen succesvol opgehaald.",
-    "data": [
-        {
-            "id": "1",
-            "name": "Macbook Air 12",
-            "product_model_subtype_id": "1",
-            "product_model_description": null,
-            "vendor_id": "1",
-            "product_model_status": null,
-            "vendor_name": "Apple",
-            "product_subtype_name": "Laptop",
-            "product_model_meta": []
-        },
-        {
-            "id": "2",
-            "name": "Macbook Air 13",
-            "product_model_subtype_id": "1",
-            "product_model_description": null,
-            "vendor_id": "1",
-            "product_model_status": null,
-            "vendor_name": "Apple",
-            "product_subtype_name": "Laptop",
-            "product_model_meta": []
-        },
-        {
-            "id": "3",
-            "name": "AirMac 1 128 GB White",
-            "product_model_subtype_id": "2",
-            "product_model_description": null,
-            "vendor_id": "1",
-            "product_model_status": null,
-            "vendor_name": "Apple",
-            "product_subtype_name": "Desktop",
-            "product_model_meta": []
-        },
-        {
-            "id": "4",
-            "name": "AirMac 2 256 GB Black",
-            "product_model_subtype_id": "2",
-            "product_model_description": null,
-            "vendor_id": "1",
-            "product_model_status": null,
-            "vendor_name": "Apple",
-            "product_subtype_name": "Desktop",
-            "product_model_meta": []
-        },
-        {
-            "id": "5",
-            "name": "AirMac 2 256 GB White",
-            "product_model_subtype_id": "2",
-            "product_model_description": null,
-            "vendor_id": "1",
-            "product_model_status": null,
-            "vendor_name": "Apple",
-            "product_subtype_name": "Desktop",
-            "product_model_meta": []
-        },
-        {
-            "id": "6",
-            "name": "Vegabar 14",
-            "product_model_subtype_id": "3",
-            "product_model_description": "vegabar 14",
-            "vendor_id": "4",
-            "product_model_status": "Actief",
-            "vendor_name": "vega",
-            "product_subtype_name": "pressure",
-            "product_model_meta": {
-                "machineCurve": {
-                    "np": {
-                        "700": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                12.962460720759278,
-                                20.65443723573673,
-                                31.029351002816465,
-                                44.58926412111886,
-                                62.87460150792057
-                            ]
-                        },
-                        "800": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                13.035157335397209,
-                                20.74906989186132,
-                                31.029351002816465,
-                                44.58926412111886,
-                                62.87460150792057
-                            ]
-                        },
-                        "900": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                13.064663380158798,
-                                20.927197054134297,
-                                31.107126521989933,
-                                44.58926412111886,
-                                62.87460150792057
-                            ]
-                        },
-                        "1000": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                13.039271391128953,
-                                21.08680188366637,
-                                31.30899920405947,
-                                44.58926412111886,
-                                62.87460150792057
-                            ]
-                        },
-                        "1100": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                12.940075520572446,
-                                21.220547481589954,
-                                31.51468295656385,
-                                44.621326083982,
-                                62.87460150792057
-                            ]
-                        }
-                    },
-                    "nq": {
-                        "700": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                119.13938764447377,
-                                150.12178608265387,
-                                178.82698019104356,
-                                202.3699313222398,
-                                227.06382297856618
-                            ]
-                        },
-                        "800": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                112.59072109293984,
-                                148.15847460389205,
-                                178.82698019104356,
-                                202.3699313222398,
-                                227.06382297856618
-                            ]
-                        },
-                        "900": {
-                            "x": [
-                                0,
-                                24.59,
-                                49.18,
-                                73.77,
-                                100
-                            ],
-                            "y": [
-                                105.6217241180404,
-                                144.00502117747064,
-                                177.15212647335034,
-                                202.3699313222398,
-                                227.06382297856618
-                            ]
-                        }
-                    }
-                }
-            }
-        },
-        {
-            "id": "7",
-            "name": "Vegabar 10",
-            "product_model_subtype_id": "3",
-            "product_model_description": null,
-            "vendor_id": "4",
-            "product_model_status": "Actief",
-            "vendor_name": "vega",
-            "product_subtype_name": "pressure",
-            "product_model_meta": []
-        },
-        {
-            "id": "8",
-            "name": "VegaFlow 10",
-            "product_model_subtype_id": "4",
-            "product_model_description": null,
-            "vendor_id": "4",
-            "product_model_status": "Actief",
-            "vendor_name": "vega",
-            "product_subtype_name": "flow",
-            "product_model_meta": []
-        }
-    ]
-}

index.js

@@ -8,24 +8,28 @@
  */
 
 // 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 gravity = require('./src/helper/gravity.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 { loadModel } = require('./datasets/assetData/modelData/index.js'); 
 
@@ -34,6 +38,7 @@ module.exports = {
     predict,
     interpolation,
     configManager,
+    assetApiConfig,
     outputUtils,
     configUtils,
     logger,
@@ -45,6 +50,10 @@ module.exports = {
     coolprop,
     convert,
     MenuManager,
+    PIDController,
+    CascadePIDController,
+    createPidController,
+    createCascadePidController,
     childRegistrationUtils,
     loadCurve, //deprecated replace with loadModel
     loadModel,

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/machineGroupControl.json

@@ -58,7 +58,7 @@
     },
     "functionality": {
       "softwareType": {
-        "default": "machineGroup",
+        "default": "machinegroup",
           "rules": {
             "type": "string",
             "description": "Logical name identifying the software type."

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/pumpingStation.json

@@ -59,7 +59,7 @@
     },
     "functionality": {
         "softwareType": {
-            "default": "pumpingStation",
+            "default": "pumpingstation",
             "rules": {
                 "type": "string",
                 "description": "Specified software type used to locate the proper default configuration."
@@ -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": {
@@ -150,7 +158,7 @@
             }
         },
         "type": {
-            "default": "pumpingStation",
+            "default": "pumpingstation",
             "rules": {
                 "type": "string",
                 "description": "Specific asset type used to identify this configuration."
@@ -316,6 +324,13 @@
                 "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": {
@@ -463,6 +478,76 @@
             }
         },
         "flowBased": {
+            "flowSetpoint": {
+                "default": 0,
+                "rules": {
+                    "type": "number",
+                    "min": 0,
+                    "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": {
                 "default": 60,
                 "rules": {

src/configs/rotatingMachine.json

@@ -16,7 +16,7 @@
         }
       },
       "unit": {
-        "default": "m3/s",
+        "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": {
@@ -435,6 +484,14 @@
         ],
         "description": "The frequency at which calculations are performed."
       }
+    },
+    "flowNumber": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "nullable": false,
+        "description": "Defines which effluent flow of the parent node to handle."
+      }
     }
   }
   

src/helper/assertionUtils.js

@@ -16,7 +16,7 @@ class Assertions {
     assertNoNaN(arr, label = "array") {
         if (Array.isArray(arr)) {
             for (const el of arr) {
-                assertNoNaN(el, label);
+                this.assertNoNaN(el, label);
             }
         } else {
             if (Number.isNaN(arr)) {

src/helper/assetUtils.js

@@ -1,3 +1,244 @@
-export 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;
 }
+
+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

@@ -6,13 +6,27 @@ class ChildRegistrationUtils {
   }
 
   async registerChild(child, positionVsParent, distance) {
-    const { softwareType } = child.config.functionality;
+    if (!child || typeof child !== 'object') {
-    const { name, id } = child.config.general;
+      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;
+    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}`);
 
-    // Enhanced child setup
+    // Enhanced child setup - multiple parents
-    child.parent = this.mainClass;
+    if (Array.isArray(child.parent)) {
+      child.parent.push(this.mainClass);
+    } else {
+      child.parent = [this.mainClass];
+    }
     child.positionVsParent = positionVsParent;
 
     // Enhanced measurement container with rich context
@@ -39,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 (obj2.hasOwnProperty(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/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 ${nameModule}]: Invalid log level: ${level}`);
+        console.error(`[ERROR] -> ${this.nameModule}: Invalid log level: ${level}`);
       }
     }
   

src/helper/menuUtils.js

@@ -480,17 +480,26 @@ generateHtml(htmlElement, options, savedValue) {
   }
 }
 
-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() !== '';
@@ -500,7 +509,71 @@ generateMenuUtilsCode(nodeName, customHelpers = {}) {
     }`
   };
 
-  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}`)
@@ -533,6 +606,11 @@ ${helpersCode}
   `;
 }
 
+// Backward-compatible alias
+generateMenuUtilsCode(nodeName, customHelpers = {}) {
+  return this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
+}
+
 }
 
 module.exports = MenuUtils;

src/helper/nodeTemplates.js

@@ -53,4 +53,4 @@ const nodeTemplates = {
   // …add more node “templates” here…
 };
 
-export default nodeTemplates;
+module.exports = nodeTemplates;

src/helper/outputUtils.js

@@ -7,6 +7,9 @@ class OutputUtils {
   }
 
   checkForChanges(output, format) {
+    if (!output || typeof output !== 'object') {
+      return {};
+    }
     const changedFields = {};
     for (const key in output) {
       if (output.hasOwnProperty(key) && output[key] !== this.output[format][key]) {
@@ -54,11 +57,11 @@ class OutputUtils {
             break;
 
           default:
-            console.log('Unknown format in output utils');
+            return null;
-            break;
         }
         return msg;
       }
+      return null;
   }
   
 

src/helper/validationUtils.js

@@ -36,9 +36,22 @@ const Logger = require("./logger");
 
 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) {
@@ -96,7 +109,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;
@@ -191,7 +204,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;
@@ -390,19 +403,52 @@ class ValidationUtils {
             return fieldSchema.default;
         }
 
+        const keyString = `${name}.${key}`;
+        const normalizeMode = rules.normalize || this._resolveStringNormalizeMode(keyString);
+        const preserveCase = normalizeMode !== "lowercase";
+
         // Check for uppercase characters and convert to lowercase if present
-        if (newConfigValue !== newConfigValue.toLowerCase()) {
+        if (!preserveCase && newConfigValue !== newConfigValue.toLowerCase()) {
-            this.logger.warn(`${name}.${key} contains uppercase characters. Converting to lowercase: ${newConfigValue} -> ${newConfigValue.toLowerCase()}`);
+            this._logOnce(
+                "info",
+                `normalize-lowercase:${keyString}`,
+                `${name}.${key} normalized to lowercase: ${newConfigValue} -> ${newConfigValue.toLowerCase()}`
+            );
             newConfigValue = newConfigValue.toLowerCase();
         }
 
         return newConfigValue;
     }
 
+    _isUnitLikeField(path) {
+        const normalized = String(path || "").toLowerCase();
+        if (!normalized) return false;
+        return /(^|\.)([a-z0-9]*unit|units)(\.|$)/.test(normalized)
+            || normalized.includes(".curveunits.");
+    }
+
+    _resolveStringNormalizeMode(path) {
+        const normalized = String(path || "").toLowerCase();
+        if (!normalized) return "none";
+
+        if (this._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";
+    }
+
     validateSet(configValue, rules, fieldSchema, name, key) {
         // 1. Ensure we have a Set. If not, use default.
         if (!(configValue instanceof Set)) {
-            this.logger.info(`${name}.${key} is not a Set. Converting to one using default value.`);
+            this.logger.debug(`${name}.${key} is not a Set. Converting to one using default value.`);
             return new Set(fieldSchema.default);
         }
     
@@ -426,9 +472,10 @@ class ValidationUtils {
             .slice(0, rules.maxLength || Infinity);
     
         // 4. Check if the filtered array meets the minimum length.
-        if (validatedArray.length < (rules.minLength || 1)) {
+        const minLength = Number.isInteger(rules.minLength) ? rules.minLength : 0;
+        if (validatedArray.length < minLength) {
             this.logger.warn(
-                `${name}.${key} contains fewer items than allowed (${rules.minLength}). Using default value.`
+                `${name}.${key} contains fewer items than allowed (${minLength}). Using default value.`
             );
             return new Set(fieldSchema.default);
         }
@@ -439,7 +486,7 @@ class ValidationUtils {
 
     validateArray(configValue, rules, fieldSchema, name, key) {
         if (!Array.isArray(configValue)) {
-            this.logger.info(`${name}.${key} is not an array. Using default value.`);
+            this.logger.debug(`${name}.${key} is not an array. Using default value.`);
             return fieldSchema.default;
         }
 
@@ -460,9 +507,10 @@ class ValidationUtils {
             })
             .slice(0, rules.maxLength || Infinity);
 
-        if (validatedArray.length < (rules.minLength || 1)) {
+        const minLength = Number.isInteger(rules.minLength) ? rules.minLength : 0;
+        if (validatedArray.length < minLength) {
             this.logger.warn(
-                `${name}.${key} contains fewer items than allowed (${rules.minLength}). Using default value.`
+                `${name}.${key} contains fewer items than allowed (${minLength}). Using default value.`
             );
             return fieldSchema.default;
         }
@@ -496,6 +544,11 @@ class ValidationUtils {
                 return fieldSchema.default;
             }
 
+            if (typeof configValue !== "string") {
+                this.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

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){
@@ -178,7 +180,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,6 +4,7 @@ const convertModule = require('../convert/index');
 
 class MeasurementContainer {
   constructor(options = {},logger) {
+    this.logger = logger || null;
     this.emitter = new EventEmitter();
     this.measurements = {};
     this.windowSize = options.windowSize || 10; // Default window size
@@ -16,7 +17,7 @@ class MeasurementContainer {
     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 +28,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;
@@ -71,6 +110,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] || 
@@ -78,6 +122,77 @@ 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];
@@ -90,25 +205,32 @@ class MeasurementContainer {
     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();
-    this._currentPosition = positionValue.toString().toLowerCase();;
     
     return this;
   }
@@ -128,33 +250,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);
       }
 
@@ -163,7 +291,7 @@ class MeasurementContainer {
         value: convertedValue,
         originalValue: val,
         unit: finalUnit,
-        sourceUnit: sourceUnit,
+        sourceUnit: unitPolicy.sourceUnit,
         timestamp,
         position: this._currentPosition,
         distance: this._currentDistance,
@@ -225,8 +353,6 @@ class MeasurementContainer {
     return requireValues ? measurement.values?.length > 0 : true;
   }
 
-
-
   unit(unitName) {
     if (!this._ensureChainIsValid()) return this;
     
@@ -332,7 +458,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;
@@ -364,7 +490,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;
@@ -402,21 +528,22 @@ class MeasurementContainer {
       .reduce((acc, v) => acc + v, 0);
   }
 
-    getFlattenedOutput() {
+    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}`] = 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}`] = m.getCurrentValue();
+                  out[`${type}.${variant}.${position}.${childId}`] = this._resolveOutputValue(type, m, requestedUnits);
                 }
               });
             }
@@ -429,7 +556,10 @@ class MeasurementContainer {
   // Difference calculations between positions
   difference({ from = "downstream", to = "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 => {
@@ -510,15 +640,33 @@ class MeasurementContainer {
 
   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] || 
@@ -538,7 +686,7 @@ class MeasurementContainer {
 
   // 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;
     }
 
@@ -557,19 +705,7 @@ class MeasurementContainer {
     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 {
@@ -619,16 +755,19 @@ class MeasurementContainer {
   }
 
   _convertPositionNum2Str(positionValue) {
-    switch (positionValue) {
+    if (positionValue === 0) {
-    case 0:
       return "atEquipment";
-    case (positionValue < 0):
-      return "upstream";
-    case (positionValue > 0):
-      return "downstream";
-    default:
-      console.log(`Invalid position provided: ${positionValue}`);
     }
+    if (positionValue < 0) {
+      return "upstream";
+    }
+    if (positionValue > 0) {
+      return "downstream";
+    }
+    if (this.logger) {
+      this.logger.warn(`Invalid position provided: ${positionValue}`);
+    }
+    return null;
   }
 
 }

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,4 +1,5 @@
 const { assetCategoryManager } = require('../../datasets/assetData');
+const assetApiConfig = require('../configs/assetApiConfig.js');
 
 class AssetMenu {
   constructor({ manager = assetCategoryManager, softwareType = null } = {}) {
@@ -67,7 +68,11 @@ class AssetMenu {
 
     return {
       categories: selectedCategories,
-      defaultCategory: categoryKey
+      defaultCategory: categoryKey,
+      apiConfig: {
+        url: `${assetApiConfig.baseUrl}/apis/products/PLC/integration/`,
+        headers: { ...assetApiConfig.headers }
+      }
     };
   }
 
@@ -75,6 +80,7 @@ class AssetMenu {
     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 `
@@ -85,13 +91,16 @@ class AssetMenu {
       ${htmlCode}
       ${dataCode}
       ${eventsCode}
+      ${syncCode}
       ${saveCode}
 
       window.EVOLV.nodes.${nodeName}.assetMenu.initEditor = function(node) {
         console.log('Initializing asset properties for ${nodeName}');
         this.injectHtml();
         this.wireEvents(node);
-        this.loadData(node);
+        this.loadData(node).catch((error) =>
+          console.error('Asset menu load failed:', error)
+        );
       };
     `;
   }
@@ -99,10 +108,11 @@ class AssetMenu {
   getDataInjectionCode(nodeName) {
     return `
       // Asset data loader for ${nodeName}
-      window.EVOLV.nodes.${nodeName}.assetMenu.loadData = function(node) {
+      window.EVOLV.nodes.${nodeName}.assetMenu.loadData = async function(node) {
         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'),
           type: document.getElementById('node-input-assetType'),
@@ -110,6 +120,79 @@ class AssetMenu {
           unit: document.getElementById('node-input-unit')
         };
 
+        function resolveCategoryKey() {
+          if (node.softwareType && categories[node.softwareType]) {
+            return node.softwareType;
+          }
+          if (node.category && categories[node.category]) {
+            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'
@@ -149,19 +232,23 @@ class AssetMenu {
           }
         }
 
-        const resolveCategoryKey = () => {
-          if (node.softwareType && categories[node.softwareType]) {
-            return node.softwareType;
-          }
-          if (node.category && categories[node.category]) {
-            return node.category;
-          }
-          return defaultCategory;
-        };
-
         const categoryKey = resolveCategoryKey();
-        node.category = categoryKey;
+        const resolvedCategoryKey = categoryKey || defaultCategory;
-        const activeCategory = categoryKey ? categories[categoryKey] : null;
+        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(
@@ -173,7 +260,7 @@ class AssetMenu {
         );
 
         const activeSupplier = suppliers.find(
-          (supplier) => (supplier.id || supplier.name) === node.supplier
+          (supplier) => String(supplier.id || supplier.name) === String(node.supplier)
         );
         const types = activeSupplier ? activeSupplier.types : [];
         populate(
@@ -185,7 +272,7 @@ class AssetMenu {
         );
 
         const activeType = types.find(
-          (type) => (type.id || type.name) === node.assetType
+          (type) => String(type.id || type.name) === String(node.assetType)
         );
         const models = activeType ? activeType.models : [];
         populate(
@@ -197,8 +284,12 @@ class AssetMenu {
         );
 
         const activeModel = models.find(
-          (model) => (model.id || model.name) === node.model
+          (model) => String(model.id || model.name) === String(node.model)
         );
+        if (activeModel) {
+          node.modelMetadata = activeModel;
+          node.modelName = activeModel.name;
+        }
         populate(
           elems.unit,
           activeModel ? activeModel.units || [] : [],
@@ -206,6 +297,7 @@ class AssetMenu {
           (unit) => ({ value: unit, label: unit }),
           activeModel ? 'Select...' : activeType ? 'Awaiting Model Selection' : 'Awaiting Type Selection'
         );
+        this.setAssetTagNumber(node, node.assetTagNumber || '');
       };
     `;
   }
@@ -284,7 +376,7 @@ class AssetMenu {
           const category = getActiveCategory();
           const supplier = category
             ? category.suppliers.find(
-                (item) => (item.id || item.name) === elems.supplier.value
+                (item) => String(item.id || item.name) === String(elems.supplier.value)
               )
             : null;
           const types = supplier ? supplier.types : [];
@@ -295,6 +387,7 @@ class AssetMenu {
             (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');
         });
@@ -303,12 +396,12 @@ class AssetMenu {
           const category = getActiveCategory();
           const supplier = category
             ? category.suppliers.find(
-                (item) => (item.id || item.name) === elems.supplier.value
+                (item) => String(item.id || item.name) === String(elems.supplier.value)
               )
             : null;
           const type = supplier
             ? supplier.types.find(
-                (item) => (item.id || item.name) === elems.type.value
+                (item) => String(item.id || item.name) === String(elems.type.value)
               )
             : null;
           const models = type ? type.models : [];
@@ -319,6 +412,7 @@ class AssetMenu {
             (model) => ({ value: model.id || model.name, label: model.name }),
             type ? 'Select...' : 'Awaiting Type Selection'
           );
+          node.modelMetadata = null;
           populate(
             elems.unit,
             [],
@@ -332,19 +426,21 @@ class AssetMenu {
           const category = getActiveCategory();
           const supplier = category
             ? category.suppliers.find(
-                (item) => (item.id || item.name) === elems.supplier.value
+                (item) => String(item.id || item.name) === String(elems.supplier.value)
               )
             : null;
           const type = supplier
             ? supplier.types.find(
-                (item) => (item.id || item.name) === elems.type.value
+                (item) => String(item.id || item.name) === String(elems.type.value)
               )
             : null;
           const model = type
             ? type.models.find(
-                (item) => (item.id || item.name) === elems.model.value
+                (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 || [] : [],
@@ -357,6 +453,100 @@ class AssetMenu {
     `;
   }
 
+  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);
+          });
+      };
+    `;
+  }
+
   getHtmlTemplate() {
     return `
       <!-- Asset Properties -->
@@ -378,6 +568,11 @@ class AssetMenu {
         <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 />
     `;
   }
@@ -419,7 +614,7 @@ class AssetMenu {
 
         node.category = resolveCategoryKey();
 
-        const fields = ['supplier', 'assetType', 'model', 'unit'];
+        const fields = ['supplier', 'assetType', 'model', 'unit', 'assetTagNumber'];
         const errors = [];
 
         fields.forEach((field) => {
@@ -440,8 +635,15 @@ class AssetMenu {
           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;
       };
     `;

src/menu/index.js

@@ -2,6 +2,7 @@ const AssetMenu = require('./asset.js');
 const { TagcodeApp, DynamicAssetMenu } = require('./tagcodeApp.js');
 const LoggerMenu = require('./logger.js');
 const PhysicalPositionMenu = require('./physicalPosition.js');
+const AquonSamplesMenu = require('./aquonSamples.js');
 const ConfigManager = require('../configs');
 
 class MenuManager {
@@ -16,6 +17,7 @@ class MenuManager {
         //this.registerMenu('asset', (nodeName) => new DynamicAssetMenu(nodeName, new TagcodeApp()));
         this.registerMenu('logger', () => new LoggerMenu());
         this.registerMenu('position', () => new PhysicalPositionMenu());
+        this.registerMenu('aquon', () => new AquonSamplesMenu());
     }
 
     /**
@@ -34,7 +36,21 @@ class MenuManager {
 
         try {
             const config = this.configManager.getConfig(nodeName);
-            return config?.functionality?.softwareType || 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;

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();

src/pid/PIDController.js

@@ -1,8 +1,16 @@
 'use strict';
 
 /**
- * Discrete PID controller with optional derivative filtering and integral limits.
+ * Production-focused discrete PID controller with modern control features:
- * Sample times are expressed in milliseconds to align with Node.js timestamps.
+ * - 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 = {}) {
@@ -17,7 +25,19 @@ class PIDController {
       integralMin = null,
       integralMax = null,
       derivativeOnMeasurement = true,
-      autoMode = 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;
@@ -29,17 +49,23 @@ class PIDController {
     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();
   }
 
-  /**
-   * Update controller gains at runtime.
-   * Accepts partial objects, e.g. setTunings({ kp: 2.0 }).
-   */
   setTunings({ kp = this.kp, ki = this.ki, kd = this.kd } = {}) {
     [kp, ki, kd].forEach((gain, index) => {
       if (!Number.isFinite(gain)) {
@@ -54,9 +80,6 @@ class PIDController {
     return this;
   }
 
-  /**
-   * Set the controller execution interval in milliseconds.
-   */
   setSampleTime(sampleTimeMs = this.sampleTime) {
     if (!Number.isFinite(sampleTimeMs) || sampleTimeMs <= 0) {
       throw new RangeError('sampleTime must be a positive number of milliseconds');
@@ -66,9 +89,6 @@ class PIDController {
     return this;
   }
 
-  /**
-   * Constrain controller output.
-   */
   setOutputLimits(min = this.outputMin, max = this.outputMax) {
     if (!Number.isFinite(min) && min !== Number.NEGATIVE_INFINITY) {
       throw new TypeError('outputMin must be finite or -Infinity');
@@ -86,9 +106,6 @@ class PIDController {
     return this;
   }
 
-  /**
-   * Constrain the accumulated integral term.
-   */
   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');
@@ -106,10 +123,6 @@ class PIDController {
     return this;
   }
 
-  /**
-   * Configure exponential filter applied to the derivative term.
-   * Value 0 disables filtering, 1 keeps the previous derivative entirely.
-   */
   setDerivativeFilter(value = this.derivativeFilter ?? 0) {
     if (!Number.isFinite(value) || value < 0 || value > 1) {
       throw new RangeError('derivativeFilter must be between 0 and 1');
@@ -119,94 +132,294 @@ class PIDController {
     return this;
   }
 
-  /**
+  setSetpointWeights({ beta = this.setpointWeight ?? 1, gamma = this.derivativeWeight ?? 0 } = {}) {
-   * Switch between automatic (closed-loop) and manual mode.
+    if (!Number.isFinite(beta) || !Number.isFinite(gamma)) {
-   */
+      throw new TypeError('setpoint and derivative weights must be finite numbers');
-  setMode(mode) {
-    if (mode !== 'automatic' && mode !== 'manual') {
-      throw new Error('mode must be either "automatic" or "manual"');
     }
 
-    this.autoMode = mode === 'automatic';
+    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;
   }
 
   /**
-   * Force a manual output (typically when in manual mode).
+   * 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 dynamic state (integral, derivative memory, timestamps).
-   */
   reset(state = {}) {
     const {
       integral = 0,
       lastOutput = 0,
-      timestamp = null
+      timestamp = null,
+      prevMeasurement = null,
+      prevError = null,
+      prevDerivativeInput = null,
+      derivativeState = 0,
     } = state;
 
     this.integral = this._applyIntegralLimits(Number.isFinite(integral) ? integral : 0);
-    this.prevError = null;
+    this.prevError = Number.isFinite(prevError) ? prevError : null;
-    this.prevMeasurement = 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 = 0;
+    this.derivativeState = Number.isFinite(derivativeState) ? derivativeState : 0;
 
     return this;
   }
 
-  /**
+  update(setpoint, measurement, timestamp = Date.now(), options = {}) {
-   * Execute one control loop iteration.
+    if (timestamp && typeof timestamp === 'object' && options && Object.keys(options).length === 0) {
-   */
+      options = timestamp;
-  update(setpoint, measurement, timestamp = Date.now()) {
+      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) {
-      this.prevError = setpoint - measurement;
+      if (this.trackOnManual) {
-      this.prevMeasurement = measurement;
+        this._trackProcessState(setpoint, measurement, error, timestamp);
-      this.lastTimestamp = timestamp;
+      }
       return this.lastOutput;
     }
 
-    if (this.lastTimestamp !== null && (timestamp - this.lastTimestamp) < this.sampleTime) {
+    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 error = setpoint - measurement;
+    const inDeadband = Math.abs(error) <= this.deadband;
-    this.integral = this._applyIntegralLimits(this.integral + error * dtSeconds);
+    if (inDeadband) {
-
-    const derivative = this._computeDerivative({ error, measurement, dtSeconds });
-    this.derivativeState = this.derivativeFilter === 0
-      ? derivative
-      : this.derivativeState + (derivative - this.derivativeState) * (1 - this.derivativeFilter);
-
-    const output = (this.kp * error) + (this.ki * this.integral) + (this.kd * this.derivativeState);
-    this.lastOutput = this._clamp(output, this.outputMin, this.outputMax);
-
       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;
   }
 
-  /**
-   * Inspect controller state for diagnostics or persistence.
-   */
   getState() {
     return {
       kp: this.kp,
@@ -217,10 +430,18 @@ class PIDController {
       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
+      lastTimestamp: this.lastTimestamp,
     };
   }
 
@@ -228,22 +449,110 @@ class PIDController {
     return this.lastOutput;
   }
 
-  _computeDerivative({ error, measurement, dtSeconds }) {
+  _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 && this.prevMeasurement !== null) {
+    if (this.derivativeOnMeasurement) {
+      if (this.prevMeasurement === null) return 0;
       return -(measurement - this.prevMeasurement) / dtSeconds;
     }
 
-    if (this.prevError === null) {
+    const derivativeInput = (this.derivativeWeight * setpoint) - measurement;
-      return 0;
+    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;
@@ -266,14 +575,89 @@ class PIDController {
   }
 
   _clamp(value, min, max) {
-    if (value < min) {
+    if (value < min) return min;
-      return min;
+    if (value > max) return max;
-    }
-    if (value > max) {
-      return max;
-    }
     return value;
   }
 }
 
-module.exports = PIDController;
+/**
+ * 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/index.js

@@ -1,11 +1,14 @@
-const PIDController = require('./PIDController');
+const { PIDController, CascadePIDController } = require('./PIDController');
 
 /**
- * Convenience factory for one-line instantiation.
+ * Convenience factories.
  */
 const createPidController = (options) => new PIDController(options);
+const createCascadePidController = (options) => new CascadePIDController(options);
 
 module.exports = {
   PIDController,
-  createPidController
+  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() {

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/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/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, []);
+});