@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scripts/run-tests.js

@@ -0,0 +1,2178 @@
+"use strict";
+
+const assert = require("assert/strict");
+const fs = require("fs");
+const net = require("net");
+const EventEmitter = require("events");
+
+const {
+    atLeast,
+    clampNumber,
+    roundedAtLeast,
+    toFiniteNumber
+} = require("../lib/numbers");
+const {
+    buildSummary
+} = require("../fronius-read/lib/sunspec-model-parsers");
+const {
+    encodeMetric,
+    encodeMetricDetailed
+} = require("../scada-server/lib/encoding");
+const {
+    buildRegisterImage,
+    validateMetricConfigs
+} = require("../scada-server/lib/register-map");
+const {
+    buildAggregatorMetrics
+} = require("../scada-server/lib/aggregator-map");
+const {
+    normalizeMessage: normalizeScadaAggregateMessage,
+    summarize: summarizeScadaValues
+} = require("../scada-aggregator/lib/aggregate");
+const {
+    createModbusServer
+} = require("../scada-server/lib/modbus-server");
+const {
+    decodePayload,
+    detectPortalId,
+    mergeDecodedMessage,
+    pruneStale
+} = require("../victron-read/lib/mqtt-state");
+const {
+    evaluateRuntimeBatteries
+} = require("../bess-control/lib/runtime");
+const {
+    distributionIsValid,
+    normalizeBatteries
+} = require("../bess-control/lib/batteries");
+const {
+    ENERGY_COUNT,
+    INSTANTANEOUS_COUNT,
+    decodeFloat32,
+    parseEemMa370
+} = require("../phoenix-contact/lib/eem-ma370");
+const {
+    aggregate: aggregatePhoenixFields,
+    buildInfluxFields: buildPhoenixInfluxFields,
+    selectFields: selectPhoenixFields
+} = require("../phoenix-contact/lib/integrations");
+const {
+    parseAdvancedBlocks,
+    requiredBlocks: requiredPhoenixBlocks
+} = require("../phoenix-contact/lib/eem-ma370-advanced");
+const {
+    readHolding: readSmaSunSpecHolding,
+    scanModelDescriptors: scanSmaModelDescriptors
+} = require("../sma-read/lib/sunspec-core");
+
+const tests = [];
+let activeRuntimeNodes = [];
+
+function test(name, fn) {
+    tests.push({ name, fn });
+}
+
+function createRuntimeNode(modulePath, typeName, config) {
+    let RegisteredNode = null;
+    const runtimeConfig = Object.assign({}, config || {});
+    const initialLocalContext = runtimeConfig.__localContext || {};
+    const initialGlobalContext = runtimeConfig.__globalContext || {};
+    const runtimeNodes = Object.assign({}, runtimeConfig.__runtimeNodes || {});
+    delete runtimeConfig.__localContext;
+    delete runtimeConfig.__globalContext;
+    delete runtimeConfig.__runtimeNodes;
+    if (!runtimeConfig.license) runtimeConfig.license = "__test_license";
+    runtimeNodes.__test_license = runtimeNodes.__test_license || {
+        getState: function () { return "ACTIVE"; },
+        isLicensed: function () { return true; },
+        hasFeature: function () { return true; },
+        on: function () {},
+        removeListener: function () {}
+    };
+
+    const localStore = new Map();
+    Object.keys(initialLocalContext).forEach(function (key) {
+        localStore.set(key, initialLocalContext[key]);
+    });
+
+    const globalStore = new Map();
+    Object.keys(initialGlobalContext).forEach(function (key) {
+        globalStore.set(key, initialGlobalContext[key]);
+    });
+    const RED = {
+        util: {
+            cloneMessage: function (msg) {
+                return JSON.parse(JSON.stringify(msg));
+            }
+        },
+        nodes: {
+            createNode: function (node) {
+                EventEmitter.call(node);
+                Object.setPrototypeOf(node, EventEmitter.prototype);
+                node.id = node.id || typeName + "-test";
+                node.status = function (status) { node.lastStatus = status; };
+                node.warn = function () {};
+                node.debug = function () {};
+                node.error = function (error) { throw error; };
+                node.sentHistory = [];
+                node.send = function (outputs) {
+                    node.sent = outputs;
+                    node.sentHistory.push(outputs);
+                };
+                node.context = function () {
+                    return {
+                        get: function (key) { return localStore.get(key); },
+                        set: function (key, value) { localStore.set(key, value); },
+                        global: {
+                            get: function (key) { return globalStore.get(key); },
+                            set: function (key, value) { globalStore.set(key, value); }
+                        }
+                    };
+                };
+            },
+            registerType: function (name, constructor) {
+                if (name === typeName) RegisteredNode = constructor;
+            },
+            getNode: function (id) {
+                return runtimeNodes[id] || null;
+            }
+        }
+    };
+
+    require(modulePath)(RED);
+    const node = new RegisteredNode(runtimeConfig);
+    activeRuntimeNodes.push(node);
+    return node;
+}
+
+async function closeRuntimeNodes() {
+    const nodes = activeRuntimeNodes.splice(0);
+
+    for (const node of nodes.reverse()) {
+        if (!node || typeof node.listeners !== "function") {
+            continue;
+        }
+
+        const listeners = node.listeners("close");
+        if (!listeners.length) {
+            continue;
+        }
+
+        node.removeAllListeners("close");
+
+        for (const listener of listeners) {
+            await new Promise(function (resolve) {
+                let settled = false;
+                function done() {
+                    if (!settled) {
+                        settled = true;
+                        resolve();
+                    }
+                }
+
+                try {
+                    if (listener.length >= 2) {
+                        listener.call(node, false, done);
+                    } else {
+                        listener.call(node, done);
+                    }
+                } catch (error) {
+                    done();
+                }
+            });
+        }
+    }
+}
+
+test("toFiniteNumber returns fallback for invalid input", function () {
+    assert.equal(toFiniteNumber("bad", 12), 12);
+    assert.equal(toFiniteNumber(undefined, 7), 7);
+    assert.equal(toFiniteNumber("15.5", 0), 15.5);
+});
+
+test("atLeast and clampNumber keep values finite and bounded", function () {
+    assert.equal(atLeast("bad", 50, 10), 50);
+    assert.equal(atLeast("25", 50, 10), 50);
+    assert.equal(clampNumber("bad", 0, 1, 0.4), 0.4);
+    assert.equal(clampNumber("2", 0, 1, 0.4), 1);
+});
+
+test("roundedAtLeast rounds finite values after fallback", function () {
+    assert.equal(roundedAtLeast("2.4", 0, 10), 2);
+    assert.equal(roundedAtLeast("bad", 5, 2), 5);
+});
+
+test("multi-grid prepares aggregated totals for InfluxDB", function () {
+    const received = [];
+    const node = createRuntimeNode("../multi-grid/multi-grid.js", "multi-grid", {
+        operation: "sum",
+        meterIdSource: "topic",
+        expectedMeterCount: 2,
+        emitPartial: false,
+        strictCategoryCheck: true,
+        influxDb: true,
+        influxMeasurement: "grid_totals",
+        influxNode: "influx-target",
+        __runtimeNodes: {
+            "influx-target": {
+                receive: function (msg) { received.push(msg); }
+            }
+        }
+    });
+    let output;
+    function input(topic, payload) {
+        node.emit("input", { topic: topic, payload: payload }, function (msg) {
+            output = msg;
+        }, function (error) {
+            if (error) throw error;
+        });
+    }
+
+    node.emit("input", {
+        topic: "meter-1", ip: "192.168.1.10", unit_id: 1, device_type: "carlo_gavazzi",
+        payload: { power_total_w: 1000, current_total_a: 10 }
+    }, function (msg) { output = msg; }, function (error) { if (error) throw error; });
+    assert.equal(output, undefined);
+    node.emit("input", {
+        topic: "meter-2", host: "192.168.1.11", unit_id: 2, device_type: "janitza", model: "umg96",
+        payload: { power_total_w: 2500, current_total_a: 15 }
+    }, function (msg) { output = msg; }, function (error) { if (error) throw error; });
+
+    assert.deepEqual(output.payload, { power_total_w: 3500, current_total_a: 25 });
+    assert.equal(output.influx, undefined);
+    assert.equal(output.influx_meter_ids, undefined);
+    assert.equal(received[0].influx.measurement, "grid_totals");
+    assert.deepEqual(received[0].influx.fields, { power_total_w: 3500, current_total_a: 25 });
+    assert.deepEqual(received[0].influx.tags, {
+        source: "multi-grid", operation: "sum", meter_count: "2",
+        meter_ids: "meter-1,meter-2", meter_ips: "192.168.1.10,192.168.1.11",
+        unit_ids: "1,2", device_types: "carlo_gavazzi,janitza", meter_models: "umg96"
+    });
+    assert.deepEqual(received[0].influx_meter_ids, ["meter-1", "meter-2"]);
+    assert.equal(received[0].influx_meters[1].ip, "192.168.1.11");
+    assert.equal(Number.isNaN(Date.parse(received[0].influx.timestamp)), false);
+    assert.equal(received.length, 1);
+    assert.notEqual(received[0], output);
+});
+
+test("fronius-write does not expose fast write in the editor", function () {
+    const html = fs.readFileSync(require.resolve("../fronius-write/fronius-write.html"), "utf8");
+    assert.equal(html.includes("fastWriteEnabled"), false);
+    assert.equal(html.includes("node-input-fastWriteEnabled"), false);
+    assert.equal(html.includes("Fast write"), false);
+    assert.equal(html.includes("fast_path"), false);
+    assert.ok(html.includes("node-input-rampUpValue"));
+    assert.ok(html.includes("node-input-rampDownValue"));
+    assert.ok(html.includes("node-input-disableReadbackVerification"));
+    assert.ok(html.includes("Disable read-back verification"));
+    assert.ok(html.includes("clampConfiguredPower"));
+    assert.ok(html.includes("this.nominalPower = this.maxPower"));
+    assert.equal(html.includes('id="row-ramp-time"'), false);
+    assert.equal(html.includes('id="row-ramp-gradient-pct"'), false);
+    assert.equal(html.includes('id="row-ramp-gradient-watts"'), false);
+    assert.equal(html.includes('id="row-ramp-gradient-vars"'), false);
+});
+
+test("IP-driven editor names follow every address change and preserve manual names otherwise", function () {
+    const cases = [
+        ["fronius-read", "fronius-read/fronius-read.html", /#node-input-host[\s\S]{0,240}\.on\("input\.froniusAutoName change\.froniusAutoName"[\s\S]{0,220}autoNameEnabled = true;[\s\S]{0,160}#node-input-name/],
+        ["fronius-write", "fronius-write/fronius-write.html", /#node-input-host[\s\S]{0,240}\.on\("input\.froniusWriteNameSync change\.froniusWriteNameSync"[\s\S]{0,220}autoNameEnabled = true;[\s\S]{0,160}#node-input-name/],
+        ["sma-read", "sma-read/sma-read.html", /#node-input-host"\)\.on\("input\.smaRead change\.smaRead"[\s\S]{0,120}autoName = true;[\s\S]{0,120}refreshAutoName/],
+        ["sma-write", "sma-write/sma-write.html", /#node-input-host"\)\.on\("input\.smaWrite change\.smaWrite"[\s\S]{0,120}autoNameEnabled = true;[\s\S]{0,120}refreshAutoName/],
+        ["carlo-gavazzi", "carlo-gavazzi/carlo-gavazzi.html", /#node-input-host[\s\S]{0,180}\.on\("input\.carloHostSync change\.carloHostSync"[\s\S]{0,300}#node-input-name"\)\.val\(newHost\)/],
+        ["janitza", "janitza/janitza.html", /#node-input-host"\)\.on\("input\.janitzaHostSync change\.janitzaHostSync"[\s\S]{0,220}#node-input-name"\)\.val\(newHost\)/],
+        ["phoenix-contact", "phoenix-contact/phoenix-contact.html", /#node-input-host"\)\.off\("\.phoenixNameSync"\)\.on\("input\.phoenixNameSync change\.phoenixNameSync"[\s\S]{0,180}#node-input-name/],
+        ["advantech-read", "advantech-read/advantech-read.html", /#node-input-host[\s\S]{0,120}\.off\("\.advantechReadName"\)[\s\S]{0,180}#node-input-name/],
+        ["advantech-write", "advantech-write/advantech-write.html", /#node-input-host[\s\S]{0,120}\.off\("\.advantechWriteName"\)[\s\S]{0,180}#node-input-name/],
+        ["pylontech-read", "pylontech-read/pylontech-read.html", /#node-input-host"\)\.off\("\.pylontechReadName"\)\.on\("input\.pylontechReadName change\.pylontechReadName"[\s\S]{0,180}#node-input-name/],
+        ["pylontech-write", "pylontech-write/pylontech-write.html", /#node-input-host"\)\.off\("\.pylontechWriteName"\)\.on\("input\.pylontechWriteName change\.pylontechWriteName"[\s\S]{0,180}#node-input-name/],
+        ["scada-server", "scada-server/scada-server.html", /#node-input-name"\)\.val\("SCADA Server"\)\.prop\("readonly", true\)/],
+        ["fronius-emulator", "fronius-emulator/fronius-emulator.html", /#node-input-name"\)\.val\("Fronius Emulator"\)\.prop\("readonly", true\)/]
+    ];
+
+    cases.forEach(function ([nodeName, relativePath, pattern]) {
+        const html = fs.readFileSync(require.resolve("../" + relativePath), "utf8");
+        assert.match(html, pattern, nodeName + " must replace Name when its IP input changes");
+    });
+
+    const advantechWrite = fs.readFileSync(require.resolve("../advantech-write/advantech-write.html"), "utf8");
+    assert.equal((advantechWrite.match(/advantechWriteSetAutoName\(\);/g) || []).length, 0, "opening advantech-write must not overwrite a manual name");
+});
+
+test("multi-inverter exposes directional ramp fields and no fast path output", function () {
+    const html = fs.readFileSync(require.resolve("../multi-inverter/multi-inverter.html"), "utf8");
+    const runtime = fs.readFileSync(require.resolve("../multi-inverter/multi-inverter.js"), "utf8");
+    const froniusRuntime = fs.readFileSync(require.resolve("../fronius-write/fronius-write.js"), "utf8");
+
+    assert.ok(html.includes("node-input-rampUpValue"));
+    assert.ok(html.includes("node-input-rampDownValue"));
+    assert.ok(html.includes("node-input-rampUpGlobalVar"));
+    assert.ok(html.includes("node-input-rampDownGlobalVar"));
+    assert.equal(html.includes("Ramp Value Variable"), false);
+    assert.equal(html.includes('id="node-row-rampValue"'), false);
+    assert.ok(froniusRuntime.includes("rampUpValue"));
+    assert.ok(froniusRuntime.includes("rampDownValue"));
+    assert.ok(froniusRuntime.includes("ramp_direction"));
+    assert.equal(runtime.includes("fast_path"), false);
+    assert.ok(runtime.includes("multi_inverter"));
+    assert.ok(runtime.includes("target.receive"));
+    assert.ok(html.includes("node-input-influxNode"));
+});
+
+test("fronius-read supports secondary InfluxDB without changing its primary output", function () {
+    const runtime = fs.readFileSync(require.resolve("../fronius-read/fronius-read.js"), "utf8");
+    const html = fs.readFileSync(require.resolve("../fronius-read/fronius-read.html"), "utf8");
+    assert.ok(runtime.includes("compactOutputMode"));
+    assert.ok(runtime.includes("target.receive(RED.util.cloneMessage(influxMessage))"));
+    assert.ok(html.includes("node-input-influxNode"));
+    assert.ok(html.includes("compactIntegrationActive"));
+});
+
+test("meter nodes expose source identifiers and Fronius write exposes diagnostics", function () {
+    const carlo = fs.readFileSync(require.resolve("../carlo-gavazzi/carlo-gavazzi.js"), "utf8");
+    const phoenix = fs.readFileSync(require.resolve("../phoenix-contact/phoenix-contact.js"), "utf8");
+    const froniusWrite = fs.readFileSync(require.resolve("../fronius-write/fronius-write.js"), "utf8");
+    assert.match(carlo, /source_id:\s*meterId/);
+    assert.match(carlo, /timestamp_ms/);
+    assert.match(phoenix, /source_id:\s*node\.meterId/);
+    assert.match(phoenix, /node\.logReadRetries/);
+    assert.ok(phoenix.includes("Phoenix Contact read retry"));
+    assert.match(froniusWrite, /setpoint_addr/);
+    assert.match(froniusWrite, /selected_enable_readback/);
+    assert.ok(froniusWrite.includes("modbus exception 4"));
+    assert.ok(froniusWrite.includes("slave device failure"));
+    assert.ok(froniusWrite.includes("writeSingleLabeled"));
+    assert.ok(froniusWrite.includes("write failed at register"));
+    assert.ok(froniusWrite.includes("disableReadbackVerification"));
+    assert.ok(froniusWrite.includes("readback_verification_disabled"));
+    assert.equal(froniusWrite.includes("post_write_verify_delay_ms"), false);
+});
+
+test("read nodes support poll off trigger input mode", function () {
+    const nodes = [
+        { name: "fronius-read", runtime: "../fronius-read/fronius-read.js", editor: "../fronius-read/fronius-read.html", field: "pollInterval", placeholder: "5000 sau off" },
+        { name: "carlo-gavazzi", runtime: "../carlo-gavazzi/carlo-gavazzi.js", editor: "../carlo-gavazzi/carlo-gavazzi.html", field: "timestep", placeholder: "1000 sau off" },
+        { name: "phoenix-contact", runtime: "../phoenix-contact/phoenix-contact.js", editor: "../phoenix-contact/phoenix-contact.html", field: "timestep", placeholder: "1000 sau off" },
+        { name: "pylontech-read", runtime: "../pylontech-read/pylontech-read.js", editor: "../pylontech-read/pylontech-read.html", field: "pollInterval", placeholder: "5000 sau off" },
+        { name: "janitza", runtime: "../janitza/janitza.js", editor: "../janitza/janitza.html", field: "timestep", placeholder: "1000 sau off" },
+        { name: "victron-read", runtime: "../victron-read/victron-read.js", editor: "../victron-read/victron-read.html", field: "pollInterval", placeholder: "5000 sau off" }
+    ];
+
+    nodes.forEach(function (item) {
+        const runtime = fs.readFileSync(require.resolve(item.runtime), "utf8");
+        const editor = fs.readFileSync(require.resolve(item.editor), "utf8");
+        const selector = "#node-input-" + item.field;
+
+        assert.ok(runtime.includes('node.on("input"'), item.name + " runtime handles input triggers");
+        assert.ok(runtime.includes('"off"') || runtime.includes("'off'"), item.name + " runtime accepts off");
+        assert.ok(runtime.includes("> 0"), item.name + " runtime starts polling only for positive intervals");
+        assert.ok(editor.includes(selector), item.name + " editor exposes poll field");
+        assert.ok(editor.includes(item.placeholder), item.name + " editor hints off mode");
+        assert.ok(editor.includes("this.inputs") || editor.includes("node.inputs"), item.name + " editor updates input count");
+        assert.ok(editor.includes('"0" ? 1 : 0'), item.name + " editor maps 0/off to one input");
+        if (item.name === "phoenix-contact") {
+            assert.ok(editor.includes("node-input-logReadRetries"));
+            assert.ok(editor.includes("Log read retries"));
+            assert.ok(editor.includes("logReadRetries: { value: false }"));
+        }
+    });
+});
+
+test("advantech nodes expose ADAM-6000 Modbus mappings", function () {
+    const pkg = JSON.parse(fs.readFileSync(require.resolve("../package.json"), "utf8").replace(/^\uFEFF/, ""));
+    const readRuntime = fs.readFileSync(require.resolve("../advantech-read/advantech-read.js"), "utf8");
+    const readHtml = fs.readFileSync(require.resolve("../advantech-read/advantech-read.html"), "utf8");
+    const writeRuntime = fs.readFileSync(require.resolve("../advantech-write/advantech-write.js"), "utf8");
+    const writeHtml = fs.readFileSync(require.resolve("../advantech-write/advantech-write.html"), "utf8");
+    const profiles = require("../lib/adam-6000-profiles");
+
+    assert.equal(pkg["node-red"].nodes["advantech-read"], "advantech-read/advantech-read.js");
+    assert.equal(pkg["node-red"].nodes["advantech-write"], "advantech-write/advantech-write.js");
+    assert.ok(readRuntime.includes('RED.nodes.registerType("advantech-read"'));
+    assert.ok(writeRuntime.includes('RED.nodes.registerType("advantech-write"'));
+    assert.ok(readHtml.includes("40001"));
+    assert.ok(readHtml.includes("40011"));
+    assert.ok(readHtml.includes("Module Profile"));
+    assert.ok(!readHtml.includes("node-input-autoDetect"));
+    assert.ok(!readHtml.includes('option value="auto"'));
+    assert.ok(readHtml.includes("Separate DI outputs"));
+    assert.ok(readHtml.includes("Separate DO outputs"));
+    assert.ok(readHtml.includes("Separate AI outputs"));
+    assert.ok(readHtml.includes("Separate AO outputs"));
+    assert.ok(readHtml.includes("ADAM_CHANNEL_COUNTS"));
+    assert.ok(readHtml.includes("validPollValue"));
+    assert.ok(readHtml.includes("isPollOff"));
+    assert.ok(readHtml.includes("this.inputs = isPollOff"));
+    assert.ok(readHtml.includes("5000 sau off"));
+    assert.ok(readHtml.includes("Debug output"));
+    assert.ok(readHtml.includes("node-input-debugOutput"));
+    assert.ok(readHtml.includes('"di1": true'));
+    assert.ok(readHtml.includes("prima pentru DI si a doua pentru DO"));
+    assert.ok(readHtml.includes("row-read-ai"));
+    assert.ok(readHtml.includes("Payload agregat"));
+    assert.ok(readRuntime.includes("buildDigitalMessages"));
+    assert.ok(readRuntime.includes("buildOutputMessages"));
+    assert.ok(readRuntime.includes("buildFamilyPayload"));
+    assert.ok(readRuntime.includes("buildFamilyAggregateMessage"));
+    assert.ok(readRuntime.includes("cloneAggregatePayload"));
+    assert.ok(readRuntime.includes("debugOutput"));
+    assert.ok(readRuntime.includes("toPollInterval"));
+    assert.ok(readRuntime.includes('trim().toLowerCase() === "off"'));
+    assert.ok(readRuntime.includes("node.outputCount > 1"));
+    assert.ok(readRuntime.includes("saveDiGlobals"));
+    assert.ok(readRuntime.includes("saveDoGlobals"));
+    assert.ok(readRuntime.includes("saveAiGlobals"));
+    assert.ok(readRuntime.includes("saveAoGlobals"));
+    assert.ok(readRuntime.includes("saveChannelGlobals"));
+    assert.ok(readHtml.includes('this.diOutputMode = diSplit ? "split" : "aggregate"'));
+    assert.ok(readHtml.includes("this.doOutputMode = doSplit"));
+    assert.ok(readHtml.includes("selectedSplitOutputCount"));
+    assert.ok(readHtml.includes('family.mode === "split"'));
+    assert.ok(readHtml.includes("Save DI globals"));
+    assert.ok(readHtml.includes("Save DO globals"));
+    assert.ok(readHtml.includes("Save AI globals"));
+    assert.ok(readHtml.includes("Save AO globals"));
+    assert.ok(readHtml.includes("DI global names"));
+    assert.ok(readHtml.includes("DO global names"));
+    assert.ok(readHtml.includes("AI global names"));
+    assert.ok(readHtml.includes("AO global names"));
+    assert.ok(readHtml.includes("advantech_di1"));
+    assert.ok(readHtml.includes("advantech_do1"));
+    assert.ok(readHtml.includes("advantech_ai1"));
+    assert.ok(readHtml.includes("advantech_ao1"));
+    assert.ok(writeHtml.includes("00017"));
+    assert.ok(writeHtml.includes("40303"));
+    assert.ok(writeHtml.includes("Module Profile"));
+    assert.ok(!writeHtml.includes("node-input-autoDetect"));
+    assert.ok(!writeHtml.includes('option value="auto"'));
+    assert.ok(writeHtml.includes("Multiple DO from one message"));
+    assert.ok(writeHtml.includes("advantechWriteAutoLabel"));
+    assert.ok(writeHtml.includes("ADAM_WRITE_CHANNEL_COUNTS"));
+    assert.ok(writeHtml.includes("syncSelectedDoOptions"));
+    assert.ok(writeHtml.includes("advantechWriteSetAutoName"));
+    assert.ok(writeHtml.includes('select id="node-input-defaultChannel"'));
+    assert.ok(writeHtml.includes("Nume automat"));
+    assert.ok(writeRuntime.includes("writeCoil"));
+    assert.ok(writeRuntime.includes("writeRegister"));
+    assert.equal(profiles.profileForModel("ADAM-6050").diCount, 12);
+    assert.equal(profiles.profileForModel("ADAM-6051").diCount, 12);
+    assert.equal(profiles.profileForModel("ADAM-6051").doCount, 2);
+    assert.equal(profiles.profileForModel("ADAM-6066").diCount, 6);
+    assert.equal(profiles.profileForModel("ADAM-6066").doCount, 6);
+    assert.equal(profiles.profileForModel("ADAM-6022").aiCount, 6);
+    assert.equal(profiles.profileForModel("ADAM-6024").aoCount, 2);
+    assert.ok(readRuntime.includes("profileForModel"));
+    assert.ok(writeRuntime.includes("profileForModel"));
+});
+
+function writeFloatRegisters(registers, offset, value) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeFloatBE(value, 0);
+    registers[offset] = buffer.readUInt16BE(0);
+    registers[offset + 1] = buffer.readUInt16BE(2);
+}
+
+test("phoenix-contact decodes EEM-MA370 Float32 word order", function () {
+    const registers = [0x4145, 0x8548];
+    assert.ok(Math.abs(decodeFloat32(registers, 0, { wordOrder: "msw_first" }) - 12.345) < 0.001);
+    assert.ok(Math.abs(decodeFloat32([registers[1], registers[0]], 0, { wordOrder: "lsw_first" }) - 12.345) < 0.001);
+});
+
+test("phoenix-contact maps EEM-MA370 measurements and energy", function () {
+    const instantaneous = new Array(INSTANTANEOUS_COUNT).fill(0);
+    const energy = new Array(ENERGY_COUNT).fill(0);
+    writeFloatRegisters(instantaneous, 0x8016 - 0x8000, -1250.5);
+    writeFloatRegisters(instantaneous, 0x801E - 0x8000, -400);
+    writeFloatRegisters(instantaneous, 0x8006 - 0x8000, 230.2);
+    writeFloatRegisters(instantaneous, 0x800C - 0x8000, 50);
+    writeFloatRegisters(energy, 0, 123456);
+    writeFloatRegisters(energy, 6, 6543);
+
+    const summary = parseEemMa370(instantaneous, energy);
+    assert.ok(Math.abs(summary.power.total_w + 1250.5) < 0.01);
+    assert.ok(Math.abs(summary.power.l1_w + 400) < 0.01);
+    assert.ok(Math.abs(summary.voltage.l1_n_v - 230.2) < 0.01);
+    assert.equal(summary.frequency_hz, 50);
+    assert.ok(Math.abs(summary.energy.import_kwh - 123.456) < 0.001);
+    assert.ok(Math.abs(summary.energy.export_kwh - 6.543) < 0.001);
+});
+
+test("phoenix-contact applies Carlo-compatible integration presets", function () {
+    assert.deepEqual(selectPhoenixFields("multiGrid", false, ["full"]), [
+        "summary.power.total_w",
+        "summary.power.l1_w",
+        "summary.power.l2_w",
+        "summary.power.l3_w"
+    ]);
+    assert.equal(selectPhoenixFields("controlExportReactive", false, ["full"]).includes("summary.reactive.total_var"), true);
+    assert.deepEqual(selectPhoenixFields("multiGrid", true, ["summary.frequency_hz"]), ["summary.frequency_hz"]);
+});
+
+test("phoenix-contact builds compact and SCADA payload contracts", function () {
+    const envelope = {
+        summary: {
+            power: { total_w: -1200, l1_w: -400 },
+            reactive: { total_var: 350 },
+            voltage: { l3_l1_v: 401 }
+        }
+    };
+    assert.deepEqual(aggregatePhoenixFields(envelope, ["summary.power.total_w", "summary.power.l1_w"], "multiGrid"), {
+        power_w: -1200,
+        power_l1_w: -400
+    });
+    assert.deepEqual(aggregatePhoenixFields(envelope, ["summary.power.total_w", "summary.reactive.total_var", "summary.voltage.l3_l1_v"], "scadaServer"), {
+        active_power_w: -1200,
+        reactive_power_var: 350,
+        voltage_l1_l3_v: 401
+    });
+});
+
+test("phoenix-contact runtime uses the shared compact payload mapping", function () {
+    const runtime = fs.readFileSync(require.resolve("../phoenix-contact/phoenix-contact.js"), "utf8");
+    assert.match(runtime, /const \{ compactKey \} = require\("\.\/lib\/integrations"\)/);
+    assert.match(runtime, /function getCompactPayloadKey\(path\) \{\s*return compactKey\(path\);\s*\}/);
+});
+
+test("phoenix-contact flattens finite fields for InfluxDB", function () {
+    const fields = buildPhoenixInfluxFields({
+        summary: {
+            power: { total_w: 500, invalid: null },
+            frequency_hz: 50
+        }
+    }, ["full"]);
+    assert.deepEqual(fields, { power_w: 500, frequency_hz: 50 });
+});
+
+test("phoenix-contact reads only advanced blocks required by selected fields", function () {
+    const blocks = requiredPhoenixBlocks([
+        "summary.energy.tariff.t1_import_kwh",
+        "summary.thd.current_l1_pct"
+    ]);
+    assert.deepEqual(blocks.map(function (block) { return block.id; }), ["tariffs", "thd"]);
+    assert.deepEqual(requiredPhoenixBlocks(["summary.power.total_w"]), []);
+});
+
+test("phoenix-contact decodes advanced tariff, runtime and THD registers", function () {
+    const tariff = new Array(49).fill(0);
+    const hours = new Array(22).fill(0);
+    const thd = new Array(10).fill(0);
+    writeFloatRegisters(tariff, 1, 123456);
+    hours[0] = 0;
+    hours[1] = 2500;
+    thd[6] = 123;
+    const parsed = parseAdvancedBlocks({ tariffs: tariff, hours: hours, thd: thd });
+    assert.ok(Math.abs(parsed.energy.tariff.t1_import_kwh - 123.456) < 0.001);
+    assert.equal(parsed.runtime.operating_hours, 2500);
+    assert.equal(parsed.thd.current_l1_pct, 12.3);
+});
+
+test("battery runtime marks stale telemetry and write errors", function () {
+    const batteries = normalizeBatteries([{ id: "bat1", socMin: 20 }], 1);
+    const runtime = evaluateRuntimeBatteries(batteries, {
+        bat1: {
+            soc: 50,
+            ts: 1000,
+            writeFeedback: { status: "error", ts: 1900 }
+        }
+    }, {
+        staleTimeoutMs: 500,
+        feedbackTimeoutMs: 500
+    }, 2000);
+
+    assert.equal(runtime[0].telemetryStale, true);
+    assert.equal(runtime[0].writeError, true);
+    assert.equal(runtime[0].excluded, true);
+    assert.deepEqual(runtime[0].excludedReasons, ["stale", "write_error"]);
+});
+
+test("battery distribution validates configured charge and discharge shares", function () {
+    assert.equal(distributionIsValid([
+        { shareChargePct: 50, shareDischargePct: 60 },
+        { shareChargePct: 50, shareDischargePct: 40 }
+    ]), true);
+    assert.equal(distributionIsValid([
+        { shareChargePct: 70, shareDischargePct: 60 },
+        { shareChargePct: 20, shareDischargePct: 40 }
+    ]), false);
+});
+
+test("multi-battery processes telemetry and command through runtime adapter", function () {
+    let RegisteredNode = null;
+    const RED = {
+        nodes: {
+            getNode: function () {
+                return {
+                    getState: function () { return "ACTIVE"; },
+                    isLicensed: function () { return true; },
+                    hasFeature: function () { return true; },
+                    on: function () {},
+                    removeListener: function () {}
+                };
+            },
+            createNode: function (node) {
+                EventEmitter.call(node);
+                Object.setPrototypeOf(node, EventEmitter.prototype);
+                node.status = function () {};
+                node.warn = function () {};
+                node.debug = function () {};
+                node.error = function (error) { throw error; };
+                node.send = function (outputs) {
+                    node.sent = outputs;
+                };
+            },
+            registerType: function (name, constructor) {
+                if (name === "multi-battery") RegisteredNode = constructor;
+            }
+        }
+    };
+
+    require("../multi-battery/multi-battery")(RED);
+    const node = new RegisteredNode({
+        batteryCount: 1,
+        batteries: [{
+            id: "bat1",
+            shareChargePct: 100,
+            shareDischargePct: 100,
+            maxChargeW: 10000,
+            maxDischargeW: 10000,
+            socMin: 20
+        }],
+        staleTimeoutMs: 0,
+        feedbackTimeoutMs: 0
+    });
+
+    node.emit("input", {
+        batteryId: "bat1",
+        payload: { battery_soc: 80 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+    node.emit("input", {
+        payload: { power_w: 5000, external_control: true }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    assert.equal(Array.isArray(node.sent), true);
+    assert.equal(node.sent[0].batteryId, "bat1");
+    assert.equal(node.sent[0].payload.power_w, 5000);
+
+    node.emit("input", {
+        payload: { power_w: 20000, external_control: true }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+    assert.equal(node.sent[0].payload.power_w, 10000);
+});
+
+test("control-export absolute mode requires all three phases", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        zeroFeedInMode: "absolute",
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 1000
+    });
+
+    let doneError = null;
+    node.emit("input", {
+        payload: {
+            power_l1_w: -100,
+            power_l2_w: -50
+        }
+    }, function (outputs) {
+        node.sent = outputs;
+    }, function (error) {
+        doneError = error || null;
+    });
+
+    assert.ok(doneError);
+    assert.match(doneError.message, /faze/);
+});
+
+test("control-export rejects measurements too far in the future", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        staleTimeoutMs: 0,
+        maxFutureTimestampMs: 100,
+        minLimit: 0,
+        maxLimit: 1000
+    });
+
+    let doneError = null;
+    node.emit("input", {
+        timestamp_ms: Date.now() + 10000,
+        payload: { power_w: -100 }
+    }, function (outputs) {
+        node.sent = outputs;
+    }, function (error) {
+        doneError = error || null;
+    });
+
+    assert.ok(doneError);
+    assert.match(doneError.message, /viitor/);
+});
+
+test("control-export status shows latest meter reference, not filtered reference", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        staleTimeoutMs: 0,
+        filterTauMs: 2800,
+        minLimit: 0,
+        maxLimit: 10000
+    });
+
+    const firstTimestamp = Date.now() - 1000;
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp,
+        payload: { power_w: -487.5 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp + 1,
+        payload: { power_w: -3290.5 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    assert.ok(node.lastStatus);
+    assert.match(node.lastStatus.text, /grid -3290W/);
+});
+
+test("control-export limits immediately when negative grid setpoint is exceeded", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -2000,
+        staleTimeoutMs: 0,
+        transientIgnoreMs: 1200,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 10000
+        }
+    });
+
+    node.emit("input", {
+        payload: { power_w: -3000 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.ok(mainMsg.payload.site_limit_w < 10000);
+    assert.notEqual(mainMsg.payload.reason, "transient_ignore");
+});
+
+test("control-export reduces immediately during hold period when export exceeds target", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 0,
+        controlPeriodMs: 60000,
+        filterTauMs: 60000,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 4000
+        }
+    });
+
+    const firstTimestamp = Date.now() - 1000;
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp,
+        payload: { power_w: -8000 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const firstMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(firstMsg.payload.site_limit_w, 4000);
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp + 1,
+        payload: { power_w: -8943 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const secondMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.ok(secondMsg.payload.site_limit_w < 4000);
+    assert.notEqual(secondMsg.payload.reason, "hold_period");
+});
+
+test("control-export rate limits repeated immediate reductions on fast telemetry", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 0,
+        controlPeriodMs: 60000,
+        filterTauMs: 60000,
+        transientIgnoreMs: 1200,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 4000
+        }
+    });
+
+    const firstTimestamp = Date.now() - 1000;
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp,
+        payload: { power_w: -8000 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp + 1,
+        payload: { power_w: -8943 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const firstReductionMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.ok(firstReductionMsg.payload.site_limit_w < 4000);
+    const outputCountAfterReduction = node.sentHistory.length;
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp + 201,
+        payload: { power_w: -9200 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    assert.equal(node.sentHistory.length, outputCountAfterReduction);
+});
+
+test("control-export applies adaptive PI reduction for measured export overshoot", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 0,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 3995
+        }
+    });
+
+    node.emit("input", {
+        payload: { power_w: -8943 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.ok(mainMsg.payload.site_limit_w < 3995);
+    assert.ok(mainMsg.payload.site_limit_w > 3052);
+    assert.equal(mainMsg.payload.reason, "export_limit");
+    assert.equal(mainMsg.payload.controller_state, "decreasing_limit");
+});
+
+test("control-export recovers upward only within measured grid margin", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 0,
+        transientIgnoreMs: 0,
+        recoveryDelayMs: 0,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 3000
+        }
+    });
+
+    node.emit("input", {
+        payload: { power_w: -7000 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.ok(mainMsg.payload.site_limit_w > 3000);
+    assert.ok(mainMsg.payload.site_limit_w <= 4000);
+    assert.equal(mainMsg.payload.reason, "recovery");
+    assert.equal(mainMsg.payload.controller_state, "increasing_limit");
+});
+
+test("control-export stable grid preset applies precision runtime values", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        tuningPreset: "stable_grid",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 10000,
+        debugLevel: "verbose",
+        __localContext: {
+            control_export_last_limit_w: 5000
+        }
+    });
+
+    node.emit("input", {
+        payload: { power_w: -8200 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(mainMsg.payload.control_period_ms, 1000);
+    assert.equal(mainMsg.payload.filter_tau_ms, 1500);
+    assert.equal(mainMsg.payload.max_step_up_w, 1000);
+    assert.equal(mainMsg.payload.max_step_down_w, 1800);
+    assert.equal(mainMsg.payload.effective_ki > 0, true);
+    assert.equal(mainMsg.payload.adaptive_min_scale, 0.45);
+});
+
+test("control-export PV cap blocks growth without ratcheting an existing limit down", function () {
+    const realNow = Date.now;
+    let nowMs = 1700000000000;
+    Date.now = function () { return nowMs; };
+    try {
+        const node = createRuntimeNode("../control-export/control-export", "control-export", {
+            mode: "grid_set_point",
+            tuningPreset: "custom",
+            gridSetPoint: 5000,
+            signConvention: "positive_import",
+            staleTimeoutMs: 0,
+            filterTauMs: 0,
+            controlPeriodMs: 1000,
+            deadband: 150,
+            exportThresholdW: 100,
+            recoverThresholdW: 40,
+            recoveryDelayMs: 0,
+            transientIgnoreMs: 0,
+            kp: 0.24,
+            ki: 0.008,
+            adaptiveGains: false,
+            maxStepUpW: 1000,
+            maxStepDownW: 1800,
+            minLimit: 0,
+            maxLimit: 200000,
+            useGlobalPvCap: true,
+            globalPvTotalVar: "total_pv",
+            globalPvCapOffsetW: 5000,
+            pvCapOnlyBlocksIncrease: true,
+            pvCapHoldMs: 0,
+            pvCapReleaseWPerSec: 100000,
+            feedForwardEnabled: true,
+            feedForwardGain: 0.85,
+            debugLevel: "verbose",
+            __localContext: { control_export_last_limit_w: 90000 },
+            __globalContext: { total_pv: 85000 }
+        });
+
+        node.emit("input", { timestamp_ms: nowMs, payload: { power_w: 40000 } }, node.send.bind(node), function (error) { if (error) throw error; });
+        let msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+        assert.equal(msg.payload.site_limit_w, 90000);
+        assert.equal(msg.payload.pv_cap_blocked_increase, true);
+        assert.equal(msg.payload.controller_requested_limit_w, 91000);
+
+        node.context().global.set("total_pv", 80000);
+        nowMs += 2000;
+        node.emit("input", { timestamp_ms: nowMs, payload: { power_w: 40000 } }, node.send.bind(node), function (error) { if (error) throw error; });
+        msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+        assert.equal(msg.payload.site_limit_w, 90000);
+        assert.equal(msg.payload.pv_cap_limit_w, 85000);
+        assert.equal(msg.payload.pv_cap_blocked_increase, true);
+        assert.ok(msg.payload.feed_forward_target_w > 109000);
+    } finally {
+        Date.now = realNow;
+    }
+});
+
+test("control-export output is accepted by multi-inverter", function () {
+    const controlNode = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 0,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 3995
+        }
+    });
+
+    controlNode.emit("input", {
+        payload: { power_w: -8943 }
+    }, controlNode.send.bind(controlNode), function (error) {
+        if (error) throw error;
+    });
+
+    const siteLimitMsg = Array.isArray(controlNode.sent) ? controlNode.sent[0] : controlNode.sent;
+    assert.equal(siteLimitMsg.topic, "site-limit");
+    assert.ok(siteLimitMsg.payload.site_limit_w < 3995);
+    assert.equal(Object.prototype.hasOwnProperty.call(siteLimitMsg.payload, "nominal_power_w"), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(siteLimitMsg.payload, "command_requested_at_ms"), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(siteLimitMsg.payload, "fast_path"), false);
+
+    const inverterNode = createRuntimeNode("../multi-inverter/multi-inverter", "multi-inverter", {
+        strategy: "max_power",
+        siteLimitTopics: "site-limit,control-export",
+        waitForFreshTelemetryOnStartup: false,
+        telemetryTimeoutMs: 0,
+        siteLimitTimeoutMs: 0,
+        publishTotalPvGlobal: false,
+        debugMode: "off",
+        inverters: [
+            { id: "inv1", minW: 0, maxW: 10000, enabled: true }
+        ]
+    });
+
+    inverterNode.emit("input", {
+        topic: "inv1",
+        payload: {
+            inverter_id: "inv1",
+            power_w: 5000
+        }
+    }, inverterNode.send.bind(inverterNode), function (error) {
+        if (error) throw error;
+    });
+
+    inverterNode.emit("input", siteLimitMsg, inverterNode.send.bind(inverterNode), function (error) {
+        if (error) throw error;
+    });
+
+    const outputs = Array.isArray(inverterNode.sent) ? inverterNode.sent : [inverterNode.sent];
+    const aggregateMsg = outputs.filter(function (msg) {
+        return msg && msg.topic === "multi-inverter/limits";
+    })[0];
+    assert.ok(aggregateMsg);
+    assert.equal(aggregateMsg.payload.site_limit_w, Math.round(siteLimitMsg.payload.site_limit_w));
+    assert.equal(aggregateMsg.payload.limits[0].id, "inv1");
+    assert.equal(aggregateMsg.payload.limits[0].limit_w, Math.round(siteLimitMsg.payload.site_limit_w));
+});
+
+test("multi-inverter suppresses allocation chatter below configured deadband", function () {
+    const node = createRuntimeNode("../multi-inverter/multi-inverter", "multi-inverter", {
+        strategy: "max_power",
+        waitForFreshTelemetryOnStartup: false,
+        telemetryTimeoutMs: 0,
+        siteLimitTimeoutMs: 0,
+        allocationDeadbandW: 50,
+        publishTotalPvGlobal: false,
+        debugMode: "off",
+        inverters: [{ id: "inv1", minW: 0, maxW: 10000, enabled: true }]
+    });
+
+    node.emit("input", {
+        topic: "inv1",
+        payload: {
+            inverter_id: "inv1",
+            power_w: 6000
+        }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    node.emit("input", {
+        topic: "site-limit",
+        payload: { site_limit_w: 5000 }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    const firstMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(firstMsg.payload.limits[0].limit_w, 5000);
+
+    node.emit("input", {
+        topic: "site-limit",
+        payload: { site_limit_w: 5025 }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    const secondMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(secondMsg.payload.limits[0].limit_w, 5000);
+    assert.equal(secondMsg.payload.limits[0].allocation_deadband_applied, true);
+});
+
+test("multi-inverter filters current-power weights without changing raw PV telemetry", function () {
+    const node = createRuntimeNode("../multi-inverter/multi-inverter", "multi-inverter", {
+        strategy: "current_power",
+        waitForFreshTelemetryOnStartup: false,
+        telemetryTimeoutMs: 0,
+        siteLimitTimeoutMs: 0,
+        telemetryFilterAlpha: 0.25,
+        telemetryRecalcDebounceMs: 0,
+        allocationSmoothingAlpha: 1,
+        allocationDeadbandW: 0,
+        publishTotalPvGlobal: true,
+        totalPvGlobalVar: "total_pv",
+        debugMode: "off",
+        inverters: [
+            { id: "inv1", minW: 0, maxW: 10000, enabled: true },
+            { id: "inv2", minW: 0, maxW: 10000, enabled: true }
+        ]
+    });
+
+    let telemetryTs = Date.now();
+    function input(id, powerW) {
+        telemetryTs += 1;
+        node.emit("input", { topic: id, source: "fronius", timestamp_ms: telemetryTs, payload: { inverter_id: id, power_w: powerW } }, node.send.bind(node), function (error) { if (error) throw error; });
+    }
+    input("inv1", 8000);
+    input("inv2", 2000);
+    node.emit("input", { topic: "site-limit", payload: { site_limit_w: 10000 } }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    input("inv1", 0);
+    const aggregate = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    const inv1 = aggregate.payload.limits.find(function (item) { return item.id === "inv1"; });
+    assert.equal(inv1.current_power_w, 0);
+    assert.equal(inv1.allocation_power_w, 6000);
+    assert.equal(inv1.limit_w, 7500);
+    assert.equal(node.context().global.get("total_pv"), 2000);
+});
+
+test("fresh grid setpoint bypasses the normal control period and propagates metadata", function () {
+    const controlNode = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -8000,
+        staleTimeoutMs: 2000,
+        fastSetpointMaxTelemetryAgeMs: 600,
+        controlPeriodMs: 60000,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: { control_export_last_limit_w: 5000 }
+    });
+
+    const measurementTs = Date.now();
+    controlNode.emit("input", {
+        timestamp_ms: measurementTs,
+        payload: { power_w: -8500 }
+    }, controlNode.send.bind(controlNode), function (error) { if (error) throw error; });
+
+    const requestedAtMs = Date.now();
+    controlNode.emit("input", {
+        topic: "control-export/setpoint",
+        timestamp_ms: requestedAtMs,
+        payload: {
+            grid_set_point_w: -7000,
+            command_id: "setpoint-command-1"
+        }
+    }, controlNode.send.bind(controlNode), function (error) { if (error) throw error; });
+
+    const siteLimitMsg = Array.isArray(controlNode.sent) ? controlNode.sent[0] : controlNode.sent;
+    assert.equal(Object.prototype.hasOwnProperty.call(siteLimitMsg.payload, "fast_path"), false);
+    assert.equal(siteLimitMsg.payload.command_id, "setpoint-command-1");
+    assert.equal(siteLimitMsg.payload.grid_target_w, -7000);
+    assert.ok(siteLimitMsg.payload.control_calculated_at_ms >= requestedAtMs);
+
+    const inverterNode = createRuntimeNode("../multi-inverter/multi-inverter", "multi-inverter", {
+        strategy: "max_power",
+        waitForFreshTelemetryOnStartup: false,
+        telemetryTimeoutMs: 0,
+        siteLimitTimeoutMs: 0,
+        publishTotalPvGlobal: false,
+        debugMode: "off",
+        inverters: [{ id: "inv1", minW: 0, maxW: 10000, enabled: true }]
+    });
+    inverterNode.emit("input", siteLimitMsg, inverterNode.send.bind(inverterNode), function (error) {
+        if (error) throw error;
+    });
+
+    const aggregateMsg = Array.isArray(inverterNode.sent) ? inverterNode.sent[0] : inverterNode.sent;
+    assert.equal(aggregateMsg.payload.command_id, "setpoint-command-1");
+    assert.equal(Object.prototype.hasOwnProperty.call(aggregateMsg.payload, "fast_path"), false);
+    assert.equal(aggregateMsg.payload.limits[0].command_id, "setpoint-command-1");
+    assert.equal(Object.prototype.hasOwnProperty.call(aggregateMsg.payload.limits[0], "fast_path"), false);
+    assert.ok(aggregateMsg.payload.limits[0].allocated_at_ms >= requestedAtMs);
+});
+
+test("control-export honors positive-export sign convention with normal preset", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        tuningPreset: "normal",
+        signConvention: "positive_export",
+        staleTimeoutMs: 0,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        debugLevel: "verbose",
+        __localContext: { control_export_last_limit_w: 5000 }
+    });
+
+    node.emit("input", { payload: { power_w: 1000 } }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.ok(msg.payload.site_limit_w < 5000);
+    assert.equal(msg.payload.sign_convention, "positive_export");
+});
+
+test("control-export prefers explicit grid reference over generic power_w", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        staleTimeoutMs: 0,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        debugLevel: "verbose",
+        __localContext: { control_export_last_limit_w: 5000 }
+    });
+
+    node.emit("input", {
+        payload: { grid_reference_w: -1000, power_w: 5000 }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(msg.payload.raw_grid_reference_w, -1000);
+    assert.ok(msg.payload.site_limit_w < 5000);
+});
+
+test("control-export uses asymmetric export and import control bands", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        staleTimeoutMs: 0,
+        deadband: 180,
+        exportThresholdW: 60,
+        recoverThresholdW: 25,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        debugLevel: "verbose",
+        __localContext: { control_export_last_limit_w: 5000 }
+    });
+
+    node.emit("input", { payload: { power_w: -100 } }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(msg.payload.export_control_band_w, 60);
+    assert.equal(msg.payload.import_control_band_w, 25);
+    assert.equal(msg.payload.reason, "export_limit");
+});
+
+test("control-export applies PI gains and anti-windup diagnostics", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: 0,
+        staleTimeoutMs: 0,
+        filterTauMs: 0,
+        adaptiveGains: false,
+        kp: 0.3,
+        ki: 0.05,
+        startLimitMode: "last_limit",
+        minLimit: 0,
+        maxLimit: 10000,
+        debugLevel: "verbose",
+        __localContext: { control_export_last_limit_w: 5000 }
+    });
+
+    node.emit("input", { payload: { power_w: -1000 } }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(msg.payload.effective_kp, 0.3);
+    assert.equal(msg.payload.effective_ki, 0.05);
+    assert.ok(msg.payload.p_term_w > 0);
+    assert.ok(msg.payload.i_term_w > 0);
+});
+
+test("control-export suppresses unchanged commands until heartbeat", function () {
+    const realNow = Date.now;
+    let nowMs = 1700000000000;
+    Date.now = function () { return nowMs; };
+    try {
+        const node = createRuntimeNode("../control-export/control-export", "control-export", {
+            mode: "zero_feed_in",
+            staleTimeoutMs: 0,
+            controlPeriodMs: 100,
+            outputHeartbeatMs: 1000,
+            startLimitMode: "last_limit",
+            minLimit: 0,
+            maxLimit: 10000,
+            __localContext: { control_export_last_limit_w: 5000 }
+        });
+
+        function meter() {
+            node.emit("input", { timestamp_ms: nowMs, payload: { power_w: 0 } }, node.send.bind(node), function (error) {
+                if (error) throw error;
+            });
+        }
+
+        meter();
+        assert.equal(node.sentHistory.length, 1);
+        nowMs += 100;
+        meter();
+        assert.equal(node.sentHistory.length, 1);
+        nowMs += 1000;
+        meter();
+        assert.equal(node.sentHistory.length, 2);
+    } finally {
+        Date.now = realNow;
+    }
+});
+
+test("control-export restores a persisted runtime grid setpoint", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -2000,
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 10000,
+        __localContext: {
+            control_export_last_limit_w: 5000,
+            control_export_grid_setpoint_w: -3000,
+            control_export_grid_setpoint_base_w: -2000
+        }
+    });
+
+    node.emit("input", { payload: { power_w: -3000 } }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(msg.payload.grid_target_w, -3000);
+});
+
+test("control-export emits safe output when a required global is invalid", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        maxLimitFromGlobal: true,
+        maxLimitGlobalVar: "missing_max",
+        staleTimeoutMs: 0,
+        safeLimitOnStale: 0,
+        minLimit: 0,
+        maxLimit: 10000
+    });
+
+    node.emit("input", { payload: { power_w: -1000 } }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(msg.payload.reason, "invalid_global");
+    assert.equal(msg.payload.site_limit_w, 0);
+    assert.equal(msg.payload.stale, true);
+});
+
+test("control-export marks an unreachable export target at minimum limit", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 10000,
+        startLimitMode: "last_limit",
+        __localContext: { control_export_last_limit_w: 0 }
+    });
+
+    node.emit("input", { payload: { power_w: -1000 } }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+    const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(msg.payload.controller_state, "target_unreachable_at_min");
+});
+
+test("control-export closed loop converges after actuator lag and load step", function () {
+    const realNow = Date.now;
+    let nowMs = 1700000000000;
+    Date.now = function () { return nowMs; };
+    try {
+        const node = createRuntimeNode("../control-export/control-export", "control-export", {
+            mode: "grid_set_point",
+            gridSetPoint: -500,
+            staleTimeoutMs: 0,
+            filterTauMs: 1000,
+            controlPeriodMs: 500,
+            deadband: 80,
+            exportThresholdW: 40,
+            recoverThresholdW: 40,
+            recoveryDelayMs: 300,
+            transientIgnoreMs: 200,
+            kp: 0.3,
+            ki: 0.05,
+            adaptiveGains: false,
+            maxStepUpW: 400,
+            maxStepDownW: 800,
+            outputHeartbeatMs: 500,
+            startLimitMode: "last_limit",
+            minLimit: 0,
+            maxLimit: 10000,
+            __localContext: { control_export_last_limit_w: 6500 }
+        });
+
+        let commandW = 6500;
+        let actualPvW = 6500;
+        let finalGridW = 0;
+        for (let elapsed = 0; elapsed <= 60000; elapsed += 100) {
+            nowMs = 1700000000000 + elapsed;
+            const loadW = elapsed < 10000 ? 6000 : 4000;
+            actualPvW += (commandW - actualPvW) * 0.1;
+            finalGridW = loadW - actualPvW;
+            node.emit("input", {
+                timestamp_ms: nowMs,
+                payload: { power_w: finalGridW }
+            }, node.send.bind(node), function (error) { if (error) throw error; });
+            const msg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+            commandW = msg.payload.site_limit_w;
+        }
+
+        const finalMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+        assert.ok(
+            Math.abs(finalGridW - (-500)) <= 100,
+            "final grid=" + finalGridW + " command=" + commandW + " reason=" + finalMsg.payload.reason + " state=" + finalMsg.payload.controller_state
+        );
+    } finally {
+        Date.now = realNow;
+    }
+});
+
+test("multi-inverter emits zero limits for duplicate configuration", function () {
+    const node = createRuntimeNode("../multi-inverter/multi-inverter", "multi-inverter", {
+        debugMode: "off",
+        publishTotalPvGlobal: false,
+        inverters: [
+            { id: "inv1", minW: 0, maxW: 10000, enabled: true },
+            { id: "inv1", minW: 0, maxW: 10000, enabled: true }
+        ]
+    });
+    node.emit("input", {
+        topic: "site-limit",
+        payload: { site_limit_w: 5000 }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(mainMsg.topic, "multi-inverter/limits");
+    assert.equal(mainMsg.payload.reason, "invalid_configuration");
+    assert.equal(mainMsg.payload.limits.every(function (limit) { return limit.limit_w === 0; }), true);
+});
+
+test("multi-inverter fails safe on future telemetry timestamp", function () {
+    const node = createRuntimeNode("../multi-inverter/multi-inverter", "multi-inverter", {
+        debugMode: "off",
+        publishTotalPvGlobal: false,
+        maxFutureTimestampMs: 100,
+        inverters: [{ id: "inv1", minW: 0, maxW: 10000, enabled: true }]
+    });
+    node.emit("input", {
+        topic: "inv1",
+        timestamp_ms: Date.now() + 10000,
+        payload: { inverter_id: "inv1", power_w: 5000 }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(mainMsg.payload.reason, "future_telemetry_timestamp");
+    assert.equal(mainMsg.payload.limits[0].limit_w, 0);
+});
+
+test("control-reactive rejects measurements too far in the future", function () {
+    const node = createRuntimeNode("../control-reactive/control-reactive", "control-reactive", {
+        staleTimeoutMs: 5000,
+        maxFutureTimestampMs: 100,
+        nominalReactivePowerVar: 25000
+    });
+    let doneError = null;
+    node.emit("input", {
+        timestamp_ms: Date.now() + 10000,
+        payload: {
+            reactive_l1_var: 100,
+            reactive_l2_var: 100,
+            reactive_l3_var: 100,
+            reactive_total_var: 300
+        }
+    }, node.send.bind(node), function (error) { doneError = error || null; });
+
+    assert.ok(doneError);
+    assert.match(doneError.message, /Timestamp din viitor/);
+});
+
+test("control-reactive treats empty telemetry fields as missing", function () {
+    const node = createRuntimeNode("../control-reactive/control-reactive", "control-reactive", {
+        staleTimeoutMs: 0,
+        nominalReactivePowerVar: 25000
+    });
+    let doneError = null;
+    node.emit("input", {
+        payload: {
+            reactive_l1_var: "",
+            reactive_l2_var: "",
+            reactive_l3_var: "",
+            reactive_total_var: ""
+        }
+    }, node.send.bind(node), function (error) { doneError = error || null; });
+
+    assert.ok(doneError);
+    assert.match(doneError.message, /Lipsesc valori reactive meter/);
+});
+
+test("control-reactive keeps the measurement filter after emitting a command", function () {
+    const node = createRuntimeNode("../control-reactive/control-reactive", "control-reactive", {
+        mode: "grid_set_point",
+        tuningPreset: "custom",
+        gridSetPointVar: 0,
+        staleTimeoutMs: 0,
+        filterTauMs: 1000,
+        minCommandIntervalMs: 10000,
+        commandDeadbandVar: 0,
+        nominalReactivePowerVar: 25000
+    });
+
+    const firstTimestamp = Date.now() - 1000;
+    const firstPayload = {
+        reactive_l1_var: 100,
+        reactive_l2_var: 200,
+        reactive_l3_var: 700,
+        reactive_total_var: 1000
+    };
+    const secondPayload = {
+        reactive_l1_var: 200,
+        reactive_l2_var: 400,
+        reactive_l3_var: 1400,
+        reactive_total_var: 2000
+    };
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp,
+        payload: firstPayload
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    node.emit("input", {
+        timestamp_ms: firstTimestamp + 200,
+        payload: secondPayload
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    assert.ok(node.lastStatus);
+    assert.match(node.lastStatus.text, /q 1167VAr/);
+});
+
+test("control-reactive stable grid preset applies conservative runtime values", function () {
+    const node = createRuntimeNode("../control-reactive/control-reactive", "control-reactive", {
+        mode: "grid_set_point",
+        tuningPreset: "stable_grid",
+        gridSetPointVar: 0,
+        staleTimeoutMs: 0,
+        nominalReactivePowerVar: 25000,
+        debugLevel: "verbose"
+    });
+
+    node.emit("input", {
+        payload: {
+            reactive_l1_var: 100,
+            reactive_l2_var: 200,
+            reactive_l3_var: 300,
+            reactive_total_var: 600
+        }
+    }, node.send.bind(node), function (error) { if (error) throw error; });
+
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(mainMsg.payload.filter_tau_ms, 5000);
+    assert.equal(mainMsg.payload.max_step_up_var, 120);
+    assert.equal(mainMsg.payload.max_step_down_var, 120);
+});
+
+test("control-export ignores inverter power telemetry as grid reference", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -5000,
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 10000
+    });
+
+    node.emit("input", {
+        topic: "meter1",
+        meter_id: "meter1",
+        payload: { power_w: -5853 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const meterStatus = node.lastStatus && node.lastStatus.text;
+    assert.match(meterStatus, /grid -5853W/);
+
+    node.emit("input", {
+        topic: "inv1",
+        inverter_id: "inv1",
+        device_type: "fronius_inverter",
+        payload: { power_w: 998 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    assert.equal(node.lastStatus.text, meterStatus);
+});
+
+test("control-export ignores inverter-like topic power telemetry", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -5000,
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 10000
+    });
+
+    node.emit("input", {
+        topic: "meter1",
+        meter_id: "meter1",
+        payload: { power_w: -5853 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const meterStatus = node.lastStatus && node.lastStatus.text;
+    assert.match(meterStatus, /grid -5853W/);
+
+    node.emit("input", {
+        topic: "inv1",
+        payload: { power_w: 998 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    assert.equal(node.lastStatus.text, meterStatus);
+});
+
+test("control-export ignores site limit command feedback", function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "grid_set_point",
+        gridSetPoint: -5000,
+        outputTopic: "site-limit",
+        staleTimeoutMs: 0,
+        minLimit: 0,
+        maxLimit: 10000
+    });
+
+    node.emit("input", {
+        topic: "meter1",
+        meter_id: "meter1",
+        payload: { power_w: -5853 }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    const meterStatus = node.lastStatus && node.lastStatus.text;
+
+    node.emit("input", {
+        topic: "site-limit",
+        payload: {
+            site_limit_w: 997,
+            grid_reference_w: 998,
+            grid_target_w: -5000,
+            controller_state: "hold_period"
+        }
+    }, node.send.bind(node), function (error) {
+        if (error) throw error;
+    });
+
+    assert.equal(node.lastStatus.text, meterStatus);
+});
+
+test("control-export watchdog emits safe limit even before first telemetry", async function () {
+    const node = createRuntimeNode("../control-export/control-export", "control-export", {
+        mode: "zero_feed_in",
+        staleTimeoutMs: 60,
+        safeLimitOnStale: 0,
+        minLimit: 0,
+        maxLimit: 1000
+    });
+
+    await new Promise(function (resolve) {
+        setTimeout(resolve, 420);
+    });
+
+    assert.ok(node.sent);
+    const mainMsg = Array.isArray(node.sent) ? node.sent[0] : node.sent;
+    assert.equal(mainMsg.payload.reason, "watchdog_stale");
+    assert.equal(mainMsg.payload.site_limit_w, 0);
+
+    await new Promise(function (resolve) {
+        node.emit("close", resolve);
+    });
+});
+
+test("victron-read decodes MQTT values and detects Portal ID", function () {
+    assert.equal(decodePayload(Buffer.from('{"value":12.5}')), 12.5);
+    assert.equal(decodePayload(Buffer.from("null")), null);
+    assert.equal(decodePayload(Buffer.from("true")), true);
+    assert.equal(detectPortalId("N/abc123/system/0/Serial"), "abc123");
+});
+
+test("victron-read normalizes runtime MQTT messages consistently", function () {
+    const snapshot = {};
+    const updatedAt = new Map();
+    const first = mergeDecodedMessage(snapshot, updatedAt, "N/abc123/grid/30/Ac/Power", 500, {
+        topicPathMode: "victron",
+        stripPortalId: true,
+        now: 1000
+    });
+    const second = mergeDecodedMessage(snapshot, updatedAt, "N/abc123/ignored", {
+        "N.abc123.battery.512.Dc.0.Voltage": 52.4,
+        "N.abc123.battery.512.Soc": 81,
+        "N.abc123.system.0.Ac.Grid.L1.Power": 123
+    }, {
+        topicPathMode: "victron",
+        stripPortalId: true,
+        now: 1100
+    });
+
+    assert.equal(first.portalId, "abc123");
+    assert.equal(first.changed, true);
+    assert.equal(second.changed, true);
+    assert.equal(snapshot.grid["30"].Ac.Power, 500);
+    assert.equal(snapshot["battery.512.Dc.0.Voltage"], 52.4);
+    assert.equal(snapshot["battery.512.Soc"], 81);
+});
+
+test("victron-read expires stale MQTT values", function () {
+    const snapshot = {};
+    const updatedAt = new Map();
+    mergeDecodedMessage(snapshot, updatedAt, "N/portal/grid/30/Ac/Power", 400, {
+        topicPathMode: "victron",
+        stripPortalId: true,
+        now: 1000
+    });
+    mergeDecodedMessage(snapshot, updatedAt, "N/portal/battery/512/Soc", 75, {
+        topicPathMode: "victron",
+        stripPortalId: true,
+        now: 1900
+    });
+
+    const removed = pruneStale(snapshot, updatedAt, 500, 2100);
+    assert.deepEqual(removed, ["grid.30.Ac.Power"]);
+    assert.equal(snapshot.grid, undefined);
+    assert.equal(snapshot.battery["512"].Soc, 75);
+});
+
+test("fronius-read parses SunSpec integer smart meter model", function () {
+    const raw = new Array(105).fill(0);
+    raw[4] = 0xFFFF; // A_SF = -1
+    raw[13] = 0; // V_SF
+    raw[15] = 0xFFFE; // Hz_SF = -2
+    raw[20] = 0; // W_SF
+    raw[25] = 0; // VA_SF
+    raw[30] = 0; // VAR_SF
+    raw[35] = 0xFFFE; // PF_SF = -2
+    raw[52] = 0; // WH_SF
+    raw[0] = 123;
+    raw[6] = 230;
+    raw[14] = 5001;
+    raw[16] = 1500;
+    raw[31] = 99;
+    raw[44] = 0;
+    raw[45] = 1000;
+
+    const summary = buildSummary([{ model_id: 203, addr: 40070, len: 105, raw }]);
+
+    assert.equal(summary.meter.model_id, 203);
+    assert.equal(summary.meter.meter_model, "three_phase_wye");
+    assert.equal(summary.meter.current_total_a, 12.3);
+    assert.equal(summary.meter.voltage_l1_v, 230);
+    assert.equal(summary.meter.frequency_hz, 50.01);
+    assert.equal(summary.meter.power_w, 1500);
+    assert.equal(summary.meter.power_factor, 0.99);
+    assert.equal(summary.meter.energy_import_wh, 1000);
+});
+
+test("fronius-read parses SunSpec float smart meter model", function () {
+    function putFloat(raw, index, value) {
+        const buffer = Buffer.allocUnsafe(4);
+        buffer.writeFloatBE(value, 0);
+        raw[index] = buffer.readUInt16BE(0);
+        raw[index + 1] = buffer.readUInt16BE(2);
+    }
+
+    const raw = new Array(124).fill(0);
+    putFloat(raw, 0, 12.5);
+    putFloat(raw, 10, 230.25);
+    putFloat(raw, 24, 50);
+    putFloat(raw, 26, -450.5);
+    putFloat(raw, 66, 12345);
+
+    const summary = buildSummary([{ model_id: 213, addr: 40070, len: 124, raw }]);
+
+    assert.equal(summary.meter.model_id, 213);
+    assert.equal(summary.meter.meter_model, "three_phase_wye");
+    assert.equal(summary.meter.current_total_a, 12.5);
+    assert.equal(summary.meter.voltage_l1_v, 230.25);
+    assert.equal(summary.meter.frequency_hz, 50);
+    assert.equal(summary.meter.power_w, -450.5);
+    assert.equal(summary.meter.energy_import_wh, 12345);
+});
+
+test("scada-server encodes swapped Modbus register order", function () {
+    assert.deepEqual(
+        encodeMetric(0x01020304, "uint32", 1, { wordOrder: "lsw_first" }),
+        [0x0304, 0x0102]
+    );
+    assert.deepEqual(
+        encodeMetric(0x01020304, "uint32", 1, { byteOrder: "little_endian" }),
+        [0x0201, 0x0403]
+    );
+});
+
+test("scada-server reports saturated integer values", function () {
+    const encoded = encodeMetricDetailed(999999, "int16", 1);
+    assert.deepEqual(encoded.words, [32767]);
+    assert.equal(encoded.issues.length, 1);
+    assert.equal(encoded.issues[0].code, "value_saturated");
+});
+
+test("scada-server rejects register ranges past Modbus limit", function () {
+    const issues = validateMetricConfigs([
+        {
+            key: "bad",
+            label: "Bad",
+            address: 65535,
+            type: "int32",
+            scale: 1,
+            path: "payload.value",
+            signMode: "as_is",
+            byteOrder: "big_endian",
+            wordOrder: "msw_first"
+        }
+    ]);
+
+    assert.equal(issues.some(function (issue) {
+        return issue.code === "address_out_of_range";
+    }), true);
+});
+
+test("scada-server validates register byte and word order", function () {
+    const issues = validateMetricConfigs([
+        {
+            key: "bad_order",
+            label: "Bad order",
+            address: 0,
+            type: "int32",
+            scale: 1,
+            path: "payload.value",
+            signMode: "as_is",
+            byteOrder: "bad",
+            wordOrder: "also_bad"
+        }
+    ]);
+
+    assert.equal(issues.some(function (issue) { return issue.code === "invalid_byte_order"; }), true);
+    assert.equal(issues.some(function (issue) { return issue.code === "invalid_word_order"; }), true);
+});
+
+test("scada-server reports encoding issues while building register image", function () {
+    const issues = [];
+    const image = buildRegisterImage([
+        {
+            key: "v",
+            label: "V",
+            address: 0,
+            type: "int16",
+            scale: 1,
+            path: "payload.value",
+            signMode: "as_is",
+            byteOrder: "big_endian",
+            wordOrder: "msw_first"
+        }
+    ], { v: 999999 }, function (issue) {
+        issues.push(issue);
+    });
+
+    assert.equal(image[0], 32767);
+    assert.equal(issues[0].code, "value_saturated");
+    assert.equal(issues[0].key, "v");
+});
+
+test("scada aggregator generates stable complete maps and averages voltage", function () {
+    const metrics = buildAggregatorMetrics({
+        aggregatorPrefix: "payload.scada",
+        aggregatorMeterCount: 3,
+        aggregatorFroniusCount: 13,
+        aggregatorIncludeVictron: true,
+        aggregatorVoltageProfile: "complete"
+    });
+    assert.equal(metrics.length, 269);
+    assert.equal(new Set(metrics.map(function (metric) { return metric.key; })).size, metrics.length);
+    assert.equal(metrics.find(function (metric) { return metric.key === "grid_meter_01_p"; }).address, 0);
+    assert.equal(metrics.find(function (metric) { return metric.key === "pv_inverter_01_p"; }).address, 96);
+    assert.equal(metrics.find(function (metric) { return metric.key === "total_site_p"; }).path, "payload.scada.totals.site.p");
+
+    const values = normalizeScadaAggregateMessage({ payload: { summary: { ac: {
+        power_w: 100, reactive_power_var: 20, voltage_l1_v: 230, voltage_l2_v: 231, voltage_l3_v: 229, frequency_hz: 50
+    } } } });
+    const totals = summarizeScadaValues([{ values: values }, { values: Object.assign({}, values, { p: 200, q: 10 }) }]);
+    assert.equal(values.u_ln_avg, 230);
+    assert.equal(totals.p, 300);
+    assert.equal(totals.q, 30);
+    assert.equal(totals.u_ln_avg, 230);
+});
+
+test("scada aggregator excludes zero telemetry from phase and fleet averages", function () {
+    const healthy = normalizeScadaAggregateMessage({ payload: { p: 5000, q: 100, u_l1n: 230, u_l2n: 231, u_l3n: 229, u_l12: 400, u_l23: 401, u_l31: 399, f: 50 } });
+    const faulty = normalizeScadaAggregateMessage({ payload: { p: 0, q: 0, u_l1n: 0, u_l2n: 0, u_l3n: 0, u_l12: 0, u_l23: 0, u_l31: 0, f: 0 } });
+    const partial = normalizeScadaAggregateMessage({ payload: { u_l1n: 230, u_l2n: 0, u_l3n: 232, u_l12: 400, u_l23: 0, u_l31: 402 } });
+    const totals = summarizeScadaValues([{ values: healthy }, { values: faulty }]);
+
+    assert.equal(partial.u_ln_avg, 231);
+    assert.equal(partial.u_ll_avg, 401);
+    assert.equal(faulty.u_ln_avg, null);
+    assert.equal(faulty.u_ll_avg, null);
+    assert.equal(totals.u_l1n, 230);
+    assert.equal(totals.u_l2n, 231);
+    assert.equal(totals.u_l3n, 229);
+    assert.equal(totals.u_ln_avg, 230);
+    assert.equal(totals.u_ll_avg, 400);
+    assert.equal(totals.f, 50);
+    assert.equal(totals.p, 5000);
+    assert.equal(totals.q, 100);
+});
+
+test("scada aggregator keeps sources separate and emits a normalized snapshot", function () {
+    const node = createRuntimeNode("../scada-aggregator/scada-aggregator.js", "scada-aggregator", {
+        aggregatorGroups: JSON.stringify([{ id: "grid_meter", label: "Grid meter", count: 1 }, { id: "pv_inverter", label: "PV inverter", count: 1 }]), emitIntervalMs: 0, staleAfterMs: 5000, sourceIdPath: "scadaSource", siteTotalSource: "grid_meter"
+    });
+    let output;
+    node.emit("input", { scadaGroup: "grid_meter", scadaSource: "grid_meter", payload: { p: 100, q: 20, u_l12: 400, u_l23: 401, u_l31: 399, f: 50 } }, function (messages) { output = messages; }, function (error) { if (error) throw error; });
+    assert.equal(output[0].payload.scada.grid_meter.grid_meter.p, 100);
+    assert.equal(output[0].payload.scada.totals.grid_meter.p, 100);
+    node.emit("input", { scadaGroup: "pv_inverter", scadaSource: "pv_inverter", payload: { p: 200, q: 10, u_l12: 402, u_l23: 402, u_l31: 402, f: 50.01 } }, function (messages) { output = messages; }, function (error) { if (error) throw error; });
+    assert.equal(output[0].payload.scada.pv_inverter.pv_inverter.p, 200);
+    assert.equal(output[0].payload.scada.totals.site.grid.p, 100);
+    assert.equal(output[0].payload.scada.totals.site.pv.p, 200);
+    assert.equal(output[0].payload.scada.totals.pv_inverter.p, 200);
+});
+
+test("sma-read splits long SunSpec models into valid Modbus requests", async function () {
+    const calls = [];
+    const client = {
+        readHoldingRegisters: async function (address, length) {
+            calls.push({ address: address, length: length });
+            return { data: new Array(length).fill(address) };
+        }
+    };
+    const response = await readSmaSunSpecHolding(client, 40000, 250);
+    assert.deepEqual(calls, [
+        { address: 40000, length: 120 },
+        { address: 40120, length: 120 },
+        { address: 40240, length: 10 }
+    ]);
+    assert.equal(response.data.length, 250);
+});
+
+test("sma-read rejects corrupt SunSpec model lengths", async function () {
+    const client = {
+        readHoldingRegisters: async function () {
+            return { data: [1, 0] };
+        }
+    };
+    await assert.rejects(scanSmaModelDescriptors(client, 40000), /Invalid SunSpec model length/);
+});
+
+test("package registers sma-read Node-RED node", function () {
+    const packageJson = JSON.parse(fs.readFileSync(require.resolve("../package.json"), "utf8").replace(/^\uFEFF/, ""));
+    const runtime = fs.readFileSync(require.resolve("../sma-read/sma-read.js"), "utf8");
+    const editor = fs.readFileSync(require.resolve("../sma-read/sma-read.html"), "utf8");
+    assert.equal(packageJson["node-red"].nodes["sma-read"], "sma-read/sma-read.js");
+    assert.doesNotMatch(runtime, /\.\.\/fronius-read\//);
+    assert.match(runtime, /require\("\.\/lib\/sunspec-core"\)/);
+    assert.match(runtime, /require\("\.\/lib\/sunspec-model-parsers"\)/);
+    assert.ok(fs.existsSync(require.resolve("../sma-read/lib/sunspec-core.js")));
+    assert.ok(fs.existsSync(require.resolve("../sma-read/lib/sunspec-model-parsers.js")));
+    assert.match(runtime, /node\.controlExport = !!config\.controlExport/);
+    assert.match(runtime, /node\.multiGrid = !!config\.multiGrid/);
+    assert.match(runtime, /node\.multiInverterUseSelectedFields/);
+    assert.match(runtime, /node\.multiGridUseSelectedFields/);
+    assert.match(runtime, /Inverter ID este obligatoriu/);
+    assert.match(runtime, /node\.unitId = atLeast\(config\.unitId, 1, 126\)/);
+    assert.match(runtime, /RED\.httpAdmin\.get\("\/sma-read\/probe"/);
+    assert.match(runtime, /configuredUnitId, 126, 3, 1/);
+    assert.match(runtime, /SUPPORTED_MODEL_IDS/);
+    assert.match(runtime, /supportedDescriptors\(sunspecDescriptors\)/);
+    assert.match(editor, /Model detectat:/);
+    assert.match(runtime, /RED\.httpAdmin\.get\("\/sma-read\/state\/:id"/);
+    assert.match(runtime, /nodeRuntimeState\.set\(node\.id/);
+    assert.match(editor, /id="node-input-controlExport"/);
+    assert.match(editor, /id="node-input-multiGrid"/);
+    assert.match(editor, /id="node-input-influxDb"/);
+    assert.match(editor, /id="node-input-debugMode"/);
+    assert.match(editor, /unitId:\s*\{\s*value:\s*126/);
+    assert.match(editor, /node-input-host[\s\S]*node-input-name/);
+    assert.match(editor, /EXPERT_LONG_PRESS_MS = 5000/);
+    assert.match(editor, /multiInverterUseSelectedFields:\s*\{\s*value:\s*false/);
+    assert.match(editor, /multiGridUseSelectedFields:\s*\{\s*value:\s*false/);
+    assert.match(editor, /return !enabled \|\| !!String\(value \|\| ""\)\.trim\(\)/);
+    assert.match(editor, /host \+ " \[" \+ inverterId \+ "\]"/);
+    assert.match(editor, /function persistFields\(fields\)/);
+    assert.match(editor, /expertPayloadFields:\s*\{\s*value:\s*"\[\]"/);
+    assert.match(editor, /savedExpertFields/);
+    assert.match(editor, /node-input-expertPayloadFields/);
+    assert.match(runtime, /payload_fields: selectedFields\.slice\(\)/);
+    assert.match(editor, /Array\.isArray\(data\.payload_fields\)/);
+    assert.match(editor, /persistFields\(this\.payloadFields\)/);
+    assert.match(editor, /id="node-input-multiInverterUseSelectedFields"/);
+    assert.match(editor, /id="node-input-multiGridUseSelectedFields"/);
+    assert.match(editor, /function persistIntegrationSelectionMode\(\)/);
+    assert.match(editor, /const savedPayloadFields = parseFields\(node\.payloadFields\)/);
+    assert.match(editor, /const customFields = payloadSelectionState\.filter/);
+    assert.match(editor, /Detectare in curs\. Campurile apar dupa identificarea dispozitivului SunSpec\./);
+    assert.match(editor, /\$\.getJSON\("sma-read\/probe"/);
+    assert.match(editor, /\$\.getJSON\("sma-read\/state\/"/);
+    assert.match(editor, /differsFromPreset/);
+    assert.match(editor, /--sma-accent:#344054/);
+    assert.match(editor, /color:\s*"#9ebbd1"/);
+    assert.match(editor, /data-help-name="sma-read"[\s\S]*<h3>Detectare SunSpec<\/h3>/);
+    assert.match(editor, /<h3>Moduri de integrare<\/h3>/);
+    assert.match(editor, /<h3>Stare si erori<\/h3>/);
+    assert.doesNotMatch(editor, /Expert Mode|node-sma-expert-note|Tine apasat/i);
+    assert.doesNotMatch(editor, /node-input-protocolProfile|id="node-sma-probe"|Test & Detect|Registre SMA custom/);
+});
+
+test("package registers sma-write with SMA SunSpec defaults", function () {
+    const packageJson = JSON.parse(fs.readFileSync(require.resolve("../package.json"), "utf8").replace(/^\uFEFF/, ""));
+    const runtime = fs.readFileSync(require.resolve("../sma-write/sma-write.js"), "utf8");
+    const editor = fs.readFileSync(require.resolve("../sma-write/sma-write.html"), "utf8");
+    assert.equal(packageJson["node-red"].nodes["sma-write"], "sma-write/sma-write.js");
+    assert.match(runtime, /registerType\("sma-write", SmaWriteNode\)/);
+    assert.match(runtime, /atLeast\(config\.unitId, 1, 126\)/);
+    assert.match(editor, /unitId:\s*\{\s*value:\s*126/);
+    assert.match(runtime, /RED\.httpAdmin\.get\("\/sma-write\/probe"/);
+    assert.match(runtime, /async function scanModels/);
+    assert.match(runtime, /id === MODEL_123/);
+    assert.match(runtime, /client\.writeRegisters\(setpointAddr, \[item\.raw\]\)/);
+    assert.match(runtime, /client\.writeRegisters\(enableAddr, \[1\]\)/);
+    assert.match(runtime, /Controlul reactiv nu este disponibil/);
+    assert.match(runtime, /write_skipped_duplicate: duplicate/);
+    assert.match(runtime, /accepted_unverified: true/);
+    assert.match(runtime, /runtime_version: RUNTIME_VERSION/);
+    assert.doesNotMatch(runtime, /reactive_power|rampRegisterValue|otherEnableAddr|verifyRegister/);
+    assert.doesNotMatch(editor, /node-sma-write-probe|Test &amp; Detect/);
+    assert.doesNotMatch(runtime, /SunSpec 123 \| v/);
+    assert.match(editor, /pr-grid pr-grid-2/);
+    assert.match(editor, /data-template-name="sma-write"/);
+    assert.match(editor, /color:\s*"#b5a2c8"/);
+    assert.doesNotMatch(runtime, /fronius/i);
+});
+
+test("package registers modbus-tcp-discover network scanner", function () {
+    const packageJson = require("../package.json");
+    const runtime = fs.readFileSync(require.resolve("../modbus-tcp-discover/modbus-tcp-discover.js"), "utf8");
+    const editor = fs.readFileSync(require.resolve("../modbus-tcp-discover/modbus-tcp-discover.html"), "utf8");
+    assert.equal(packageJson["node-red"].nodes["modbus-tcp-discover"], "modbus-tcp-discover/modbus-tcp-discover.js");
+    assert.match(runtime, /registerType\("modbus-tcp-discover", DiscoverNode\)/);
+    assert.match(runtime, /const MAX_HOSTS = 4096/);
+    assert.match(runtime, /const MAX_PORTS = 32/);
+    assert.match(runtime, /socket\.connect\(\{ host: host, port: port \}\)/);
+    assert.match(runtime, /msg && msg\.cancel/);
+    assert.match(runtime, /probeModbus/);
+    assert.match(runtime, /parseDeviceIdentification/);
+    assert.match(runtime, /readSunSpecCommon/);
+    assert.match(runtime, /profileDefaults/);
+    assert.match(runtime, /sunspec_only/);
+    assert.match(runtime, /probeMqtt/);
+    assert.match(runtime, /mqttConnectPacket/);
+    assert.match(runtime, /unit_id_behavior/);
+    assert.match(runtime, /ignored_or_mirrored/);
+    assert.match(runtime, /finalNeighbors\.get\(device\.ip\)/);
+    assert.match(runtime, /const usesArp = node\.discoveryMode === "arp_tcp"/);
+    assert.match(runtime, /const usesPing = node\.discoveryMode === "ping_tcp"/);
+    assert.match(runtime, /confirmed_modbus_hosts/);
+    assert.match(runtime, /detected_sunspec_hosts/);
+    assert.match(runtime, /confirmed_mqtt_hosts/);
+    assert.match(runtime, /indexDevices/);
+    assert.match(runtime, /device_index/);
+    assert.match(runtime, /removeUnavailable/);
+    assert.match(runtime, /item === null \|\| item === undefined/);
+    assert.match(runtime, /sma-native/);
+    assert.match(runtime, /sunspec/);
+    assert.match(runtime, /neighborTable/);
+    assert.match(runtime, /device_offline/);
+    assert.match(runtime, /format === "influx"/);
+    assert.match(runtime, /format === "csv"/);
+    assert.match(editor, /data-template-name="modbus-tcp-discover"/);
+    assert.match(editor, /category: "Atelierul de Tehnologii"/);
+    assert.match(editor, /outputs: 2/);
+    assert.match(editor, /msg\.target/);
+    assert.match(editor, /Ping \+ TCP/);
+    assert.match(editor, /ARP\/neighbour \+ TCP/);
+    assert.match(editor, /node-input-unitIds/);
+    assert.match(editor, /node-input-onlyChanges/);
+    assert.match(editor, /node-input-emitMode/);
+    assert.match(editor, /Doar lista finala/);
+    assert.match(editor, /<option value="sunspec">SunSpec<\/option>/);
+    assert.match(editor, /node-input-detailLevel/);
+    assert.match(editor, /full_discovery/);
+    assert.match(editor, /node-input-deviceCollection/);
+    assert.match(runtime, /ports: indexPortResults\(checks\)/);
+    assert.match(runtime, /mqtt\[String\(mqttPort\)\] = mqttResult/);
+    assert.match(runtime, /device\.arp_neighbor = true/);
+    assert.match(runtime, /identification_confidence/);
+    assert.match(runtime, /categoryCollections/);
+    assert.doesNotMatch(runtime, /full: "matched_hosts"/);
+});
+
+function modbusReadRequest(transactionId, unitId, startAddress, quantity) {
+    const buffer = Buffer.alloc(12);
+    buffer.writeUInt16BE(transactionId, 0);
+    buffer.writeUInt16BE(0, 2);
+    buffer.writeUInt16BE(6, 4);
+    buffer.writeUInt8(unitId, 6);
+    buffer.writeUInt8(3, 7);
+    buffer.writeUInt16BE(startAddress, 8);
+    buffer.writeUInt16BE(quantity, 10);
+    return buffer;
+}
+
+function readOnce(port, request) {
+    return new Promise(function (resolve, reject) {
+        const socket = net.createConnection({ host: "127.0.0.1", port: port }, function () {
+            socket.write(request);
+        });
+
+        socket.once("data", function (chunk) {
+            socket.destroy();
+            resolve(chunk);
+        });
+
+        socket.once("error", reject);
+        socket.setTimeout(3000, function () {
+            socket.destroy();
+            reject(new Error("timeout"));
+        });
+    });
+}
+
+test("scada-server returns Modbus exception for out-of-range reads", async function () {
+    const server = createModbusServer({
+        host: "127.0.0.1",
+        port: 0,
+        unitId: 1,
+        readHoldingRegisters: function () {
+            return { exceptionCode: 2, issueCode: "read_out_of_range" };
+        }
+    });
+
+    await server.start();
+    try {
+        const address = server.address();
+        const response = await readOnce(address.port, modbusReadRequest(7, 1, 10, 2));
+        assert.equal(response.readUInt16BE(0), 7);
+        assert.equal(response.readUInt8(7), 0x83);
+        assert.equal(response.readUInt8(8), 2);
+    } finally {
+        await server.stop();
+    }
+});
+
+(async function run() {
+    for (const item of tests) {
+        try {
+            await item.fn();
+            console.log("ok - " + item.name);
+        } catch (error) {
+            console.error("not ok - " + item.name);
+            throw error;
+        } finally {
+            await closeRuntimeNodes();
+        }
+    }
+
+    console.log("OK: tests passed");
+})().catch(function (error) {
+    console.error(error.stack || error.message);
+    process.exit(1);
+});