@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/multi-inverter/multi-inverter.js

@@ -0,0 +1,1393 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const {
+        clamp,
+        roundAllocations,
+        capacityOf,
+        totalFreshPower,
+        chooseEffectiveStrategy,
+        allocateIterative,
+        buildPolicyAllocations,
+        applyPolicyToStale,
+        smoothAllocations
+    } = require("./lib/engine-core");
+
+    const {
+        atLeast,
+        clampNumber
+    } = require("../lib/numbers");
+
+
+    function firstFinite() {
+
+        for (let i = 0; i < arguments.length; i++) {
+            if (arguments[i] === null || arguments[i] === undefined || arguments[i] === "") continue;
+            const n = Number(arguments[i]);
+            if (Number.isFinite(n)) return n;
+        }
+
+        return null;
+
+    }
+
+
+    function normalizeTopicList(text) {
+
+        return String(text || "")
+            .split(",")
+            .map(function (s) { return s.trim(); })
+            .filter(Boolean)
+            .filter(function (v, i, arr) { return arr.indexOf(v) === i; });
+
+    }
+
+
+    function normalizeDebugMode(mode) {
+
+        if (mode === "off" || mode === "normal" || mode === "verbose") {
+            return mode;
+        }
+
+        if (mode === "always") {
+            return "verbose";
+        }
+
+        if (mode === "errors_only" || mode === "state_changes") {
+            return "normal";
+        }
+
+        return "off";
+
+    }
+
+    function normalizeGlobalVarName(value, fallback) {
+        const key = String(value || "").trim();
+        return key || String(fallback || "total_pv");
+    }
+
+    function normalizeRampType(value) {
+        const raw = String(value || "").trim().toLowerCase();
+
+        if (raw === "0" || raw === "none" || raw === "off") return "none";
+        if (raw === "1" || raw === "time" || raw === "ramp_time") return "time";
+        if (raw === "2" || raw === "gradient_pct" || raw === "gradient_percent") return "gradient_pct";
+        if (
+            raw === "3" ||
+            raw === "gradient_w" ||
+            raw === "gradient_watts" ||
+            raw === "gradient_var" ||
+            raw === "gradient_vars"
+        ) {
+            return "gradient_w";
+        }
+
+        return "none";
+    }
+
+
+    function ControlNode(config) {
+
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = config.name || "";
+        node.strategy = config.strategy || "current_power";
+        node.siteLimitTopics = normalizeTopicList(config.siteLimitTopics || "site-limit,control-export,control-reactive");
+
+        node.telemetryTimeoutMs = atLeast(config.telemetryTimeoutMs, 0, 6000);
+        node.maxFutureTimestampMs = atLeast(config.maxFutureTimestampMs, 0, 2000);
+        node.siteLimitTimeoutMs = atLeast(config.siteLimitTimeoutMs, 0, 8000);
+        node.missingSiteLimitBehavior = config.missingSiteLimitBehavior || "set_zero";
+        node.missingSiteLimitValueW = atLeast(config.missingSiteLimitValueW, 0, 0);
+
+        node.staleTelemetryBehavior = config.staleTelemetryBehavior || "set_inverter_min";
+        node.staleTelemetryFixedValueW = atLeast(config.staleTelemetryFixedValueW, 0, 0);
+
+        node.waitForFreshTelemetryOnStartup = config.waitForFreshTelemetryOnStartup !== false;
+        node.recalculateOnTelemetry = config.recalculateOnTelemetry !== false;
+        node.telemetryRecalcDebounceMs = atLeast(config.telemetryRecalcDebounceMs, 0, 350);
+        node.telemetryFilterAlpha = clampNumber(config.telemetryFilterAlpha, 0.05, 1, 0.35);
+
+        node.rampType = normalizeRampType(config.rampType || "none");
+        node.rampValue = atLeast(config.rampValue, 0, 0);
+        node.rampUpValue = atLeast(config.rampUpValue, 0, 0);
+        node.rampDownValue = atLeast(config.rampDownValue, 0, 0);
+        node.rampFromGlobal = !!config.rampFromGlobal;
+        node.rampTypeGlobalVar = normalizeGlobalVarName(config.rampTypeGlobalVar, "scada_ramp_type");
+        node.rampValueGlobalVar = normalizeGlobalVarName(config.rampValueGlobalVar, "scada_ramp_value");
+        node.rampUpGlobalVar = normalizeGlobalVarName(config.rampUpGlobalVar, "scada_ramp_up_value");
+        node.rampDownGlobalVar = normalizeGlobalVarName(config.rampDownGlobalVar, "scada_ramp_down_value");
+
+        node.allocationSmoothingAlpha = clampNumber(config.allocationSmoothingAlpha, 0.01, 1, 0.35);
+        node.allocationDeadbandW = atLeast(config.allocationDeadbandW, 0, 300);
+
+        node.debugMode = normalizeDebugMode(config.debugMode);
+        node.enableDebugOutput = node.debugMode !== "off";
+        node.publishTotalPvGlobal = config.publishTotalPvGlobal !== false;
+        node.totalPvGlobalVar = normalizeGlobalVarName(config.totalPvGlobalVar, "total_pv");
+        node.influxDb = !!config.influxDb;
+        node.influxMeasurement = String(config.influxMeasurement || "multi_inverter").trim() || "multi_inverter";
+        node.influxNode = String(config.influxNode || "").trim();
+
+        node.inverters = Array.isArray(config.inverters)
+            ? config.inverters.map(function (inv, idx) {
+                return {
+                    index: idx,
+                    id: String((inv && inv.id) || "").trim(),
+                    minW: atLeast(inv && inv.minW, 0, 0),
+                    maxW: atLeast(inv && inv.maxW, 0, 0),
+                    nominalPowerW: atLeast(
+                        inv && inv.nominalPowerW !== undefined ? inv.nominalPowerW : (inv && inv.nominalW),
+                        1,
+                        inv && inv.maxW ? inv.maxW : 1
+                    ),
+                    enabled: inv ? inv.enabled !== false : true
+                };
+            })
+            : [];
+
+
+        const telemetry = {};
+        const lastSmoothedAllocation = {};
+        const lastEmittedLimitById = {};
+
+        let lastSiteLimit = null;
+        let lastSiteLimitMode = "active";
+        let lastSiteLimitMsg = null;
+        let lastSiteLimitTs = 0;
+
+        let lastDebugSignature = "";
+        let lastReason = "";
+        let hasEmittedAllocation = false;
+
+        let telemetryDebounceTimer = null;
+        let watchdogTimer = null;
+        let lastSendFn = null;
+        const globalCtx = node.context().global;
+
+
+        function emit(outputs) {
+            if (node.influxDb && Array.isArray(outputs) && outputs[0] && outputs[0].payload) {
+                const payload = outputs[0].payload;
+                const fields = {};
+                Object.keys(payload).forEach(function (key) {
+                    if (typeof payload[key] === "number" && Number.isFinite(payload[key])) fields[key] = payload[key];
+                });
+                (Array.isArray(payload.limits) ? payload.limits : []).forEach(function (item) {
+                    const id = String(item && item.inverter_id || "").replace(/[^a-zA-Z0-9_]/g, "_");
+                    if (!id) return;
+                    ["limit_w", "limit_var", "power_limit_w", "reactive_limit_var"].forEach(function (key) {
+                        if (typeof item[key] === "number" && Number.isFinite(item[key])) fields[id + "_" + key] = item[key];
+                    });
+                });
+                const target = RED.nodes.getNode(node.influxNode);
+                if (target && typeof target.receive === "function" && Object.keys(fields).length) {
+                    target.receive({
+                        topic: "multi-inverter/influx",
+                        payload: fields,
+                        influx: {
+                            measurement: node.influxMeasurement,
+                            tags: { source: "multi-inverter", strategy: node.strategy },
+                            fields: fields,
+                            timestamp: new Date().toISOString()
+                        }
+                    });
+                } else if (!target) {
+                    node.warn("multi-inverter: selecteaza un nod adt-influxdb.");
+                }
+            }
+            if (typeof lastSendFn === "function") {
+                lastSendFn(outputs);
+            } else {
+                node.send(outputs);
+            }
+        }
+
+
+        function activeInverters() {
+            return node.inverters.filter(function (inv) {
+                return inv.enabled && inv.id && inv.maxW > 0 && inv.minW <= inv.maxW;
+            });
+        }
+
+        function isValidInverter(inv) {
+            return !!(inv && inv.id && inv.maxW > 0 && inv.minW <= inv.maxW);
+        }
+
+
+        function duplicateIds() {
+
+            const seen = new Set();
+            const dup = new Set();
+
+            activeInverters().forEach(function (inv) {
+                if (seen.has(inv.id)) dup.add(inv.id);
+                else seen.add(inv.id);
+            });
+
+            return Array.from(dup);
+
+        }
+
+
+        function parseTelemetryPower(payload, siteLimitMode) {
+
+            if (Number.isFinite(Number(payload))) {
+                const scalar = Number(payload);
+                return siteLimitMode === "reactive" ? Math.abs(scalar) : scalar;
+            }
+
+            if (!payload || typeof payload !== "object") {
+                return null;
+            }
+
+            const activeCandidate = firstFinite(
+                payload.power_w,
+                payload.active_power_w,
+                payload.p_w,
+                payload.ac_active_power_w,
+                payload.summary && payload.summary.ac && payload.summary.ac.power_w
+            );
+
+            const reactiveCandidate = firstFinite(
+                payload.power_var,
+                payload.reactive_power_var,
+                payload.ac_reactive_power_var,
+                payload.q_var,
+                payload.var,
+                payload.vars,
+                payload.limit_var,
+                payload.site_limit_var,
+                payload.summary && payload.summary.ac && payload.summary.ac.reactive_power_var
+            );
+
+            if (siteLimitMode === "reactive") {
+                if (reactiveCandidate !== null) return Math.abs(Number(reactiveCandidate));
+                if (activeCandidate !== null) return Math.abs(Number(activeCandidate));
+                return null;
+            }
+
+            if (activeCandidate !== null) return Number(activeCandidate);
+            if (reactiveCandidate !== null) return Number(reactiveCandidate);
+            return null;
+
+        }
+
+
+        function extractTimestampMs(msg) {
+
+            const candidate = firstFinite(
+                msg && msg.timestamp,
+                msg && msg.ts,
+                msg && msg.time,
+                msg && msg.timestamp_ms,
+                msg && msg.time_ms,
+                msg && msg.payload && msg.payload.timestamp,
+                msg && msg.payload && msg.payload.ts,
+                msg && msg.payload && msg.payload.time,
+                msg && msg.payload && msg.payload.timestamp_ms,
+                msg && msg.payload && msg.payload.time_ms
+            );
+
+            if (candidate === null) return Date.now();
+            if (candidate < 1e11) return Math.round(candidate * 1000);
+            return Math.round(candidate);
+
+        }
+
+
+        function isFresh(ts, nowMs) {
+
+            if (node.telemetryTimeoutMs <= 0) return true;
+            if (!Number.isFinite(ts)) return false;
+            return (nowMs - ts) <= node.telemetryTimeoutMs;
+
+        }
+
+
+        function isSiteLimitFresh(nowMs) {
+
+            if (node.siteLimitTimeoutMs <= 0) return Number.isFinite(lastSiteLimit);
+            if (!Number.isFinite(lastSiteLimitTs)) return false;
+            return (nowMs - lastSiteLimitTs) <= node.siteLimitTimeoutMs;
+
+        }
+
+
+        function extractSiteLimitInfo(msg) {
+
+            const topic = String(msg.topic || "").trim();
+            const payload = msg.payload;
+
+            const topicMatch = node.siteLimitTopics.includes(topic) ||
+                topic === "site-limit" ||
+                topic === "control-export" ||
+                topic === "control-reactive";
+            const hasObjectPayload = payload && typeof payload === "object";
+            const activeCandidate = hasObjectPayload ? Number(payload.site_limit_w) : NaN;
+            const reactiveCandidate = hasObjectPayload
+                ? firstFinite(payload.limit_var, payload.site_limit_var)
+                : null;
+            const hasActivePayload = Number.isFinite(activeCandidate);
+            const hasReactivePayload = Number.isFinite(reactiveCandidate);
+            const hasValidPayload = hasActivePayload || hasReactivePayload;
+
+            if (!topicMatch || !hasValidPayload) {
+                return null;
+            }
+
+            return {
+                siteLimit: hasActivePayload ? activeCandidate : Number(reactiveCandidate),
+                siteLimitMode: hasActivePayload ? "active" : "reactive",
+                reason: payload.reason || null,
+                controllerStale: !!payload.stale,
+                controllerErrorW: Number.isFinite(Number(payload.error_w)) ? Number(payload.error_w) : null,
+                controllerErrorVar: Number.isFinite(Number(payload.error_var)) ? Number(payload.error_var) : null,
+                controllerTimestampMs: Number.isFinite(Number(payload.timestamp_ms)) ? Number(payload.timestamp_ms) : null,
+                commandId: payload.command_id ? String(payload.command_id) : null,
+                commandRequestedAtMs: Number.isFinite(Number(payload.command_requested_at_ms)) ? Number(payload.command_requested_at_ms) : null,
+                controlReceivedAtMs: Number.isFinite(Number(payload.control_received_at_ms)) ? Number(payload.control_received_at_ms) : null,
+                controlCalculatedAtMs: Number.isFinite(Number(payload.control_calculated_at_ms)) ? Number(payload.control_calculated_at_ms) : null
+            };
+
+        }
+
+        function siteLimitFieldForMode(mode) {
+            return mode === "reactive" ? "site_limit_var" : "site_limit_w";
+        }
+
+        function perInverterLimitFieldForMode(mode) {
+            return mode === "reactive" ? "limit_var" : "limit_w";
+        }
+
+
+        function effectiveRamp() {
+            let type = node.rampType;
+            let value = 0;
+            let upValue = node.rampUpValue;
+            let downValue = node.rampDownValue;
+
+            if (node.rampFromGlobal) {
+                const globalType = globalCtx.get(node.rampTypeGlobalVar);
+                const globalUpValue = globalCtx.get(node.rampUpGlobalVar);
+                const globalDownValue = globalCtx.get(node.rampDownGlobalVar);
+                const legacyGlobalValue = globalCtx.get(node.rampValueGlobalVar);
+                type = normalizeRampType(globalType);
+                upValue = Number(globalUpValue);
+                downValue = Number(globalDownValue);
+
+                if (!Number.isFinite(upValue)) {
+                    upValue = Number(legacyGlobalValue);
+                }
+
+                if (!Number.isFinite(downValue)) {
+                    downValue = Number(legacyGlobalValue);
+                }
+            }
+
+            return type !== "none"
+                ? {
+                    type: type,
+                    value: Math.max(0, Number(value || 0)),
+                    upValue: Math.max(0, Number.isFinite(upValue) ? upValue : 0),
+                    downValue: Math.max(0, Number.isFinite(downValue) ? downValue : 0)
+                }
+                : null;
+        }
+
+        function rampForDirection(baseRamp, direction) {
+            const fallbackType = baseRamp && baseRamp.type && baseRamp.type !== "none" ? baseRamp.type : "time";
+
+            const upValue = node.rampFromGlobal && baseRamp && Number.isFinite(baseRamp.upValue)
+                ? baseRamp.upValue
+                : node.rampUpValue;
+            const downValue = node.rampFromGlobal && baseRamp && Number.isFinite(baseRamp.downValue)
+                ? baseRamp.downValue
+                : node.rampDownValue;
+
+            if (direction === "up" && upValue > 0) {
+                return { type: fallbackType, value: upValue };
+            }
+
+            if (direction === "down" && downValue > 0) {
+                return { type: fallbackType, value: downValue };
+            }
+
+            return baseRamp && baseRamp.type && baseRamp.type !== "none"
+                ? { type: baseRamp.type, value: Number(baseRamp.value || 0) }
+                : null;
+        }
+
+
+        function freshPowerMap(list, nowMs) {
+
+            const map = {};
+
+            list.forEach(function (inv) {
+                const t = telemetry[inv.id];
+                if (t && isFresh(t.ts, nowMs) && Number.isFinite(t.powerW)) {
+                    map[inv.id] = Number.isFinite(t.filteredPowerW) ? t.filteredPowerW : t.powerW;
+                }
+            });
+
+            return map;
+
+        }
+
+
+        function staleInputs(list, nowMs) {
+
+            return list.filter(function (inv) {
+                const t = telemetry[inv.id];
+                return !(t && isFresh(t.ts, nowMs) && Number.isFinite(t.powerW));
+            }).map(function (inv) {
+                return inv.id;
+            });
+
+        }
+
+        function computeTotalPvW(nowMs) {
+            const validRows = node.inverters.filter(function (inv) {
+                return isValidInverter(inv);
+            });
+
+            return validRows.reduce(function (sum, inv) {
+                const t = telemetry[inv.id];
+                if (!(t && Number.isFinite(t.powerW) && isFresh(t.ts, nowMs))) {
+                    return sum;
+                }
+                return sum + Math.max(0, Number(t.powerW));
+            }, 0);
+        }
+
+        function publishTotalPv(nowMs) {
+            try {
+                if (!node.publishTotalPvGlobal) return;
+                if (!node.totalPvGlobalVar) return;
+                const totalPvW = Math.round(computeTotalPvW(nowMs));
+                globalCtx.set(node.totalPvGlobalVar, totalPvW);
+            } catch (err) {
+                node.warn("[multi-inverter] total_pv_global_write_failed | " + err.message);
+            }
+        }
+
+
+        function currentPowerHoldLimit(activeList, freshMap) {
+
+            const total = activeList.reduce(function (sum, inv) {
+                const current = Number(freshMap[inv.id] || 0);
+                return sum + clamp(current, inv.minW, inv.maxW);
+            }, 0);
+
+            return Math.max(0, Math.round(total));
+
+        }
+
+
+        function sumAllocations(map) {
+            return Object.values(map || {}).reduce(function (sum, v) {
+                return sum + Number(v || 0);
+            }, 0);
+        }
+
+        function getTelemetrySource(msg) {
+            const payload = msg && msg.payload && typeof msg.payload === "object" ? msg.payload : null;
+            return String(
+                (msg && msg.source) ||
+                (payload && payload.source) ||
+                (msg && msg.origin) ||
+                (payload && payload.origin) ||
+                "unknown"
+            ).trim() || "unknown";
+        }
+
+        function buildAllZeroLimits(nowMs, reason) {
+            const rowList = Array.isArray(node.inverters) ? node.inverters : [];
+            const validRowList = rowList.filter(function (inv) { return isValidInverter(inv); });
+            const controlMode = lastSiteLimitMode === "reactive" ? "reactive" : "active";
+            const limitField = perInverterLimitFieldForMode(controlMode);
+
+            const limits = validRowList.map(function (inv) {
+                const item = {
+                    id: inv.id,
+                    enabled: !!inv.enabled,
+                    disabled: !inv.enabled,
+                    min_w: inv.minW,
+                    max_w: inv.maxW,
+                    nominal_power_w: inv.nominalPowerW,
+                    nominal_reactive_power_var: inv.nominalPowerW,
+                    current_power_w: null,
+                    current_power_fresh: false
+                };
+                item[limitField] = 0;
+                return item;
+            });
+
+            return {
+                topic: "multi-inverter/limits",
+                payload: {
+                    limits: limits,
+                    site_limit_w: controlMode === "active" && Number.isFinite(lastSiteLimit) ? Math.round(lastSiteLimit) : null,
+                    site_limit_var: controlMode === "reactive" && Number.isFinite(lastSiteLimit) ? Math.round(lastSiteLimit) : null,
+                    control_mode: controlMode,
+                    allocation_strategy: node.strategy,
+                    effective_strategy: "failsafe",
+                    stale_inputs: validRowList.map(function (inv) { return inv.id; }),
+                    fresh_power_map: {},
+                    total_fresh_power_w: 0,
+                    available_capacity_w: 0,
+                    unallocated_w: 0,
+                    clipped: false,
+                    ramp: null,
+                    reason: reason || "invalid_telemetry",
+                    timestamp_ms: nowMs
+                }
+            };
+        }
+
+        function emitFailsafeAllZero(reason, details) {
+            const nowMs = Date.now();
+            node.warn("[multi-inverter] " + reason + (details ? " | " + details : ""));
+            node.status({ fill: "red", shape: "ring", text: "failsafe | " + reason });
+
+            const outputs = new Array(1 + (node.enableDebugOutput ? 1 : 0)).fill(null);
+            outputs[0] = buildAllZeroLimits(nowMs, reason);
+
+            if (node.enableDebugOutput) {
+                outputs[outputs.length - 1] = debugMessage(
+                    "invalid_telemetry",
+                    false,
+                    Number.isFinite(lastSiteLimit) ? Math.round(lastSiteLimit) : 0,
+                    nowMs,
+                    activeInverters(),
+                    [],
+                    {},
+                    {},
+                    { availableCapacityW: 0, unallocatedW: 0, clipped: false },
+                    null,
+                    "failsafe",
+                    lastSiteLimitMsg ? {
+                        reason: lastSiteLimitMsg.reason || null,
+                        stale: !!lastSiteLimitMsg.controllerStale,
+                        errorW: lastSiteLimitMsg.controllerErrorW,
+                        errorVar: lastSiteLimitMsg.controllerErrorVar,
+                        timestampMs: lastSiteLimitMsg.controllerTimestampMs
+                    } : null,
+                    "telemetry",
+                    lastSiteLimitMode
+                );
+                outputs[outputs.length - 1].payload.failsafe_reason = reason;
+                outputs[outputs.length - 1].payload.failsafe_details = details || null;
+            }
+
+            emit(outputs);
+        }
+
+
+        function buildOperationalOutputs(activeList, smoothedAllocations, ramp, siteLimitW, effectiveStrategy, staleList, freshMap, result) {
+
+            const outputs = new Array(activeList.length + (node.enableDebugOutput ? 1 : 0)).fill(null);
+            const activeIds = activeList.map(function (inv) { return inv.id; });
+            const freshTotal = totalFreshPower(freshMap);
+
+            activeList.forEach(function (inv, idx) {
+
+                const limitW = Math.round(Number(smoothedAllocations[inv.id] || 0));
+                const t = telemetry[inv.id];
+
+                const currentPowerW = t && Number.isFinite(t.powerW) ? t.powerW : null;
+                const allocationPowerW = t && Number.isFinite(t.filteredPowerW) ? t.filteredPowerW : currentPowerW;
+                const currentPowerFresh = !!(t && Number.isFinite(t.powerW) && staleList.indexOf(inv.id) === -1);
+
+                const payload = { limit_w: limitW };
+                payload.nominal_power_w = inv.nominalPowerW;
+                payload.nominal_reactive_power_var = inv.nominalPowerW;
+
+                if (ramp && ramp.type && ramp.type !== "none" && Number.isFinite(Number(ramp.value)) && Number(ramp.value) > 0) {
+                    payload.ramp = { type: ramp.type, value: Number(ramp.value) };
+                }
+
+                outputs[idx] = {
+                    topic: inv.id,
+                    payload: payload,
+                    inverter_id: inv.id,
+                    inverter_index: idx,
+                    site_limit_w: Math.round(siteLimitW),
+                    current_power_w: currentPowerW,
+                    allocation_power_w: allocationPowerW,
+                    current_power_fresh: currentPowerFresh,
+                    min_w: inv.minW,
+                    max_w: inv.maxW,
+                    nominal_power_w: inv.nominalPowerW,
+                    nominal_reactive_power_var: inv.nominalPowerW,
+                    allocation_strategy: node.strategy,
+                    effective_strategy: effectiveStrategy,
+                    stale_inputs: staleList,
+                    fresh_power_map: freshMap,
+                    total_fresh_power_w: freshTotal,
+                    available_capacity_w: result.availableCapacityW,
+                    clipped: result.clipped,
+                    unallocated_w: result.unallocatedW,
+                    active_inverters: activeIds,
+                    ramp_type: payload.ramp ? payload.ramp.type : null,
+                    ramp_value: payload.ramp ? payload.ramp.value : null
+                };
+
+            });
+
+            return outputs;
+
+        }
+
+
+        function statusFor(reason, staleList, activeCount, configuredCount, limitW) {
+
+            const limitText = "limit " + Math.round(limitW || 0) + "W";
+            const countsText = "active " + activeCount + "/" + configuredCount;
+            const staleText = "stale " + staleList.length;
+
+            if (reason === "invalid_configuration" || reason === "runtime_error") {
+                node.status({ fill: "red", shape: "ring", text: reason + " | " + countsText });
+                return;
+            }
+
+            if (reason === "waiting_startup_telemetry") {
+                node.status({ fill: "yellow", shape: "ring", text: "waiting | " + countsText + " | " + staleText });
+                return;
+            }
+
+            if (reason === "site_limit_missing") {
+                node.status({ fill: "yellow", shape: "ring", text: reason + " | " + limitText + " | " + staleText });
+                return;
+            }
+
+            if (staleList.length > 0) {
+                node.status({ fill: "yellow", shape: "dot", text: limitText + " | " + countsText + " | " + staleText });
+                return;
+            }
+
+            node.status({ fill: "green", shape: "dot", text: limitText + " | " + countsText + " | " + staleText });
+
+        }
+
+
+        function shouldEmitDebug(mode, reason, signatureChanged) {
+
+            if (!node.enableDebugOutput) return false;
+            if (mode === "verbose") return true;
+            if (mode === "off") return false;
+
+            return reason !== "allocated" || signatureChanged;
+
+        }
+
+
+        function debugMessage(reason, valid, siteLimitW, nowMs, activeList, staleList, freshMap, allocations, result, ramp, effectiveStrategy, controllerInfo, triggerSource, siteLimitMode) {
+
+            const summary = "limit=" + Math.round(siteLimitW || 0) +
+                ", active=" + activeList.length + "/" + node.inverters.length +
+                ", stale=" + staleList.length +
+                ", strategy=" + String(effectiveStrategy || node.strategy || "-");
+            const controlMode = siteLimitMode === "reactive" ? "reactive" : "active";
+
+            return {
+                topic: "multi-inverter/diagnostic",
+                payload: {
+                    valid: valid,
+                    reason: reason,
+                    trigger_source: triggerSource || null,
+                    summary: summary,
+                    site_limit_w: controlMode === "active" ? siteLimitW : null,
+                    site_limit_var: controlMode === "reactive" ? siteLimitW : null,
+                    control_mode: controlMode,
+                    site_limit_age_ms: Number.isFinite(lastSiteLimitTs) ? Math.max(0, nowMs - lastSiteLimitTs) : null,
+                    allocation_strategy: node.strategy,
+                    effective_strategy: effectiveStrategy,
+                    ramp: ramp,
+                    startup_wait_for_fresh_telemetry: node.waitForFreshTelemetryOnStartup,
+                    recalculate_on_telemetry: node.recalculateOnTelemetry,
+                    telemetry_recalc_debounce_ms: node.telemetryRecalcDebounceMs,
+                    telemetry_filter_alpha: node.telemetryFilterAlpha,
+                    has_emitted_allocation: hasEmittedAllocation,
+                    configured_inverters: node.inverters.map(function (inv) {
+                        return {
+                            index: inv.index,
+                            id: inv.id,
+                            min_w: inv.minW,
+                            max_w: inv.maxW,
+                            nominal_power_w: inv.nominalPowerW,
+                            nominal_reactive_power_var: inv.nominalPowerW,
+                            enabled: inv.enabled
+                        };
+                    }),
+                    active_inverters: activeList.map(function (inv) { return inv.id; }),
+                    stale_inputs: staleList,
+                    stale_telemetry_behavior: node.staleTelemetryBehavior,
+                    stale_telemetry_fixed_value_w: node.staleTelemetryFixedValueW,
+                    missing_site_limit_behavior: node.missingSiteLimitBehavior,
+                    missing_site_limit_value_w: node.missingSiteLimitValueW,
+                    fresh_power_map: freshMap,
+                    allocations_w: allocations,
+                    available_capacity_w: result ? result.availableCapacityW : 0,
+                    total_fresh_power_w: totalFreshPower(freshMap),
+                    unallocated_w: result ? result.unallocatedW : 0,
+                    clipped: result ? result.clipped : false,
+                    controller_reason: controllerInfo ? controllerInfo.reason : null,
+                    controller_stale: controllerInfo ? controllerInfo.stale : null,
+                    controller_error_w: controllerInfo ? controllerInfo.errorW : null,
+                    controller_error_var: controllerInfo ? controllerInfo.errorVar : null,
+                    controller_timestamp_ms: controllerInfo ? controllerInfo.timestampMs : null,
+                    debug_mode: node.debugMode,
+                    debug_enabled: node.enableDebugOutput,
+                    timestamp_ms: nowMs
+                }
+            };
+
+        }
+
+
+        function runAllocationCycle(triggerSource) {
+
+            const nowMs = Date.now();
+            publishTotalPv(nowMs);
+            const rowList = Array.isArray(node.inverters) ? node.inverters : [];
+            const validRowList = rowList.filter(function (inv) {
+                return isValidInverter(inv);
+            });
+            const activeList = rowList.filter(function (inv) {
+                return inv.enabled && isValidInverter(inv);
+            });
+            const configuredCount = rowList.length;
+            const dups = duplicateIds();
+
+            const outputs = new Array(1 + (node.enableDebugOutput ? 1 : 0)).fill(null);
+
+            if (dups.length > 0 || validRowList.length === 0) {
+
+                const reason = "invalid_configuration";
+                statusFor(reason, [], activeList.length, configuredCount, 0);
+
+                const dbg = debugMessage(
+                    reason,
+                    false,
+                    0,
+                    nowMs,
+                    activeList,
+                    [],
+                    {},
+                    {},
+                    { availableCapacityW: 0, unallocatedW: 0, clipped: false },
+                    null,
+                    node.strategy,
+                    null,
+                    "validation",
+                    lastSiteLimitMode
+                );
+
+                dbg.payload.duplicate_ids = dups;
+                dbg.payload.message = activeList.length === 0 ? "No active inverters configured" : "Duplicate inverter IDs";
+
+                outputs[0] = buildAllZeroLimits(nowMs, reason);
+                if (node.enableDebugOutput) outputs[outputs.length - 1] = dbg;
+
+                emit(outputs);
+                return;
+
+            }
+
+            if (activeList.length === 0) {
+                const controlMode = lastSiteLimitMode === "reactive" ? "reactive" : "active";
+                const limitField = perInverterLimitFieldForMode(controlMode);
+                const zeroLimits = validRowList.map(function (inv) {
+                    const item = {
+                        id: inv.id,
+                        enabled: false,
+                        disabled: true,
+                        min_w: inv.minW,
+                        max_w: inv.maxW,
+                        nominal_power_w: inv.nominalPowerW,
+                        nominal_reactive_power_var: inv.nominalPowerW,
+                        current_power_w: null,
+                        current_power_fresh: false
+                    };
+                    item[limitField] = 0;
+                    return item;
+                });
+
+                outputs[0] = {
+                    topic: "multi-inverter/limits",
+                    payload: {
+                        limits: zeroLimits,
+                        site_limit_w: controlMode === "active" && Number.isFinite(lastSiteLimit) ? Math.round(lastSiteLimit) : null,
+                        site_limit_var: controlMode === "reactive" && Number.isFinite(lastSiteLimit) ? Math.round(lastSiteLimit) : null,
+                        control_mode: controlMode,
+                        allocation_strategy: node.strategy,
+                        effective_strategy: "disabled",
+                        stale_inputs: [],
+                        fresh_power_map: {},
+                        total_fresh_power_w: 0,
+                        available_capacity_w: 0,
+                        unallocated_w: 0,
+                        clipped: false,
+                        ramp: null,
+                        timestamp_ms: nowMs
+                    }
+                };
+
+                statusFor("site_limit_missing", [], 0, configuredCount, 0);
+                emit(outputs);
+                return;
+            }
+
+            const freshMap = freshPowerMap(activeList, nowMs);
+            const staleList = staleInputs(activeList, nowMs);
+            const freshCount = activeList.length - staleList.length;
+            const startupMissingTelemetry = node.waitForFreshTelemetryOnStartup && !hasEmittedAllocation && freshCount === 0;
+
+            let siteLimitValid = isSiteLimitFresh(nowMs);
+            let siteLimitMode = lastSiteLimitMode === "reactive" ? "reactive" : "active";
+            let siteLimitW = Number.isFinite(lastSiteLimit) ? lastSiteLimit : 0;
+            let allocationBudgetW = siteLimitMode === "reactive"
+                ? Math.abs(Number(siteLimitW || 0))
+                : Math.max(0, Number(siteLimitW || 0));
+            let reason = "allocated";
+
+            if (startupMissingTelemetry) {
+
+                reason = "waiting_startup_telemetry";
+                statusFor(reason, staleList, activeList.length, configuredCount, siteLimitW);
+
+                if (node.enableDebugOutput && shouldEmitDebug(node.debugMode, reason, true)) {
+                    outputs[outputs.length - 1] = debugMessage(
+                        reason,
+                        false,
+                        Math.round(siteLimitW || 0),
+                        nowMs,
+                        activeList,
+                        staleList,
+                        freshMap,
+                        {},
+                        { availableCapacityW: 0, unallocatedW: 0, clipped: false },
+                        null,
+                        node.strategy,
+                        lastSiteLimitMsg ? {
+                            reason: lastSiteLimitMsg.reason || null,
+                            stale: !!lastSiteLimitMsg.controllerStale,
+                            errorW: lastSiteLimitMsg.controllerErrorW,
+                            errorVar: lastSiteLimitMsg.controllerErrorVar,
+                            timestampMs: lastSiteLimitMsg.controllerTimestampMs
+                        } : null,
+                        triggerSource,
+                        siteLimitMode
+                    );
+
+                    emit(outputs);
+                }
+
+                return;
+
+            }
+
+            let effectiveStrategy = node.strategy;
+            let ramp = effectiveRamp();
+            let allocationResult;
+            let allocations;
+
+            if (!siteLimitValid) {
+
+                reason = "site_limit_missing";
+                const missingPolicy = buildPolicyAllocations(activeList, node.missingSiteLimitBehavior, node.missingSiteLimitValueW);
+                allocations = missingPolicy.allocations;
+                siteLimitW = missingPolicy.totalW;
+                siteLimitMode = "active";
+                allocationBudgetW = Math.max(0, Number(siteLimitW || 0));
+                effectiveStrategy = "missing_site_limit_policy";
+                allocationResult = {
+                    allocations: allocations,
+                    clipped: false,
+                    unallocatedW: 0,
+                    availableCapacityW: capacityOf(activeList),
+                    minCapacityW: 0
+                };
+
+            } else {
+
+                const staleSet = new Set(staleList);
+                const freshActiveList = activeList.filter(function (inv) {
+                    return !staleSet.has(inv.id);
+                });
+                const staleOnlyList = activeList.filter(function (inv) {
+                    return staleSet.has(inv.id);
+                });
+
+                const staleForced = buildPolicyAllocations(
+                    staleOnlyList,
+                    node.staleTelemetryBehavior,
+                    node.staleTelemetryFixedValueW
+                );
+                const freshBudgetW = Math.max(0, Math.round(allocationBudgetW - staleForced.totalW));
+
+                effectiveStrategy = chooseEffectiveStrategy(node.strategy, freshActiveList, freshMap, []);
+                const freshResult = allocateIterative(freshBudgetW, freshActiveList, freshMap, effectiveStrategy);
+
+                const startupCapped = (function () {
+                    if (hasEmittedAllocation || freshActiveList.length === 0) {
+                        return { allocations: freshResult.allocations, capped: false };
+                    }
+
+                    const out = {};
+                    let capped = false;
+
+                    freshActiveList.forEach(function (inv) {
+                        const proposed = Math.max(0, Number(freshResult.allocations[inv.id] || 0));
+                        const t = telemetry[inv.id];
+                        const hasFreshCurrent = !!(t && Number.isFinite(t.powerW));
+
+                        if (!hasFreshCurrent) {
+                            out[inv.id] = proposed;
+                            return;
+                        }
+
+                        const currentPower = clamp(Number(t.powerW || 0), inv.minW, inv.maxW);
+                        const bounded = Math.min(proposed, currentPower);
+
+                        if (bounded < proposed) {
+                            capped = true;
+                        }
+
+                        out[inv.id] = bounded;
+                    });
+
+                    return { allocations: out, capped: capped };
+                })();
+
+                allocations = Object.assign({}, startupCapped.allocations, staleForced.allocations);
+
+                const allocatedTotalW = sumAllocations(allocations);
+                allocationResult = {
+                    allocations: allocations,
+                    clipped: freshResult.clipped || staleForced.totalW > allocationBudgetW,
+                    unallocatedW: Math.max(0, Math.round(allocationBudgetW - allocatedTotalW)),
+                    availableCapacityW: capacityOf(activeList),
+                    minCapacityW: 0
+                };
+
+                if (allocationResult.clipped) {
+                    reason = "site_limit_clipped";
+                } else if (startupCapped.capped && reason === "allocated") {
+                    reason = "startup_cap_current_power";
+                } else if (staleList.length > 0 && reason === "allocated") {
+                    reason = "stale_policy_applied";
+                }
+            }
+
+            if (!siteLimitValid && staleList.length > 0) {
+                const staleApplied = applyPolicyToStale(
+                    allocations,
+                    activeList,
+                    staleList,
+                    node.staleTelemetryBehavior,
+                    node.staleTelemetryFixedValueW
+                );
+                allocations = staleApplied.allocations;
+                if (staleApplied.changed && reason === "allocated") {
+                    reason = "stale_policy_applied";
+                }
+            }
+
+            // A site-limit command is already the output of the closed-loop controller.
+            // Apply it immediately so multi-inverter does not add another lag that can
+            // make control-export over-correct. Keep smoothing only for telemetry-driven
+            // redistribution between inverters.
+            const effectiveSmoothingAlpha = triggerSource === "site_limit"
+                ? 1
+                : node.allocationSmoothingAlpha;
+            const smoothedAllocations = smoothAllocations(allocations, effectiveSmoothingAlpha, lastSmoothedAllocation);
+            const controlMode = siteLimitMode === "reactive" ? "reactive" : "active";
+            const limitField = perInverterLimitFieldForMode(controlMode);
+            const signedMultiplier = controlMode === "reactive" && Number(siteLimitW) < 0 ? -1 : 1;
+
+            const limits = validRowList.map(function (inv) {
+                const t = telemetry[inv.id];
+                const currentPowerW = t && Number.isFinite(t.powerW) ? t.powerW : null;
+                const allocationPowerW = t && Number.isFinite(t.filteredPowerW) ? t.filteredPowerW : currentPowerW;
+                const isFreshPower = !!(t && Number.isFinite(t.powerW) && staleList.indexOf(inv.id) === -1);
+                const isDisabled = !inv.enabled;
+                let limitW = isDisabled
+                    ? 0
+                    : Math.round(Number(smoothedAllocations[inv.id] || 0));
+                const previousEmittedLimit = Number(lastEmittedLimitById[inv.id]);
+                const deadbandActive = node.allocationDeadbandW > 0 &&
+                    Number.isFinite(previousEmittedLimit) &&
+                    !isDisabled &&
+                    Math.abs(limitW - previousEmittedLimit) > 0 &&
+                    Math.abs(limitW - previousEmittedLimit) < node.allocationDeadbandW;
+
+                if (deadbandActive) {
+                    limitW = previousEmittedLimit;
+                }
+
+                const finalLimit = controlMode === "reactive"
+                    ? (signedMultiplier * Math.abs(limitW))
+                    : limitW;
+                const rampDirection = Number.isFinite(previousEmittedLimit)
+                    ? (limitW > previousEmittedLimit ? "up" : (limitW < previousEmittedLimit ? "down" : "hold"))
+                    : "hold";
+                const itemRamp = rampForDirection(ramp, rampDirection);
+                lastEmittedLimitById[inv.id] = limitW;
+
+                const item = {
+                    id: inv.id,
+                    enabled: !isDisabled,
+                    disabled: isDisabled,
+                    min_w: inv.minW,
+                    max_w: inv.maxW,
+                    nominal_power_w: inv.nominalPowerW,
+                    nominal_reactive_power_var: inv.nominalPowerW,
+                    current_power_w: currentPowerW,
+                    allocation_power_w: allocationPowerW,
+                    current_power_fresh: isFreshPower,
+                    allocation_deadband_applied: deadbandActive,
+                    ramp_direction: rampDirection
+                };
+                item[limitField] = finalLimit;
+                item.nominal_power_w = inv.nominalPowerW;
+                item.nominal_reactive_power_var = inv.nominalPowerW;
+                if (lastSiteLimitMsg && lastSiteLimitMsg.commandId) {
+                    item.command_id = lastSiteLimitMsg.commandId;
+                    item.command_requested_at_ms = lastSiteLimitMsg.commandRequestedAtMs;
+                    item.control_received_at_ms = lastSiteLimitMsg.controlReceivedAtMs;
+                    item.control_calculated_at_ms = lastSiteLimitMsg.controlCalculatedAtMs;
+                    item.allocated_at_ms = nowMs;
+                }
+
+                if (!isDisabled && itemRamp && itemRamp.type && itemRamp.type !== "none" && Number.isFinite(Number(itemRamp.value)) && Number(itemRamp.value) > 0) {
+                    item.ramp = { type: itemRamp.type, value: Number(itemRamp.value) };
+                }
+
+                return item;
+            });
+
+            outputs[0] = {
+                topic: "multi-inverter/limits",
+                payload: {
+                    limits: limits,
+                    site_limit_w: controlMode === "active" ? Math.round(siteLimitW) : null,
+                    site_limit_var: controlMode === "reactive" ? Math.round(siteLimitW) : null,
+                    control_mode: controlMode,
+                    allocation_strategy: node.strategy,
+                    effective_strategy: effectiveStrategy,
+                    telemetry_filter_alpha: node.telemetryFilterAlpha,
+                    allocation_smoothing_applied: effectiveSmoothingAlpha < 0.999,
+                    allocation_deadband_w: node.allocationDeadbandW,
+                    stale_inputs: staleList,
+                    fresh_power_map: freshMap,
+                    total_fresh_power_w: totalFreshPower(freshMap),
+                    available_capacity_w: allocationResult.availableCapacityW,
+                    unallocated_w: allocationResult.unallocatedW,
+                    clipped: allocationResult.clipped,
+                    active_inverters: activeList.map(function (a) { return a.id; }),
+                    ramp: (ramp && ramp.type && ramp.type !== "none") ? { type: ramp.type, value: Number(ramp.value || 0) } : null,
+                    timestamp_ms: nowMs
+                }
+            };
+            if (lastSiteLimitMsg && lastSiteLimitMsg.commandId) {
+                outputs[0].payload.command_id = lastSiteLimitMsg.commandId;
+                outputs[0].payload.command_requested_at_ms = lastSiteLimitMsg.commandRequestedAtMs;
+                outputs[0].payload.control_received_at_ms = lastSiteLimitMsg.controlReceivedAtMs;
+                outputs[0].payload.control_calculated_at_ms = lastSiteLimitMsg.controlCalculatedAtMs;
+                outputs[0].payload.allocated_at_ms = nowMs;
+            }
+            outputs[0].payload[siteLimitFieldForMode(controlMode)] = Math.round(siteLimitW);
+
+            statusFor(reason, staleList, activeList.length, configuredCount, siteLimitW);
+
+            const controllerInfo = lastSiteLimitMsg ? {
+                reason: lastSiteLimitMsg.reason || null,
+                stale: !!lastSiteLimitMsg.controllerStale,
+                errorW: lastSiteLimitMsg.controllerErrorW,
+                errorVar: lastSiteLimitMsg.controllerErrorVar,
+                timestampMs: lastSiteLimitMsg.controllerTimestampMs
+            } : null;
+
+            const signature = JSON.stringify({
+                reason: reason,
+                siteLimitW: Math.round(siteLimitW),
+                strategy: effectiveStrategy,
+                stale: staleList,
+                alloc: roundAllocations(smoothedAllocations),
+                ramp: ramp
+            });
+
+            const signatureChanged = signature !== lastDebugSignature || reason !== lastReason;
+            lastDebugSignature = signature;
+            lastReason = reason;
+
+            if (node.enableDebugOutput && shouldEmitDebug(node.debugMode, reason, signatureChanged)) {
+                outputs[outputs.length - 1] = debugMessage(
+                    reason,
+                    true,
+                    Math.round(siteLimitW),
+                    nowMs,
+                    activeList,
+                    staleList,
+                    freshMap,
+                    roundAllocations(smoothedAllocations),
+                    allocationResult,
+                    ramp,
+                    effectiveStrategy,
+                    controllerInfo,
+                    triggerSource,
+                    siteLimitMode
+                );
+            }
+
+            hasEmittedAllocation = true;
+            emit(outputs);
+
+        }
+
+
+        node.on("input", function (msg, send, done) {
+
+            lastSendFn = send;
+
+            try {
+                const topic = String(msg.topic || "").trim();
+                const ts = extractTimestampMs(msg);
+                const nowMs = Date.now();
+
+                const maybeSiteLimit = extractSiteLimitInfo(msg);
+
+                if (maybeSiteLimit) {
+                    const incomingMode = maybeSiteLimit.siteLimitMode === "reactive" ? "reactive" : "active";
+                    const incomingLimit = Number(maybeSiteLimit.siteLimit || 0);
+                    lastSiteLimitMode = incomingMode;
+                    lastSiteLimit = incomingMode === "reactive"
+                        ? incomingLimit
+                        : Math.max(0, incomingLimit);
+                    lastSiteLimitMsg = maybeSiteLimit;
+                    lastSiteLimitTs = Date.now();
+
+                    if (telemetryDebounceTimer) {
+                        clearTimeout(telemetryDebounceTimer);
+                        telemetryDebounceTimer = null;
+                    }
+
+                    runAllocationCycle("site_limit");
+                    done();
+                    return;
+                }
+
+                const activeList = activeInverters();
+                const payloadObj = (msg.payload && typeof msg.payload === "object") ? msg.payload : null;
+                const payloadPowerW = parseTelemetryPower(msg.payload, lastSiteLimitMode);
+                const telemetryLike = Number.isFinite(payloadPowerW);
+                const payloadInverterId = payloadObj
+                    ? String(payloadObj.inverter_id || payloadObj.id || "").trim()
+                    : "";
+                const msgInverterId = String(msg.inverter_id || msg.id || "").trim();
+                const resolvedInverterId = payloadInverterId || msgInverterId || topic;
+
+                if (telemetryLike && (ts - nowMs) > node.maxFutureTimestampMs) {
+                    emitFailsafeAllZero(
+                        "future_telemetry_timestamp",
+                        "Timestamp telemetrie din viitor peste limita admisa"
+                    );
+                    done();
+                    return;
+                }
+
+                if (telemetryLike && !resolvedInverterId) {
+                    emitFailsafeAllZero(
+                        "missing_inverter_id",
+                        "Mesaj de telemetrie fara inverter_id (payload/msg/topic)"
+                    );
+                    done();
+                    return;
+                }
+
+                if (
+                    telemetryLike &&
+                    payloadInverterId &&
+                    msgInverterId &&
+                    payloadInverterId !== msgInverterId
+                ) {
+                    emitFailsafeAllZero(
+                        "inverter_id_mismatch",
+                        "payload.inverter_id='" + payloadInverterId + "' difera de msg.inverter_id='" + msgInverterId + "'"
+                    );
+                    done();
+                    return;
+                }
+
+                if (
+                    telemetryLike &&
+                    topic &&
+                    resolvedInverterId &&
+                    topic !== resolvedInverterId
+                ) {
+                    emitFailsafeAllZero(
+                        "inverter_id_mismatch",
+                        "topic='" + topic + "' difera de inverter_id='" + resolvedInverterId + "'"
+                    );
+                    done();
+                    return;
+                }
+
+                const telemetryId = resolvedInverterId;
+                const knownIds = node.inverters
+                    .filter(function (inv) { return isValidInverter(inv); })
+                    .map(function (inv) { return inv.id; });
+
+                if (
+                    telemetryLike &&
+                    telemetryId &&
+                    knownIds.indexOf(telemetryId) === -1
+                ) {
+                    emitFailsafeAllZero(
+                        "unknown_inverter_id",
+                        "ID '" + telemetryId + "' nu exista in lista de invertoare configurata"
+                    );
+                    done();
+                    return;
+                }
+
+                if (telemetryLike && telemetryId && activeList.some(function (inv) { return inv.id === telemetryId; })) {
+                    const powerW = Number(payloadPowerW);
+                    const source = getTelemetrySource(msg);
+                    const prev = telemetry[telemetryId];
+
+                    if (prev && Number.isFinite(prev.ts) && ts < prev.ts) {
+                        node.status({ fill: "yellow", shape: "ring", text: "ignored older telemetry | " + telemetryId });
+                        done();
+                        return;
+                    }
+                    const potentialUnknownSourceConflict = !!(
+                        prev &&
+                        prev.source === "unknown" &&
+                        source === "unknown" &&
+                        Number.isFinite(prev.ts) &&
+                        Math.abs(Number(ts) - Number(prev.ts)) <= 250 &&
+                        Math.abs(Number(prev.powerW) - powerW) > 0.001
+                    );
+
+                    if (
+                        prev &&
+                        Number.isFinite(prev.powerW) &&
+                        Number.isFinite(powerW) &&
+                        (
+                            (prev.source && source && prev.source !== source) ||
+                            potentialUnknownSourceConflict
+                        ) &&
+                        Math.abs(Number(prev.powerW) - powerW) > 0.001
+                    ) {
+                        emitFailsafeAllZero(
+                            "duplicate_inverter_id_conflict",
+                            "ID '" + telemetryId + "' primit din surse diferite cu valori diferite (" + prev.powerW + " vs " + powerW + ")"
+                        );
+                        done();
+                        return;
+                    }
+
+                    const filteredPowerW = prev && Number.isFinite(prev.filteredPowerW)
+                        ? node.telemetryFilterAlpha * powerW + (1 - node.telemetryFilterAlpha) * prev.filteredPowerW
+                        : powerW;
+                    telemetry[telemetryId] = {
+                        powerW: powerW,
+                        filteredPowerW: filteredPowerW,
+                        ts: ts,
+                        source: source
+                    };
+                    publishTotalPv(Date.now());
+
+                    if (!node.recalculateOnTelemetry) {
+                        done();
+                        return;
+                    }
+
+                    if (node.telemetryRecalcDebounceMs <= 0) {
+                        runAllocationCycle("telemetry");
+                    } else {
+                        if (telemetryDebounceTimer) {
+                            clearTimeout(telemetryDebounceTimer);
+                        }
+
+                        telemetryDebounceTimer = setTimeout(function () {
+                            telemetryDebounceTimer = null;
+                            runAllocationCycle("telemetry");
+                        }, node.telemetryRecalcDebounceMs);
+                    }
+
+                    done();
+                    return;
+                }
+
+                done();
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: err.message });
+
+                const outputs = new Array(1 + (node.enableDebugOutput ? 1 : 0)).fill(null);
+
+                if (node.enableDebugOutput) {
+                    outputs[outputs.length - 1] = {
+                        topic: "multi-inverter/diagnostic",
+                        payload: {
+                            valid: false,
+                            reason: "runtime_error",
+                            error: err.message,
+                            timestamp_ms: Date.now(),
+                            debug_mode: node.debugMode,
+                            debug_enabled: node.enableDebugOutput
+                        }
+                    };
+
+                    emit(outputs);
+                }
+
+                done(err);
+            }
+
+        });
+
+        const watchdogIntervalMs = Math.max(
+            250,
+            Math.min(
+                node.telemetryTimeoutMs > 0 ? node.telemetryTimeoutMs : 1000,
+                node.siteLimitTimeoutMs > 0 ? node.siteLimitTimeoutMs : 1000,
+                1000
+            )
+        );
+        watchdogTimer = setInterval(function () {
+            if (hasEmittedAllocation || Number.isFinite(lastSiteLimit)) {
+                runAllocationCycle("watchdog");
+            }
+        }, watchdogIntervalMs);
+
+
+        node.on("close", function (done) {
+            if (telemetryDebounceTimer) {
+                clearTimeout(telemetryDebounceTimer);
+                telemetryDebounceTimer = null;
+            }
+            if (watchdogTimer) {
+                clearInterval(watchdogTimer);
+                watchdogTimer = null;
+            }
+            done();
+        });
+
+    
+        });
+    }
+
+
+    RED.nodes.registerType("multi-inverter", ControlNode);
+
+};