@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/control-export/control-export.js

@@ -0,0 +1,2192 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const {
+        atLeast,
+        clampNumber,
+        toFiniteNumber
+    } = require("../lib/numbers");
+    const {
+        createA3TestServer
+    } = require("../lib/a3-test-server");
+
+
+    function clamp(value, min, max) {
+
+        if (!Number.isFinite(value)) return min;
+
+        return Math.min(Math.max(value, min), max);
+
+    }
+
+
+    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 normalizeDebugLevel(value) {
+
+        const level = String(value || "").toLowerCase();
+
+        if (level === "normal" || level === "verbose") return level;
+
+        return "off";
+
+    }
+
+
+    function ControlExportNode(config) {
+
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+
+        node.name = config.name || "";
+
+        node.mode = config.mode || "zero_feed_in";
+        node.zeroFeedInMode = config.zeroFeedInMode === "absolute" ? "absolute" : "relative";
+        node.requireAllPhases = config.requireAllPhases !== false;
+        node.tuningPreset = (function (value) {
+            const key = String(value || "").toLowerCase();
+            if (key === "custom" || key === "stable_grid") return key;
+            return "normal";
+        })(config.tuningPreset);
+
+        const configuredGridSetPoint = toFiniteNumber(config.gridSetPoint, 0);
+        node.gridSetPoint = configuredGridSetPoint;
+
+        node.nominalPower = toFiniteNumber(config.nominalPower, 1000);
+        node.nominalPowerFromGlobal = !!config.nominalPowerFromGlobal;
+        node.nominalPowerGlobalVar = String(config.nominalPowerGlobalVar || "nominal_power").trim() || "nominal_power";
+
+        node.signConvention = (config.signConvention === "positive_export" || config.signConvention === "positive_import")
+            ? config.signConvention
+            : "positive_import";
+
+        node.deadband = atLeast(config.deadband, 0, 180);
+
+        node.minLimit = toFiniteNumber(config.minLimit, 0);
+
+        node.configuredMaxLimit = toFiniteNumber(config.maxLimit, 1000);
+        node.maxLimitFromGlobal = !!config.maxLimitFromGlobal;
+        node.maxLimitGlobalVar = String(config.maxLimitGlobalVar || "max_limit").trim() || "max_limit";
+        node.maxLimit = node.configuredMaxLimit;
+
+        node.outputTopic = config.outputTopic || "site-limit";
+
+        node.smoothingAlpha = clampNumber(config.smoothingAlpha, 0, 1, 0.15);
+
+        node.filterTauMs = atLeast(config.filterTauMs, 0, 2800);
+
+        node.kp = atLeast(config.kp, 0, 0.22);
+
+        node.ki = atLeast(config.ki, 0, 0.01);
+
+        node.controlPeriodMs = atLeast(config.controlPeriodMs, 50, 800);
+        node.exportThresholdW = atLeast(config.exportThresholdW, 0, 60);
+
+        node.recoverThresholdW = atLeast(config.recoverThresholdW, 0, 25);
+
+        node.recoveryDelayMs = atLeast(config.recoveryDelayMs, 0, 3000);
+        node.transientIgnoreMs = atLeast(config.transientIgnoreMs, 0, 1200);
+        node.maxStepUpW = atLeast(config.maxStepUpW, 0, 500);
+        node.maxStepDownW = atLeast(config.maxStepDownW, 0, 1500);
+        node.adaptiveGains = config.adaptiveGains !== false;
+        node.adaptiveErrorBandW = atLeast(config.adaptiveErrorBandW, 1, 4000);
+        node.adaptiveMinScale = clampNumber(config.adaptiveMinScale, 0.05, 1, 0.2);
+
+        if (node.tuningPreset === "stable_grid") {
+            node.deadband = 150;
+            node.filterTauMs = 1500;
+            node.kp = 0.24;
+            node.ki = 0.008;
+            node.controlPeriodMs = 1000;
+            node.exportThresholdW = 100;
+            node.recoverThresholdW = 40;
+            node.recoveryDelayMs = 2000;
+            node.transientIgnoreMs = 800;
+            node.maxStepUpW = 1000;
+            node.maxStepDownW = 1800;
+            node.adaptiveGains = true;
+            node.adaptiveErrorBandW = 5000;
+            node.adaptiveMinScale = 0.45;
+        }
+
+        node.maxStepW = atLeast(config.maxStepW, 0, 0); // compatibilitate
+
+        node.staleTimeoutMs = atLeast(config.staleTimeoutMs, 0, 5000);
+        node.maxFutureTimestampMs = atLeast(config.maxFutureTimestampMs, 0, 2000);
+        node.fastSetpointMaxTelemetryAgeMs = atLeast(config.fastSetpointMaxTelemetryAgeMs, 50, 600);
+        node.outputHeartbeatMs = clampNumber(config.outputHeartbeatMs, 250, 3500, 2000);
+        node.debugLevel = normalizeDebugLevel(config.debugLevel);
+        node.failSecureEnabled = !!config.failSecureEnabled;
+        node.failSecureTimeSec = atLeast(config.failSecureTimeSec, 1, 10);
+        node.a3TestsEnabled = !!config.a3TestsEnabled;
+        node.a3ModbusHost = String(config.a3ModbusHost || "0.0.0.0").trim() || "0.0.0.0";
+        node.a3ModbusPort = atLeast(config.a3ModbusPort, 1, 1502);
+        node.a3ModbusUnitId = atLeast(config.a3ModbusUnitId, 0, 1);
+        node.a3RampType = String(config.a3RampType || "none").trim() || "none";
+        node.a3RampValue = atLeast(config.a3RampValue, 0, 0);
+
+        if (node.a3TestsEnabled) {
+            node.mode = "nominal_power";
+            node.nominalPowerFromGlobal = false;
+        }
+
+        if (node.maxLimit < node.minLimit) {
+
+            const swap = node.maxLimit;
+
+            node.maxLimit = node.minLimit;
+
+            node.minLimit = swap;
+
+        }
+
+        node.configuredMaxLimit = node.maxLimit;
+
+        node.recoverThresholdW = Math.min(node.recoverThresholdW, node.exportThresholdW);
+
+        node.safeLimitOnStale = toFiniteNumber(config.safeLimitOnStale, 0);
+        node.startLimitMode = (function(v) {
+            const m = String(v || "").toLowerCase();
+            if (m === "min_limit") return m;
+            return "last_limit";
+        })(config.startLimitMode);
+        node.useGlobalPvCap = !!config.useGlobalPvCap;
+        node.globalPvTotalVar = String(config.globalPvTotalVar || "total_pv").trim() || "total_pv";
+        node.globalPvCapOffsetW = atLeast(config.globalPvCapOffsetW, 0, 500);
+        node.pvCapOnlyBlocksIncrease = config.pvCapOnlyBlocksIncrease !== false;
+        node.pvCapHoldMs = atLeast(config.pvCapHoldMs, 0, 10000);
+        node.pvCapReleaseWPerSec = atLeast(config.pvCapReleaseWPerSec, 0, 1000);
+        node.feedForwardEnabled = config.feedForwardEnabled !== false;
+        node.feedForwardGain = clampNumber(config.feedForwardGain, 0, 1.5, 0.85);
+
+
+        let lastLimit = null;
+
+        let filteredGridReference = null;
+
+        let lastMeasurementTs = null;
+        let lastFilterWallClockMs = null;
+        let lastFilterSourceKey = null;
+        let gridMedianSamples = [];
+
+        let lastControlTs = 0;
+
+        let lastExportDetectedTs = 0;
+
+        let lastImmediateReductionTs = 0;
+
+        let lastRawGridReference = null;
+
+        let lastMsgTimestampMs = null;
+
+        let integratorState = 0;
+        let failSecureBreachStartMs = null;
+        let failSecureActive = false;
+        let lastFailSecureOutputActive = false;
+        let outsideDeadbandSinceMs = null;
+        let lastCriticalPhase = null;
+        let watchdogTimer = null;
+        let a3Server = null;
+        let lastInputAtMs = node.staleTimeoutMs > 0 && node.mode !== "nominal_power" ? Date.now() : null;
+        let lastAcceptedMeasurementTs = null;
+        let lastPersistedLimit = null;
+        let lastPersistedAtMs = 0;
+        let lastOutputAtMs = 0;
+        let lastOutputLimit = null;
+        let lastOutputStale = null;
+        let lastWatchdogSafeAtMs = 0;
+        const pvTelemetryBySource = new Map();
+        let pvAvailableEstimateW = null;
+        let pvEstimateHoldUntilMs = 0;
+        let lastPvEstimateUpdateMs = 0;
+        const nodeCtx = node.context();
+        const globalCtx = node.context().global;
+        const persistedLastLimitKey = "control_export_last_limit_w__" + String(node.id || "node");
+        const persistedGridSetpointKey = "control_export_grid_setpoint_w";
+        const persistedGridSetpointBaseKey = "control_export_grid_setpoint_base_w";
+
+        (function initializeRuntimeGridSetpoint() {
+            if (node.mode !== "grid_set_point") return;
+            const persisted = Number(nodeCtx.get(persistedGridSetpointKey));
+            const persistedBase = Number(nodeCtx.get(persistedGridSetpointBaseKey));
+            if (Number.isFinite(persisted) && Number.isFinite(persistedBase) && persistedBase === configuredGridSetPoint) {
+                node.gridSetPoint = persisted;
+            } else {
+                node.gridSetPoint = configuredGridSetPoint;
+                nodeCtx.set(persistedGridSetpointKey, node.gridSetPoint);
+            }
+            nodeCtx.set(persistedGridSetpointBaseKey, configuredGridSetPoint);
+        })();
+
+        function refreshMaxLimitFromGlobal() {
+            let maxLimit = node.configuredMaxLimit;
+            if (node.maxLimitFromGlobal) {
+                const raw = globalCtx.get(node.maxLimitGlobalVar);
+                const value = Number(raw);
+                if (Number.isFinite(value)) maxLimit = value;
+            }
+            node.maxLimit = Math.max(node.minLimit, maxLimit);
+            return node.maxLimit;
+        }
+
+        function validateRequiredGlobalValues() {
+            const requirements = [];
+            if (node.nominalPowerFromGlobal) requirements.push([node.nominalPowerGlobalVar, "Nominal Power"]);
+            if (node.maxLimitFromGlobal) requirements.push([node.maxLimitGlobalVar, "Max Limit"]);
+
+            for (const requirement of requirements) {
+                const key = String(requirement[0] || "").trim();
+                const raw = key ? globalCtx.get(key) : undefined;
+                if (raw === undefined || raw === null || raw === "" || !Number.isFinite(Number(raw))) {
+                    node.status({ fill: "red", shape: "ring", text: "ALARM: global " + requirement[1] + " missing (" + key + ")" });
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        function controlBands() {
+            const deadband = Math.max(0, Number(node.deadband) || 0);
+            return {
+                exportW: Math.min(deadband, Math.max(0, Number(node.exportThresholdW) || 0)),
+                importW: Math.min(deadband, Math.max(0, Number(node.recoverThresholdW) || 0))
+            };
+        }
+
+        if (!validateRequiredGlobalValues()) {
+            node.warn("control-export blocked: required global value is missing or invalid");
+        }
+
+        function getPersistedLastLimit() {
+            const localValue = Number(nodeCtx.get("control_export_last_limit_w"));
+            if (Number.isFinite(localValue)) {
+                return clamp(localValue, node.minLimit, node.maxLimit);
+            }
+
+            const globalValue = Number(globalCtx.get(persistedLastLimitKey));
+            if (Number.isFinite(globalValue)) {
+                return clamp(globalValue, node.minLimit, node.maxLimit);
+            }
+
+            return null;
+        }
+
+        function persistLastLimit(value, options) {
+            if (!Number.isFinite(value)) return;
+            const clamped = clamp(Number(value), node.minLimit, node.maxLimit);
+            const opts = options || {};
+            const nowMs = Number.isFinite(opts.nowMs) ? opts.nowMs : Date.now();
+            const force = opts.force === true;
+            if (!force && Number.isFinite(lastPersistedLimit)) {
+                const changedEnough = Math.abs(clamped - lastPersistedLimit) >= 1;
+                const elapsedEnough = (nowMs - lastPersistedAtMs) >= 5000;
+                if (!changedEnough && !elapsedEnough) return;
+            }
+            nodeCtx.set("control_export_last_limit_w", clamped);
+            globalCtx.set(persistedLastLimitKey, clamped);
+            lastPersistedLimit = clamped;
+            lastPersistedAtMs = nowMs;
+        }
+
+        (function initializeStartLimit() {
+            if (node.startLimitMode === "last_limit") {
+                const persisted = getPersistedLastLimit();
+                if (Number.isFinite(persisted)) {
+                    lastLimit = persisted;
+                    return;
+                }
+            }
+
+            lastLimit = clamp(node.minLimit, node.minLimit, node.maxLimit);
+        })();
+
+
+        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 hasExplicitGridReference(payload) {
+            if (!payload || typeof payload !== "object") return false;
+
+            return (
+                payload.grid_reference_w !== undefined ||
+                payload.pcc_power !== undefined ||
+                payload.pcc_power_w !== undefined ||
+                payload.grid_power !== undefined ||
+                payload.grid_power_w !== undefined ||
+                (payload.summary && payload.summary.power && payload.summary.power.total_w !== undefined) ||
+                (payload.summary && payload.summary.meter && payload.summary.meter.power_w !== undefined)
+            );
+        }
+
+        function isControlCommandMessage(msg) {
+            const payload = msg && msg.payload;
+            const topic = String(msg && msg.topic || "").trim().toLowerCase();
+
+            if (topic === String(node.outputTopic || "").trim().toLowerCase()) return true;
+            if (topic === "site-limit" || topic === "control-export") return true;
+            if (topic.indexOf("control-export/") === 0) return true;
+
+            if (!payload || typeof payload !== "object") return false;
+
+            return (
+                payload.site_limit_w !== undefined ||
+                payload.limit_w !== undefined ||
+                payload.grid_target_w !== undefined ||
+                payload.controller_state !== undefined ||
+                payload.control_active !== undefined
+            );
+        }
+
+        function topicLooksLikeInverterTelemetry(topic) {
+            const t = String(topic || "").trim().toLowerCase();
+            if (!t) return false;
+
+            if (
+                t.indexOf("meter") >= 0 ||
+                t.indexOf("grid") >= 0 ||
+                t.indexOf("pcc") >= 0 ||
+                t.indexOf("carlo") >= 0 ||
+                t.indexOf("gavazzi") >= 0
+            ) {
+                return false;
+            }
+
+            return (
+                /^inv(\b|[_-]?\d+)/.test(t) ||
+                t.indexOf("inverter") >= 0 ||
+                t.indexOf("fronius") >= 0 ||
+                t.indexOf("pv") >= 0
+            );
+        }
+
+        function isInverterTelemetryWithoutGridReference(msg) {
+            const payload = msg && msg.payload;
+            if (!payload || typeof payload !== "object") return false;
+            if (hasExplicitGridReference(payload)) return false;
+
+            const deviceType = String(
+                payload.device_type ||
+                msg.device_type ||
+                ""
+            ).toLowerCase();
+            const payloadField = String(
+                payload.payload_field ||
+                msg.payload_field ||
+                ""
+            ).toLowerCase();
+
+            if (
+                payload.meter_id ||
+                msg.meter_id ||
+                deviceType.indexOf("meter") >= 0 ||
+                payloadField.indexOf("meter") >= 0 ||
+                payloadField.indexOf("grid") >= 0 ||
+                payloadField.indexOf("pcc") >= 0
+            ) {
+                return false;
+            }
+
+            if (deviceType.indexOf("inverter") >= 0 || deviceType.indexOf("pv") >= 0) {
+                return true;
+            }
+
+            if (topicLooksLikeInverterTelemetry(msg && msg.topic)) {
+                return true;
+            }
+
+            return !!(
+                payload.inverter_id ||
+                payload.inverter_type ||
+                payload.inverter_profile ||
+                msg.inverter_id ||
+                msg.inverter_type ||
+                msg.inverter_profile
+            );
+        }
+
+        function extractGridReference(msg) {
+
+            const p = msg.payload;
+
+
+            if (typeof p === "number") return p;
+
+
+            if (typeof p === "string" && p.trim() !== "" && Number.isFinite(Number(p))) {
+
+                return Number(p);
+
+            }
+
+
+            if (p && typeof p === "object") {
+                if (isInverterTelemetryWithoutGridReference(msg)) return null;
+
+                const candidate = firstFinite(
+
+                    p.grid_reference_w,
+
+                    p.pcc_power,
+
+                    p.pcc_power_w,
+
+                    p.grid_power,
+
+                    p.grid_power_w,
+
+                    p.summary && p.summary.meter && p.summary.meter.power_w,
+
+                    p.summary && p.summary.power && p.summary.power.total_w,
+
+                    p.power_w,
+
+                    p.power,
+
+                    p.value
+
+                );
+
+                if (candidate !== null) return candidate;
+
+            }
+
+
+            return null;
+
+        }
+
+
+        function extractWorstPhaseReference(msg) {
+
+            const payload = msg && msg.payload;
+
+            if (!payload || typeof payload !== "object") {
+                return null;
+            }
+
+            const phaseValues = [
+                {
+                    name: "L1",
+                    value: firstFinite(
+                    payload.power_l1_w,
+                    payload.l1_power_w,
+                    payload.l1_w,
+                    payload.summary && payload.summary.power && payload.summary.power.l1_w
+                    )
+                },
+                {
+                    name: "L2",
+                    value: firstFinite(
+                    payload.power_l2_w,
+                    payload.l2_power_w,
+                    payload.l2_w,
+                    payload.summary && payload.summary.power && payload.summary.power.l2_w
+                    )
+                },
+                {
+                    name: "L3",
+                    value: firstFinite(
+                    payload.power_l3_w,
+                    payload.l3_power_w,
+                    payload.l3_w,
+                    payload.summary && payload.summary.power && payload.summary.power.l3_w
+                    )
+                }
+            ];
+
+            const validPhaseValues = phaseValues.filter(function (phase) {
+                return Number.isFinite(phase.value);
+            });
+
+            if (node.requireAllPhases && validPhaseValues.length !== 3) {
+                return null;
+            }
+
+            if (!validPhaseValues.length) {
+                return null;
+            }
+
+            const worst = validPhaseValues.reduce(function (best, phase) {
+                const normalized = normalizeGridReference(phase.value);
+                if (!best) {
+                    return {
+                        name: phase.name,
+                        raw: phase.value,
+                        normalized: normalized
+                    };
+                }
+
+                // In normalized convention, larger values mean stronger export.
+                // Pick the phase with the highest export pressure so zero-feed-in
+                // protects all phases, not only the one closest to 0.
+                if (normalized > best.normalized) {
+                    return {
+                        name: phase.name,
+                        raw: phase.value,
+                        normalized: normalized
+                    };
+                }
+
+                return best;
+            }, null);
+
+            lastCriticalPhase = worst ? worst.name : null;
+            return worst ? worst.raw : null;
+
+        }
+
+
+        function extractControlReference(msg) {
+
+            if (node.mode !== "zero_feed_in") {
+                return extractGridReference(msg);
+            }
+
+            if (node.zeroFeedInMode === "absolute") {
+                return extractWorstPhaseReference(msg);
+            }
+
+            if (isInverterTelemetryWithoutGridReference(msg)) {
+                return null;
+            }
+            lastCriticalPhase = null;
+            return extractGridReference(msg);
+
+        }
+
+
+        function normalizeByConvention(rawValue) {
+
+            if (node.signConvention === "positive_import") return -rawValue;
+
+            return rawValue;
+
+        }
+
+
+        function denormalizeByConvention(normalizedValue) {
+
+            if (node.signConvention === "positive_import") return -normalizedValue;
+
+            return normalizedValue;
+
+        }
+
+
+        function normalizeGridReference(rawValue) {
+
+            return normalizeByConvention(rawValue);
+
+        }
+
+
+        function isStale(timestampMs, nowMs) {
+
+            if (node.staleTimeoutMs <= 0) return false;
+
+            if (!Number.isFinite(timestampMs)) return true;
+
+            return (nowMs - timestampMs) > node.staleTimeoutMs;
+
+        }
+
+
+        function updateFilter(gridReference, measurementTsMs, nowMs, sourceKey) {
+
+            if (!Number.isFinite(gridReference)) return filteredGridReference;
+
+            const effectiveSourceKey = String(sourceKey || "total");
+            if (lastFilterSourceKey !== effectiveSourceKey) {
+                gridMedianSamples = [];
+            }
+            gridMedianSamples.push(gridReference);
+            if (gridMedianSamples.length > 3) gridMedianSamples.shift();
+            const filterInput = gridMedianSamples.length < 3
+                ? gridReference
+                : gridMedianSamples.slice().sort(function (a, b) { return a - b; })[1];
+
+            if (
+                filteredGridReference === null ||
+                !Number.isFinite(lastMeasurementTs) ||
+                (lastFilterSourceKey !== null && lastFilterSourceKey !== effectiveSourceKey)
+            ) {
+
+                filteredGridReference = filterInput;
+
+                lastMeasurementTs = measurementTsMs;
+                lastFilterWallClockMs = nowMs;
+                lastFilterSourceKey = effectiveSourceKey;
+
+                return filteredGridReference;
+
+            }
+
+
+            if (node.filterTauMs > 0) {
+
+                const sourceDtMs = measurementTsMs - lastMeasurementTs;
+                const arrivalDtMs = Number.isFinite(lastFilterWallClockMs) ? nowMs - lastFilterWallClockMs : NaN;
+                const dtMs = sourceDtMs > 0
+                    ? sourceDtMs
+                    : (arrivalDtMs > 0 ? arrivalDtMs : 1);
+
+                const alpha = clamp(dtMs / (node.filterTauMs + dtMs), 0, 1);
+
+                filteredGridReference = alpha * filterInput + (1 - alpha) * filteredGridReference;
+
+            } else {
+
+                filteredGridReference =
+
+                    node.smoothingAlpha * filterInput +
+
+                    (1 - node.smoothingAlpha) * filteredGridReference;
+
+            }
+
+
+            lastMeasurementTs = measurementTsMs;
+            lastFilterWallClockMs = nowMs;
+            lastFilterSourceKey = effectiveSourceKey;
+
+            return filteredGridReference;
+
+        }
+
+
+        function getGridTarget() {
+
+            const rawTarget = node.mode === "zero_feed_in" ? 0 : node.gridSetPoint;
+
+            return normalizeByConvention(rawTarget);
+
+        }
+
+        function extractFastSetpointCommand(msg, nowMs) {
+            const topic = String(msg && msg.topic || "").trim().toLowerCase();
+            const payload = msg && msg.payload;
+            if (topic !== "control-export/setpoint" || !payload || typeof payload !== "object") return null;
+
+            const value = Number(payload.grid_set_point_w);
+            if (!Number.isFinite(value)) {
+                throw new Error("grid_set_point_w trebuie sa fie numeric");
+            }
+
+            const requestedAtMs = extractTimestampMs(msg);
+            if ((requestedAtMs - nowMs) > node.maxFutureTimestampMs) {
+                throw new Error("Timestamp setpoint din viitor peste limita admisa");
+            }
+            if ((nowMs - requestedAtMs) > node.fastSetpointMaxTelemetryAgeMs) {
+                throw new Error("Comanda grid setpoint este expirata");
+            }
+
+            return {
+                value: value,
+                commandId: String(payload.command_id || msg.command_id || ("setpoint-" + nowMs)),
+                requestedAtMs: requestedAtMs,
+                receivedAtMs: nowMs
+            };
+        }
+
+
+        function integratorBounds() {
+
+            const span = Math.max(0, node.maxLimit - node.minLimit);
+
+            return {
+
+                min: -span,
+
+                max: span
+
+            };
+
+        }
+
+        function effectiveGains(errorAbs) {
+            if (!node.adaptiveGains) {
+                return { kp: node.kp, ki: node.ki, scale: 1 };
+            }
+
+            const progress = clamp(Number(errorAbs || 0) / node.adaptiveErrorBandW, 0, 1);
+            const scale = node.adaptiveMinScale + (1 - node.adaptiveMinScale) * progress;
+            return {
+                kp: node.kp * scale,
+                ki: node.ki * scale,
+                scale: scale
+            };
+        }
+
+
+        function canIncreaseLimit(nowMs, filteredReference, target) {
+
+            if (!Number.isFinite(filteredReference)) return true;
+
+            if (filteredReference > (target + controlBands().exportW)) return false;
+
+            return (nowMs - lastExportDetectedTs) >= node.recoveryDelayMs;
+
+        }
+
+        function canReduceImmediately(nowMs, protectiveReference, target, controlDue) {
+
+            if (controlDue) return false;
+
+            if (!Number.isFinite(protectiveReference) || !Number.isFinite(target)) return false;
+
+            const overshootW = protectiveReference - target;
+
+            const requiredOvershootW = controlBands().exportW;
+
+            if (overshootW <= requiredOvershootW) return false;
+
+            if (lastImmediateReductionTs <= 0) return true;
+
+            const cooldownMs = Math.max(
+                Number(node.transientIgnoreMs) || 0,
+                Number(node.controlPeriodMs) || 0,
+                800
+            );
+
+            return (nowMs - lastImmediateReductionTs) >= cooldownMs;
+
+        }
+
+        function computeClosedLoopLimit(filteredReference, nowMs, dtMs, protectiveMode, pvTotalW) {
+
+            const target = getGridTarget();
+
+            const error = filteredReference - target;
+            const bands = controlBands();
+
+            const previousLimit = Number.isFinite(lastLimit)
+
+                ? lastLimit
+
+                : clamp(node.maxLimit, node.minLimit, node.maxLimit);
+
+
+            const exportDetected = error > bands.exportW;
+
+            if (exportDetected) {
+
+                lastExportDetectedTs = nowMs;
+
+            }
+
+            let candidateLimit = previousLimit;
+            let reason = "deadband";
+            let recoveryBlocked = false;
+            let pTerm = 0;
+            let stepLimited = false;
+            let gains = effectiveGains(Math.abs(error));
+            let effectiveKi = gains.ki;
+            let candidateIntegrator = integratorState;
+            let feedForwardTargetW = null;
+            let feedForwardDeltaW = 0;
+            if (node.feedForwardEnabled && Number.isFinite(pvTotalW)) {
+                feedForwardTargetW = clamp(
+                    Math.max(0, Number(pvTotalW)) - node.feedForwardGain * error,
+                    node.minLimit,
+                    node.maxLimit
+                );
+                feedForwardDeltaW = feedForwardTargetW - previousLimit;
+            }
+            const boundedDtMs = Math.min(
+                Math.max(1, Number(dtMs) || node.controlPeriodMs),
+                Math.max(node.controlPeriodMs * 4, 1000)
+            );
+            const dtSeconds = boundedDtMs / 1000;
+            const insideBand = error <= bands.exportW && error >= -bands.importW;
+
+            if (insideBand && Number.isFinite(lastLimit)) {
+                outsideDeadbandSinceMs = null;
+                integratorState = 0;
+
+                return {
+
+                    siteLimit: previousLimit,
+                    previousLimit: previousLimit,
+
+                    gridTarget: target,
+
+                    correction: 0,
+
+                    error: error,
+
+                    pTerm: 0,
+
+                    iTerm: integratorState,
+
+                    active: false,
+
+                    exportDetected: exportDetected,
+
+                    rampDirection: "hold",
+
+                    reason: "deadband",
+
+                    controllerState: "inside_deadband",
+                    gainsScale: gains.scale,
+                    effectiveKp: gains.kp,
+                    effectiveKi: gains.ki,
+                    feedForwardTargetW: feedForwardTargetW,
+                    feedForwardDeltaW: feedForwardDeltaW,
+
+                    recoveryBlocked: false,
+
+                    clampedByMin: false,
+
+                    clampedByMax: false
+
+                };
+
+            }
+
+            if (!Number.isFinite(outsideDeadbandSinceMs)) {
+                outsideDeadbandSinceMs = nowMs;
+            }
+
+            const outsideDurationMs = Math.max(0, nowMs - outsideDeadbandSinceMs);
+            const transientBlocked = error < -bands.importW && outsideDurationMs < node.transientIgnoreMs;
+
+            if (exportDetected) {
+                pTerm = gains.kp * error;
+                const bounds = integratorBounds();
+                candidateIntegrator = clamp(
+                    integratorState + gains.ki * error * dtSeconds,
+                    bounds.min,
+                    bounds.max
+                );
+                let correctionW = Math.max(0, pTerm + candidateIntegrator);
+                if (Number.isFinite(feedForwardTargetW)) {
+                    correctionW = Math.max(correctionW, previousLimit - feedForwardTargetW);
+                }
+                if (protectiveMode) {
+                    correctionW = Math.max(correctionW, error - bands.exportW);
+                }
+                candidateLimit = previousLimit - correctionW;
+                reason = "export_limit";
+            } else if (error < -bands.importW) {
+                if (!canIncreaseLimit(nowMs, filteredReference, target)) {
+                    candidateLimit = previousLimit;
+                    reason = "recovery_hold";
+                    recoveryBlocked = true;
+                    effectiveKi = 0;
+                } else if (transientBlocked) {
+                    candidateLimit = previousLimit;
+                    reason = "transient_ignore";
+                    recoveryBlocked = true;
+                    effectiveKi = 0;
+                } else {
+                    const bounds = integratorBounds();
+                    pTerm = gains.kp * error;
+                    candidateIntegrator = clamp(
+                        integratorState + gains.ki * error * dtSeconds,
+                        bounds.min,
+                        bounds.max
+                    );
+                    const marginW = Math.max(0, target - filteredReference);
+                    const requestedIncreaseW = Math.max(
+                        0,
+                        -(pTerm + candidateIntegrator),
+                        Number.isFinite(feedForwardTargetW) ? feedForwardTargetW - previousLimit : 0
+                    );
+                    const stepUpW = Math.min(
+                        marginW,
+                        node.maxStepUpW > 0 ? node.maxStepUpW : Infinity,
+                        requestedIncreaseW
+                    );
+                    candidateLimit = previousLimit + stepUpW;
+                    reason = "recovery";
+                }
+            } else {
+                candidateLimit = previousLimit;
+                reason = "deadband";
+            }
+
+            const maxStepUp = node.maxStepUpW > 0 ? node.maxStepUpW : Infinity;
+            const maxStepDown = node.maxStepDownW > 0 ? node.maxStepDownW : Infinity;
+            const rawDelta = candidateLimit - previousLimit;
+
+            if (rawDelta > maxStepUp) {
+                candidateLimit = previousLimit + maxStepUp;
+                stepLimited = true;
+            } else if (rawDelta < -maxStepDown) {
+                candidateLimit = previousLimit - maxStepDown;
+                stepLimited = true;
+            }
+
+
+            const unclampedCandidate = candidateLimit;
+
+            candidateLimit = clamp(candidateLimit, node.minLimit, node.maxLimit);
+
+            const clampedByMin = candidateLimit <= node.minLimit && unclampedCandidate < node.minLimit;
+
+            const clampedByMax = candidateLimit >= node.maxLimit && unclampedCandidate > node.maxLimit;
+
+            const constrainedInControlDirection =
+                (error > bands.exportW && candidateLimit > unclampedCandidate) ||
+                (error < -bands.importW && candidateLimit < unclampedCandidate) ||
+                stepLimited || recoveryBlocked;
+            if (!constrainedInControlDirection) {
+                integratorState = candidateIntegrator;
+            }
+
+
+            const rampDirection = candidateLimit > previousLimit
+
+                ? "up"
+
+                : candidateLimit < previousLimit
+
+                    ? "down"
+
+                    : "hold";
+
+
+            let controllerState = "tracking";
+
+            if (clampedByMin && error > bands.exportW) controllerState = "target_unreachable_at_min";
+
+            else if (clampedByMax && error < -bands.importW) controllerState = "target_unreachable_at_max";
+
+            else if (recoveryBlocked) controllerState = reason === "transient_ignore" ? "transient_ignore" : "recovery_blocked";
+
+            else if (clampedByMin) controllerState = "at_min_limit";
+
+            else if (clampedByMax) controllerState = "at_max_limit";
+
+            else if (rampDirection === "up") controllerState = "increasing_limit";
+
+            else if (rampDirection === "down") controllerState = "decreasing_limit";
+            else if (reason === "deadband") controllerState = "inside_deadband";
+            if (stepLimited && controllerState === "tracking") controllerState = "step_limited";
+
+
+            return {
+
+                siteLimit: candidateLimit,
+                previousLimit: previousLimit,
+
+                gridTarget: target,
+
+                correction: previousLimit - candidateLimit,
+
+                error: error,
+
+                pTerm: pTerm,
+
+                iTerm: integratorState,
+
+                active: rampDirection !== "hold",
+
+                exportDetected: exportDetected,
+
+                rampDirection: rampDirection,
+
+                reason: reason,
+
+                controllerState: controllerState,
+                gainsScale: gains.scale,
+                effectiveKp: gains.kp,
+                effectiveKi: effectiveKi,
+                feedForwardTargetW: feedForwardTargetW,
+                feedForwardDeltaW: feedForwardDeltaW,
+
+                recoveryBlocked: recoveryBlocked,
+
+                clampedByMin: clampedByMin,
+
+                clampedByMax: clampedByMax
+
+            };
+
+        }
+
+        function buildStatus(info) {
+
+            if (info.reason === "stale") {
+
+                node.status({ fill: "yellow", shape: "ring", text: "stale | limit " + Math.round(info.siteLimit) + "W" });
+
+                return;
+
+            }
+
+
+            if (info.mode === "nominal_power") {
+
+                node.status({ fill: "blue", shape: "dot", text: "nominal | limit " + Math.round(info.siteLimit) + "W" });
+
+                return;
+
+            }
+
+
+            const gridNow = Number.isFinite(info.gridReference) ? Math.round(denormalizeByConvention(info.gridReference)) : 0;
+
+            const target = Number.isFinite(info.gridTarget) ? Math.round(denormalizeByConvention(info.gridTarget)) : 0;
+
+            const limit = Math.round(info.siteLimit);
+
+            const state = info.controllerState || info.reason || "idle";
+            const text = "grid " + gridNow + "W | target " + target + "W | limit " + limit + "W | " + state;
+
+
+            if (info.active) {
+
+                node.status({
+
+                    fill: "green",
+
+                    shape: "dot",
+
+                    text: text
+
+                });
+
+                return;
+
+            }
+
+
+            node.status({
+
+                fill: "blue",
+
+                shape: "ring",
+
+                text: text
+
+            });
+
+        }
+
+
+        function buildOutputPayload(context) {
+
+            const gridReferenceOut = Number.isFinite(context.gridReference)
+                ? denormalizeByConvention(context.gridReference)
+                : context.gridReference;
+            const filteredReferenceOut = Number.isFinite(context.filteredReference)
+                ? denormalizeByConvention(context.filteredReference)
+                : context.filteredReference;
+            const gridTargetOut = Number.isFinite(context.gridTarget)
+                ? denormalizeByConvention(context.gridTarget)
+                : context.gridTarget;
+            const basePayload = {
+                site_limit_w: context.siteLimit,
+                grid_reference_w: filteredReferenceOut,
+                grid_target_w: gridTargetOut,
+                reason: context.reason,
+                controller_state: context.controllerState,
+                stale: context.stale,
+                pv_total_w: Number.isFinite(context.pvTotalW) ? Math.round(context.pvTotalW) : null,
+                pv_cap_limit_w: Number.isFinite(context.pvCapLimitW) ? Math.round(context.pvCapLimitW) : null,
+                pv_cap_offset_w: Number.isFinite(context.pvCapOffsetW) ? Math.round(context.pvCapOffsetW) : null,
+                pv_cap_applied: !!context.pvCapApplied,
+                pv_available_estimate_w: Number.isFinite(context.pvAvailableEstimateW) ? Math.round(context.pvAvailableEstimateW) : null,
+                pv_cap_blocked_increase: !!context.pvCapBlockedIncrease,
+                controller_requested_limit_w: Number.isFinite(context.controllerRequestedLimitW)
+                    ? Math.round(context.controllerRequestedLimitW)
+                    : Math.round(context.siteLimit),
+                feed_forward_target_w: Number.isFinite(context.feedForwardTargetW) ? Math.round(context.feedForwardTargetW) : null,
+                timestamp_ms: context.msgTimestampMs
+            };
+
+            if (node.a3TestsEnabled) {
+                const command = a3Server ? a3Server.getCommand() : null;
+                basePayload.powerType = "active";
+                basePayload.mode = "watts";
+                basePayload.a3_tests = true;
+                basePayload.ramp = {
+                    type: command ? command.rampType : node.a3RampType,
+                    value: command ? command.rampValue : node.a3RampValue
+                };
+                basePayload.a3_sequence = command ? command.sequence : 0;
+            }
+
+            if (context.fastCommand) {
+                basePayload.command_id = context.fastCommand.commandId;
+                basePayload.command_requested_at_ms = context.fastCommand.requestedAtMs;
+                basePayload.control_received_at_ms = context.fastCommand.receivedAtMs;
+                basePayload.control_calculated_at_ms = Date.now();
+            }
+
+            if (node.debugLevel === "off") {
+                return basePayload;
+            }
+
+            const normalPayload = Object.assign({}, basePayload, {
+                raw_grid_reference_w: context.rawGridReference,
+                filtered_grid_reference_w: filteredReferenceOut,
+                error_w: context.error,
+                correction_w: context.correction,
+                control_active: context.active,
+                export_detected: context.exportDetected,
+                recovery_blocked: context.recoveryBlocked,
+                ramp_direction: context.rampDirection,
+                clamped_by_min: context.clampedByMin,
+                clamped_by_max: context.clampedByMax,
+                measurement_age_ms: context.measurementAgeMs
+            });
+            normalPayload.feed_forward_delta_w = Number.isFinite(context.feedForwardDeltaW)
+                ? Math.round(context.feedForwardDeltaW)
+                : null;
+            normalPayload.pv_cap_hold_active = !!context.pvCapHoldActive;
+
+            if (Number.isFinite(context.previousLimit)) {
+                normalPayload.previous_limit_w = Math.round(context.previousLimit);
+                normalPayload.new_limit_w = Math.round(context.siteLimit);
+                normalPayload.delta_limit_w = Math.round(context.siteLimit - context.previousLimit);
+            }
+            normalPayload.control_due = !!context.controlDue;
+            normalPayload.immediate_reduction = !!context.immediateReductionDue;
+            normalPayload.immediate_reduction_blocked = !!context.immediateReductionBlocked;
+            normalPayload.immediate_reduction_cooldown_remaining_ms = Number.isFinite(context.immediateReductionCooldownRemainingMs)
+                ? Math.round(context.immediateReductionCooldownRemainingMs)
+                : null;
+
+            if (node.debugLevel === "normal") {
+                return normalPayload;
+            }
+
+            return Object.assign({}, normalPayload, {
+                normalized_grid_reference_w: context.gridReference,
+                normalized_filtered_grid_reference_w: context.filteredReference,
+                normalized_grid_target_w: context.gridTarget,
+                p_term_w: context.pTerm,
+                i_term_w: context.iTerm,
+                effective_kp: context.effectiveKp,
+                effective_ki: context.effectiveKi,
+                adaptive_gain_scale: context.gainsScale,
+                sign_convention: node.signConvention,
+                critical_phase: lastCriticalPhase,
+                export_control_band_w: controlBands().exportW,
+                import_control_band_w: controlBands().importW,
+                kp: node.kp,
+                ki: node.ki,
+                max_step_up_w: node.maxStepUpW,
+                max_step_down_w: node.maxStepDownW,
+                adaptive_gains: node.adaptiveGains,
+                adaptive_error_band_w: node.adaptiveErrorBandW,
+                adaptive_min_scale: node.adaptiveMinScale,
+                control_period_ms: node.controlPeriodMs,
+                output_heartbeat_ms: node.outputHeartbeatMs,
+                filter_tau_ms: node.filterTauMs,
+                feed_forward_enabled: node.feedForwardEnabled,
+                feed_forward_gain: node.feedForwardGain,
+                pv_cap_only_blocks_increase: node.pvCapOnlyBlocksIncrease,
+                pv_cap_hold_ms: node.pvCapHoldMs,
+                pv_cap_release_w_per_s: node.pvCapReleaseWPerSec,
+                debug_level: node.debugLevel
+            });
+
+        }
+
+        function failSecureThresholdW() {
+            return Math.max(20, controlBands().exportW);
+        }
+
+        function shouldEmitMainOutput(siteLimit, stale, nowMs, force) {
+            if (force) return true;
+            if (!Number.isFinite(lastOutputAtMs) || lastOutputAtMs <= 0) return true;
+            if (!Number.isFinite(lastOutputLimit) || Math.abs(Number(siteLimit) - lastOutputLimit) >= 1) return true;
+            if (lastOutputStale !== !!stale) return true;
+            return (nowMs - lastOutputAtMs) >= node.outputHeartbeatMs;
+        }
+
+        function rememberMainOutput(siteLimit, stale, nowMs) {
+            lastOutputAtMs = nowMs;
+            lastOutputLimit = Number(siteLimit);
+            lastOutputStale = !!stale;
+        }
+
+        function isPvTelemetryForConfiguredSource(msg) {
+            if (!node.useGlobalPvCap && !node.feedForwardEnabled) return false;
+
+            const payload = msg && msg.payload;
+            if (!payload || typeof payload !== "object") return false;
+            if (!Number.isFinite(Number(payload.power_w))) return false;
+
+            if (payload.site_limit_w !== undefined) return false;
+            if (payload.grid_reference_w !== undefined) return false;
+            if (payload.grid_target_w !== undefined) return false;
+            if (payload.pcc_power !== undefined || payload.pcc_power_w !== undefined) return false;
+            if (payload.grid_power !== undefined) return false;
+            if (payload.summary && payload.summary.power && Number.isFinite(Number(payload.summary.power.total_w))) return false;
+
+            const sourceId = String(
+                payload.inverter_id ||
+                msg.inverter_id ||
+                msg.topic ||
+                ""
+            ).trim();
+
+            if (!sourceId) return false;
+            if (sourceId === String(node.outputTopic || "").trim()) return false;
+
+            const configuredSource = String(node.globalPvTotalVar || "").trim();
+            if (!configuredSource) return false;
+
+            // Single-inverter mode without global context:
+            // allow using PV Global Variable as direct telemetry topic/inverter_id (e.g. "inv1").
+            return sourceId === configuredSource;
+        }
+
+        function updatePvTelemetryFromMessage(msg, nowMs) {
+            const payload = msg && msg.payload;
+            const sourceId = String(
+                payload.inverter_id ||
+                msg.inverter_id ||
+                msg.topic ||
+                "pv"
+            ).trim() || "pv";
+
+            pvTelemetryBySource.set(sourceId, {
+                powerW: Math.max(0, Number(payload.power_w)),
+                ts: Number.isFinite(nowMs) ? nowMs : Date.now()
+            });
+        }
+
+        function readLocalPvTotalW(nowMs) {
+            if (!pvTelemetryBySource.size) return null;
+
+            const timeoutMs = node.staleTimeoutMs > 0
+                ? Math.max(1000, node.staleTimeoutMs)
+                : 5000;
+
+            let total = 0;
+            let count = 0;
+
+            pvTelemetryBySource.forEach(function (entry, key) {
+                if (!entry || !Number.isFinite(entry.powerW) || !Number.isFinite(entry.ts)) {
+                    pvTelemetryBySource.delete(key);
+                    return;
+                }
+
+                if ((nowMs - entry.ts) > timeoutMs) {
+                    pvTelemetryBySource.delete(key);
+                    return;
+                }
+
+                total += Math.max(0, Number(entry.powerW));
+                count += 1;
+            });
+
+            if (!count) return null;
+            return total;
+        }
+
+        function extractPvTotalFromGlobalValue(raw, nowMs) {
+            const direct = Number(raw);
+            if (Number.isFinite(direct)) {
+                return Math.max(0, direct);
+            }
+
+            if (!raw || typeof raw !== "object") return null;
+
+            const value = firstFinite(
+                raw.power_w,
+                raw.total_pv_w,
+                raw.total_w,
+                raw.value,
+                raw.payload && raw.payload.power_w,
+                raw.payload && raw.payload.total_pv_w,
+                raw.payload && raw.payload.value
+            );
+            if (!Number.isFinite(value)) return null;
+
+            const timestampMs = firstFinite(
+                raw.timestamp_ms,
+                raw.time_ms,
+                raw.timestamp,
+                raw.ts,
+                raw.time,
+                raw.payload && raw.payload.timestamp_ms,
+                raw.payload && raw.payload.time_ms,
+                raw.payload && raw.payload.timestamp,
+                raw.payload && raw.payload.ts,
+                raw.payload && raw.payload.time
+            );
+            if (Number.isFinite(timestampMs)) {
+                const tsMs = timestampMs < 1e11 ? Math.round(timestampMs * 1000) : Math.round(timestampMs);
+                const timeoutMs = node.staleTimeoutMs > 0 ? Math.max(1000, node.staleTimeoutMs) : 5000;
+                if ((nowMs - tsMs) > timeoutMs || (tsMs - nowMs) > node.maxFutureTimestampMs) return null;
+            }
+
+            return Math.max(0, Number(value));
+        }
+
+        function readGlobalPvTotalW(nowMs) {
+            if (!node.useGlobalPvCap && !node.feedForwardEnabled) return null;
+            if (node.globalPvTotalVar) {
+                const raw = globalCtx.get(node.globalPvTotalVar);
+                const n = extractPvTotalFromGlobalValue(raw, nowMs);
+                if (Number.isFinite(n)) {
+                    return n;
+                }
+            }
+
+            return readLocalPvTotalW(nowMs);
+        }
+
+        function updatePvAvailabilityEstimate(rawPvTotalW, nowMs) {
+            if (!Number.isFinite(rawPvTotalW)) return null;
+
+            const raw = Math.max(0, Number(rawPvTotalW));
+            if (!Number.isFinite(pvAvailableEstimateW) || raw >= pvAvailableEstimateW) {
+                pvAvailableEstimateW = raw;
+                pvEstimateHoldUntilMs = nowMs + node.pvCapHoldMs;
+                lastPvEstimateUpdateMs = nowMs;
+                return pvAvailableEstimateW;
+            }
+
+            const dtSeconds = lastPvEstimateUpdateMs > 0
+                ? Math.max(0, nowMs - lastPvEstimateUpdateMs) / 1000
+                : 0;
+            if (nowMs >= pvEstimateHoldUntilMs && node.pvCapReleaseWPerSec > 0) {
+                const maximumReleaseW = node.pvCapReleaseWPerSec * dtSeconds;
+                pvAvailableEstimateW = Math.max(raw, pvAvailableEstimateW - maximumReleaseW);
+            }
+            lastPvEstimateUpdateMs = nowMs;
+            return pvAvailableEstimateW;
+        }
+
+        function computeDynamicPvCapOffsetW(errorW) {
+            const baseOffset = Math.max(0, Number(node.globalPvCapOffsetW) || 0);
+            if (baseOffset <= 0) return 0;
+            if (!Number.isFinite(errorW)) return baseOffset;
+
+            // Near setpoint keep only a small margin, farther away allow full offset.
+            const minOffset = Math.min(baseOffset, Math.max(0, Number(node.recoverThresholdW) || 0));
+            const nearBand = Math.max(
+                1,
+                Number(node.deadband) || 0,
+                Number(node.exportThresholdW) || 0,
+                Number(node.recoverThresholdW) || 0
+            );
+            const farBand = Math.max(nearBand + 1, Number(node.adaptiveErrorBandW) || (nearBand + 1));
+            const progress = clamp((Math.abs(errorW) - nearBand) / (farBand - nearBand), 0, 1);
+
+            return minOffset + (baseOffset - minOffset) * progress;
+        }
+
+        function readNominalPowerW() {
+            if (node.a3TestsEnabled && a3Server) {
+                const command = a3Server.getCommand();
+                if (command && Number.isFinite(command.nominalPower)) {
+                    return command.nominalPower;
+                }
+            }
+
+            if (!node.nominalPowerFromGlobal) {
+                return Number(node.nominalPower);
+            }
+            const key = String(node.nominalPowerGlobalVar || "").trim();
+            if (!key) {
+                return Number(node.nominalPower);
+            }
+            const raw = globalCtx.get(key);
+            const n = Number(raw);
+            if (Number.isFinite(n)) {
+                return n;
+            }
+            return Number(node.nominalPower);
+        }
+
+        function evaluateFailSecure(context, nowMs) {
+            if (!node.failSecureEnabled) {
+                failSecureBreachStartMs = null;
+                failSecureActive = false;
+                return {
+                    active: false,
+                    durationMs: 0,
+                    minLimitW: node.minLimit,
+                    siteLimitW: Number(context && context.siteLimit)
+                };
+            }
+
+            const minLimitW = Number(node.minLimit);
+            const siteLimitW = Number(context && context.siteLimit);
+            const epsilon = 1e-6;
+            const gridReferenceW = Number(context && context.gridReference);
+            const thresholdW = failSecureThresholdW();
+            const eligible = node.mode !== "nominal_power" && Number.isFinite(siteLimitW);
+            const atMinimum = siteLimitW <= (minLimitW + epsilon);
+            const residualExport = Number.isFinite(gridReferenceW) && gridReferenceW >= thresholdW;
+            const violation = eligible && atMinimum && residualExport;
+
+            if (violation) {
+                if (!Number.isFinite(failSecureBreachStartMs)) {
+                    failSecureBreachStartMs = nowMs;
+                }
+                const durationMs = Math.max(0, nowMs - failSecureBreachStartMs);
+                const triggerMs = Math.max(1000, Math.round(node.failSecureTimeSec * 1000));
+                failSecureActive = durationMs >= triggerMs;
+                return {
+                    active: failSecureActive,
+                    durationMs: durationMs,
+                    minLimitW: minLimitW,
+                    siteLimitW: siteLimitW,
+                    residualExportW: gridReferenceW,
+                    thresholdW: thresholdW
+                };
+            }
+
+            failSecureBreachStartMs = null;
+            failSecureActive = false;
+            return {
+                active: false,
+                durationMs: 0,
+                minLimitW: minLimitW,
+                siteLimitW: siteLimitW,
+                residualExportW: gridReferenceW,
+                thresholdW: thresholdW
+            };
+        }
+
+        function buildFailSecureMessage(failSecureState, nowMs) {
+            if (!node.failSecureEnabled) {
+                lastFailSecureOutputActive = false;
+                return null;
+            }
+
+            if (failSecureState && failSecureState.active) {
+                lastFailSecureOutputActive = true;
+                return {
+                    topic: "control-export/fail-secure",
+                    payload: 1,
+                    fail_secure: {
+                        active: true,
+                        duration_ms: failSecureState.durationMs,
+                        min_limit_w: failSecureState.minLimitW,
+                        site_limit_w: failSecureState.siteLimitW,
+                        residual_export_w: failSecureState.residualExportW,
+                        threshold_w: failSecureState.thresholdW,
+                        timeout_s: node.failSecureTimeSec,
+                        timestamp_ms: nowMs
+                    }
+                };
+            }
+
+            if (lastFailSecureOutputActive) {
+                lastFailSecureOutputActive = false;
+                return {
+                    topic: "control-export/fail-secure",
+                    payload: 0,
+                    fail_secure: {
+                        active: false,
+                        timestamp_ms: nowMs
+                    }
+                };
+            }
+
+            return null;
+        }
+
+        function emitSafetyOutput(reason, nowMs, sendFn, force) {
+            const safeLimit = clamp(node.safeLimitOnStale, node.minLimit, node.maxLimit);
+            lastLimit = safeLimit;
+            integratorState = 0;
+            outsideDeadbandSinceMs = null;
+            const gridTarget = node.mode === "nominal_power" ? null : getGridTarget();
+            const mainMsg = {
+                topic: node.outputTopic,
+                payload: buildOutputPayload({
+                    siteLimit: safeLimit,
+                    rawGridReference: null,
+                    gridReference: lastRawGridReference,
+                    filteredReference: filteredGridReference,
+                    gridTarget: gridTarget,
+                    correction: 0,
+                    error: null,
+                    pTerm: 0,
+                    effectiveKp: node.kp,
+                    effectiveKi: node.ki,
+                    gainsScale: 1,
+                    iTerm: 0,
+                    active: false,
+                    reason: reason,
+                    controllerState: "stale_fallback",
+                    stale: true,
+                    pvTotalW: null,
+                    pvCapLimitW: null,
+                    pvCapOffsetW: null,
+                    pvCapApplied: false,
+                    exportDetected: false,
+                    recoveryBlocked: false,
+                    rampDirection: "hold",
+                    clampedByMin: safeLimit <= node.minLimit,
+                    clampedByMax: safeLimit >= node.maxLimit,
+                    measurementAgeMs: Number.isFinite(lastInputAtMs) ? Math.max(0, nowMs - lastInputAtMs) : null,
+                    msgTimestampMs: nowMs,
+                    previousLimit: lastOutputLimit,
+                    controlDue: true,
+                    immediateReductionDue: false,
+                    immediateReductionBlocked: false,
+                    immediateReductionCooldownRemainingMs: null
+                })
+            };
+            if (!shouldEmitMainOutput(safeLimit, true, nowMs, force)) return false;
+            if (node.failSecureEnabled) {
+                sendFn([mainMsg, null]);
+            } else {
+                sendFn(mainMsg);
+            }
+            rememberMainOutput(safeLimit, true, nowMs);
+            return true;
+        }
+
+
+        function emitA3NominalCommand(nowMs, reason) {
+            const command = a3Server ? a3Server.getCommand() : {
+                nominalPower: node.nominalPower,
+                rampType: node.a3RampType,
+                rampValue: node.a3RampValue,
+                sequence: 0
+            };
+            const siteLimit = clamp(command.nominalPower, node.minLimit, node.maxLimit);
+
+            lastLimit = siteLimit;
+            persistLastLimit(lastLimit, { nowMs: nowMs, force: true });
+
+            buildStatus({
+                mode: "nominal_power",
+                siteLimit: siteLimit,
+                gridReference: lastRawGridReference,
+                gridTarget: null,
+                active: false,
+                reason: reason || "a3_modbus_command",
+                rampDirection: "hold",
+                controllerState: "a3_nominal_mode"
+            });
+
+            node.send({
+                topic: node.outputTopic,
+                payload: buildOutputPayload({
+                    siteLimit: siteLimit,
+                    rawGridReference: null,
+                    gridReference: lastRawGridReference,
+                    filteredReference: filteredGridReference,
+                    gridTarget: null,
+                    correction: 0,
+                    error: null,
+                    pTerm: 0,
+                    effectiveKp: node.kp,
+                    effectiveKi: node.ki,
+                    gainsScale: 1,
+                    iTerm: 0,
+                    active: false,
+                    reason: reason || "a3_modbus_command",
+                    controllerState: "a3_nominal_mode",
+                    stale: false,
+                    pvTotalW: null,
+                    pvCapLimitW: null,
+                    pvCapOffsetW: null,
+                    pvCapApplied: false,
+                    exportDetected: false,
+                    recoveryBlocked: false,
+                    rampDirection: "hold",
+                    clampedByMin: siteLimit <= node.minLimit,
+                    clampedByMax: siteLimit >= node.maxLimit,
+                    measurementAgeMs: null,
+                    msgTimestampMs: nowMs,
+                    previousLimit: null,
+                    controlDue: true,
+                    immediateReductionDue: false,
+                    immediateReductionBlocked: false,
+                    immediateReductionCooldownRemainingMs: null
+                })
+            });
+            rememberMainOutput(siteLimit, false, nowMs);
+        }
+
+
+        node.on("input", function (msg, send, done) {
+
+            try {
+                const nowMs = Date.now();
+                if (!validateRequiredGlobalValues()) {
+                    emitSafetyOutput("invalid_global", nowMs, send, false);
+                    done();
+                    return;
+                }
+                refreshMaxLimitFromGlobal();
+                const fastCommand = extractFastSetpointCommand(msg, nowMs);
+
+                if (fastCommand) {
+                    if (node.mode !== "grid_set_point") {
+                        throw new Error("Fast grid setpoint necesita mode=grid_set_point");
+                    }
+                    const measurementAgeMs = Number.isFinite(lastMsgTimestampMs)
+                        ? Math.max(0, nowMs - lastMsgTimestampMs)
+                        : Infinity;
+                    if (!Number.isFinite(lastRawGridReference) || measurementAgeMs > node.fastSetpointMaxTelemetryAgeMs) {
+                        throw new Error("Nu exista telemetrie grid proaspata pentru fast setpoint");
+                    }
+                    node.gridSetPoint = fastCommand.value;
+                    nodeCtx.set(persistedGridSetpointKey, node.gridSetPoint);
+                    nodeCtx.set(persistedGridSetpointBaseKey, configuredGridSetPoint);
+                    integratorState = 0;
+                    outsideDeadbandSinceMs = null;
+                    msg = {
+                        topic: "control-export/fast-setpoint-eval",
+                        timestamp_ms: lastMsgTimestampMs,
+                        payload: { power_w: denormalizeByConvention(lastRawGridReference) }
+                    };
+                }
+
+                const msgTimestampMs = extractTimestampMs(msg);
+
+                if ((msgTimestampMs - nowMs) > node.maxFutureTimestampMs) {
+                    throw new Error("Timestamp din viitor peste limita admisa");
+                }
+
+                if (isPvTelemetryForConfiguredSource(msg)) {
+                    updatePvTelemetryFromMessage(msg, nowMs);
+                    done();
+                    return;
+                }
+
+                if (!fastCommand && isControlCommandMessage(msg)) {
+                    done();
+                    return;
+                }
+
+                const stale = isStale(msgTimestampMs, nowMs);
+
+                if (!stale && Number.isFinite(lastAcceptedMeasurementTs) && msgTimestampMs < lastAcceptedMeasurementTs) {
+                    node.status({ fill: "yellow", shape: "ring", text: "ignored older telemetry" });
+                    done();
+                    return;
+                }
+
+                const controlDtMs = lastControlTs > 0 ? Math.max(1, nowMs - lastControlTs) : node.controlPeriodMs;
+
+                const controlDue = !!fastCommand || !Number.isFinite(lastLimit) || (nowMs - lastControlTs) >= node.controlPeriodMs;
+
+
+                let siteLimit;
+
+                let gridReference = lastRawGridReference;
+
+                let filteredReference = filteredGridReference;
+
+                let gridTarget = null;
+
+                let correction = null;
+
+                let error = null;
+
+                let pTerm = null;
+                let effectiveKp = null;
+                let effectiveKi = null;
+                let gainsScale = null;
+
+                let iTerm = integratorState;
+
+                let active = false;
+
+                let reason = "nominal";
+
+                let exportDetected = false;
+
+                let rampDirection = "hold";
+
+                let controllerState = node.mode === "nominal_power" ? "nominal_mode" : "waiting_measurement";
+
+                let recoveryBlocked = false;
+
+                let clampedByMin = false;
+
+                let clampedByMax = false;
+
+                let rawGridReference = null;
+                let pvTotalW = null;
+                let pvCapLimitW = null;
+                let pvCapOffsetW = null;
+                let pvCapApplied = false;
+                let pvCapBlockedIncrease = false;
+                let pvCapHoldActive = false;
+                let pvAvailableEstimateForOutputW = null;
+                let controllerRequestedLimitW = null;
+                let feedForwardTargetW = null;
+                let feedForwardDeltaW = null;
+                let previousLimitForDebug = Number.isFinite(lastLimit) ? Number(lastLimit) : null;
+                let immediateReductionDue = false;
+                let immediateReductionBlocked = false;
+                let immediateReductionCooldownRemainingMs = null;
+
+
+                pvTotalW = readGlobalPvTotalW(nowMs);
+                pvAvailableEstimateForOutputW = updatePvAvailabilityEstimate(pvTotalW, nowMs);
+                pvCapHoldActive = Number.isFinite(pvAvailableEstimateForOutputW) && nowMs < pvEstimateHoldUntilMs;
+
+                if (node.mode === "nominal_power") {
+                    outsideDeadbandSinceMs = null;
+
+                    const nominalPowerW = readNominalPowerW();
+                    siteLimit = clamp(nominalPowerW, node.minLimit, node.maxLimit);
+
+                    reason = "nominal";
+
+                    integratorState = 0;
+
+                } else if (stale) {
+                    outsideDeadbandSinceMs = null;
+
+                    siteLimit = node.safeLimitOnStale;
+
+                    reason = "stale";
+
+                    controllerState = "stale_fallback";
+
+                    integratorState = 0;
+
+                } else {
+
+                    rawGridReference = extractControlReference(msg);
+
+                    if (rawGridReference === null) {
+
+                        if (isInverterTelemetryWithoutGridReference(msg)) {
+                            done();
+                            return;
+                        }
+
+                        if (node.mode === "zero_feed_in" && node.zeroFeedInMode === "absolute") {
+                            throw new Error("Pentru Zero Feed-In absolut sunt necesare puterile pe faze (L1/L2/L3)");
+                        }
+                        throw new Error("Mesajul nu conține referința din rețea");
+
+                    }
+
+                    lastInputAtMs = nowMs;
+
+                    gridReference = normalizeGridReference(rawGridReference);
+
+                    filteredReference = updateFilter(
+                        gridReference,
+                        msgTimestampMs,
+                        nowMs,
+                        node.mode === "zero_feed_in" && node.zeroFeedInMode === "absolute"
+                            ? (lastCriticalPhase || "phase")
+                            : "total"
+                    );
+
+                    lastRawGridReference = gridReference;
+
+                    lastMsgTimestampMs = msgTimestampMs;
+
+
+                    const gridTargetNow = getGridTarget();
+                    const protectiveReference = (function () {
+                        if (Number.isFinite(gridReference) && Number.isFinite(filteredReference)) {
+                            return Math.max(gridReference, filteredReference);
+                        }
+                        if (Number.isFinite(filteredReference)) return filteredReference;
+                        return gridReference;
+                    })();
+                    immediateReductionDue = canReduceImmediately(
+                        nowMs,
+                        protectiveReference,
+                        gridTargetNow,
+                        controlDue
+                    );
+                    if (!controlDue && Number.isFinite(protectiveReference) && Number.isFinite(gridTargetNow)) {
+                        const overshootW = protectiveReference - gridTargetNow;
+                        const requiredOvershootW = controlBands().exportW;
+                        const cooldownMs = Math.max(Number(node.transientIgnoreMs) || 0, Number(node.controlPeriodMs) || 0, 800);
+                        immediateReductionBlocked = overshootW > requiredOvershootW && !immediateReductionDue;
+                        immediateReductionCooldownRemainingMs = lastImmediateReductionTs > 0
+                            ? Math.max(0, cooldownMs - (nowMs - lastImmediateReductionTs))
+                            : 0;
+                    }
+
+                    if (controlDue || immediateReductionDue) {
+
+                        const result = computeClosedLoopLimit(
+                            immediateReductionDue ? protectiveReference : filteredReference,
+                            nowMs,
+                            controlDtMs,
+                            immediateReductionDue,
+                            pvTotalW
+                        );
+
+                        siteLimit = result.siteLimit;
+                        previousLimitForDebug = Number.isFinite(result.previousLimit) ? result.previousLimit : previousLimitForDebug;
+
+                        gridTarget = result.gridTarget;
+
+                        correction = result.correction;
+
+                        error = result.error;
+
+                        pTerm = result.pTerm;
+                        effectiveKp = result.effectiveKp;
+                        effectiveKi = result.effectiveKi;
+                        gainsScale = result.gainsScale;
+                        feedForwardTargetW = result.feedForwardTargetW;
+                        feedForwardDeltaW = result.feedForwardDeltaW;
+
+                        iTerm = result.iTerm;
+
+                        active = result.active;
+
+                        reason = result.reason;
+
+                        exportDetected = result.exportDetected;
+
+                        rampDirection = result.rampDirection;
+
+                        controllerState = result.controllerState;
+
+                        recoveryBlocked = result.recoveryBlocked;
+
+                        clampedByMin = result.clampedByMin;
+
+                        clampedByMax = result.clampedByMax;
+
+                        lastControlTs = nowMs;
+
+                        if (immediateReductionDue) {
+                            lastImmediateReductionTs = nowMs;
+                        }
+
+                    } else {
+
+                        siteLimit = Number.isFinite(lastLimit)
+
+                            ? lastLimit
+
+                            : clamp(node.maxLimit, node.minLimit, node.maxLimit);
+
+                        gridTarget = getGridTarget();
+
+                        error = Number.isFinite(filteredReference) ? (filteredReference - gridTarget) : null;
+
+                        pTerm = Number.isFinite(error) ? node.kp * error : null;
+                        effectiveKp = node.kp;
+                        effectiveKi = node.ki;
+                        gainsScale = 1;
+
+                        iTerm = integratorState;
+
+                        correction = 0;
+
+                        active = false;
+
+                        exportDetected = Number.isFinite(filteredReference) && filteredReference > (gridTarget + controlBands().exportW);
+
+                        rampDirection = "hold";
+
+                        reason = "hold_period";
+
+                        controllerState = "hold_period";
+
+                    }
+
+                }
+
+
+                siteLimit = clamp(siteLimit, node.minLimit, node.maxLimit);
+                controllerRequestedLimitW = siteLimit;
+                if (node.useGlobalPvCap && node.mode !== "nominal_power" && Number.isFinite(pvAvailableEstimateForOutputW)) {
+                    pvCapOffsetW = computeDynamicPvCapOffsetW(error);
+                    pvCapLimitW = Math.max(0, pvAvailableEstimateForOutputW + pvCapOffsetW);
+                    const previousEmittedLimitW = Number.isFinite(previousLimitForDebug)
+                        ? previousLimitForDebug
+                        : node.minLimit;
+                    const capFloorW = node.pvCapOnlyBlocksIncrease
+                        ? Math.min(siteLimit, previousEmittedLimitW)
+                        : node.minLimit;
+                    const cappedByPv = clamp(
+                        Math.min(siteLimit, Math.max(capFloorW, pvCapLimitW)),
+                        node.minLimit,
+                        node.maxLimit
+                    );
+                    if (cappedByPv < siteLimit) {
+                        siteLimit = cappedByPv;
+                        pvCapApplied = true;
+                        pvCapBlockedIncrease = node.pvCapOnlyBlocksIncrease && siteLimit >= previousEmittedLimitW;
+                        if (controllerState && controllerState !== "stale_fallback") {
+                            controllerState = "pv_cap";
+                        }
+                    }
+                }
+
+                // Controller memory follows the actual emitted limit. In growth-only
+                // mode the PV cap may block an increase, but never creates a new decrease.
+                if (Number.isFinite(siteLimit)) {
+                    lastLimit = siteLimit;
+                }
+
+                if (!Number.isFinite(lastLimit) || node.mode === "nominal_power") {
+
+                    lastLimit = siteLimit;
+
+                }
+                if (reason !== "stale") {
+                    persistLastLimit(lastLimit, { nowMs: nowMs });
+                }
+
+
+                buildStatus({
+
+                    mode: node.mode,
+
+                    siteLimit: siteLimit,
+
+                    gridReference: gridReference,
+
+                    gridTarget: gridTarget,
+
+                    active: active,
+
+                    reason: reason,
+
+                    rampDirection: rampDirection,
+
+                    controllerState: controllerState
+
+                });
+
+
+                const measurementAgeMs = Number.isFinite(lastMsgTimestampMs) ? Math.max(0, nowMs - lastMsgTimestampMs) : null;
+
+                const mainMsg = {
+
+                    topic: node.outputTopic,
+
+                    payload: buildOutputPayload({
+                        siteLimit: siteLimit,
+                        rawGridReference: rawGridReference,
+                        gridReference: gridReference,
+                        filteredReference: filteredReference,
+                        gridTarget: gridTarget,
+                        correction: correction,
+                        error: error,
+                        pTerm: pTerm,
+                        effectiveKp: effectiveKp,
+                        effectiveKi: effectiveKi,
+                        gainsScale: gainsScale,
+                        iTerm: iTerm,
+                        active: active,
+                        reason: reason,
+                        controllerState: controllerState,
+                        stale: stale,
+                        pvTotalW: pvTotalW,
+                        pvCapLimitW: pvCapLimitW,
+                        pvCapOffsetW: pvCapOffsetW,
+                        pvCapApplied: pvCapApplied,
+                        pvAvailableEstimateW: pvAvailableEstimateForOutputW,
+                        pvCapBlockedIncrease: pvCapBlockedIncrease,
+                        pvCapHoldActive: pvCapHoldActive,
+                        controllerRequestedLimitW: controllerRequestedLimitW,
+                        feedForwardTargetW: feedForwardTargetW,
+                        feedForwardDeltaW: feedForwardDeltaW,
+                        exportDetected: exportDetected,
+                        recoveryBlocked: recoveryBlocked,
+                        rampDirection: rampDirection,
+                        clampedByMin: clampedByMin,
+                        clampedByMax: clampedByMax,
+                        measurementAgeMs: measurementAgeMs,
+                        msgTimestampMs: msgTimestampMs,
+                        fastCommand: fastCommand,
+                        previousLimit: previousLimitForDebug,
+                        controlDue: controlDue,
+                        immediateReductionDue: immediateReductionDue,
+                        immediateReductionBlocked: immediateReductionBlocked,
+                        immediateReductionCooldownRemainingMs: immediateReductionCooldownRemainingMs
+                    })
+
+                };
+
+                const failSecureState = evaluateFailSecure({
+                    stale: stale,
+                    error: error,
+                    siteLimit: siteLimit,
+                    gridReference: filteredReference !== null ? filteredReference : gridReference
+                }, nowMs);
+
+                const failSecureMsg = buildFailSecureMessage(failSecureState, nowMs);
+                const emitMain = shouldEmitMainOutput(siteLimit, stale, nowMs, !!fastCommand);
+
+                if (node.failSecureEnabled) {
+                    if (emitMain || failSecureMsg) {
+                        send([emitMain ? mainMsg : null, failSecureMsg]);
+                    }
+                } else if (emitMain) {
+                    send(mainMsg);
+                }
+
+                if (emitMain) {
+                    rememberMainOutput(siteLimit, stale, nowMs);
+                }
+
+                if (!stale) {
+                    lastAcceptedMeasurementTs = msgTimestampMs;
+                }
+
+
+                done();
+
+            } catch (err) {
+
+                node.status({
+
+                    fill: "red",
+
+                    shape: "ring",
+
+                    text: err.message
+
+                });
+
+                if (node.mode !== "nominal_power" && !isControlCommandMessage(msg)) {
+                    emitSafetyOutput("invalid_telemetry", Date.now(), send, false);
+                }
+
+                done(err);
+
+            }
+
+        });
+
+        if (node.staleTimeoutMs > 0 && node.mode !== "nominal_power") {
+            watchdogTimer = setInterval(function () {
+                const nowMs = Date.now();
+                if (!Number.isFinite(lastInputAtMs) || (nowMs - lastInputAtMs) <= node.staleTimeoutMs) {
+                    return;
+                }
+                if ((nowMs - lastWatchdogSafeAtMs) < node.outputHeartbeatMs) return;
+
+                const globalsValid = validateRequiredGlobalValues();
+                if (globalsValid) refreshMaxLimitFromGlobal();
+                lastWatchdogSafeAtMs = nowMs;
+                node.status({ fill: "yellow", shape: "ring", text: (globalsValid ? "watchdog stale" : "invalid global") + " | safe output" });
+                emitSafetyOutput(globalsValid ? "watchdog_stale" : "invalid_global", nowMs, node.send.bind(node), false);
+            }, Math.max(250, Math.min(node.staleTimeoutMs, 1000)));
+        }
+
+        if (node.a3TestsEnabled) {
+            a3Server = createA3TestServer({
+                host: node.a3ModbusHost,
+                port: node.a3ModbusPort,
+                unitId: node.a3ModbusUnitId,
+                nominalPower: node.nominalPower,
+                minNominal: node.minLimit,
+                maxNominal: node.maxLimit,
+                rampType: node.a3RampType,
+                rampValue: node.a3RampValue,
+                onCommand: function () {
+                    emitA3NominalCommand(Date.now(), "a3_modbus_command");
+                },
+                onError: function (err) {
+                    node.warn("control-export A3 Modbus: " + err.message);
+                },
+                onProtocolIssue: function (issue) {
+                    if (node.debugLevel !== "off") {
+                        node.warn("control-export A3 Modbus issue: " + issue.code);
+                    }
+                }
+            });
+
+            a3Server.start().then(function () {
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: "A3 Modbus " + node.a3ModbusHost + ":" + node.a3ModbusPort
+                });
+                emitA3NominalCommand(Date.now(), "a3_start");
+            }).catch(function (err) {
+                node.status({ fill: "red", shape: "ring", text: "A3 Modbus: " + err.message });
+                node.error("control-export A3 Modbus: " + err.message);
+            });
+        }
+
+        node.on("close", function(done) {
+            if (watchdogTimer) {
+                clearInterval(watchdogTimer);
+                watchdogTimer = null;
+            }
+            persistLastLimit(lastLimit, { force: true });
+            if (a3Server) {
+                const server = a3Server;
+                a3Server = null;
+                server.stop().finally(function () {
+                    if (typeof done === "function") done();
+                });
+                return;
+            }
+
+            if (typeof done === "function") done();
+        });
+
+    
+        });
+    }
+
+
+    RED.nodes.registerType("control-export", ControlExportNode);
+
+};